Пример #1
0
        /// <summary>
        /// Create a new "split edge" with the section of points between
        /// (and including) the two intersections.
        /// The label for the new edge is the same as the label for the parent edge.
        /// </summary>
        /// <param name="ei0"></param>
        /// <param name="ei1"></param>
        public Edge CreateSplitEdge(EdgeIntersection ei0, EdgeIntersection ei1)
        {
            int         npts           = ei1.SegmentIndex - ei0.SegmentIndex + 2;
            ICoordinate lastSegStartPt = edge.Points[ei1.SegmentIndex];
            // if the last intersection point is not equal to the its segment start pt,
            // add it to the points list as well.
            // (This check is needed because the distance metric is not totally reliable!)
            // The check for point equality is 2D only - Z values are ignored
            bool useIntPt1 = ei1.Distance > 0.0 || !ei1.Coordinate.Equals2D(lastSegStartPt);

            if (!useIntPt1)
            {
                npts--;
            }

            ICoordinate[] pts = new ICoordinate[npts];
            int           ipt = 0;

            pts[ipt++] = new Coordinate(ei0.Coordinate);
            for (int i = ei0.SegmentIndex + 1; i <= ei1.SegmentIndex; i++)
            {
                pts[ipt++] = edge.Points[i];
            }

            if (useIntPt1)
            {
                pts[ipt] = ei1.Coordinate;
            }
            return(new Edge(pts, new Label(edge.Label)));
        }
Пример #2
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="outstream"></param>
 public void Write(StreamWriter outstream)
 {
     outstream.WriteLine("Intersections:");
     for (IEnumerator it = GetEnumerator(); it.MoveNext();)
     {
         EdgeIntersection ei = (EdgeIntersection)it.Current;
         ei.Write(outstream);
     }
 }
 /// <summary> 
 /// Adds an intersection into the list, if it isn't already there.
 /// The input segmentIndex and dist are expected to be normalized.
 /// </summary>
 /// <param name="intPt"></param>
 /// <param name="segmentIndex"></param>
 /// <param name="dist"></param>
 /// <returns>The EdgeIntersection found or added.</returns>
 public EdgeIntersection Add(ICoordinate intPt, int segmentIndex, double dist)
 {
     EdgeIntersection eiNew = new EdgeIntersection(intPt, segmentIndex, dist);
     EdgeIntersection ei = (EdgeIntersection) nodeMap[eiNew];
     if (ei != null) 
         return ei;            
     nodeMap.Add(eiNew, eiNew);
     return eiNew;
 }
Пример #4
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="pt"></param>
 /// <returns></returns>
 public bool IsIntersection(ICoordinate pt)
 {
     for (IEnumerator it = GetEnumerator(); it.MoveNext();)
     {
         EdgeIntersection ei = (EdgeIntersection)it.Current;
         if (ei.Coordinate.Equals(pt))
         {
             return(true);
         }
     }
     return(false);
 }
Пример #5
0
        /// <summary>
        /// Adds an intersection into the list, if it isn't already there.
        /// The input segmentIndex and dist are expected to be normalized.
        /// </summary>
        /// <param name="intPt"></param>
        /// <param name="segmentIndex"></param>
        /// <param name="dist"></param>
        /// <returns>The EdgeIntersection found or added.</returns>
        public EdgeIntersection Add(ICoordinate intPt, int segmentIndex, double dist)
        {
            EdgeIntersection eiNew = new EdgeIntersection(intPt, segmentIndex, dist);
            EdgeIntersection ei    = (EdgeIntersection)nodeMap[eiNew];

            if (ei != null)
            {
                return(ei);
            }
            nodeMap[eiNew] = eiNew;
            return(eiNew);
        }
Пример #6
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="argIndex"></param>
 private void AddSelfIntersectionNodes(int argIndex)
 {
     for (IEnumerator i = edges.GetEnumerator(); i.MoveNext();)
     {
         Edge      e    = (Edge)i.Current;
         Locations eLoc = e.Label.GetLocation(argIndex);
         for (IEnumerator eiIt = e.EdgeIntersectionList.GetEnumerator(); eiIt.MoveNext();)
         {
             EdgeIntersection ei = (EdgeIntersection)eiIt.Current;
             AddSelfIntersectionNode(argIndex, ei.Coordinate, eLoc);
         }
     }
 }
