private void MergeGeometry(IFeature target, IFeature source) { if (!target.Attributes[FeatureAttributes.POI_SOURCE].Equals(Sources.OSM) || !source.Attributes[FeatureAttributes.POI_SOURCE].Equals(Sources.OSM)) { // only merge geometry between OSM features return; } if (target.Geometry is GeometryCollection geometryCollection) { if (source.Geometry is GeometryCollection geometryCollectionSource) { target.Geometry = _geometryFactory.CreateGeometryCollection(geometryCollection.Geometries.Concat(geometryCollectionSource.Geometries).ToArray()); } else { target.Geometry = _geometryFactory.CreateGeometryCollection(geometryCollection.Geometries.Concat(new[] { source.Geometry }).ToArray()); } } else { target.Geometry = _geometryFactory.CreateGeometryCollection(new[] { target.Geometry, source.Geometry }); } }
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 Geometry[] {}).Boundary; Assert.IsTrue(false); } catch (ArgumentException e) { } }
private GeometryCollection ReadGeometryCollection() { int nGeometries = m_objReader.ReadInt32(); if (nGeometries <= 0) { return(null); } Geometry[] geometries = new Geometry[nGeometries]; for (int i = 0; i < nGeometries; i++) { BytesOrder byteOrder = (BytesOrder)m_objReader.ReadByte(); // handle the byte order m_objReader.Order = byteOrder; int geomType = m_objReader.ReadInt32(); switch (geomType) { case 1: geometries[i] = ReadPoint(); break; case 2: geometries[i] = ReadLineString(); break; case 3: geometries[i] = ReadPolygon(); break; case 4: geometries[i] = ReadMultiPoint(); break; case 5: geometries[i] = ReadMultiLineString(); break; case 6: geometries[i] = ReadMultiPolygon(); break; case 7: geometries[i] = ReadGeometryCollection(); break; default: throw new GeometryIOException("The geometry type is not supported."); } } return(m_objFactory.CreateGeometryCollection(geometries)); }
protected virtual Geometry Transform(GeometryCollection geom, Geometry parent) { GeometryList transGeomList = new GeometryList(); for (int i = 0; i < geom.NumGeometries; i++) { Geometry transformGeom = Transform(geom[i]); if (transformGeom == null) { continue; } if (pruneEmptyGeometry && transformGeom.IsEmpty) { continue; } transGeomList.Add(transformGeom); } if (preserveGeometryCollectionType) { return(geomFactory.CreateGeometryCollection(transGeomList.ToArray())); } return(geomFactory.BuildGeometry(transGeomList)); }
/// <summary> /// Gets the computed variable-width line buffer. /// </summary> /// <returns>A polygon</returns> public Geometry GetResult() { Utilities.Assert.IsTrue(_line.NumPoints == _width.Length); var parts = new List <Geometry>(); var pts = _line.Coordinates; for (int i = 0; i < _line.NumPoints; i++) { double 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); }
public void test_Dimension() { //create a geomerty collection GeometryCollection geoColl = CreateCollection(); //returns 0 because a point has a dimension of 0 & that is the largest dimesion in the collection Assertion.AssertEquals("Dimension-1: ", 0, geoColl.GetDimension()); //now try it with a null geometry collection GeometryFactory gf = new GeometryFactory(_precMod, _sRID); geoColl = gf.CreateGeometryCollection(null); //returns -1 because the collection is empty Assertion.AssertEquals("Dimension-2: ", -1, geoColl.GetDimension()); //now try it with a different geometry collection geoColl = CreateCollection2(); //returns 1 because linestring has a dimension of 1 & that is the largest dimension in the collection Assertion.AssertEquals("Dimension-3: ", 1, geoColl.GetDimension()); //returns 1 because linestring has a dimension of 1 & that is the largest dimension in the collection geoColl = CreateCollection3(); Assertion.AssertEquals("Dimension-4: ", 1, geoColl.GetDimension()); }
private GeometryCollection CreateCollection() { //this is used to prevent having to rewrite this code over & over //create a new coordinate Coordinate coordinate = new Coordinate(); //create a new point GeometryFactory gf = new GeometryFactory(_precMod, _sRID); Point point = gf.CreatePoint(coordinate); //create a new geometries array Geometry[] geom = new Geometry[10]; //fill with points for (int i = 0; i < 10; i++) { //if this isn't here the coordinates for all the points are reset every time the coordinate is reset coordinate = new Coordinate(); //make the x coordinate equal to the iterator coordinate.X = (double)i; //make the y coordinate equal to the iterator plus 10 coordinate.Y = (double)i + 10; //create a new point to put in the geometry point = gf.CreatePoint(coordinate); //put the point in the geometies geom[i] = point; } //put the geometries into a geometry collection GeometryCollection geoColl = gf.CreateGeometryCollection(geom); return(geoColl); }
/// <summary> /// Computes the buffer polygon. /// </summary> /// <returns>A buffer polygon</returns> public Geometry GetResult() { var parts = new List <Geometry>(); var pts = _line.Coordinates; // construct segment buffers for (int i = 1; i < pts.Length; i++) { double dist0 = _distance[i - 1]; double dist1 = _distance[i]; if (dist0 > 0 || dist1 > 0) { var poly = SegmentBuffer(pts[i - 1], pts[i], dist0, dist1); if (poly != null) { parts.Add(poly); } } } var partsGeom = _geomFactory.CreateGeometryCollection(parts.ToArray()); var buffer = partsGeom.Union(); // ensure an empty polygon is returned if needed if (buffer.IsEmpty) { return(_geomFactory.CreatePolygon()); } return(buffer); }
public void test_Coordinates() { //create a geomerty collection GeometryCollection geoColl = CreateCollection(); //this geometry conatins 10 sets of coordinates Assertion.AssertEquals("Coordinates-1: ", 10, geoColl.GetCoordinates().Count); //now try it with a null geometry collection GeometryFactory gf = new GeometryFactory(_precMod, _sRID); geoColl = gf.CreateGeometryCollection(null); Assertion.AssertEquals("Coordinates-2: ", 0, geoColl.GetCoordinates().Count); //now try it with a different geometry collection geoColl = CreateCollection2(); //1000 sets of coordinates Assertion.AssertEquals("Cordinates-3: ", 1000, geoColl.GetCoordinates().Count); //now try it with a mixed geometry collection geoColl = CreateCollection3(); Assertion.AssertEquals("Coordinates-4: ", 130, geoColl.GetCoordinates().Count); }
private GeometryCollection CreateCollection2() { //create a new geometries array Geometry[] geom = new Geometry[10]; Coordinate coordinate = new Coordinate(); Coordinates coords = new Coordinates(); GeometryFactory gf = new GeometryFactory(_precMod, _sRID); LineString lineString = gf.CreateLineString(coords); for (int c = 0; c < 10; c++) { for (int i = c; i < c + 10; i++) { //if this isn't here the coordinates for all the points are reset every time the coordinate is reset coordinate = new Coordinate(); //make the x coordinate equal to the iterator coordinate.X = (double)i; //make the y coordinate equal to the iterator plus 10 coordinate.Y = (double)i + 10; coords.Add(coordinate); } lineString = gf.CreateLineString(coords); geom[c] = lineString; } //put the geometries into a geometry collection GeometryCollection geoColl = gf.CreateGeometryCollection(geom); return(geoColl); }
public static IGeometry SqlGeometryToGeometry(SqlGeometry geom, GeometryFactory factory) { if (geom.STIsEmpty()) { return(factory.CreateGeometryCollection(null)); } OpenGisGeometryType geometryType = (OpenGisGeometryType)Enum.Parse(typeof(OpenGisGeometryType), geom.STGeometryType().Value); switch (geometryType) { case OpenGisGeometryType.Point: return(SqlGeometryToGeometryPoint(geom, factory)); case OpenGisGeometryType.LineString: return(SqlGeometryToGeometryLineString(geom, factory)); case OpenGisGeometryType.Polygon: return(SqlGeometryToGeometryPolygon(geom, factory)); case OpenGisGeometryType.MultiPoint: return(SqlGeometryToGeometryMultiPoint(geom, factory)); case OpenGisGeometryType.MultiLineString: return(SqlGeometryToGeometryMultiLineString(geom, factory)); case OpenGisGeometryType.MultiPolygon: return(SqlGeometryToGeometryMultiPolygon(geom, factory)); case OpenGisGeometryType.GeometryCollection: return(SqlGeometryToGeometryGeometryCollection(geom, factory)); } throw new ArgumentException(string.Format("Cannot convert SqlServer '{0}' to Geometry", geom.STGeometryType()), "geom"); }
/// <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 an atomic geometry, /// not a collection(unless the dimension is <see cref="Dimension.Unknown"/>, /// in which case a <c>GEOMETRYCOLLECTION EMPTY</c> is created. /// </summary> /// <param name="dim">The dimension of the empty geometry</param> /// <param name="geomFact">The geometry factory being used for the operation</param> /// <returns>An empty atomic geometry of the appropriate dimension</returns> internal static Geometry CreateEmptyResult(Dimension dim, GeometryFactory geomFact) { Geometry result = null; switch (dim) { case Dimension.Point: result = geomFact.CreatePoint(); break; case Dimension.Curve: result = geomFact.CreateLineString(); break; case Dimension.Surface: result = geomFact.CreatePolygon(); break; case Dimension.Unknown: result = geomFact.CreateGeometryCollection(); break; default: Assert.ShouldNeverReachHere("Unable to determine overlay result geometry dimension"); break; } return(result); }
/// <summary> /// Reads a <see cref="GeometryCollection"/> 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 GeometryCollection ReadGeometryCollection(BinaryReader reader, GeometryFactory factory) { int numGeometries = reader.ReadInt32(); var geometries = new Geometry[numGeometries]; ReadGeometryArray(reader, geometries); return(factory.CreateGeometryCollection(geometries)); }
/// <summary> /// Transforms a <see cref="GeometryCollection"/>. /// </summary> /// <param name="geoms">GeometryCollection to transform</param> /// <param name="transform">MathTransform</param> /// <returns>Transformed GeometryCollection</returns> public static GeoAPI.Geometries.IGeometryCollection TransformGeometryCollection(GeoAPI.Geometries.IGeometryCollection geoms, IMathTransform transform) { List <IGeometry> coll = new List <IGeometry>(geoms.Geometries.Length); foreach (IGeometry g in geoms.Geometries) { coll.Add(TransformGeometry(g, transform)); } return(GeometryFactory.CreateGeometryCollection(coll.ToArray())); }
/// <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 GeometryCollection ReadGeometryCollectionText(WktStreamTokenizer tokenizer, GeometryFactory factory) { var nextToken = GetNextEmptyOrOpener(tokenizer); if (nextToken.Equals("EMPTY")) { return(factory.CreateGeometryCollection(null)); } var geometries = new List <Geometry>(); geometries.Add(ReadGeometryTaggedText(tokenizer)); nextToken = GetNextCloserOrComma(tokenizer); while (nextToken.Equals(",")) { geometries.Add(ReadGeometryTaggedText(tokenizer)); nextToken = GetNextCloserOrComma(tokenizer); } return(factory.CreateGeometryCollection(geometries.ToArray())); }
private static object CreateResult(List <Geometry> result, GeometryFactory geometryFactory) { if (result.Count == 1) { return(result[0]); } var resultGeoms = result.ToArray(); return(geometryFactory.CreateGeometryCollection(resultGeoms)); }
private static IGeometryCollection SqlGeometryToGeometryGeometryCollection(SqlGeometry geometry, GeometryFactory factory) { IGeometry[] geoms = new IGeometry[geometry.STNumGeometries().Value]; for (int i = 1; i <= geoms.Length; i++) { geoms[i - 1] = SqlGeometryToGeometry(geometry.STGeometryN(i), factory); } return(factory.CreateGeometryCollection(geoms)); }
/// <summary> /// Transforms a <see cref="NetTopologySuite.Geometries.GeometryCollection"/>. /// </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 GeometryCollection TransformGeometryCollection(GeometryCollection geoms, MathTransform transform, GeometryFactory targetFactory) { var geomList = new Geometry[geoms.NumGeometries]; for (var i = 0; i < geoms.NumGeometries; i++) { geomList[i] = TransformGeometry(geoms[i], transform, targetFactory); } return(targetFactory.CreateGeometryCollection(geomList)); }
public void CreateEmptyGeometryCollectionSucceeds() { GeometryFactory factory = new GeometryFactory( new BufferedCoordinate2DFactory(), new BufferedCoordinate2DSequenceFactory()); IGeometryCollection g = factory.CreateGeometryCollection(); Assert.IsNotNull(g); Assert.IsTrue(g.IsEmpty); }
internal static GeometryCollection ToNTSGeometryCollection(Geometries.GeometryCollection geometryCollection, GeometryFactory factory) { Geometry[] geometries = new Geometry[geometryCollection.Collection.Count]; int index = 0; foreach (Geometries.Geometry geometry in geometryCollection.Collection) { geometries[index++] = ToNTSGeometry(geometry, factory); } return(factory.CreateGeometryCollection(geometries) as GeometryCollection); }
/** * Creates a <code>GeometryCollection</code> using the next token in the * stream. * *@param tokenizer tokenizer over a stream of text in Well-known Text * format. The next tokens must form a <GeometryCollection Text>. *@return a <code>GeometryCollection</code> specified by the * next token in the stream *@throws ParseException if the coordinates used to create a <code>Polygon</code> * shell and holes do not form closed linestrings, or if an unexpected * token was encountered *@throws IOException if an I/O error occurs */ private GeometryCollection ReadGeometryCollectionText(WktStreamTokenizer tokenizer) { string nextToken = GetNextEmptyOrOpener(tokenizer); if (nextToken == "EMPTY") { return(_geometryFactory.CreateGeometryCollection(new Geometry[] {})); } ArrayList geometries = new ArrayList(); Geometry geometry = ReadGeometryTaggedText(tokenizer); geometries.Add(geometry); nextToken = GetNextCloserOrComma(tokenizer); while (nextToken == ",") { geometry = ReadGeometryTaggedText(tokenizer); geometries.Add(geometry); nextToken = GetNextCloserOrComma(tokenizer); } Geometry[] array = new Geometry[geometries.Count]; return(_geometryFactory.CreateGeometryCollection((Geometry[])geometries.ToArray(typeof(Geometry)))); }
/** * Reads one or more WKT geometries from a string. * * @param wkt * @param geomFact * @return * @throws ParseException * @throws IOException */ public static Geometry ReadGeometriesFromWktString(string wkt, GeometryFactory 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 GeometryCollection ReadGeometryCollectionText(IList tokens) { string nextToken = GetNextEmptyOrOpener(tokens); if (nextToken.Equals("EMPTY")) //NOXLATE { return(geometryFactory.CreateGeometryCollection(Array.Empty <NetTopologySuite.Geometries.Geometry>())); } var geometries = new List <NetTopologySuite.Geometries.Geometry>(); var geometry = ReadGeometryTaggedText(tokens); geometries.Add(geometry); nextToken = GetNextCloserOrComma(tokens); while (nextToken.Equals(",")) //NOXLATE { geometry = ReadGeometryTaggedText(tokens); geometries.Add(geometry); nextToken = GetNextCloserOrComma(tokens); } return(geometryFactory.CreateGeometryCollection(geometries.ToArray())); }
/// <summary> /// Gets the geometry for the triangles in a triangulated subdivision as a <see cref="GeometryCollection"/> /// of triangular <see cref="Polygon"/>s. /// </summary> /// <param name="geomFact">the GeometryFactory to use</param> /// <returns>a GeometryCollection of triangular Polygons</returns> public GeometryCollection GetTriangles(GeometryFactory geomFact) { var triPtsList = GetTriangleCoordinates(false); var tris = new Polygon[triPtsList.Count]; int i = 0; foreach (var triPt in triPtsList) { tris[i++] = geomFact .CreatePolygon(geomFact.CreateLinearRing(triPt)); } return(geomFact.CreateGeometryCollection(tris)); }
public void SetUp() { var point = factory.CreatePoint(new Coordinate(1, 1)); var linestring = factory.CreateLineString(new[] { new Coordinate(1, 1), new Coordinate(2, 2), new Coordinate(3, 3), }); var shell = factory.CreateLinearRing(new[] { new Coordinate(1, 1), new Coordinate(2, 2), new Coordinate(3, 3), new Coordinate(1, 1) }); var polygon = factory.CreatePolygon(shell); geometries = new Geometry[] { 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]]]}]"; "[{\"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]]]}]}"; }
private GeometryCollection LoadData() { List <Geometry> data = null; try { data = readWKTFile(EmbeddedResourceManager.GetResourceStream("NetTopologySuite.Tests.NUnit.TestData.world.wkt")); } catch (Exception e) { Console.WriteLine(e.StackTrace); } return(Factory.CreateGeometryCollection(data.ToArray())); }
public void TestCreateEmpty() { CheckEmpty(Factory.CreateEmpty(Dimension.Point), typeof(Point)); CheckEmpty(Factory.CreateEmpty(Dimension.Curve), typeof(LineString)); CheckEmpty(Factory.CreateEmpty(Dimension.Surface), typeof(Polygon)); CheckEmpty(Factory.CreatePoint(), typeof(Point)); CheckEmpty(Factory.CreateLineString(), typeof(LineString)); CheckEmpty(Factory.CreatePolygon(), typeof(Polygon)); CheckEmpty(Factory.CreateMultiPoint(), typeof(MultiPoint)); CheckEmpty(Factory.CreateMultiLineString(), typeof(MultiLineString)); CheckEmpty(Factory.CreateMultiPolygon(), typeof(MultiPolygon)); CheckEmpty(Factory.CreateGeometryCollection(), typeof(GeometryCollection)); }
/// <summary> /// Writes two geometries to an svg file /// </summary> /// <param name="filename">The path of the svg file.</param> /// <param name="a">The A geometry</param> /// <param name="b">The B geometry</param> public void DisplayTest(string filename, Geometry a, Geometry b) { Geotools.Geometries.PrecisionModel pm = new Geotools.Geometries.PrecisionModel(1, 0, 0); GeometryFactory fact = new GeometryFactory(pm, 0); GeometrySVGWriter svgWriter = new GeometrySVGWriter(fact.PrecisionModel); StreamWriter sw = new StreamWriter(filename); GeometryCollection geomCollection = fact.CreateGeometryCollection(new Geometry[] { a, b }); double minx, miny, maxx, maxy; geomCollection.Extent2D(out minx, out miny, out maxx, out maxy); sw.WriteLine(String.Format("<svg viewBox=\"{0} {1} {2} {3}\">", minx, miny, maxx, maxy * 1.2)); svgWriter.Write(a, sw, "fill-rule:evenodd;", "fill:blue;stroke:blue;stroke-width:1;fill-opacity:0.2"); svgWriter.Write(b, sw, "fill-rule:evenodd;", "fill:red;stroke:red;stroke-width:1;fill-opacity:0.2"); sw.WriteLine("</svg>"); sw.Close(); }
/// <summary> /// Creates a geometrycollection from the wkb. /// </summary> /// <returns>A geometry.</returns> private Geometry CreateWKBGeometryCollection() { //The next byte in the array tells the number of geometries in this collection. int numGeometries = (int)_bReader.ReadUInt32(); //Create a new array for the geometries. Geometry[] geometries = new Geometry[numGeometries]; //Loop on the number of geometries. for (int i = 0; i < numGeometries; i++) { //Call the main create function with the next geometry. geometries[i] = Create(); } //Create and return the next geometry. return(_geometryFactory.CreateGeometryCollection(geometries)); }
private static Geometry CreateWKBGeometryCollection(BinaryReader reader, WkbByteOrder byteOrder, GeometryFactory 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 Geometry[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)); }