/// <summary> /// Creates stub edges for all the intersections in this /// Edge (if any) and inserts them into the graph. /// </summary> /// <param name="edge"></param> /// <param name="l"></param> public virtual void ComputeEdgeEnds(Edge edge, IList l) { EdgeIntersectionList eiList = edge.EdgeIntersectionList; // ensure that the list has entries for the first and last point of the edge eiList.AddEndpoints(); IEnumerator it = eiList.GetEnumerator(); EdgeIntersection eiCurr = null; // no intersections, so there is nothing to do if (!it.MoveNext()) { return; } EdgeIntersection eiNext = (EdgeIntersection)it.Current; do { EdgeIntersection eiPrev = eiCurr; eiCurr = eiNext; eiNext = null; if (it.MoveNext()) { eiNext = (EdgeIntersection)it.Current; } if (eiCurr != null) { CreateEdgeEndForPrev(edge, l, eiCurr, eiPrev); CreateEdgeEndForNext(edge, l, eiCurr, eiNext); } }while (eiCurr != null); }
/// <summary> /// /// </summary> /// <param name="pts"></param> /// <param name="label"></param> public Edge(IList<Coordinate> pts, Label label) { _eiList = new EdgeIntersectionList(this); _pts = pts; base.Label = label; }
/// <summary> /// Check that a ring does not self-intersect, except at its endpoints. /// Algorithm is to count the number of times each node along edge occurs. /// If any occur more than once, that must be a self-intersection. /// </summary> private void CheckNoSelfIntersectingRing(EdgeIntersectionList eiList) { ISet nodeSet = new HashedSet(); bool isFirst = true; for (IEnumerator i = eiList.Iterator(); i.MoveNext();) { EdgeIntersection ei = (EdgeIntersection)i.Current; if (isFirst) { isFirst = false; continue; } if (nodeSet.Contains(ei.coord)) { validErr = new ValidationError( ValidationErrorType.RingSelfIntersection, ei.coord); return; } else { nodeSet.Add(ei.coord); } } }
/// <summary> /// Check that a ring does not self-intersect, except at its endpoints. /// Algorithm is to count the number of times each node along edge occurs. /// If any occur more than once, that must be a self-intersection. /// </summary> /// <param name="eiList"></param> private void CheckSelfIntersectingRing(EdgeIntersectionList eiList) { //Set nodeSet = new TreeSet(); awc don't need sorted list, just a hashtable Hashtable nodeSet = new Hashtable(); bool isFirst = true; //for (Iterator i = eiList.iterator(); i.hasNext(); ) foreach (EdgeIntersection ei in eiList) { //EdgeIntersection ei = (EdgeIntersection) i.next(); if (isFirst) { isFirst = false; continue; } if (nodeSet.Contains(ei.Coordinate)) { _validErr = new TopologyValidationError( TopologyValidationError.RingSelfIntersection, ei.Coordinate); return; } else { //TODO: awc - should probably use hashcode nodeSet.Add(ei.Coordinate, ei.Coordinate); } } }
/// <summary> /// Find a point from the list of testCoords /// that is NOT a node in the edge for the list of searchCoords. /// </summary> /// <param name="testCoords"></param> /// <param name="searchRing"></param> /// <param name="graph"></param> /// <returns>The point found, or <c>null</c> if none found.</returns> public static ICoordinate FindPointNotNode(ICoordinate[] testCoords, ILinearRing searchRing, GeometryGraph graph) { // find edge corresponding to searchRing. Edge searchEdge = graph.FindEdge(searchRing); // find a point in the testCoords which is not a node of the searchRing EdgeIntersectionList eiList = searchEdge.EdgeIntersectionList; // somewhat inefficient - is there a better way? (Use a node map, for instance?) foreach (ICoordinate pt in testCoords) { if (!eiList.IsIntersection(pt)) { return(pt); } } return(null); }
/// <summary> /// Find a point from the list of testCoords /// that is NOT a node in the edge for the list of searchCoords /// </summary> /// <returns> the point found, or null if none found /// </returns> internal static Coordinate FindPointNotNode(ICoordinateList testCoords, LinearRing searchRing, GeometryGraph graph) { // find edge corresponding to searchRing. Edge searchEdge = graph.FindEdge(searchRing); // find a point in the testCoords which is not a node of the searchRing EdgeIntersectionList eiList = searchEdge.EdgeIntersectionList; // somewhat inefficient - is there a better way? (Use a node map, for instance?) for (int i = 0; i < testCoords.Count; i++) { Coordinate pt = testCoords[i]; if (!eiList.IsIntersection(pt)) { return(pt); } } return(null); }
/// <summary> /// Check that a ring does not self-intersect, except at its endpoints. /// Algorithm is to count the number of times each node along edge occurs. /// If any occur more than once, that must be a self-intersection. /// </summary> private void CheckNoSelfIntersectingRing(EdgeIntersectionList eiList) { var nodeSet = new HashSet <Coordinate>(); bool isFirst = true; foreach (EdgeIntersection ei in eiList) { if (isFirst) { isFirst = false; continue; } if (nodeSet.Contains(ei.Coordinate)) { _validErr = new TopologyValidationError(TopologyValidationErrorType.RingSelfIntersection, ei.Coordinate); return; } nodeSet.Add(ei.Coordinate); } }
} // public ArrayList ComputeEdgeEnds( ArrayList edges ) /// <summary> /// Creates stub edges for all the intersections in this Edge (if any) and inserts them into the graph. /// </summary> /// <param name="edge"></param> /// <param name="list"></param> public void ComputeEdgeEnds(Edge edge, ArrayList list) { EdgeIntersectionList eiList = edge.EdgeIntersectionList; //Trace.WriteLine( eiList.ToString() ); // ensure that the list has entries for the first and last point of the edge if (!edge.IsClosed) { eiList.AddEndpoints(); } EdgeIntersection eiPrev = null; EdgeIntersection eiCurr = null; // no intersections, so there is nothing to do if (eiList.IsEmpty()) { return; // return if the list is empty } int index = 0; // index of eiList array. EdgeIntersection eiNext = eiList[index]; // gets the first intersection do { index++; eiPrev = eiCurr; // previouse one or null for first loop eiCurr = eiNext; // current one or the first one eiNext = null; if (index < eiList.Count) { eiNext = eiList[index]; // if there are more } if (eiCurr != null) { CreateEdgeEndForPrev(edge, list, eiCurr, eiPrev); CreateEdgeEndForNext(edge, list, eiCurr, eiNext); } } while (eiCurr != null); } // public void ComputeEdgeEnds( Edge edge, ArrayList l )
/// <summary> /// Check that a ring does not self-intersect, except at its endpoints. /// Algorithm is to count the number of times each node along edge occurs. /// If any occur more than once, that must be a self-intersection. /// </summary> private void CheckNoSelfIntersectingRing(EdgeIntersectionList eiList) { ISet nodeSet = new ListSet(); bool isFirst = true; foreach(EdgeIntersection ei in eiList) { if (isFirst) { isFirst = false; continue; } if (nodeSet.Contains(ei.Coordinate)) { _validErr = new TopologyValidationError(TopologyValidationErrors.RingSelfIntersection, ei.Coordinate); return; } nodeSet.Add(ei.Coordinate); } }