Exemplo n.º 1
0
        private static void AddSegment([NotNull] IFeature feature,
                                       [NotNull] IIndexedSegments geom,
                                       [NotNull] IList <Subcurve> connectedList,
                                       [NotNull] SegmentProxy segProxy, double min,
                                       double max)
        {
            if (min >= max)
            {
                return;
            }

            Subcurve current = null;

            if (connectedList.Count > 0)
            {
                current = connectedList[connectedList.Count - 1];
            }

            if (current != null)
            {
                if (current.PartIndex != segProxy.PartIndex)
                {
                    current = null;
                }
                else if (current.EndSegmentIndex + current.EndFraction <
                         segProxy.SegmentIndex + min)
                {
                    current = null;
                }
            }

            if (current == null)
            {
                current = new Subcurve(geom, segProxy.PartIndex, segProxy.SegmentIndex,
                                       min, segProxy.SegmentIndex, max);
                connectedList.Add(current);
            }
            else
            {
                if (current.EndSegmentIndex + current.EndFraction < segProxy.SegmentIndex + max)
                {
                    current.EndSegmentIndex = segProxy.SegmentIndex;
                    current.EndFraction     = max;
                }
            }
        }
Exemplo n.º 2
0
        private static List <SubClosedCurve> GetClosedCurves(List <Subcurve> curves)
        {
            var connected = new List <SubClosedCurve>(curves.Count);

            Subcurve atStart = null;

            foreach (Subcurve curve in curves)
            {
                if (MathUtils.AreEqual(curve.StartFullIndex, 0))
                {
                    if (atStart != null)
                    {
                        connected.Add(new SubClosedCurve(atStart));
                    }

                    atStart = curve;
                    continue;
                }

                if (atStart != null &&
                    atStart.PartIndex == curve.PartIndex &&
                    curve.BaseGeometry.IsPartClosed(curve.PartIndex) &&
                    MathUtils.AreEqual(curve.EndFullIndex,
                                       curve.BaseGeometry.GetPartSegmentCount(curve.PartIndex)))
                {
                    connected.Add(new SubClosedCurve(atStart, curve));
                    atStart = null;
                }
                else
                {
                    connected.Add(new SubClosedCurve(curve));
                }
            }

            if (atStart != null)
            {
                connected.Add(new SubClosedCurve(atStart));
            }

            return(connected);
        }
Exemplo n.º 3
0
        private void AddSegment([NotNull] IFeature feature,
                                [NotNull] IIndexedSegments geom,
                                [NotNull] IList <Subcurve> standardConnectedList,
                                [NotNull] IList <Subcurve> nearSelfConnectedList,
                                [NotNull] SegmentPart segPart,
                                double connectedMinLength,
                                double nearSquared)
        {
            Subcurve         current       = null;
            IList <Subcurve> connectedList = standardConnectedList;

            SegmentProxy neighbor = segPart.NearSelf;

            if (neighbor != null)
            {
                // Get the distance between the parts that are near
                double d0        = double.MaxValue;
                int    partIndex = segPart.PartIndex;

                if (geom.IsPartClosed(partIndex) || segPart.SegmentIndex > neighbor.SegmentIndex)
                {
                    if (segPart.PartIndex == neighbor.PartIndex)
                    // TODO revise; workaround to avoid exception (invalid index)
                    {
                        // raw estimate for distance betwenn segPart and neighborPart
                        // this estimate is too small, because not the entire part of neighbor is near segPart
                        var curve = new SubClosedCurve(geom, partIndex,
                                                       neighbor.SegmentIndex + 1,
                                                       segPart.FullMin);
                        d0 = curve.GetLength();
                        if (d0 < connectedMinLength)
                        {
                            double d0Max = d0 + neighbor.Length;
                            if (d0Max > connectedMinLength)
                            {
                                // closer investigation necessary
                                double min;
                                double max;
                                GetClosePart(neighbor, geom, segPart, nearSquared, Is3D,
                                             out min, out max);

                                d0 = d0 + (1 - max) * neighbor.Length;
                            }                     // else segPart is definitly near neighbor
                        }                         //else segPart is definitly not near neighbor
                    }
                }

                if (geom.IsPartClosed(partIndex) || segPart.SegmentIndex < neighbor.SegmentIndex)
                {
                    if (segPart.PartIndex == neighbor.PartIndex)
                    // TODO revise; workaround to avoid exception (invalid index)
                    {
                        var curve = new SubClosedCurve(geom, partIndex,
                                                       segPart.FullMax,
                                                       neighbor.SegmentIndex);

                        double d0Min = curve.GetLength();
                        if (d0Min < connectedMinLength)
                        {
                            double d0Max = d0Min + neighbor.Length;
                            if (d0Max > connectedMinLength)
                            {
                                // closer investigation necessary
                                double min;
                                double max;
                                GetClosePart(neighbor, geom, segPart, nearSquared, Is3D,
                                             out min, out max);

                                d0Min = d0Min + min * neighbor.Length;
                            }                     //else segPart is definitly near neighbor
                        }                         // else segPart is definitly not near neighbor

                        d0 = Math.Min(d0, d0Min);
                    }
                }

                if (d0 < connectedMinLength)
                {
                    connectedList = nearSelfConnectedList;
                }
            }

            if (connectedList.Count > 0)
            {
                current = connectedList[connectedList.Count - 1];
            }

            if (current != null)
            {
                if (current.PartIndex != segPart.PartIndex)
                {
                    current = null;
                }
                else if (current.EndFullIndex < segPart.FullMin)
                {
                    current = null;
                }
            }

            if (current == null)
            {
                current = new Subcurve(geom, segPart.PartIndex, segPart.SegmentIndex,
                                       segPart.MinFraction, segPart.SegmentIndex,
                                       segPart.MaxFraction);
                connectedList.Add(current);
            }
            else
            {
                if (current.EndFullIndex < segPart.FullMax)
                {
                    current.EndSegmentIndex = segPart.SegmentIndex;
                    current.EndFraction     = segPart.MaxFraction;
                }
            }
        }