/// <summary> /// /// </summary> /// <param name="precisionModel"></param> /// <param name="quadrantSegments"></param> public OffsetCurveBuilder(IPrecisionModel precisionModel, int quadrantSegments) { this.precisionModel = precisionModel; // compute intersections in full precision, to provide accuracy // the points are rounded as they are inserted into the curve line li = new RobustLineIntersector(); var limitedQuadSegs = quadrantSegments < 1 ? 1 : quadrantSegments; filletAngleQuantum = Math.PI / 2.0 / limitedQuadSegs; }
/// <summary> /// Initializes a new instance of the <see cref="HotPixel"/> class. /// </summary> /// <param name="pt"></param> /// <param name="scaleFactor"></param> /// <param name="li"></param> public HotPixel(ICoordinate pt, double scaleFactor, LineIntersector li) { originalPt = pt; this.pt = pt; this.scaleFactor = scaleFactor; this.li = li; if (scaleFactor != 1.0) { this.pt = new Coordinate(Scale(pt.X), Scale(pt.Y)); p0Scaled = new Coordinate(); p1Scaled = new Coordinate(); } InitCorners(this.pt); }
/// <summary> /// Computes all interior intersections in the collection of <see cref="SegmentString" />s, /// and returns their <see cref="Coordinate" />s. /// /// Does NOT node the segStrings. /// </summary> /// <param name="segStrings"></param> /// <param name="li"></param> /// <returns>A list of Coordinates for the intersections.</returns> private IList FindInteriorIntersections(IList segStrings, LineIntersector li) { IntersectionFinderAdder intFinderAdder = new IntersectionFinderAdder(li); noder.SegmentIntersector = intFinderAdder; noder.ComputeNodes(segStrings); return intFinderAdder.InteriorIntersections; }
/// <summary> /// Computes all interior intersections in the collection of <see cref="SegmentString" />s, /// and returns their <see cref="Coordinate" />s. /// Does NOT node the segStrings. /// </summary> /// <param name="segStrings"></param> /// <param name="li"></param> /// <returns>A list of <see cref="Coordinate" />s for the intersections.</returns> private IList FindInteriorIntersections(IList segStrings, LineIntersector li) { IntersectionFinderAdder intFinderAdder = new IntersectionFinderAdder(li); SinglePassNoder noder = new MCIndexNoder(intFinderAdder); noder.ComputeNodes(segStrings); return intFinderAdder.InteriorIntersections; }
/// <summary> /// Initializes a new instance of the <see cref="IteratedNoder"/> class. /// </summary> /// <param name="pm"></param> public IteratedNoder(PrecisionModel pm) { li = new RobustLineIntersector(); li.PrecisionModel = pm; }
/// <summary> /// Initializes a new instance of the <see cref="IntersectionAdder"/> class. /// </summary> /// <param name="li"></param> public IntersectionAdder(LineIntersector li) { this.li = li; }
/// <summary> /// /// </summary> /// <param name="li"></param> /// <param name="includeProper"></param> /// <param name="recordIsolated"></param> public SegmentIntersector(LineIntersector li, bool includeProper, bool recordIsolated) { this.li = li; this.includeProper = includeProper; this.recordIsolated = recordIsolated; }
/// <summary> /// /// </summary> /// <param name="li"></param> /// <param name="p0"></param> /// <param name="p1"></param> /// <returns><c>true</c> if there is an intersection point which is not an endpoint of the segment p0-p1.</returns> private bool HasInteriorIntersection(LineIntersector li, ICoordinate p0, ICoordinate p1) { for (int i = 0; i < li.IntersectionNum; i++) { ICoordinate intPt = li.GetIntersection(i); if (!(intPt.Equals(p0) || intPt.Equals(p1))) return true; } return false; }
/// <summary> /// /// </summary> /// <param name="li"></param> /// <param name="bdyNodes"></param> /// <returns></returns> private bool IsBoundaryPoint(LineIntersector li, ICollection[] bdyNodes) { if (bdyNodes == null) return false; if (IsBoundaryPoint(li, bdyNodes[0])) return true; if (IsBoundaryPoint(li, bdyNodes[1])) return true; return false; }
/// <summary> /// /// </summary> /// <param name="li"></param> /// <param name="bdyNodes"></param> /// <returns></returns> private bool IsBoundaryPoint(LineIntersector li, ICollection bdyNodes) { for (IEnumerator i = bdyNodes.GetEnumerator(); i.MoveNext(); ) { Node node = (Node) i.Current; ICoordinate pt = node.Coordinate; if (li.IsIntersection(pt)) return true; } return false; }
/// <summary> /// Creates an intersection finder which finds all proper intersections. /// </summary> /// <param name="li">The <see cref="LineIntersector" /> to use.</param> public IntersectionFinderAdder(LineIntersector li) { this.li = li; interiorIntersections = new ArrayList(); }
/// <summary> /// /// </summary> /// <param name="g"></param> /// <param name="li"></param> /// <param name="includeProper"></param> /// <returns></returns> public SegmentIntersector ComputeEdgeIntersections(GeometryGraph g, LineIntersector li, bool includeProper) { SegmentIntersector si = new SegmentIntersector(li, includeProper, true); si.SetBoundaryNodes(BoundaryNodes, g.BoundaryNodes); EdgeSetIntersector esi = CreateEdgeSetIntersector(); esi.ComputeIntersections(edges, g.edges, si); return si; }
/// <summary> /// Compute self-nodes, taking advantage of the Geometry type to /// minimize the number of intersection tests. (E.g. rings are /// not tested for self-intersection, since they are assumed to be valid). /// </summary> /// <param name="li">The <c>LineIntersector</c> to use.</param> /// <param name="computeRingSelfNodes">If <c>false</c>, intersection checks are optimized to not test rings for self-intersection.</param> /// <returns>The SegmentIntersector used, containing information about the intersections found.</returns> public SegmentIntersector ComputeSelfNodes(LineIntersector li, bool computeRingSelfNodes) { SegmentIntersector si = new SegmentIntersector(li, true, false); EdgeSetIntersector esi = CreateEdgeSetIntersector(); // optimized test for Polygons and Rings if (!computeRingSelfNodes && (parentGeom is ILinearRing || parentGeom is IPolygon || parentGeom is IMultiPolygon)) esi.ComputeIntersections(edges, si, false); else esi.ComputeIntersections(edges, si, true); AddSelfIntersectionNodes(argIndex); return si; }
/// <summary> /// Initializes a new instance of the <see cref="MCIndexSnapRounder"/> class. /// </summary> /// <param name="pm">The <see cref="PrecisionModel" /> to use.</param> public MCIndexSnapRounder(PrecisionModel pm) { li = new RobustLineIntersector(); li.PrecisionModel = pm; scaleFactor = pm.Scale; }
/// <summary> /// Adds EdgeIntersections for one or both /// intersections found for a segment of an edge to the edge intersection list. /// </summary> /// <param name="li"></param> /// <param name="segmentIndex"></param> /// <param name="geomIndex"></param> public void AddIntersections(LineIntersector li, int segmentIndex, int geomIndex) { for (var i = 0; i < li.IntersectionNum; i++) AddIntersection(li, segmentIndex, geomIndex, i); }
/// <summary> /// /// </summary> /// <param name="segStrings"></param> /// <param name="li"></param> private void SnapRound(IList segStrings, LineIntersector li) { IList intersections = FindInteriorIntersections(segStrings, li); ComputeIntersectionSnaps(intersections); ComputeVertexSnaps(segStrings); }
/// <summary> /// Add an EdgeIntersection for intersection intIndex. /// An intersection that falls exactly on a vertex of the edge is normalized /// to use the higher of the two possible segmentIndexes. /// </summary> /// <param name="li"></param> /// <param name="segmentIndex"></param> /// <param name="geomIndex"></param> /// <param name="intIndex"></param> public void AddIntersection(LineIntersector li, int segmentIndex, int geomIndex, int intIndex) { ICoordinate intPt = new Coordinate(li.GetIntersection(intIndex)); var normalizedSegmentIndex = segmentIndex; var dist = li.GetEdgeDistance(geomIndex, intIndex); // normalize the intersection point location var nextSegIndex = normalizedSegmentIndex + 1; if (nextSegIndex < Points.Length) { var nextPt = Points[nextSegIndex]; // Normalize segment index if intPt falls on vertex // The check for point equality is 2D only - Z values are ignored if (intPt.Equals2D(nextPt)) { normalizedSegmentIndex = nextSegIndex; dist = 0.0; } // Add the intersection point to edge intersection list. EdgeIntersectionList.Add(intPt, normalizedSegmentIndex, dist); } }
/// <summary> /// /// </summary> /// <param name="li"></param> public EdgeSetNoder(LineIntersector li) { this.li = li; }
/// <summary> /// Add an <see cref="SegmentNode" /> for intersection intIndex. /// An intersection that falls exactly on a vertex /// of the <see cref="SegmentString" /> is normalized /// to use the higher of the two possible segmentIndexes. /// </summary> /// <param name="li"></param> /// <param name="segmentIndex"></param> /// <param name="geomIndex"></param> /// <param name="intIndex"></param> public void AddIntersection(LineIntersector li, int segmentIndex, int geomIndex, int intIndex) { ICoordinate intPt = new Coordinate(li.GetIntersection(intIndex)); AddIntersection(intPt, segmentIndex); }