public static Geometry ToLines(Geometry g1, Geometry g2) { var geoms = FunctionsUtil.BuildGeometry(g1, g2); return(FunctionsUtil.GetFactoryOrDefault(new[] { g1, g2 }) .BuildGeometry(LinearComponentExtracter.GetLines(geoms))); }
private static Geometry polygonize(Geometry g, bool extractOnlyPolygonal) { var lines = LinearComponentExtracter.GetLines(g); var polygonizer = new Polygonizer(extractOnlyPolygonal); polygonizer.Add(lines); return(polygonizer.GetGeometry()); }
private void Init(IGeometry geom) { var lines = LinearComponentExtracter.GetLines(geom); foreach (ILineString line in lines) { Coordinate[] pts = line.Coordinates; AddLine(pts); } }
/// <summary> /// Gets the computed offset points. /// </summary> public List<Coordinate> GetPoints(double offsetDistance) { var offsetPts = new List<Coordinate>(); var lines = LinearComponentExtracter.GetLines(_g); foreach (ILineString line in lines) ExtractPoints(line, offsetDistance, offsetPts); //System.out.println(toMultiPoint(offsetPts)); return offsetPts; }
private static List <ISegmentString> CreateSegmentStrings(Geometry geom) { var segs = new List <ISegmentString>(); var lines = LinearComponentExtracter.GetLines(geom); foreach (LineString line in lines) { segs.Add(new BasicSegmentString(line.Coordinates, null)); } return(segs); }
private static IEnumerable <IGeometry> ExtractLines(IEnumerable <IGeometry> geoms) { var lines = new List <IGeometry>(); var lce = new LinearComponentExtracter(lines); foreach (var geom in geoms) { geom.Apply(lce); } return(lines); }
private static IList <Segment> CreateConstraintSegments(IGeometry geom) { ICollection <IGeometry> lines = LinearComponentExtracter.GetLines(geom); List <Segment> constraintSegs = new List <Segment>(); foreach (IGeometry line in lines) { CreateConstraintSegments((ILineString)line, constraintSegs); } return(constraintSegs); }
///<summary> /// Extracts all linear components from a given <see cref="IGeometry"/> /// to <see cref="ISegmentString"/>s. /// The <see cref="ISegmentString"/> data item is set to be the source <see cref="IGeometry"/>. /// </summary> /// <param name="geom">The <see cref="IGeometry"/> to extract from.</param> /// <returns>a list of <see cref="ISegmentString"/>s.</returns> public static IList <ISegmentString> ExtractNodedSegmentStrings(IGeometry geom) { var segStr = new List <ISegmentString>(); var lines = LinearComponentExtracter.GetLines(geom); foreach (IGeometry line in lines) { Coordinate[] pts = line.Coordinates; segStr.Add(new NodedSegmentString(pts, geom)); } return(segStr); }
private static Geometry GetPolygonLines(Geometry g) { var lines = new List <Geometry>(); var lineExtracter = new LinearComponentExtracter(lines); var polys = PolygonExtracter.GetPolygons(g); foreach (var poly in polys) { poly.Apply(lineExtracter); } return(g.Factory.BuildGeometry(polys)); }
/// <summary> /// Computes simplicity for polygonal geometries. /// Polygonal geometries are simple if and only if /// all of their component rings are simple. /// </summary> /// <param name="geom">A Polygonal geometry</param> /// <returns><c>true</c> if the geometry is simple</returns> private bool IsSimplePolygonal(Geometry geom) { var rings = LinearComponentExtracter.GetLines(geom); foreach (LinearRing ring in rings) { if (!IsSimpleLinearGeometry(ring)) { return(false); } } return(true); }
private static Geometry Polygonize(Geometry g, bool extractOnlyPolygonal) { var lines = LinearComponentExtracter.GetLines(g); var polygonizer = new Polygonizer(extractOnlyPolygonal); polygonizer.Add(lines); return(polygonizer.GetGeometry()); /* * Collection polys = polygonizer.getPolygons(); * Polygon[] polyArray = GeometryFactory.toPolygonArray(polys); * return g.getFactory().createGeometryCollection(polyArray); */ }
/// <summary> /// /// </summary> /// <param name="geom"></param> private void ComputeSegmentIntersection(IGeometry geom) { // check segment intersection // get all lines from geom (e.g. if it's a multi-ring polygon) IList lines = LinearComponentExtracter.GetLines(geom); SegmentIntersectionTester si = new SegmentIntersectionTester(); bool hasIntersection = si.HasIntersectionWithLineStrings(rectSeq, lines); if (hasIntersection) { intersects = true; return; } }
public static Geometry ExtractChains(Geometry g, int maxChainSize) { var lines = LinearComponentExtracter.GetLines(g); var chains = new List <Geometry>(); foreach (LineString line in lines) { for (int i = 0; i < line.NumPoints - 1; i += maxChainSize) { var chain = ExtractChain(line, i, maxChainSize); chains.Add(chain); } } return(g.Factory.BuildGeometry(chains)); }
private static Geometry BuildBufferLineSimplifiedSet(Geometry g, double distance) { var simpLines = new List <Geometry>(); var lines = LinearComponentExtracter.GetLines(g); foreach (var line in lines) { var pts = line.Coordinates; simpLines.Add(g.Factory.CreateLineString(BufferInputLineSimplifier.Simplify(pts, distance))); } var simpGeom = g.Factory.BuildGeometry(simpLines); return(simpGeom); }
private void Extract(IGeometry geom) { if (_geomFact == null) { _geomFact = geom.Factory; } /* * PolygonExtracter.getPolygons(geom, polygons); * LineStringExtracter.getLines(geom, lines); * PointExtracter.getPoints(geom, points); */ _polygons.AddRange(PolygonExtracter.GetPolygons(geom).Cast <IPolygon>()); _lines.AddRange(LinearComponentExtracter.GetLines(geom).Cast <ILineString>()); _points.AddRange(PointExtracter.GetPoints(geom).Cast <IPoint>()); }
private static IGeometry GetPolygonLines(IGeometry g) { var lines = new List <IGeometry>(); var lineExtracter = new LinearComponentExtracter(lines); var polys = PolygonExtracter.GetPolygons(g); foreach (var poly in polys) { poly.Apply(lineExtracter); } return(g.Factory.BuildGeometry(polys)); /* * return g.Factory.BuildGeometry(new List<IGeometry>( * Gisoft.GeoAPI.DataStructures.Caster.Cast<IGeometry>(polys))); */ }
public static Geometry ExtractSegments(Geometry g) { var lines = LinearComponentExtracter.GetLines(g); var segments = new List <Geometry>(); foreach (LineString line in lines) { for (int i = 1; i < line.NumPoints; i++) { var seg = g.Factory.CreateLineString( new[] { line.GetCoordinateN(i - 1), line.GetCoordinateN(i) } ); segments.Add(seg); } } return(g.Factory.BuildGeometry(segments)); }
/* * /// <summary> * /// * /// </summary> * /// <param name="locs"></param> * /// <param name="polys"></param> * /// <param name="locPtPoly"></param> * private void ComputeInside(IEnumerable<GeometryLocation> locs, IEnumerable<IPolygon> polys, GeometryLocation[] locPtPoly) * { * foreach (GeometryLocation loc in locs) * { * foreach (IPolygon poly in polys) * { * ComputeInside(loc, poly, locPtPoly); * if (_minDistance <= _terminateDistance) * return; * } * } * } * * /// <summary> * /// * /// </summary> * /// <param name="ptLoc"></param> * /// <param name="poly"></param> * /// <param name="locPtPoly"></param> * private void ComputeInside(GeometryLocation ptLoc, IPolygon poly, GeometryLocation[] locPtPoly) * { * Coordinate pt = ptLoc.Coordinate; * // if pt is not in exterior, distance to geom is 0 * if (Location.Exterior != _ptLocator.Locate(pt, poly)) * { * _minDistance = 0.0; * locPtPoly[0] = ptLoc; * GeometryLocation locPoly = new GeometryLocation(poly, pt); * locPtPoly[1] = locPoly; * return; * } * } * */ /// <summary> /// Computes distance between facets (lines and points) of input geometries. /// </summary> private void ComputeFacetDistance() { var locGeom = new GeometryLocation[2]; /* * Geometries are not wholely inside, so compute distance from lines and points * of one to lines and points of the other */ var lines0 = LinearComponentExtracter.GetLines(_geom[0]); var lines1 = LinearComponentExtracter.GetLines(_geom[1]); var pts0 = PointExtracter.GetPoints(_geom[0]); var pts1 = PointExtracter.GetPoints(_geom[1]); // exit whenever minDistance goes LE than terminateDistance ComputeMinDistanceLines(lines0, lines1, locGeom); UpdateMinDistance(locGeom, false); if (_minDistance <= _terminateDistance) { return; } locGeom[0] = null; locGeom[1] = null; ComputeMinDistanceLinesPoints(lines0, pts1, locGeom); UpdateMinDistance(locGeom, false); if (_minDistance <= _terminateDistance) { return; } locGeom[0] = null; locGeom[1] = null; ComputeMinDistanceLinesPoints(lines1, pts0, locGeom); UpdateMinDistance(locGeom, true); if (_minDistance <= _terminateDistance) { return; } locGeom[0] = null; locGeom[1] = null; ComputeMinDistancePoints(pts0, pts1, locGeom); UpdateMinDistance(locGeom, false); }
/// <summary> /// /// </summary> private void ComputeLineDistance() { GeometryLocation[] locGeom = new GeometryLocation[2]; /* * Geometries are not wholely inside, so compute distance from lines and points * of one to lines and points of the other */ IList lines0 = LinearComponentExtracter.GetLines(geom[0]); IList lines1 = LinearComponentExtracter.GetLines(geom[1]); IList pts0 = PointExtracter.GetPoints(geom[0]); IList pts1 = PointExtracter.GetPoints(geom[1]); // bail whenever minDistance goes to zero, since it can't get any less ComputeMinDistanceLines(lines0, lines1, locGeom); UpdateMinDistance(locGeom, false); if (minDistance <= terminateDistance) { return; } locGeom[0] = null; locGeom[1] = null; ComputeMinDistanceLinesPoints(lines0, pts1, locGeom); UpdateMinDistance(locGeom, false); if (minDistance <= terminateDistance) { return; } locGeom[0] = null; locGeom[1] = null; ComputeMinDistanceLinesPoints(lines1, pts0, locGeom); UpdateMinDistance(locGeom, true); if (minDistance <= terminateDistance) { return; } locGeom[0] = null; locGeom[1] = null; ComputeMinDistancePoints(pts0, pts1, locGeom); UpdateMinDistance(locGeom, false); }
private static List <LineSegment> ExtractSegmentsNorm(Geometry geom) { var segs = new List <LineSegment>(); var lines = LinearComponentExtracter.GetLines(geom); foreach (var line in lines) { var pts = line.Coordinates; for (int i = 0; i < pts.Length - 1; i++) { var seg = new LineSegment(pts[i], pts[i + 1]); seg.Normalize(); segs.Add(seg); } } return(segs); }
private static IGeometry ExtractLines(ICollection <IGeometry> geoms) { IGeometryFactory factory = null; var lines = new List <IGeometry>(); foreach (var g in geoms) { if (factory == null) { factory = g.Factory; } var coll = LinearComponentExtracter.GetLines(g); lines.AddRange(coll); } if (factory == null) { return(null); } return(factory.BuildGeometry(geoms)); }
protected override void Visit(IGeometry geom) { /** * It may be the case that the rectangle and the * envelope of the geometry component are disjoint, * so it is worth checking this simple condition. */ var elementEnv = geom.EnvelopeInternal; if (!_rectEnv.Intersects(elementEnv)) { return; } // check segment intersections // get all lines from geometry component // (there may be more than one if it's a multi-ring polygon) var lines = LinearComponentExtracter.GetLines(geom); CheckIntersectionWithLineStrings(lines); }
/// <summary> /// Nodes the linework of a set of Geometrys using SnapRounding. /// </summary> /// <param name="geoms">A collection of Geometrys of any type</param> /// <returns>A list of LineStrings representing the noded linework of the input</returns> public ReadOnlyCollection <LineString> Node(IEnumerable <Geometry> geoms) { // get geometry factory // DEVIATION: JTS uses an "ExtractLines" helper, but by inlining it, // we can make the parameter any ol' IEnumerable<Geometry> without // iterating over it multiple times. var lines = new List <Geometry>(); var lce = new LinearComponentExtracter(lines); bool first = true; foreach (var g in geoms) { if (first) { _geomFact = g.Factory; first = false; } g.Apply(lce); } var segStrings = ToSegmentStrings(lines); //Noder sr = new SimpleSnapRounder(pm); var sr = new MCIndexSnapRounder(_pm); sr.ComputeNodes(segStrings); var nodedLines = sr.GetNodedSubstrings(); //TODO: improve this to check for full snap-rounded correctness if (IsValidityChecked) { var nv = new NodingValidator(nodedLines); nv.CheckValid(); } return(ToLineStrings(nodedLines)); }
public static IGeometry toLines(IGeometry g) { return(g.Factory.BuildGeometry(LinearComponentExtracter.GetLines(g))); }
public static IGeometry ExtractLines(IGeometry g) { ICollection <IGeometry> lines = LinearComponentExtracter.GetLines(g); return(g.Factory.BuildGeometry(lines)); }
public static Geometry ExtractLines(Geometry g) { var lines = LinearComponentExtracter.GetLines(g); return(g.Factory.BuildGeometry(lines)); }
public static IGeometry extractLines(IGeometry g) { var lines = LinearComponentExtracter.GetLines(g); return(g.Factory.BuildGeometry(NetTopologySuite.Utilities.CollectionUtil.Cast <IGeometry>((ICollection)lines))); }