///<summary> /// Gets the union of the input geometries. /// If no input geometries were provided, a POINT EMPTY is returned. ///</summary> ///<returns>a Geometry containing the union</returns> /// <returns>an empty GEOMETRYCOLLECTION if no geometries were provided in the input</returns> public IGeometry Union() { if (_geomFact == null) { return(null); } IGeometry unionPoints = null; if (_points.Count > 0) { IGeometry ptGeom = _geomFact.BuildGeometry(convertPoints(_points).ToList()); unionPoints = UnionNoOpt(ptGeom); } IGeometry unionLines = null; if (_lines.Count > 0) { IGeometry lineGeom = _geomFact.BuildGeometry(convertLineStrings(_lines).ToList()); unionLines = UnionNoOpt(lineGeom); } IGeometry unionPolygons = null; if (_polygons.Count > 0) { unionPolygons = CascadedPolygonUnion.Union(_polygons); } /** * Performing two unions is somewhat inefficient, * but is mitigated by unioning lines and points first */ IGeometry unionLA = UnionWithNull(unionLines, unionPolygons); IGeometry union = null; if (unionPoints == null) { union = unionLA; } else if (unionLA == null) { union = unionPoints; } else { union = PointGeometryUnion.Union((IPoint)unionPoints, unionLA); } if (union == null) { return(_geomFact.CreateGeometryCollection(null)); } return(union); }
public IEnumerable <object> GetOidsInView(Envelope bbox, CancellationToken?cancellationToken = null) { var box = _geometryFactory.ToGeometry(bbox); var res = new Collection <object>(); _geometrys.Where(x => box.Intersects(_geometryFactory.BuildGeometry(x.Value))).ToList().ForEach(x => res.Add(x.Key.Id)); return(res); }
/// <summary> /// Returns all objects whose <see cref="GeoAPI.Geometries.Envelope"/> intersects 'bbox'. /// </summary> /// <remarks> /// This method is usually much faster than the QueryFeatures method, because intersection tests /// are performed on objects simplified by their <see cref="GeoAPI.Geometries.Envelope"/>, and using the Spatial Index /// </remarks> /// <param name="bbox">Box that objects should intersect</param> /// <returns></returns> public Collection <uint> GetObjectIDsInView(Envelope bbox) { var box = _geometryFactory.ToGeometry(bbox); var res = new Collection <uint>(); _geometrys.Where(x => box.Intersects(_geometryFactory.BuildGeometry(x.Value))).ToList().ForEach(x => { res.Add(Convert.ToUInt32(x.Key.Id)); }); return(res); }
///<summary> /// Converts a flat path to a <see cref="IGeometry"/>. ///</summary> /// <param name="pathIt">The path iterator of the path to convert</param> /// <returns>A Geometry representing the path</returns> public IGeometry Read(WpfGeometry pathIt) { var pathPtSeq = ToCoordinates(pathIt); var polys = new List <IGeometry>(); var seqIndex = 0; while (seqIndex < pathPtSeq.Count) { // assume next seq is shell // TODO: test this var pts = pathPtSeq[seqIndex]; var shell = _geometryFactory.CreateLinearRing(pts); seqIndex++; var holes = new List <ILinearRing>(); Coordinate[] holePts; // add holes as long as rings are CCW while (seqIndex < pathPtSeq.Count && IsHole(holePts = pathPtSeq[seqIndex])) { var hole = _geometryFactory.CreateLinearRing(holePts); holes.Add(hole); seqIndex++; } var holeArray = holes.ToArray();//GeometryFactory.ToLinearRingArray(holes); polys.Add(_geometryFactory.CreatePolygon(shell, holeArray)); } return(_geometryFactory.BuildGeometry(polys)); }
/// <summary> /// /// </summary> /// <param name="g"></param> /// <param name="distance"></param> /// <returns></returns> public IGeometry Buffer(IGeometry g, double distance) { PrecisionModel precisionModel = _workingPrecisionModel ?? new PrecisionModel(g.PrecisionModel); // factory must be the same as the one used by the input _geomFact = g.Factory; OffsetCurveBuilder curveBuilder = new OffsetCurveBuilder(precisionModel, _quadrantSegments); curveBuilder.EndCapStyle = _endCapStyle; OffsetCurveSetBuilder curveSetBuilder = new OffsetCurveSetBuilder(g, distance, curveBuilder); IList bufferSegStrList = curveSetBuilder.GetCurves(); // short-circuit test if (bufferSegStrList.Count <= 0) { IGeometry emptyGeom = _geomFact.CreateGeometryCollection(new Geometry[0]); return(emptyGeom); } ComputeNodedEdges(bufferSegStrList, precisionModel); _graph = new PlanarGraph(new OverlayNodeFactory()); _graph.AddEdges(_edgeList.Edges); IList subgraphList = CreateSubgraphs(_graph); PolygonBuilder polyBuilder = new PolygonBuilder(_geomFact); BuildSubgraphs(subgraphList, polyBuilder); IList resultPolyList = polyBuilder.Polygons; IGeometry resultGeom = _geomFact.BuildGeometry(resultPolyList); return(resultGeom); }
/// <summary> /// Builds a geometry (<see cref="LineString" /> or <see cref="MultiLineString" />) /// representing the sequence. /// </summary> /// <param name="sequences"> /// A <see cref="IList" /> of <see cref="IList" />s of <see cref="DirectedEdge" />s /// with <see cref="LineMergeEdge" />s as their parent edges. /// </param> /// <returns> /// The sequenced geometry, or <c>null</c> if no sequence exists. /// </returns> private IGeometry BuildSequencedGeometry(IEnumerable sequences) { IList lines = new ArrayList(); IEnumerator i1 = sequences.GetEnumerator(); while (i1.MoveNext()) { IList seq = (IList)i1.Current; IEnumerator i2 = seq.GetEnumerator(); while (i2.MoveNext()) { DirectedEdge de = (DirectedEdge)i2.Current; LineMergeEdge e = (LineMergeEdge)de.Edge; ILineString line = e.Line; ILineString lineToAdd = line; if (!de.EdgeDirection && !line.IsClosed) { lineToAdd = Reverse(line); } lines.Add(lineToAdd); } } if (lines.Count == 0) { return(factory.CreateMultiLineString(new ILineString[] { })); } return(factory.BuildGeometry(lines)); }
public IGeometry unionAllBuffer(IList <IGeometry> geoms) { var gColl = _factory.BuildGeometry(geoms); var unionAll = gColl.Buffer(0.0); return(unionAll); }
/// <summary> /// /// </summary> /// <param name="resultPointList"></param> /// <param name="resultLineList"></param> /// <param name="resultPolyList"></param> /// <returns></returns> private IGeometry ComputeGeometry(IList resultPointList, IList resultLineList, IList resultPolyList) { ArrayList geomList = new ArrayList(); // element geometries of the result are always in the order Point, Curve, A //geomList.addAll(resultPointList); foreach (object obj in resultPointList) { geomList.Add(obj); } //geomList.addAll(resultLineList); foreach (object obj in resultLineList) { geomList.Add(obj); } //geomList.addAll(resultPolyList); foreach (object obj in resultPolyList) { geomList.Add(obj); } // build the most specific point possible return(_geomFact.BuildGeometry(geomList)); }
private static IGeometry CreateMultiPolygon(Ordinates ordinates, bool empty) { if (empty) { Factory.CreateMultiPolygon(null); } switch (Rnd.Next(2)) { case 0: int numPolygons = Rnd.Next(4); var polygons = new IPolygon[numPolygons]; for (int i = 0; i < numPolygons; i++) { polygons[i] = (IPolygon)CreatePolygon(ordinates, false); } return(Factory.BuildGeometry(new Collection <IGeometry>(polygons)).Union()); case 1: polygons = new IPolygon[2]; double radius = 5 * Rnd.NextDouble(); double x = RandomOrdinate(Ordinate.X, Factory.PrecisionModel); double y = RandomOrdinate(Ordinate.Y, Factory.PrecisionModel); var shell = CreateCircleRing(ordinates, x, y, radius); var hole = CreateCircleRing(ordinates, x, y, 0.66 * radius, true); polygons[0] = Factory.CreatePolygon(shell, new[] { hole }); shell = CreateCircleRing(ordinates, x, y, 0.5 * radius); hole = CreateCircleRing(ordinates, x, y, 0.15 * radius, true); polygons[1] = Factory.CreatePolygon(shell, new[] { hole }); return(Factory.CreateMultiPolygon(polygons)); default: throw new NotSupportedException(); } }
/// <summary> /// /// </summary> /// <param name="geom"></param> /// <param name="parent"></param> /// <returns></returns> protected virtual IGeometry TransformMultiPoint(IMultiPoint geom, IGeometry parent) { ArrayList transGeomList = new ArrayList(); for (int i = 0; i < geom.NumGeometries; i++) { IGeometry transformGeom = TransformPoint((IPoint)geom.GetGeometryN(i), geom); if (transformGeom == null) { continue; } if (transformGeom.IsEmpty) { continue; } transGeomList.Add(transformGeom); } return(factory.BuildGeometry(transGeomList)); }
public IGeometry Buffer(IGeometry g, double distance) { IPrecisionModel precisionModel = _workingPrecisionModel; if (precisionModel == null) { precisionModel = g.PrecisionModel; } // factory must be the same as the one used by the input _geomFact = g.Factory; OffsetCurveBuilder curveBuilder = new OffsetCurveBuilder(precisionModel, _bufParams); OffsetCurveSetBuilder curveSetBuilder = new OffsetCurveSetBuilder(g, distance, curveBuilder); var bufferSegStrList = curveSetBuilder.GetCurves(); // short-circuit test if (bufferSegStrList.Count <= 0) { return(CreateEmptyResultGeometry()); } //BufferDebug.runCount++; //String filename = "run" + BufferDebug.runCount + "_curves"; //System.out.println("saving " + filename); //BufferDebug.saveEdges(bufferEdgeList, filename); // DEBUGGING ONLY //WKTWriter wktWriter = new WKTWriter(); //Debug.println("Rings: " + wktWriter.write(convertSegStrings(bufferSegStrList.iterator()))); //wktWriter.setMaxCoordinatesPerLine(10); //System.out.println(wktWriter.writeFormatted(convertSegStrings(bufferSegStrList.iterator()))); ComputeNodedEdges(bufferSegStrList, precisionModel); _graph = new PlanarGraph(new OverlayNodeFactory()); _graph.AddEdges(_edgeList.Edges); IEnumerable <BufferSubgraph> subgraphList = CreateSubgraphs(_graph); PolygonBuilder polyBuilder = new PolygonBuilder(_geomFact); BuildSubgraphs(subgraphList, polyBuilder); var resultPolyList = polyBuilder.Polygons; // just in case... if (resultPolyList.Count <= 0) { return(CreateEmptyResultGeometry()); } IGeometry resultGeom = _geomFact.BuildGeometry(resultPolyList); return(resultGeom); }
private void ComputeResult() { IEnumerable <HalfEdge> edges = _graph.GetVertexEdges(); foreach (HalfEdge e in edges) { if (MarkHalfEdge.IsMarked(e)) { continue; } Process(e); } _result = _factory.BuildGeometry(_lines); }
/// <summary> /// Gets a geometry representing the polygons formed by the polygonization. /// If a valid polygonal geometry was extracted the result is a <see cref="IPolygonal"/> geometry. /// </summary> /// <returns>A geometry containing the polygons</returns> public IGeometry GetGeometry() { if (_geomFactory == null) { _geomFactory = new Geometries.GeometryFactory(); } Polygonize(); if (_extractOnlyPolygonal) { return(_geomFactory.BuildGeometry(_polyList)); } // result may not be valid Polygonal, so return as a GeometryCollection return(_geomFactory.CreateGeometryCollection(Geometries.GeometryFactory.ToGeometryArray(_polyList))); }
///<summary> /// Computes the combination of the input geometries to produce the most appropriate <see cref="IGeometry"/> or <see cref="IGeometryCollection"/> ///</summary> /// <returns>A Geometry which is the combination of the inputs</returns> /// <returns></returns> public IGeometry Combine() { var elems = new List <IGeometry>(); foreach (var geom in _inputGeoms) { ExtractElements(geom, elems); } if (elems.Count == 0) { return(_geomFactory != null?_geomFactory.CreateGeometryCollection() : null); } return(_geomFactory.BuildGeometry(elems)); }
private IGeometry ExtractElements(IGeometry geom, bool[] interacts, bool isInteracting) { var extractedGeoms = new List <IGeometry>(); for (int i = 0; i < geom.NumGeometries; i++) { var elem = geom.GetGeometryN(i); if (interacts[i] == isInteracting) { extractedGeoms.Add(elem); } } return(_geomFactory.BuildGeometry(extractedGeoms)); }
public void buildgeometry_creates_unnecessary_geometrycollection() { const string wkt = "MULTIPOLYGON (((0 0, 10 0, 10 10, 0 10, 0 0)), ((20 0, 30 0, 30 10, 20 10, 20 0)))"; IGeometryFactory factory = GeometryFactory.Default; IGeometry read = new WKTReader().Read(wkt); Assert.IsNotNull(read); Assert.IsInstanceOf <IMultiPolygon>(read); IGeometry built = factory.BuildGeometry(new[] { read }); Assert.IsNotNull(built); Assert.IsInstanceOf <IGeometryCollection>(built); Assert.AreEqual(1, built.NumGeometries); }
private IGeometry ComputeGeometry(IEnumerable <IGeometry> resultPtList, IEnumerable <IGeometry> resultLiList, IEnumerable <IGeometry> resultPlList, SpatialFunction opCode) { var geomList = new List <IGeometry>(); // element geometries of the result are always in the order Point,Curve,A geomList.AddRange(resultPtList); geomList.AddRange(resultLiList); geomList.AddRange(resultPlList); if (geomList.Count == 0) { return(CreateEmptyResult(opCode, arg[0].Geometry, arg[1].Geometry, _geomFact)); } // build the most specific point possible return(_geomFact.BuildGeometry(geomList)); }
private IGeometry ToNodedLines(ICollection <ISegmentString> segStrings, IGeometryFactory geomFact) { var lines = new List <IGeometry>(); foreach (NodedSegmentString nss in segStrings) { // skip collapsed lines if (nss.Count < 2) { continue; } //Coordinate[] pts = getCoords(nss); var pts = nss.NodeList.GetSplitCoordinates(); lines.Add(geomFact.CreateLineString(pts)); } return(geomFact.BuildGeometry(lines)); }
private IGeometry ExtractByEnvelope(IEnvelope env, IGeometry geom, IList disjointGeoms) { var intersectingGeoms = new List <IGeometry>(); for (var i = 0; i < geom.NumGeometries; i++) { var elem = geom.GetGeometryN(i); if (elem.EnvelopeInternal.Intersects(env)) { intersectingGeoms.Add(elem); } else { disjointGeoms.Add(elem); } } return(geomFactory.BuildGeometry(intersectingGeoms)); }
public IGeometry Buffer(IGeometry g, double distance) { IPrecisionModel precisionModel = _workingPrecisionModel; if (precisionModel == null) { precisionModel = g.PrecisionModel; } // factory must be the same as the one used by the input _geomFact = g.Factory; OffsetCurveBuilder curveBuilder = new OffsetCurveBuilder(precisionModel, _bufParams); OffsetCurveSetBuilder curveSetBuilder = new OffsetCurveSetBuilder(g, distance, curveBuilder); var bufferSegStrList = curveSetBuilder.GetCurves(); // short-circuit test if (bufferSegStrList.Count <= 0) { return(CreateEmptyResultGeometry()); } ComputeNodedEdges(bufferSegStrList, precisionModel); _graph = new PlanarGraph(new OverlayNodeFactory()); _graph.AddEdges(_edgeList.Edges); IEnumerable <BufferSubgraph> subgraphList = CreateSubgraphs(_graph); PolygonBuilder polyBuilder = new PolygonBuilder(_geomFact); BuildSubgraphs(subgraphList, polyBuilder); var resultPolyList = polyBuilder.Polygons; // just in case... if (resultPolyList.Count <= 0) { return(CreateEmptyResultGeometry()); } IGeometry resultGeom = _geomFact.BuildGeometry(resultPolyList); return(resultGeom); }
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)); }
/// <summary> /// /// </summary> /// <param name="g"></param> /// <param name="distance"></param> /// <returns></returns> public IGeometry Buffer(IGeometry g, double distance) { var precisionModel = workingPrecisionModel ?? g.PrecisionModel; // factory must be the same as the one used by the input geomFact = g.Factory; var curveBuilder = new OffsetCurveBuilder(precisionModel, quadrantSegments) { EndCapStyle = endCapStyle }; var curveSetBuilder = new OffsetCurveSetBuilder(g, distance, curveBuilder); var bufferSegStrList = curveSetBuilder.GetCurves(); // short-circuit test if (bufferSegStrList.Count <= 0) { IGeometry emptyGeom = geomFact.CreateGeometryCollection(new IGeometry[0]); return(emptyGeom); } ComputeNodedEdges(bufferSegStrList, precisionModel); graph = new PlanarGraph(new OverlayNodeFactory()); graph.AddEdges(edgeList.Edges); var subgraphList = CreateSubgraphs(graph); var polyBuilder = new PolygonBuilder(geomFact); BuildSubgraphs(subgraphList, polyBuilder); var resultPolyList = polyBuilder.Polygons; var resultGeom = geomFact.BuildGeometry(resultPolyList); return(resultGeom); }
public IGeometry Buffer(IGeometry g, double distance) { IPrecisionModel precisionModel = _workingPrecisionModel; if (precisionModel == null) precisionModel = g.PrecisionModel; // factory must be the same as the one used by the input _geomFact = g.Factory; OffsetCurveBuilder curveBuilder = new OffsetCurveBuilder(precisionModel, _bufParams); OffsetCurveSetBuilder curveSetBuilder = new OffsetCurveSetBuilder(g, distance, curveBuilder); var bufferSegStrList = curveSetBuilder.GetCurves(); // short-circuit test if (bufferSegStrList.Count <= 0) { return CreateEmptyResultGeometry(); } //BufferDebug.runCount++; //String filename = "run" + BufferDebug.runCount + "_curves"; //System.out.println("saving " + filename); //BufferDebug.saveEdges(bufferEdgeList, filename); // DEBUGGING ONLY //WKTWriter wktWriter = new WKTWriter(); //Debug.println("Rings: " + wktWriter.write(convertSegStrings(bufferSegStrList.iterator()))); //wktWriter.setMaxCoordinatesPerLine(10); //System.out.println(wktWriter.writeFormatted(convertSegStrings(bufferSegStrList.iterator()))); ComputeNodedEdges(bufferSegStrList, precisionModel); _graph = new PlanarGraph(new OverlayNodeFactory()); _graph.AddEdges(_edgeList.Edges); IEnumerable<BufferSubgraph> subgraphList = CreateSubgraphs(_graph); PolygonBuilder polyBuilder = new PolygonBuilder(_geomFact); BuildSubgraphs(subgraphList, polyBuilder); var resultPolyList = polyBuilder.Polygons; // just in case... if (resultPolyList.Count <= 0) { return CreateEmptyResultGeometry(); } IGeometry resultGeom = _geomFact.BuildGeometry(resultPolyList); return resultGeom; }
private IGeometry BuildGeometry(ICollection <IGeometry> geoms) { var lst = new List <IGeometry>(geoms.Count); IGeometry shell = null; foreach (var geom in geoms) { if (geom is IPolygon) { if (shell != null) { if (shell.Disjoint(geom)) { shell = shell.Union(geom); } else if (geom.Contains(shell)) { shell = geom.Difference(shell); } else if (shell.Touches(geom)) { shell = shell.Union(geom); } else if (shell.Contains(geom)) { shell = shell.Difference(geom); } else if (shell.Intersects(geom)) { shell = shell.SymmetricDifference(geom); } else { throw new NotSupportedException(); lst.Add(shell); shell = geom; } } else { shell = geom; } } else { /* * if (shell != null) * { * lst.Add(shell); * shell = null; * } */ lst.Add(geom); } } if (shell != null) { lst.Insert(0, shell); } if (lst.Count > 1) { return(_geometryFactory.BuildGeometry(lst)); } return(lst[0]); }
public IGeometry Buffer(IGeometry g, double distance) { IPrecisionModel precisionModel = _workingPrecisionModel; if (precisionModel == null) precisionModel = g.PrecisionModel; // factory must be the same as the one used by the input _geomFact = g.Factory; OffsetCurveBuilder curveBuilder = new OffsetCurveBuilder(precisionModel, _bufParams); OffsetCurveSetBuilder curveSetBuilder = new OffsetCurveSetBuilder(g, distance, curveBuilder); var bufferSegStrList = curveSetBuilder.GetCurves(); // short-circuit test if (bufferSegStrList.Count <= 0) { return CreateEmptyResultGeometry(); } ComputeNodedEdges(bufferSegStrList, precisionModel); _graph = new PlanarGraph(new OverlayNodeFactory()); _graph.AddEdges(_edgeList.Edges); IEnumerable<BufferSubgraph> subgraphList = CreateSubgraphs(_graph); PolygonBuilder polyBuilder = new PolygonBuilder(_geomFact); BuildSubgraphs(subgraphList, polyBuilder); var resultPolyList = polyBuilder.Polygons; // just in case... if (resultPolyList.Count <= 0) { return CreateEmptyResultGeometry(); } IGeometry resultGeom = _geomFact.BuildGeometry(resultPolyList); return resultGeom; }
/// <summary> /// Gets the union of the input geometries. /// If no input geometries were provided but a <see cref="IGeometryFactory"/> was provided, /// an empty <see cref="IGeometryCollection"/> is returned. /// <para/>Otherwise, the return value is <c>null</c> /// </summary> /// <returns> /// A Geometry containing the union /// or an empty <see cref="IGeometryCollection"/> if no geometries were provided in the input, /// or <c>null</c> if not GeometryFactory was provided /// </returns> public IGeometry Union() { if (_geomFact == null) { return(null); } /** * For points and lines, only a single union operation is * required, since the OGC model allows self-intersecting * MultiPoint and MultiLineStrings. * This is not the case for polygons, so Cascaded Union is required. */ IGeometry unionPoints = null; if (_points.Count > 0) { var ptGeom = _geomFact.BuildGeometry(_points); unionPoints = UnionNoOpt(ptGeom); } IGeometry unionLines = null; if (_lines.Count > 0) { var lineGeom = _geomFact.BuildGeometry(_lines); unionLines = UnionNoOpt(lineGeom); } IGeometry unionPolygons = null; if (_polygons.Count > 0) { unionPolygons = CascadedPolygonUnion.Union(_polygons); } /* * Performing two unions is somewhat inefficient, * but is mitigated by unioning lines and points first */ var unionLA = UnionWithNull(unionLines, unionPolygons); IGeometry union; if (unionPoints == null) { union = unionLA; } else if (unionLA == null) { union = unionPoints; } else { union = PointGeometryUnion.Union((IPuntal)unionPoints, unionLA); } if (union == null) { return(_geomFact.CreateGeometryCollection()); } return(union); }
private IGeometry ToNodedLines(ICollection<ISegmentString> segStrings, IGeometryFactory geomFact) { var lines = new List<IGeometry>(); foreach (NodedSegmentString nss in segStrings) { // skip collapsed lines if (nss.Count < 2) continue; //Coordinate[] pts = getCoords(nss); var pts = nss.NodeList.GetSplitCoordinates(); lines.Add(geomFact.CreateLineString(pts)); } return geomFact.BuildGeometry(lines); }
/// <summary> /// /// </summary> /// <param name="g"></param> /// <param name="distance"></param> /// <returns></returns> public IGeometry Buffer(IGeometry g, double distance) { IPrecisionModel precisionModel = workingPrecisionModel; if (precisionModel == null) precisionModel = g.PrecisionModel; // factory must be the same as the one used by the input geomFact = g.Factory; OffsetCurveBuilder curveBuilder = new OffsetCurveBuilder(precisionModel, quadrantSegments); curveBuilder.EndCapStyle = endCapStyle; OffsetCurveSetBuilder curveSetBuilder = new OffsetCurveSetBuilder(g, distance, curveBuilder); IList bufferSegStrList = curveSetBuilder.GetCurves(); // short-circuit test if (bufferSegStrList.Count <= 0) { IGeometry emptyGeom = geomFact.CreateGeometryCollection(new IGeometry[0]); return emptyGeom; } ComputeNodedEdges(bufferSegStrList, precisionModel); graph = new PlanarGraph(new OverlayNodeFactory()); graph.AddEdges(edgeList.Edges); IList subgraphList = CreateSubgraphs(graph); PolygonBuilder polyBuilder = new PolygonBuilder(geomFact); BuildSubgraphs(subgraphList, polyBuilder); IList resultPolyList = polyBuilder.Polygons; IGeometry resultGeom = geomFact.BuildGeometry(resultPolyList); return resultGeom; }
/// <summary> /// Builds and returns the <see cref="Geometry" />. /// </summary> /// <returns></returns> public IGeometry GetGeometry() { // end last line in case it was not done by user EndLine(); return(geomFact.BuildGeometry(lines)); }
/// <summary> /// Builds a geometry (<see cref="LineString" /> or <see cref="MultiLineString" />) /// representing the sequence. /// </summary> /// <param name="sequences"> /// An enumeration of <see cref="IList{DirectedEdge}" />s of <see cref="DirectedEdge" />s /// with <see cref="LineMergeEdge" />s as their parent edges. /// </param> /// <returns> /// The sequenced geometry, or <c>null</c> if no sequence exists. /// </returns> private IGeometry BuildSequencedGeometry(IEnumerable <IEnumerable <DirectedEdge> > sequences) { IList <IGeometry> lines = new List <IGeometry>(); foreach (IList <DirectedEdge> seq in sequences) { foreach (DirectedEdge de in seq) { LineMergeEdge e = (LineMergeEdge)de.Edge; ILineString line = e.Line; ILineString lineToAdd = line; if (!de.EdgeDirection && !line.IsClosed) { lineToAdd = Reverse(line); } lines.Add(lineToAdd); } } return(lines.Count == 0 ? _factory.CreateMultiLineString(new ILineString[] { }) : _factory.BuildGeometry(lines)); }
/// <summary> /// Converts a flat path to a <see cref="IGeometry"/>. /// </summary> /// <param name="wpfGeometry">The geometry to convert</param> /// <returns>A Geometry representing the path</returns> public IGeometry Read(WpfGeometry wpfGeometry) { var pathGeometry = PathGeometry.CreateFromGeometry(wpfGeometry); /* * .Item1 ... Closed * .Item2 ... Filled * .Item3 ... List<Coordinate[]> */ var pathPtSeq = ToCoordinates(pathGeometry); var geoms = new List <IGeometry>(); var seqIndex = 0; while (seqIndex < pathPtSeq.Count) { // assume next seq is shell // TODO: test this var pts = pathPtSeq[seqIndex]; if (pts.Item3.Length == 1) { geoms.Add(_geometryFactory.CreatePoint(pts.Item3[0])); } else if (!pts.Item1) // Closed { geoms.Add(_geometryFactory.CreateLineString(pts.Item3)); } else { if (!pts.Item2) { geoms.Add(_geometryFactory.CreateLineString(pts.Item3)); continue; } var rings = new List <IGeometry>(new[] { _geometryFactory.CreateLinearRing(pts.Item3) }); seqIndex++; Coordinate[] holePts; // add holes as long as rings are CCW while (seqIndex < pathPtSeq.Count && IsHole(holePts = pathPtSeq[seqIndex].Item3)) { rings.Add(_geometryFactory.CreateLinearRing(holePts)); seqIndex++; } var noder = new Noding.Snapround.GeometryNoder(new Geometries.PrecisionModel(100000000.0)); var nodedLinework = noder.Node(rings); // Use the polygonizer var p = new Polygonizer(pathGeometry.FillRule == FillRule.EvenOdd); p.Add(new List <IGeometry>(Caster.Upcast <ILineString, IGeometry>(nodedLinework))); var tmpPolygons = p.GetPolygons(); if (pathGeometry.FillRule == FillRule.Nonzero) { var unionized = CascadedPolygonUnion.Union(Geometries.GeometryFactory.ToPolygonArray(tmpPolygons)); tmpPolygons = new List <IGeometry>(new[] { unionized }); } geoms.AddRange(tmpPolygons); } } return(_geometryFactory.BuildGeometry(geoms)); }