///<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));
}
