public void testBoundaryOfEmptyGeometry() { Assert.IsTrue(geometryFactory.CreatePoint((Coordinate)null).Boundary.GetType() == typeof(GeometryCollection)); Assert.IsTrue(geometryFactory.CreateLinearRing(new Coordinate[] {}).Boundary.GetType() == typeof(MultiPoint)); Assert.IsTrue(geometryFactory.CreateLineString(new Coordinate[] {}).Boundary.GetType() == typeof(MultiPoint)); Assert.IsTrue( geometryFactory.CreatePolygon(geometryFactory.CreateLinearRing(new Coordinate[] {}), new LinearRing[] {}) .Boundary.GetType() == typeof(MultiLineString)); Assert.IsTrue(geometryFactory.CreateMultiPolygon(new Polygon[] {}).Boundary.GetType() == typeof(MultiLineString)); Assert.IsTrue(geometryFactory.CreateMultiLineString(new LineString[] {}).Boundary.GetType() == typeof(MultiPoint)); Assert.IsTrue(geometryFactory.CreateMultiPoint(new Point[] {}).Boundary.GetType() == typeof(GeometryCollection)); try { var b = geometryFactory.CreateGeometryCollection(new IGeometry[] {}).Boundary; Assert.IsTrue(false); } catch (ArgumentException e) { } }
private void MergeFeatures(IFeature featureToMergeTo, IFeature feature) { if (featureToMergeTo.Attributes[FeatureAttributes.ID].Equals(feature.Attributes[FeatureAttributes.ID])) { return; } if (featureToMergeTo.Geometry is GeometryCollection geometryCollection) { if (feature.Geometry is GeometryCollection geometryCollectionSource) { featureToMergeTo.Geometry = _geometryFactory.CreateGeometryCollection(geometryCollection.Geometries.Concat(geometryCollectionSource.Geometries).ToArray()); } else { featureToMergeTo.Geometry = _geometryFactory.CreateGeometryCollection(geometryCollection.Geometries.Concat(new[] { feature.Geometry }).ToArray()); } } else { featureToMergeTo.Geometry = _geometryFactory.CreateGeometryCollection(new[] { featureToMergeTo.Geometry, feature.Geometry }); } if (featureToMergeTo.Attributes[FeatureAttributes.POI_CATEGORY].Equals(Categories.NONE)) { featureToMergeTo.Attributes[FeatureAttributes.POI_CATEGORY] = feature.Attributes[FeatureAttributes.POI_CATEGORY]; } if (double.Parse(featureToMergeTo.Attributes[FeatureAttributes.SEARCH_FACTOR].ToString()) < double.Parse(feature.Attributes[FeatureAttributes.SEARCH_FACTOR].ToString())) { featureToMergeTo.Attributes[FeatureAttributes.SEARCH_FACTOR] = feature.Attributes[FeatureAttributes.SEARCH_FACTOR]; } if (string.IsNullOrWhiteSpace(featureToMergeTo.Attributes[FeatureAttributes.ICON].ToString())) { featureToMergeTo.Attributes[FeatureAttributes.ICON] = feature.Attributes[FeatureAttributes.ICON]; featureToMergeTo.Attributes[FeatureAttributes.ICON_COLOR] = feature.Attributes[FeatureAttributes.ICON_COLOR]; } // adding names of merged feature featureToMergeTo.MergeTitles(feature); if (!featureToMergeTo.Attributes[FeatureAttributes.POI_SOURCE] .Equals(feature.Attributes[FeatureAttributes.POI_SOURCE]) || !feature.Attributes[FeatureAttributes.POI_SOURCE].Equals(Sources.OSM)) { // do not merge OSM elements to each other since they won't exists in the database for fetching featureToMergeTo.AddIdToCombinedPoi(feature); } featureToMergeTo.MergeCombinedPoiIds(feature); }
/// <summary> /// Finalizes the result. /// </summary> protected override IGeometry FinalizeResult() { if (Source.VertexCount == 0) { return(null); } // if only points are in the graph if (_lines.Count == 0 && _polygons.Count == 0) { if (_points.Count == 1) { return(_points.First()); } return(_factory.CreateMultiPoint(_points)); } // if no faces are extracted else if (_polygons.Count == 0) { if (_points.Count == 0) { if (_lines.Count == 1) { return(_lines.First()); } return(_factory.CreateMultiLineString(_lines)); } return(_factory.CreateGeometryCollection(_points.Concat <IGeometry>(_lines))); } // if faces are extracted if (_points.Count == 0 && _lines.Count == 0) { if (_polygons.Count == 1) { return(_polygons.First()); } else { return(_factory.CreateMultiPolygon(_polygons)); } } else { return(_factory.CreateGeometryCollection(_points.Concat <IGeometry>(_lines).Concat <IGeometry>(_polygons))); } }
/// <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> /// Gets the computed variable-width line buffer. /// </summary> /// <returns>A polygon</returns> public IGeometry GetResult() { Utilities.Assert.IsTrue(_line.NumPoints == _width.Length); var parts = new List <IGeometry>(); var pts = _line.Coordinates; for (var i = 0; i < _line.NumPoints; i++) { var dist = _width[i] / 2; var ptBuf = _line.GetPointN(i).Buffer(dist); parts.Add(ptBuf); if (i >= 1) { var curvePts = GenerateSegmentCurve(pts[i - 1], pts[i], _width[i - 1], _width[i]); var segBuf = _geomFactory.CreatePolygon(curvePts); parts.Add(segBuf); } } var partsGeom = _geomFactory.CreateGeometryCollection(GeometryFactory.ToGeometryArray(parts)); var buffer = partsGeom.Union(); return(buffer); }
// see: https://github.com/NetTopologySuite/NetTopologySuite/issues/111 public void issue_111_polygonhandler_with_invalid_values() { IGeometryFactory factory = GeometryFactory.Default; Coordinate[] points = new Coordinate[5]; points[0] = new Coordinate(0, 0); points[1] = new Coordinate(1, 0); points[2] = new Coordinate(1, 1); points[3] = new Coordinate(0, 1); points[4] = new Coordinate(0, 0); IPolygon poly = factory.CreatePolygon(points); IMultiPolygon mpoly = factory.CreateMultiPolygon(new[] { poly }); IGeometry[] arr = new[] { mpoly, GeometryCollection.Empty }; IGeometryCollection geometries = factory.CreateGeometryCollection(arr); ShapeGeometryType shapeType = Shapefile.GetShapeType(geometries); Assert.AreEqual(ShapeGeometryType.PolygonZM, shapeType); string tempPath = Path.GetTempFileName(); ShapefileWriter sfw = new ShapefileWriter(Path.GetFileNameWithoutExtension(tempPath), shapeType); sfw.Write(geometries); }
/// <summary> /// Creates the result of the overlay operation. /// </summary> /// <param name="geometry">The geometry.</param> /// <param name="otherGeometry">The other geometry.</param> /// <param name="predicate">The overlay predicate.</param> /// <returns>The result of the overlay.</returns> private IGeometry CreateResult(IGeometry geometry, IGeometry otherGeometry, Func <IFace, Boolean> predicate) { // merge the geometries into a single graph HalfedgeGraph graph = new HalfedgeGraph(new HalfedgeGraph.FixedIdentifierProvider(1)); graph.MergeGeometry(geometry); _aIdentifiers = new HashSet <Int32>(graph.Vertices.SelectMany(v => v.Identifiers)); HalfedgeGraph otherGraph = new HalfedgeGraph(new HalfedgeGraph.FixedIdentifierProvider(2)); otherGraph.MergeGeometry(otherGeometry); _bIdentifiers = new HashSet <Int32>(otherGraph.Vertices.SelectMany(v => v.Identifiers)); graph.MergeGraph(otherGraph); // query the results IGeometryFactory factory = _geometryFactory ?? geometry.Factory; List <IPolygon> result = graph.Faces.Where(predicate).Select(face => face.ToGeometry(factory)).ToList(); if (result.Count == 0) { return(null); } if (result.Count == 1) { return(result[0]); } return(factory.CreateGeometryCollection(result)); }
public object ToGeometryCollection(object[] geometries) { if (geometries.Length == 0) { return(GeometryCollection.Empty); } return(_geometryFactory.CreateGeometryCollection(geometries.Cast <IGeometry>().ToArray())); }
/// <summary> /// Reads a <see cref="IGeometryCollection"/> from the input stream. /// </summary> /// <param name="reader">The binary reader.</param> /// <param name="factory">The geometry factory to use for geometry creation.</param> /// <returns>The GeometryCollection</returns> protected IGeometryCollection ReadGeometryCollection(BinaryReader reader, IGeometryFactory factory) { int numGeometries = reader.ReadInt32(); var geometries = new IGeometry[numGeometries]; ReadGeometryArray(reader, geometries); return(factory.CreateGeometryCollection(geometries)); }
/// <summary> /// /// </summary> /// <param name="geom"></param> public static void UnionUsingBufferOp(IGeometry[] geom) { IGeometryFactory fact = geom[0].Factory; IGeometry geomColl = fact.CreateGeometryCollection(geom); IGeometry union = geomColl.Buffer(0.0); Console.WriteLine(union); }
private IGeometry BufferUnion(IGeometry g0, IGeometry g1) { IGeometryFactory factory = g0.Factory; IGeometry gColl = factory.CreateGeometryCollection(new IGeometry[] { g0, g1 }); IGeometry unionAll = gColl.Buffer(0.0); return(unionAll); }
///<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); }
#pragma warning disable CS0809 // Obsolete member overrides non-obsolete member public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) #pragma warning restore CS0809 // Obsolete member overrides non-obsolete member { reader.Read(); if (!(reader.TokenType == JsonToken.PropertyName && (string)reader.Value == "type")) { throw new ArgumentException("invalid tokentype: " + reader.TokenType); } reader.Read(); if (reader.TokenType != JsonToken.String) { throw new ArgumentException("invalid tokentype: " + reader.TokenType); } GeoJsonObjectType geometryType = (GeoJsonObjectType)Enum.Parse(typeof(GeoJsonObjectType), (string)reader.Value); switch (geometryType) { case GeoJsonObjectType.Point: Coordinate coordinate = _geoJsonSerializer.Deserialize <Coordinate>(reader); return(_factory.CreatePoint(coordinate)); case GeoJsonObjectType.LineString: Coordinate[] coordinates = _geoJsonSerializer.Deserialize <Coordinate[]>(reader); return(_factory.CreateLineString(coordinates)); case GeoJsonObjectType.Polygon: List <Coordinate[]> coordinatess = _geoJsonSerializer.Deserialize <List <Coordinate[]> >(reader); return(CreatePolygon(coordinatess)); case GeoJsonObjectType.MultiPoint: coordinates = _geoJsonSerializer.Deserialize <Coordinate[]>(reader); return(_factory.CreateMultiPoint(coordinates)); case GeoJsonObjectType.MultiLineString: coordinatess = _geoJsonSerializer.Deserialize <List <Coordinate[]> >(reader); List <ILineString> strings = new List <ILineString>(); for (int i = 0; i < coordinatess.Count; i++) { strings.Add(_factory.CreateLineString(coordinatess[i])); } return(_factory.CreateMultiLineString(strings.ToArray())); case GeoJsonObjectType.MultiPolygon: List <List <Coordinate[]> > coordinatesss = _geoJsonSerializer.Deserialize <List <List <Coordinate[]> > >(reader); List <IPolygon> polygons = new List <IPolygon>(); foreach (List <Coordinate[]> coordinateses in coordinatesss) { polygons.Add(CreatePolygon(coordinateses)); } return(_factory.CreateMultiPolygon(polygons.ToArray())); case GeoJsonObjectType.GeometryCollection: List <IGeometry> geoms = _geoJsonSerializer.Deserialize <List <IGeometry> >(reader); return(_factory.CreateGeometryCollection(geoms.ToArray())); } return(null); }
/// <summary> /// Converts the geometry from Geography Markup Language (GML) representation. /// </summary> /// <param name="source">The source collection of XML elements.</param> /// <param name="geometryFactory">The geometry factory.</param> /// <param name="referenceSystemFactory">The reference system factory.</param> /// <returns>The converted geometry.</returns> /// <exception cref="System.ArgumentNullException"> /// The source is null. /// or /// The geometry factory is null. /// or /// The reference system factory is null. /// </exception> /// <exception cref="System.ArgumentException">The specified source is invalid.</exception> public static IGeometry ToGeometry(this IEnumerable <XElement> source, IGeometryFactory geometryFactory, IReferenceSystemFactory referenceSystemFactory) { if (source == null) { throw new ArgumentNullException(nameof(source)); } if (geometryFactory == null) { throw new ArgumentNullException(nameof(geometryFactory)); } if (referenceSystemFactory == null) { throw new ArgumentNullException(nameof(referenceSystemFactory)); } try { List <IGeometry> geometries = new List <IGeometry>(); foreach (XElement element in source) { geometries.Add(ToGeometry(element, geometryFactory, referenceSystemFactory)); } if (geometries.Count == 0) { return(null); } if (geometries.Count == 1) { return(geometries[0]); } if (geometries.All(geometry => geometry is IPoint)) { return(geometryFactory.CreateMultiPoint(geometries.Cast <IPoint>())); } if (geometries.All(geometry => geometry is ILineString)) { return(geometryFactory.CreateMultiLineString(geometries.Cast <ILineString>())); } if (geometries.All(geometry => geometry is IPolygon)) { return(geometryFactory.CreateMultiPolygon(geometries.Cast <IPolygon>())); } return(geometryFactory.CreateGeometryCollection(geometries)); } catch (Exception ex) { throw new ArgumentException(CoreMessages.SourceIsInvalid, nameof(source), ex); } }
/// <summary> /// Transforms a <see cref="GeoAPI.Geometries.IGeometryCollection"/>. /// </summary> /// <param name="geoms">GeometryCollection to transform</param> /// <param name="transform">MathTransform</param> /// <param name="targetFactory">The factory to create the target geometry</param> /// <returns>Transformed GeometryCollection</returns> public static IGeometryCollection TransformGeometryCollection(IGeometryCollection geoms, IMathTransform transform, IGeometryFactory targetFactory) { var geomList = new IGeometry[geoms.NumGeometries]; for (var i = 0; i < geoms.NumGeometries; i++) { geomList[i] = TransformGeometry(geoms[i], transform, targetFactory); } return(targetFactory.CreateGeometryCollection(geomList)); }
/// <summary> /// Creates a <see cref="GeometryCollection"/> using the next token in the stream. /// </summary> /// <param name="tokenizer"> Tokenizer over a stream of text in Well-known Text /// format. The next tokens must form a GeometryCollection Text.</param> /// <param name="factory">The factory to create the result geometry</param> /// <returns> /// A <see cref="GeometryCollection"/> specified by the next token in the stream.</returns> private static IGeometryCollection ReadGeometryCollectionText(WktStreamTokenizer tokenizer, IGeometryFactory factory) { var nextToken = GetNextEmptyOrOpener(tokenizer); if (nextToken.Equals("EMPTY")) { return(factory.CreateGeometryCollection(null)); } var geometries = new List <IGeometry>(); geometries.Add(ReadGeometryTaggedText(tokenizer)); nextToken = GetNextCloserOrComma(tokenizer); while (nextToken.Equals(",")) { geometries.Add(ReadGeometryTaggedText(tokenizer)); nextToken = GetNextCloserOrComma(tokenizer); } return(factory.CreateGeometryCollection(geometries.ToArray())); }
private IGeometry ReadGeometryCollection(int dim, int lrsDim, SdoGeometry sdoGeom) { List <IGeometry> geometries = new List <IGeometry>(); foreach (SdoGeometry elemGeom in sdoGeom.getElementGeometries()) { geometries.Add(ReadGeometry(elemGeom)); } return(factory.CreateGeometryCollection(geometries.ToArray())); }
/** * Reads one or more WKT geometries from a string. * * @param wkt * @param geomFact * @return * @throws ParseException * @throws IOException */ public static IGeometry ReadGeometriesFromWktString(String wkt, IGeometryFactory geomFact) { var reader = new WKTReader(geomFact); WKTFileReader fileReader = new WKTFileReader(new StringReader(wkt), reader); var geomList = fileReader.Read(); if (geomList.Count == 1) return geomList[0]; return geomFact.CreateGeometryCollection(GeometryFactory.ToGeometryArray(geomList)); }
/// <summary> /// Transforms a <see cref="GeoAPI.Geometries.IGeometryCollection"/>. /// </summary> /// <param name="geoms">GeometryCollection to transform</param> /// <param name="from">Source Projection</param> /// <param name="to">Target Projection</param> /// <param name="toFactory">The factory to create geometries for <paramref name="to"/></param> /// <returns>Transformed GeometryCollection</returns> public static IGeometryCollection TransformGeometryCollection(IGeometryCollection geoms, ProjectionInfo from, ProjectionInfo to, IGeometryFactory toFactory) { var gOut = new IGeometry[geoms.Count]; for (var i = 0; i < geoms.Count; i++) { gOut[i] = TransformGeometry(geoms.GetGeometryN(i), from, to, toFactory); } return(toFactory.CreateGeometryCollection(gOut)); }
internal static NTSGeometryCollection ToNTSGeometryCollection(Geometries.GeometryCollection geom, IGeometryFactory factory) { NTSGeometry[] geometries = new NTSGeometry[geom.Collection.Count]; int index = 0; foreach (Geometries.Geometry geometry in geom.Collection) { geometries[index++] = ToNTSGeometry(geometry, factory); } return(factory.CreateGeometryCollection(geometries) as NTSGeometryCollection); }
/// <summary> /// Transforms a <see cref="GeometryCollection" /> object. /// </summary> /// <param name="factory"></param> /// <param name="geoms"></param> /// <param name="transform"></param> /// <returns></returns> public static IGeometryCollection TransformGeometryCollection(IGeometryFactory factory, GeometryCollection geoms, IMathTransform transform) { List <IGeometry> coll = new List <IGeometry>(geoms.Geometries.Length); foreach (IGeometry g in geoms.Geometries) { IGeometry item = TransformGeometry(factory, g, transform); coll.Add(item); } return(factory.CreateGeometryCollection(coll.ToArray())); }
/// <summary> /// Creates a <c>GeometryCollection</c> using the next token in the /// stream. /// </summary> /// <param name="tokens"> /// Tokenizer over a stream of text in Well-known Text /// format. The next tokens must form a <GeometryCollection Text. /// </param> /// <param name="factory"> </param> /// <returns> /// A <c>GeometryCollection</c> specified by the /// next token in the stream.</returns> private IGeometryCollection ReadGeometryCollectionText(IEnumerator <Token> tokens, IGeometryFactory factory) { string nextToken = GetNextEmptyOrOpener(tokens); if (nextToken.Equals("EMPTY")) { return(factory.CreateGeometryCollection()); } var geometries = new List <IGeometry>(); var geometry = ReadGeometryTaggedText(tokens); geometries.Add(geometry); nextToken = GetNextCloserOrComma(tokens); while (nextToken.Equals(",")) { geometry = ReadGeometryTaggedText(tokens); geometries.Add(geometry); nextToken = GetNextCloserOrComma(tokens); } return(factory.CreateGeometryCollection(geometries.ToArray())); }
private IGeometry ReadGeometryCollection(int dim, int lrsDim, SdoGeometry sdoGeom) { List <IGeometry> geometries = new List <IGeometry>(); //foreach (SdoGeometry elemGeom in sdoGeom.getElementGeometries()) //{ // geometries.Add(ReadGeometry(elemGeom)); //} // TODO : Check if this will work SdoGeometry does not // have a getElementgeometries method anymore geometries.Add(ReadGeometry(sdoGeom)); return(factory.CreateGeometryCollection(geometries.ToArray())); }
/** * Reads one or more WKT geometries from a string. * * @param wkt * @param geomFact * @return * @throws ParseException * @throws IOException */ public static IGeometry ReadGeometriesFromWktString(string wkt, IGeometryFactory geomFact) { var reader = new WKTReader(geomFact); var fileReader = new WKTFileReader(new StringReader(wkt), reader); var geomList = fileReader.Read(); if (geomList.Count == 1) { return(geomList[0]); } return(geomFact.CreateGeometryCollection(GeometryFactory.ToGeometryArray(geomList))); }
/// <summary> /// Creates a <c>GeometryCollection</c> using the next token in the /// stream. /// </summary> /// <param name="tokens"> /// Tokenizer over a stream of text in Well-known Text /// format. The next tokens must form a <GeometryCollection Text. /// </param> /// <returns> /// A <c>GeometryCollection</c> specified by the /// next token in the stream.</returns> private IGeometryCollection ReadGeometryCollectionText(IList tokens) { string nextToken = GetNextEmptyOrOpener(tokens); if (nextToken.Equals("EMPTY")) { return(geometryFactory.CreateGeometryCollection(new IGeometry[] { })); } List <IGeometry> geometries = new List <IGeometry>(); IGeometry geometry = ReadGeometryTaggedText(tokens); geometries.Add(geometry); nextToken = GetNextCloserOrComma(tokens); while (nextToken.Equals(",")) { geometry = ReadGeometryTaggedText(tokens); geometries.Add(geometry); nextToken = GetNextCloserOrComma(tokens); } return(geometryFactory.CreateGeometryCollection(geometries.ToArray())); }
public void SetUp() { IPoint point = factory.CreatePoint(new Coordinate(1, 1)); ILineString linestring = factory.CreateLineString(new[] { new Coordinate(1, 1), new Coordinate(2, 2), new Coordinate(3, 3), }); ILinearRing shell = factory.CreateLinearRing(new[] { new Coordinate(1, 1), new Coordinate(2, 2), new Coordinate(3, 3), new Coordinate(1, 1) }); IPolygon polygon = factory.CreatePolygon(shell); geometries = new IGeometry[] { point, linestring, polygon }; serializedGeometries = "\"geometries\":[{\"type\":\"Point\",\"coordinates\":[1.0,1.0]},{\"type\":\"LineString\",\"coordinates\":[[1.0,1.0],[2.0,2.0],[3.0,3.0]]},{\"type\":\"Polygon\",\"coordinates\":[[[1.0,1.0],[2.0,2.0],[3.0,3.0],[1.0,1.0]]]}]"; collection = factory.CreateGeometryCollection(geometries); serializedCollection = "{\"type\":\"GeometryCollection\",\"geometries\":[{\"type\":\"Point\",\"coordinates\":[1.0,1.0]},{\"type\":\"LineString\",\"coordinates\":[[1.0,1.0],[2.0,2.0],[3.0,3.0]]},{\"type\":\"Polygon\",\"coordinates\":[[[1.0,1.0],[2.0,2.0],[3.0,3.0],[1.0,1.0]]]}]}"; }
/// <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> /// Gets the geometry for the triangles in a triangulated subdivision as a <see cref="IGeometryCollection"/> /// of triangular <see cref="IPolygon"/>s. /// </summary> /// <param name="geomFact">the GeometryFactory to use</param> /// <returns>a GeometryCollection of triangular Polygons</returns> public IGeometryCollection GetTriangles(IGeometryFactory geomFact) { var triPtsList = GetTriangleCoordinates(false); IPolygon[] tris = new Polygon[triPtsList.Count]; int i = 0; foreach (var triPt in triPtsList) { tris[i++] = geomFact .CreatePolygon(geomFact.CreateLinearRing(triPt), null); } return(geomFact.CreateGeometryCollection(tris)); }
///<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 static IGeometryCollection ParseWkbGeometryCollection(byte[] blob, ref int offset, IGeometryFactory factory, GaiaImport gaiaImport) { var number = gaiaImport.GetInt32(blob, ref offset); var geometries = new IGeometry[number]; for (var i = 0; i < number; i++) { if (blob[offset++] != (byte)GaiaGeoBlobMark.GAIA_MARK_ENTITY) { throw new Exception(); } geometries[i] = ParseWkbGeometry((GaiaGeoGeometry)gaiaImport.GetInt32(blob, ref offset), blob, ref offset, factory, gaiaImport); } return(factory.CreateGeometryCollection(geometries)); }
// see: https://github.com/NetTopologySuite/NetTopologySuite/issues/111 public void issue_111_pointhandler_with_invalid_values() { IGeometryFactory factory = GeometryFactory.Default; IPoint p = factory.CreatePoint(new Coordinate(0, 0)); IGeometry[] arr = { p, GeometryCollection.Empty }; IGeometryCollection geometries = factory.CreateGeometryCollection(arr); ShapeGeometryType shapeType = Shapefile.GetShapeType(geometries); Assert.AreEqual(ShapeGeometryType.PointZM, shapeType); string tempPath = Path.GetTempFileName(); ShapefileWriter sfw = new ShapefileWriter(Path.GetFileNameWithoutExtension(tempPath), shapeType); sfw.Write(geometries); }
/// <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> /// Transforms a <see cref="GeoAPI.Geometries.IGeometryCollection"/>. /// </summary> /// <param name="geoms">GeometryCollection to transform</param> /// <param name="from">Source Projection</param> /// <param name="to">Target Projection</param> /// <param name="toFactory">The factory to create geometries for <paramref name="to"/></param> /// <returns>Transformed GeometryCollection</returns> public static IGeometryCollection TransformGeometryCollection(IGeometryCollection geoms, ProjectionInfo from, ProjectionInfo to, IGeometryFactory toFactory) { var gOut = new IGeometry[geoms.Count]; for (var i = 0; i < geoms.Count; i++) gOut[i] = TransformGeometry(geoms.GetGeometryN(i), from, to, toFactory); return toFactory.CreateGeometryCollection(gOut); }
/// <summary> /// Gets the geometry for the triangles in a triangulated subdivision as a <see cref="IGeometryCollection"/> /// of triangular <see cref="IPolygon"/>s. /// </summary> /// <param name="geomFact">the GeometryFactory to use</param> /// <returns>a GeometryCollection of triangular Polygons</returns> public IGeometryCollection GetTriangles(IGeometryFactory geomFact) { var triPtsList = GetTriangleCoordinates(false); IPolygon[] tris = new Polygon[triPtsList.Count]; int i = 0; foreach (var triPt in triPtsList) { tris[i++] = geomFact .CreatePolygon(geomFact.CreateLinearRing(triPt), null); } return geomFact.CreateGeometryCollection(tris); }
/// <summary> /// Transforms a <see cref="GeoAPI.Geometries.IGeometryCollection"/>. /// </summary> /// <param name="geoms">GeometryCollection to transform</param> /// <param name="transform">MathTransform</param> /// <param name="targetFactory">The factory to create the target geometry</param> /// <returns>Transformed GeometryCollection</returns> public static IGeometryCollection TransformGeometryCollection(IGeometryCollection geoms, IMathTransform transform, IGeometryFactory targetFactory) { var geomList = new IGeometry[geoms.NumGeometries]; for(var i = 0; i < geoms.NumGeometries; i++) { geomList[i] = TransformGeometry(geoms[i], transform, targetFactory); } return targetFactory.CreateGeometryCollection(geomList); }
public static IGeometry ReadGeometriesFromWkbHexString(String wkb, IGeometryFactory geomFact) { var reader = new WKBReader(geomFact); var fileReader = new WKBHexFileReader(reader); var geomList = new List<IGeometry>(); using (var ms = new MemoryStream()) { new StreamWriter(ms).Write(wkb); geomList.AddRange(fileReader.Read(ms)); } if (geomList.Count == 1) return geomList[1]; return geomFact.CreateGeometryCollection(GeometryFactory.ToGeometryArray(geomList)); }
/// <summary> /// Creates an empty result geometry of the appropriate dimension, /// based on the given overlay operation and the dimensions of the inputs. /// The created geometry is always an atomic geometry, /// not a collection. /// <para/> /// The empty result is constructed using the following rules: /// <list type="Bullet"> /// <item><see cref="SpatialFunction.Intersection"/> - result has the dimension of the lowest input dimension</item> /// <item><see cref="SpatialFunction.Union"/> - result has the dimension of the highest input dimension</item> /// <item><see cref="SpatialFunction.Difference"/> - result has the dimension of the left-hand input</item> /// <item><see cref="SpatialFunction.SymDifference"/> - result has the dimension of the highest input dimension /// (since symDifference is the union of the differences).</item> /// </list> /// </summary> /// <param name="overlayOpCode">The overlay operation being performed</param> /// <param name="a">An input geometry</param> /// <param name="b">An input geometry</param> /// <param name="geomFact">The geometry factory being used for the operation</param> /// <returns>An empty atomic geometry of the appropriate dimension</returns> public static IGeometry CreateEmptyResult(SpatialFunction overlayOpCode, IGeometry a, IGeometry b, IGeometryFactory geomFact) { IGeometry result = null; switch (ResultDimension(overlayOpCode, a, b)) { case Dimension.False: result = geomFact.CreateGeometryCollection(new IGeometry[0]); break; case Dimension.Point: result = geomFact.CreatePoint((Coordinate)null); break; case Dimension.Curve: result = geomFact.CreateLineString((Coordinate[])null); break; case Dimension.Surface: result = geomFact.CreatePolygon(null, null); break; } return result; }
internal static NTSGeometryCollection ToNTSGeometryCollection(Geometries.GeometryCollection geom, IGeometryFactory factory) { NTSGeometry[] geometries = new NTSGeometry[geom.Collection.Count]; int index = 0; foreach (Geometries.Geometry geometry in geom.Collection) geometries[index++] = ToNTSGeometry(geometry, factory); return factory.CreateGeometryCollection(geometries) as NTSGeometryCollection; }
private static IGeometry CreateWKBGeometryCollection(BinaryReader reader, WkbByteOrder byteOrder, IGeometryFactory factory) { // The next byte in the array tells the number of geometries in this collection. var numGeometries = (int) ReadUInt32(reader, byteOrder); // Create a new array for the geometries. var geometries = new IGeometry[numGeometries]; // Loop on the number of geometries. for (var i = 0; i < numGeometries; i++) { // Call the main create function with the next geometry. geometries[i] = Parse(reader, factory); } // Create and return the next geometry. return factory.CreateGeometryCollection(geometries); }
/// <summary> /// Transforms a <see cref="GeometryCollection" /> object. /// </summary> /// <param name="factory"></param> /// <param name="geoms"></param> /// <param name="transform"></param> /// <returns></returns> public static IGeometryCollection TransformGeometryCollection(IGeometryFactory factory, GeometryCollection geoms, IMathTransform transform) { List<IGeometry> coll = new List<IGeometry>(geoms.Geometries.Length); foreach (IGeometry g in geoms.Geometries) { IGeometry item = TransformGeometry(factory, g, transform); coll.Add(item); } return factory.CreateGeometryCollection(coll.ToArray()); }
private static IGeometryCollection ParseWkbGeometryCollection(byte[] blob, ref int offset, IGeometryFactory factory, GaiaImport gaiaImport) { var number = gaiaImport.GetInt32(blob, ref offset); var geometries = new IGeometry[number]; for (var i = 0; i < number; i++) { if (blob[offset++] != (byte)GaiaGeoBlobMark.GAIA_MARK_ENTITY) throw new Exception(); geometries[i] = ParseWkbGeometry((GaiaGeoGeometry)gaiaImport.GetInt32(blob, ref offset), blob, ref offset, factory, gaiaImport); } return factory.CreateGeometryCollection(geometries); }
/// <summary> /// Creates a <see cref="GeometryCollection"/> using the next token in the stream. /// </summary> /// <param name="tokenizer"> Tokenizer over a stream of text in Well-known Text /// format. The next tokens must form a GeometryCollection Text.</param> /// <param name="factory">The factory to create the result geometry</param> /// <returns> /// A <see cref="GeometryCollection"/> specified by the next token in the stream.</returns> private static IGeometryCollection ReadGeometryCollectionText(WktStreamTokenizer tokenizer, IGeometryFactory factory) { var nextToken = GetNextEmptyOrOpener(tokenizer); if (nextToken.Equals("EMPTY")) return factory.CreateGeometryCollection(null); var geometries = new List<IGeometry>(); geometries.Add(ReadGeometryTaggedText(tokenizer)); nextToken = GetNextCloserOrComma(tokenizer); while (nextToken.Equals(",")) { geometries.Add(ReadGeometryTaggedText(tokenizer)); nextToken = GetNextCloserOrComma(tokenizer); } return factory.CreateGeometryCollection(geometries.ToArray()); }
/// <summary> /// Creates a <c>GeometryCollection</c> using the next token in the /// stream. /// </summary> /// <param name="tokens"> /// Tokenizer over a stream of text in Well-known Text /// format. The next tokens must form a <GeometryCollection Text. /// </param> /// <param name="factory"> </param> /// <returns> /// A <c>GeometryCollection</c> specified by the /// next token in the stream.</returns> private IGeometryCollection ReadGeometryCollectionText(IEnumerator<Token> tokens, IGeometryFactory factory) { string nextToken = GetNextEmptyOrOpener(tokens); if (nextToken.Equals("EMPTY")) return factory.CreateGeometryCollection(new IGeometry[] { } ); var geometries = new List<IGeometry>(); var geometry = ReadGeometryTaggedText(tokens); geometries.Add(geometry); nextToken = GetNextCloserOrComma(tokens); while (nextToken.Equals(",")) { geometry = ReadGeometryTaggedText(tokens); geometries.Add(geometry); nextToken = GetNextCloserOrComma(tokens); } return factory.CreateGeometryCollection(geometries.ToArray()); }
/// <summary> /// Gets the cells in the Voronoi diagram for this triangulation. /// The cells are returned as a <see cref="IGeometryCollection" /> of <see cref="IPolygon"/>s /// </summary> /// <remarks> /// The userData of each polygon is set to be the <see cref="Coordinate" /> /// of the cell site. This allows easily associating external /// data associated with the sites to the cells. /// </remarks> /// <param name="geomFact">a geometry factory</param> /// <returns>a GeometryCollection of Polygons</returns> public IGeometryCollection GetVoronoiDiagram(IGeometryFactory geomFact) { var vorCells = GetVoronoiCellPolygons(geomFact); return geomFact.CreateGeometryCollection(GeometryFactory.ToGeometryArray(vorCells)); }