/// <summary> /// Computes the noding for a collection of <see cref="ISegmentString" />s. /// Some Noders may add all these nodes to the input <see cref="ISegmentString" />s; /// others may only add some or none at all. /// </summary> /// <param name="inputSegmentStrings"></param> public void ComputeNodes(IList <ISegmentString> inputSegmentStrings) { _nodedSegStrings = inputSegmentStrings; _noder = new MCIndexNoder(); _pointSnapper = new MCIndexPointSnapper(_noder.Index); SnapRound(inputSegmentStrings, _li); }
/// <summary> /// Computes all interior intersections in the collection of <see cref="ISegmentString" />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 static IList<Coordinate> FindInteriorIntersections(IList<ISegmentString> segStrings, LineIntersector li) { InteriorIntersectionFinderAdder intFinderAdder = new InteriorIntersectionFinderAdder(li); SinglePassNoder noder = new MCIndexNoder(intFinderAdder); noder.ComputeNodes(segStrings); return intFinderAdder.InteriorIntersections; }
/// <summary> /// Computes the noding for a collection of <see cref="ISegmentString" />s. /// Some Noders may add all these nodes to the input <see cref="ISegmentString" />s; /// others may only add some or none at all. /// </summary> /// <param name="inputSegmentStrings"></param> public void ComputeNodes(IList<ISegmentString> inputSegmentStrings) { _nodedSegStrings = inputSegmentStrings; _noder = new MCIndexNoder(); _pointSnapper = new MCIndexPointSnapper(_noder.Index); SnapRound(inputSegmentStrings, _li); }
public static Geometry MCIndexNoding(Geometry geom) { INoder noder = new MCIndexNoder(new IntersectionAdder(new RobustLineIntersector())); noder.ComputeNodes(SegmentStringUtil.ExtractNodedSegmentStrings(geom)); return(SegmentStringUtil.ToGeometry(noder.GetNodedSubstrings(), geom.Factory)); }
/// <summary> /// Computes the noding for a collection of <see cref="SegmentString" />s. /// Some Noders may add all these nodes to the input <see cref="SegmentString" />s; /// others may only add some or none at all. /// </summary> /// <param name="inputSegmentStrings"></param> public void ComputeNodes(IList inputSegmentStrings) { this.nodedSegStrings = inputSegmentStrings; noder = new MCIndexNoder(); pointSnapper = new MCIndexPointSnapper(noder.MonotoneChains, noder.Index); SnapRound(inputSegmentStrings, li); }
/// <summary> /// Computes the noding for a collection of <see cref="SegmentString" />s. /// Some Noders may add all these nodes to the input <see cref="SegmentString" />s; /// others may only add some or none at all. /// </summary> /// <param name="inputSegmentStrings"></param> public void ComputeNodes(IList inputSegmentStrings) { this.nodedSegStrings = inputSegmentStrings; noder = new MCIndexNoder(); pointSnapper = new MCIndexPointSnapper(noder.MonotoneChains, noder.Index); SnapRound(inputSegmentStrings, li); }
/// <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> /// Computes all interior intersections in the collection of <see cref="ISegmentString" />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 static IList <Coordinate> FindInteriorIntersections(IList <ISegmentString> segStrings, LineIntersector li) { InteriorIntersectionFinderAdder intFinderAdder = new InteriorIntersectionFinderAdder(li); SinglePassNoder noder = new MCIndexNoder(intFinderAdder); noder.ComputeNodes(segStrings); return(intFinderAdder.InteriorIntersections); }
public static int InteriorIntersectionCount(Geometry geom) { var intCounter = NodingIntersectionFinder.CreateIntersectionCounter(new RobustLineIntersector()); INoder noder = new MCIndexNoder(intCounter); noder.ComputeNodes(SegmentStringUtil.ExtractNodedSegmentStrings(geom)); return(intCounter.Count); }
/// <summary> /// Computes all interior intersections in the collection of <see cref="ISegmentString" />s, /// and returns their <see cref="Coordinate" />s. /// <para/> /// Also adds the intersection nodes to the segments. /// </summary> /// <param name="segStrings"></param> /// <returns>A list of <see cref="Coordinate" />s for the intersections.</returns> private IList <Coordinate> FindInteriorIntersections(IList <ISegmentString> segStrings) { var intAdder = new SnapRoundingIntersectionAdder(_pm); var noder = new MCIndexNoder(); noder.SegmentIntersector = intAdder; noder.ComputeNodes(segStrings); return(intAdder.Intersections); }
/// <summary> /// Detects interior intersections in the collection of {@link SegmentString}s, /// and adds nodes for them to the segment strings. /// Also creates HotPixel nodes for the intersection points. /// </summary> /// <param name="segStrings">The input NodedSegmentStrings</param> private void AddIntersectionPixels(IList<ISegmentString> segStrings) { var intAdder = new SnapRoundingIntersectionAdder(_pm); var noder = new MCIndexNoder(intAdder); //noder.SegmentIntersector = intAdder; noder.ComputeNodes(segStrings); var intPts = intAdder.Intersections; _pixelIndex.AddNodes(intPts); }
public static IGeometry MCIndexNoding(Geometry geom) { IList <ISegmentString> segs = CreateNodedSegmentStrings(geom); INoder noder = new MCIndexNoder(new IntersectionAdder(new RobustLineIntersector())); noder.ComputeNodes(segs); IList <ISegmentString> nodedSegStrings = noder.GetNodedSubstrings(); return(FromSegmentStrings(nodedSegStrings)); }
public void ComputeNodes(IList inputSegmentStrings) { this.nodedSegStrings = inputSegmentStrings; noder = new MCIndexNoder(); pointSnapper = new MCIndexPointSnapper( noder.MonotoneChains, noder.Index); SnapRound(inputSegmentStrings, li); // testing purposes only - remove in final version //checkCorrectness(inputSegmentStrings); }
/// <summary> /// Computes all interior intersections in the collection of <see cref="ISegmentString"/>s, /// and returns their <see cref="NodedSegmentString"/>s. /// <para/> /// Also adds the intersection nodes to the segments. /// </summary> /// <returns>A list of noded substrings</returns> private IList <ISegmentString> ComputeIntersections(IList <ISegmentString> inputSS) { var intAdder = new SnappingIntersectionAdder(_snapTolerance, snapIndex); /* * Use an overlap tolerance to ensure all * possible snapped intersections are found */ var noder = new MCIndexNoder(intAdder, 2 * _snapTolerance); noder.ComputeNodes(inputSS); return(noder.GetNodedSubstrings()); }
public static Geometry MCIndexNodingWithPrecision(Geometry geom, double scaleFactor) { var fixedPM = new PrecisionModel(scaleFactor); LineIntersector li = new RobustLineIntersector(); li.PrecisionModel = fixedPM; INoder noder = new MCIndexNoder(new IntersectionAdder(li)); noder.ComputeNodes(SegmentStringUtil.ExtractNodedSegmentStrings(geom)); return(SegmentStringUtil.ToGeometry(noder.GetNodedSubstrings(), geom.Factory)); }
private INoder CreateNoder(PrecisionModel precisionModel) { if (workingNoder != null) return workingNoder; // otherwise use a fast (but non-robust) noder MCIndexNoder noder = new MCIndexNoder(); LineIntersector li = new RobustLineIntersector(); li.PrecisionModel = precisionModel; noder.SegmentIntersector = new IntersectionAdder(li); return noder; }
public static IGeometry MCIndexNodingWithPrecision(Geometry geom, double scaleFactor) { List <ISegmentString> segs = CreateNodedSegmentStrings(geom); LineIntersector li = new RobustLineIntersector(); li.PrecisionModel = new PrecisionModel(scaleFactor); INoder noder = new MCIndexNoder(new IntersectionAdder(li)); noder.ComputeNodes(segs); IList <ISegmentString> nodedSegStrings = noder.GetNodedSubstrings(); return(FromSegmentStrings(nodedSegStrings)); }
/// <summary> /// /// </summary> /// <param name="precisionModel"></param> /// <returns></returns> private INoder GetNoder(IPrecisionModel precisionModel) { if (workingNoder != null) { return(workingNoder); } // otherwise use a fast (but non-robust) noder LineIntersector li = new RobustLineIntersector(); li.PrecisionModel = precisionModel; MCIndexNoder noder = new MCIndexNoder(new IntersectionAdder(li)); return(noder); }
private static INoder CreateFloatingPrecisionNoder(bool doValidation) { var mcNoder = new MCIndexNoder(); var li = new RobustLineIntersector(); mcNoder.SegmentIntersector = new IntersectionAdder(li); INoder noder = mcNoder; if (doValidation) { noder = new ValidatingNoder(mcNoder); } return(noder); }
private INoder GetNoder(IPrecisionModel precisionModel) { if (_workingNoder != null) return _workingNoder; // otherwise use a fast (but non-robust) noder var noder = new MCIndexNoder(new IntersectionAdder(new RobustLineIntersector { PrecisionModel = precisionModel})); //var li = new RobustLineIntersector(); //li.PrecisionModel = precisionModel; //noder.SegmentIntersector = new IntersectionAdder(li); // Noder noder = new IteratedNoder(precisionModel); return noder; // Noder noder = new SimpleSnapRounder(precisionModel); // Noder noder = new MCIndexSnapRounder(precisionModel); // Noder noder = new ScaledNoder(new MCIndexSnapRounder(new PrecisionModel(1.0)), // precisionModel.getScale()); }
/** * Nodes a LineString and returns a List of Noded LineString's. Used to * repare auto-intersecting LineString and Polygons. This method cannot * process CoordinateSequence. The noding process is limited to 3d * geometries.<br/> * Preserves duplicate coordinates. * * @param coords coordinate array to be noded * @param gf geometryFactory to use * @return a list of noded LineStrings */ private ISet <LineString> nodeLineString(Coordinate[] coords, GeometryFactory gf) { MCIndexNoder noder = new MCIndexNoder(); noder.SegmentIntersector = new IntersectionAdder(new RobustLineIntersector()); List <ISegmentString> list = new (); list.Add(new NodedSegmentString(coords, null)); noder.ComputeNodes(list); List <LineString> lineStringList = new (); foreach (NetTopologySuite.Geometries.Geometry segmentString in noder.GetNodedSubstrings()) { lineStringList.Add(gf.CreateLineString( segmentString.Coordinates )); } // WARNING : merger loose original linestrings // It is useful for LinearRings but should not be used for (Multi)LineStrings LineMerger merger = new LineMerger(); merger.Add(lineStringList); lineStringList = (List <LineString>)merger.GetMergedLineStrings(); // Remove duplicate linestrings preserving main orientation ISet <LineString> lineStringSet = new HashSet <LineString>(); foreach (LineString line in lineStringList) { // TODO as equals makes a topological comparison, comparison with line.reverse maybe useless if (!lineStringSet.Contains(line) && !lineStringSet.Contains((LineString)line.Reverse())) { lineStringSet.Add(line); } } return(lineStringSet); }
private static void ProcessNodes(Geometry geom, NodingIntersectionFinder intFinder) { var noder = new MCIndexNoder(intFinder); noder.ComputeNodes(SegmentStringUtil.ExtractNodedSegmentStrings(geom)); }
/// <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; }