/// <summary> /// Performs a brute-force comparison of every segment in each <see cref="SegmentString" />. /// This has n^2 performance. /// </summary> /// <param name="e0"></param> /// <param name="e1"></param> private void ComputeVertexSnaps(SegmentString e0, SegmentString e1) { ICoordinate[] pts0 = e0.Coordinates; ICoordinate[] pts1 = e1.Coordinates; for (int i0 = 0; i0 < pts0.Length - 1; i0++) { HotPixel hotPixel = new HotPixel(pts0[i0], scaleFactor, li); for (int i1 = 0; i1 < pts1.Length - 1; i1++) { // don't snap a vertex to itself if (e0 == e1) { if (i0 == i1) { continue; } } bool isNodeAdded = AddSnappedNode(hotPixel, e1, i1); // if a node is created for a vertex, that vertex must be noded too if (isNodeAdded) { e0.AddIntersection(pts0[i0], i0); } } } }
/// <summary> /// Snaps (nodes) all interacting segments to this hot pixel. /// The hot pixel may represent a vertex of an edge, /// in which case this routine uses the optimization /// of not noding the vertex itself /// </summary> /// <param name="hotPixel">The hot pixel to snap to.</param> /// <param name="parentEdge">The edge containing the vertex, if applicable, or <c>null</c>.</param> /// <param name="vertexIndex"></param> /// <returns><c>true</c> if a node was added for this pixel.</returns> public bool Snap(HotPixel hotPixel, SegmentString parentEdge, int vertexIndex) { Envelope pixelEnv = hotPixel.GetSafeEnvelope(); HotPixelSnapAction hotPixelSnapAction = new HotPixelSnapAction(hotPixel, parentEdge, vertexIndex); _index.Query(pixelEnv, new QueryVisitor(pixelEnv, hotPixelSnapAction)); return hotPixelSnapAction.IsNodeAdded; }
/// <summary> /// Computes nodes introduced as a result of /// snapping segments to vertices of other segments. /// </summary> /// <param name="edges"></param> public void ComputeVertexSnaps(IList edges) { foreach (object obj in edges) { SegmentString edge0 = (SegmentString)obj; ComputeVertexSnaps(edge0); } }
/// <summary> /// Computes nodes introduced as a result of snapping segments /// to snap points (hot pixels). /// </summary> /// <param name="li"> /// </param> private void ComputeSnaps(IList segStrings, IList snapPts) { for (IEnumerator i0 = segStrings.GetEnumerator(); i0.MoveNext();) { SegmentString ss = (SegmentString)i0.Current; ComputeSnaps(ss, snapPts); } }
/// <summary> /// Computes nodes introduced as a result of snapping segments to snap points (hot pixels). /// </summary> /// <param name="segStrings"></param> /// <param name="snapPts"></param> private void ComputeSnaps(IList segStrings, IList snapPts) { foreach (object obj in segStrings) { SegmentString ss = (SegmentString)obj; ComputeSnaps(ss, snapPts); } }
/// <summary> /// Computes nodes introduced as a result of snapping segments to /// vertices of other segments. /// </summary> /// <param name="segStrings"> /// The list of segment strings to snap together. /// </param> public void ComputeVertexSnaps(IList edges) { for (IEnumerator i0 = edges.GetEnumerator(); i0.MoveNext();) { SegmentString edge0 = (SegmentString)i0.Current; ComputeVertexSnaps(edge0); } }
/// <summary> /// Snaps (nodes) all interacting segments to this hot pixel. /// The hot pixel may represent a vertex of an edge, /// in which case this routine uses the optimization /// of not noding the vertex itself /// </summary> /// <param name="hotPixel">The hot pixel to snap to.</param> /// <param name="parentEdge">The edge containing the vertex, if applicable, or <c>null</c>.</param> /// <param name="vertexIndex"></param> /// <returns><c>true</c> if a node was added for this pixel.</returns> public bool Snap(HotPixel hotPixel, SegmentString parentEdge, int vertexIndex) { IEnvelope pixelEnv = hotPixel.GetSafeEnvelope(); HotPixelSnapAction hotPixelSnapAction = new HotPixelSnapAction(hotPixel, parentEdge, vertexIndex); index.Query(pixelEnv, new QueryVisitor(pixelEnv, hotPixelSnapAction)); return(hotPixelSnapAction.IsNodeAdded); }
public HotPixelSnapAction(MCIndexPointSnapper pointSnapper, HotPixel hotPixel, SegmentString parentEdge, int vertexIndex) { this.enclosingInstance = pointSnapper; this.hotPixel = hotPixel; this.parentEdge = parentEdge; this.vertexIndex = vertexIndex; }
/// <summary> /// /// </summary> /// <param name="inputSegmentStrings"></param> private void CheckCorrectness(IList inputSegmentStrings) { IList resultSegStrings = SegmentString.GetNodedSubstrings(inputSegmentStrings); NodingValidator nv = new NodingValidator(resultSegStrings); try { nv.CheckValid(); } catch (Exception ex) { Trace.WriteLine(ex.ToString()); } }
/// <summary> /// /// </summary> /// <param name="ss"></param> /// <param name="snapPts"></param> private void ComputeSnaps(SegmentString ss, IList snapPts) { foreach (ICoordinate snapPt in snapPts) { HotPixel hotPixel = new HotPixel(snapPt, scaleFactor, li); for (int i = 0; i < ss.Count - 1; i++) { AddSnappedNode(hotPixel, ss, i); } } }
/// <summary> /// Snaps (nodes) all interacting segments to this hot pixel. /// The hot pixel may represent a vertex of an edge, /// in which case this routine uses the optimization /// of not noding the vertex itself /// /// </summary> /// <param name="hotPixel">the hot pixel to snap to /// </param> /// <param name="parentEdge">the edge containing the vertex, if applicable, or <code>null</code> /// </param> /// <param name="vertexIndex">the index of the vertex, if applicable, or -1 /// </param> /// <returns> <see langword="true"/> if a node was added for this pixel /// </returns> public bool Snap(HotPixel hotPixel, SegmentString parentEdge, int vertexIndex) { Envelope pixelEnv = hotPixel.SafeEnvelope; HotPixelSnapAction hotPixelSnapAction = new HotPixelSnapAction( this, hotPixel, parentEdge, vertexIndex); index.Query(pixelEnv, new PointSnapperItemVisitor(pixelEnv, hotPixelSnapAction, this)); return(hotPixelSnapAction.NodeAdded); }
/// <summary> /// Creates a {SegmentString} for a coordinate list which is a raw offset curve, /// and adds it to the list of buffer curves. /// The SegmentString is tagged with a Label giving the topology of the curve. /// The curve may be oriented in either direction. /// If the curve is oriented CW, the locations will be: /// Left: Location.Exterior. /// Right: Location.Interior. /// </summary> private void AddCurve(ICoordinate[] coord, Locations leftLoc, Locations rightLoc) { // don't add null curves! if (coord.Length < 2) { return; } // add the edge for a coordinate list which is a raw offset curve var e = new SegmentString(coord, new Label(0, Locations.Boundary, leftLoc, rightLoc)); curveList.Add(e); }
/// <summary> /// Adds a new node (equal to the snap pt) to the segment /// if the segment passes through the hot pixel. /// </summary> /// <param name="hotPix"></param> /// <param name="segStr"></param> /// <param name="segIndex"></param> /// <returns></returns> public static bool AddSnappedNode(HotPixel hotPix, SegmentString segStr, int segIndex) { ICoordinate p0 = segStr.GetCoordinate(segIndex); ICoordinate p1 = segStr.GetCoordinate(segIndex + 1); if (hotPix.Intersects(p0, p1)) { segStr.AddIntersection(hotPix.Coordinate, segIndex); return true; } return false; }
/// <summary> /// Adds a new node (equal to the snap pt) to the segment /// if the segment passes through the hot pixel. /// </summary> /// <param name="hotPix"></param> /// <param name="segStr"></param> /// <param name="segIndex"></param> /// <returns></returns> public static bool AddSnappedNode(HotPixel hotPix, SegmentString segStr, int segIndex) { ICoordinate p0 = segStr.GetCoordinate(segIndex); ICoordinate p1 = segStr.GetCoordinate(segIndex + 1); if (hotPix.Intersects(p0, p1)) { segStr.AddIntersection(hotPix.Coordinate, segIndex); return(true); } return(false); }
private void ComputeSnaps(SegmentString ss, IList snapPts) { for (IEnumerator it = snapPts.GetEnumerator(); it.MoveNext();) { Coordinate snapPt = (Coordinate)it.Current; HotPixel hotPixel = new HotPixel(snapPt, scaleFactor, li); for (int i = 0; i < ss.Count - 1; i++) { AddSnappedNode(hotPixel, ss, i); } } }
/// <summary> /// Computes nodes introduced as a result of /// snapping segments to vertices of other segments. /// </summary> /// <param name="edges"></param> public void ComputeVertexSnaps(IList edges) { foreach (object obj0 in edges) { SegmentString edge0 = (SegmentString)obj0; foreach (object obj1 in edges) { SegmentString edge1 = (SegmentString)obj1; ComputeVertexSnaps(edge0, edge1); } } }
/// <summary> /// Creates a {SegmentString} for a coordinate list which is a raw offset curve, /// and adds it to the list of buffer curves. /// The SegmentString is tagged with a Label giving the topology of the curve. /// The curve may be oriented in either direction. /// If the curve is oriented CW, the locations will be: /// Left: Location.Exterior. /// Right: Location.Interior. /// </summary> private void AddCurve(IList <Coordinate> coord, LocationType leftLoc, LocationType rightLoc) { // don't add null curves! if (coord.Count < 2) { return; } // add the edge for a coordinate list which is a raw offset curve SegmentString e = new SegmentString(coord, new Label(0, LocationType.Boundary, leftLoc, rightLoc)); _curveList.Add(e); }
/// <summary> /// /// </summary> /// <param name="ss"></param> /// <param name="snapPts"></param> private void ComputeSnaps(SegmentString ss, IList snapPts) { foreach (object objo in snapPts) { Coordinate snapPt = (Coordinate)objo; HotPixel hotPixel = new HotPixel(snapPt, _scaleFactor, _li); for (int i = 0; i < ss.Count - 1; i++) { AddSnappedNode(hotPixel, ss, i); } } }
private void AddCurve(ICoordinateList coords, int leftLoc, int rightLoc) { // don't Add null curves! if (coords.Count < 2) { return; } // Add the edge for a coordinate list which is a raw offset curve SegmentString e = new SegmentString(coords, new Label(0, LocationType.Boundary, leftLoc, rightLoc)); curveList.Add(e); }
/// <summary> /// Performs a brute-force comparison of every segment in each <see cref="SegmentString" />. /// This has n^2 performance. /// </summary> /// <param name="e"></param> private void ComputeVertexSnaps(SegmentString e) { ICoordinate[] pts0 = e.Coordinates; for (int i = 0; i < pts0.Length - 1; i++) { HotPixel hotPixel = new HotPixel(pts0[i], scaleFactor, li); bool isNodeAdded = pointSnapper.Snap(hotPixel, e, i); // if a node is created for a vertex, that vertex must be noded too if (isNodeAdded) { e.AddIntersection(pts0[i], i); } } }
/// <summary> /// /// </summary> /// <param name="mc"></param> /// <param name="startIndex"></param> public override void Select(MonotoneChain mc, int startIndex) { SegmentString ss = (SegmentString)mc.Context; // don't snap a vertex to itself if (parentEdge != null) { if (ss == parentEdge && startIndex == vertexIndex) { return; } } isNodeAdded = SimpleSnapRounder.AddSnappedNode(hotPixel, ss, startIndex); }
/// <summary> /// Creates a <see cref="SegmentString"/> for a coordinate list which is a raw offset curve, /// and adds it to the list of Buffer curves. /// The SegmentString is tagged with a Label giving the topology of the curve. /// The curve may be oriented in either direction. /// If the curve is oriented CW, the locations will be: /// <list type="bullet"> /// <item> /// <description> /// Left: LocationType.Exterior /// </description> /// </item> /// <item> /// <description> /// Right: LocationType.Interior /// </description> /// </item> /// </list> /// </summary> private void AddCurve(Coordinate[] coord, int leftLoc, int rightLoc) { // don't Add null curves! if (coord.Length < 2) { return; } // Add the edge for a coordinate list which is a raw offset curve SegmentString e = new SegmentString(new CoordinateCollection(coord), new Label(0, LocationType.Boundary, leftLoc, rightLoc)); curveList.Add(e); }
private void CheckCorrectness(IList inputSegmentStrings) { IList resultSegStrings = SegmentString.GetNodedSubstrings(inputSegmentStrings); NodingValidator nv = new NodingValidator(resultSegStrings); try { nv.CheckValid(); } catch (Exception ex) { ExceptionManager.Publish(ex); } }
/// <summary> /// /// </summary> /// <param name="bufferSegStrList"></param> /// <param name="precisionModel"></param> private void ComputeNodedEdges(IList bufferSegStrList, IPrecisionModel precisionModel) { INoder noder = GetNoder(precisionModel); noder.ComputeNodes(bufferSegStrList); IList nodedSegStrings = noder.GetNodedSubstrings(); foreach (object obj in nodedSegStrings) { SegmentString segStr = (SegmentString)obj; Label oldLabel = (Label)segStr.Data; Edge edge = new Edge(segStr.Coordinates, new Label(oldLabel)); InsertEdge(edge); } }
private void ComputeNodedEdges(IList bufferSegStrList, PrecisionModel precisionModel) { INoder noder = CreateNoder(precisionModel); noder.ComputeNodes(bufferSegStrList); IList nodedSegStrings = noder.NodedSubstrings; int nCount = nodedSegStrings.Count; for (int i = 0; i < nCount; i++) { SegmentString segStr = (SegmentString)nodedSegStrings[i]; Label oldLabel = (Label)segStr.Data; Edge edge = new Edge(segStr.Coordinates, new Label(oldLabel)); InsertEdge(edge); } }
/// <summary> /// Initializes a new instance of the <see cref="HotPixelSnapAction"/> class. /// </summary> /// <param name="hotPixel"></param> /// <param name="parentEdge"></param> /// <param name="vertexIndex"></param> public HotPixelSnapAction(HotPixel hotPixel, SegmentString parentEdge, int vertexIndex) { _hotPixel = hotPixel; _parentEdge = parentEdge; _vertexIndex = vertexIndex; }
/// <summary> /// /// </summary> /// <param name="ss"></param> /// <param name="snapPts"></param> private void ComputeSnaps(SegmentString ss, IList snapPts) { foreach (object objo in snapPts) { Coordinate snapPt = (Coordinate)objo; HotPixel hotPixel = new HotPixel(snapPt, _scaleFactor, _li); for (int i = 0; i < ss.Count - 1; i++) AddSnappedNode(hotPixel, ss, i); } }
/// <summary> /// Initializes a new instance of the <see cref="HotPixelSnapAction"/> class. /// </summary> /// <param name="hotPixel"></param> /// <param name="parentEdge"></param> /// <param name="vertexIndex"></param> public HotPixelSnapAction(HotPixel hotPixel, SegmentString parentEdge, int vertexIndex) { this.hotPixel = hotPixel; this.parentEdge = parentEdge; this.vertexIndex = vertexIndex; }
/// <summary> /// Returns a <see cref="IList"/> of fully noded <see cref="SegmentString"/>s. /// The <see cref="SegmentString"/>s have the same context as their parent. /// </summary> /// <returns></returns> public IList GetNodedSubstrings() { return(SegmentString.GetNodedSubstrings(nodedSegStrings)); }
/// <summary> /// /// </summary> /// <param name="ss"></param> /// <param name="snapPts"></param> private void ComputeSnaps(SegmentString ss, IList snapPts) { foreach (ICoordinate snapPt in snapPts) { HotPixel hotPixel = new HotPixel(snapPt, scaleFactor, li); for (int i = 0; i < ss.Count - 1; i++) AddSnappedNode(hotPixel, ss, i); } }
/// <summary> /// Performs a brute-force comparison of every segment in each <see cref="SegmentString" />. /// This has n^2 performance. /// </summary> /// <param name="e0"></param> /// <param name="e1"></param> private void ComputeVertexSnaps(SegmentString e0, SegmentString e1) { ICoordinate[] pts0 = e0.Coordinates; ICoordinate[] pts1 = e1.Coordinates; for (int i0 = 0; i0 < pts0.Length - 1; i0++) { HotPixel hotPixel = new HotPixel(pts0[i0], scaleFactor, li); for (int i1 = 0; i1 < pts1.Length - 1; i1++) { // don't snap a vertex to itself if (e0 == e1) if (i0 == i1) continue; bool isNodeAdded = AddSnappedNode(hotPixel, e1, i1); // if a node is created for a vertex, that vertex must be noded too if (isNodeAdded) e0.AddIntersection(pts0[i0], i0); } } }
/// <summary> /// Performs a brute-force comparison of every segment in each <see cref="SegmentString" />. /// This has n^2 performance. /// </summary> /// <param name="e"></param> private void ComputeVertexSnaps(SegmentString e) { ICoordinate[] pts0 = e.Coordinates; for(int i = 0; i < pts0.Length - 1; i++) { HotPixel hotPixel = new HotPixel(pts0[i], scaleFactor, li); bool isNodeAdded = pointSnapper.Snap(hotPixel, e, i); // if a node is created for a vertex, that vertex must be noded too if (isNodeAdded) e.AddIntersection(pts0[i], i); } }