Пример #7
0
        /// <summary>
        /// Creates new edges for all the edges that the intersections in this
        /// list split the parent edge into.
        /// Adds the edges to the input list (this is so a single list
        /// can be used to accumulate all split edges for a Geometry).
        /// </summary>
        /// <param name="edgeList"></param>
        public void AddSplitEdges(IList edgeList)
        {
            // ensure that the list has entries for the first and last point of the edge
            AddEndpoints();

            IEnumerator it = GetEnumerator();

            it.MoveNext();
            // there should always be at least two entries in the list
            EdgeIntersection eiPrev = (EdgeIntersection)it.Current;

            while (it.MoveNext())
            {
                EdgeIntersection ei      = (EdgeIntersection)it.Current;
                Edge             newEdge = CreateSplitEdge(eiPrev, ei);
                edgeList.Add(newEdge);

                eiPrev = ei;
            }
        }
Пример #8
0
        /// <summary>
        /// Create a EdgeStub for the edge before the intersection eiCurr.
        /// The previous intersection is provided
        /// in case it is the endpoint for the stub edge.
        /// Otherwise, the previous point from the parent edge will be the endpoint.
        /// eiCurr will always be an EdgeIntersection, but eiPrev may be null.
        /// </summary>
        /// <param name="edge"></param>
        /// <param name="l"></param>
        /// <param name="eiCurr"></param>
        /// <param name="eiPrev"></param>
        public void CreateEdgeEndForPrev(Edge edge, IList l, EdgeIntersection eiCurr, EdgeIntersection eiPrev)
        {
            int iPrev = eiCurr.SegmentIndex;
            if (eiCurr.Distance == 0.0) 
            {
                // if at the start of the edge there is no previous edge
                if (iPrev == 0)
                    return;
                iPrev--;
            }

            ICoordinate pPrev = edge.GetCoordinate(iPrev);
            // if prev intersection is past the previous vertex, use it instead
            if (eiPrev != null && eiPrev.SegmentIndex >= iPrev)
                pPrev = eiPrev.Coordinate;

            Label label = new Label(edge.Label);
            // since edgeStub is oriented opposite to it's parent edge, have to flip sides for edge label
            label.Flip();
            EdgeEnd e = new EdgeEnd(edge, eiCurr.Coordinate, pPrev, label);        
            l.Add(e);
        }
Пример #9
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public int CompareTo(object obj)
        {
            EdgeIntersection other = (EdgeIntersection)obj;

            return(Compare(other.SegmentIndex, other.Distance));
        }
Пример #10
0
        /// <summary>
        /// Create a StubEdge for the edge after the intersection eiCurr.
        /// The next intersection is provided
        /// in case it is the endpoint for the stub edge.
        /// Otherwise, the next point from the parent edge will be the endpoint.
        /// eiCurr will always be an EdgeIntersection, but eiNext may be null.
        /// </summary>
        /// <param name="edge"></param>
        /// <param name="l"></param>
        /// <param name="eiCurr"></param>
        /// <param name="eiNext"></param>
        public void CreateEdgeEndForNext(Edge edge, IList l, EdgeIntersection eiCurr, EdgeIntersection eiNext)
        {
            int iNext = eiCurr.SegmentIndex + 1;
            // if there is no next edge there is nothing to do            
            if (iNext >= edge.NumPoints && eiNext == null)          
                return;

            ICoordinate pNext = edge.GetCoordinate(iNext);
            // if the next intersection is in the same segment as the current, use it as the endpoint
            if (eiNext != null && eiNext.SegmentIndex == eiCurr.SegmentIndex)
                pNext = eiNext.Coordinate;

            EdgeEnd e = new EdgeEnd(edge, eiCurr.Coordinate, pNext, new Label(edge.Label));
            l.Add(e);
        }
Пример #11
0
        /// <summary>
        /// Create a new "split edge" with the section of points between
        /// (and including) the two intersections.
        /// The label for the new edge is the same as the label for the parent edge.
        /// </summary>
        /// <param name="ei0"></param>
        /// <param name="ei1"></param>
        public Edge CreateSplitEdge(EdgeIntersection ei0, EdgeIntersection ei1)
        {        
            int npts = ei1.SegmentIndex - ei0.SegmentIndex + 2;
            ICoordinate lastSegStartPt = edge.Points[ei1.SegmentIndex];
            // if the last intersection point is not equal to the its segment start pt,
            // add it to the points list as well.
            // (This check is needed because the distance metric is not totally reliable!)
            // The check for point equality is 2D only - Z values are ignored
            bool useIntPt1 = ei1.Distance > 0.0 || ! ei1.Coordinate.Equals2D(lastSegStartPt);
            if (! useIntPt1) 
                npts--;

            ICoordinate[] pts = new ICoordinate[npts];
            int ipt = 0;
            pts[ipt++] = new Coordinate(ei0.Coordinate);
            for (int i = ei0.SegmentIndex + 1; i <= ei1.SegmentIndex; i++) 
                pts[ipt++] = edge.Points[i];

            if (useIntPt1) 
                pts[ipt] = ei1.Coordinate;
            return new Edge(pts, new Label(edge.Label));
        }