private static IGeometryCollection ClipGeometryCollection(IGeometryCollection geom, Envelope clipEnv) { var clipPoly = geom.Factory.ToGeometry(clipEnv); var clipped = new List<IGeometry>(); for (var i = 0; i < geom.NumGeometries; i++) { var g = geom.GetGeometryN(i); IGeometry result = null; // don't clip unless necessary if (clipEnv.Contains(g.EnvelopeInternal)) result = g; else if (clipEnv.Intersects(g.EnvelopeInternal)) { result = clipPoly.Intersection(g); // keep vertex key info result.UserData = g.UserData; } if (result != null && !result.IsEmpty) { clipped.Add(result); } } return geom.Factory.CreateGeometryCollection(GeometryFactory.ToGeometryArray(clipped)); }
/// <summary> /// Adds a <see cref="IGeometry"/> to the centroid total. /// </summary> /// <param name="geom">>The <see cref="IGeometry"/> to add.</param> private void Add(IGeometry geom) { if (geom.IsEmpty) { return; } if (geom is IPoint) { AddPoint(geom.Coordinate); } else if (geom is ILineString) { AddLineSegments(geom.Coordinates); } else if (geom is IPolygon) { IPolygon poly = (IPolygon)geom; Add(poly); } else if (geom is IGeometryCollection) { IGeometryCollection gc = (IGeometryCollection)geom; for (int i = 0; i < gc.NumGeometries; i++) { Add(gc.GetGeometryN(i)); } } }
protected internal override int CompareToSameClass(object o, IComparer <ICoordinateSequence> comp) { IGeometryCollection gc = (IGeometryCollection)o; int n1 = NumGeometries; int n2 = gc.NumGeometries; int i = 0; while (i < n1 && i < n2) { IGeometry thisGeom = GetGeometryN(i); Assert.IsTrue(thisGeom is Geometry); IGeometry otherGeom = gc.GetGeometryN(i); int holeComp = ((Geometry)thisGeom).CompareToSameClass(otherGeom, comp); if (holeComp != 0) { return(holeComp); } i++; } if (i < n1) { return(1); } if (i < n2) { return(-1); } return(0); }
private static IGeometryCollection ClipGeometryCollection(IGeometryCollection geom, Envelope clipEnv) { IGeometry clipPoly = geom.Factory.ToGeometry(clipEnv); List <IGeometry> clipped = new List <IGeometry>(); for (int i = 0; i < geom.NumGeometries; i++) { IGeometry g = geom.GetGeometryN(i); IGeometry result = null; // don't clip unless necessary if (clipEnv.Contains(g.EnvelopeInternal)) { result = g; } else if (clipEnv.Intersects(g.EnvelopeInternal)) { result = clipPoly.Intersection(g); // keep vertex key info result.UserData = g.UserData; } if (result != null && !result.IsEmpty) { clipped.Add(result); } } return(geom.Factory.CreateGeometryCollection(GeometryFactory.ToGeometryArray(clipped))); }
/// <summary> /// /// </summary> /// <param name="collection"></param> /// <param name="operation"></param> /// <returns></returns> private IGeometryCollection EditGeometryCollection(IGeometryCollection collection, GeometryEditorOperation operation) { IGeometryCollection newCollection = (IGeometryCollection)operation.Edit(collection, factory); ArrayList geometries = new ArrayList(); for (int i = 0; i < newCollection.NumGeometries; i++) { IGeometry geometry = Edit(newCollection.GetGeometryN(i), operation); if (geometry.IsEmpty) { continue; } geometries.Add(geometry); } if (newCollection is IMultiPoint) { return(factory.CreateMultiPoint((IPoint[])geometries.ToArray(typeof(IPoint)))); } if (newCollection is IMultiLineString) { return(factory.CreateMultiLineString((ILineString[])geometries.ToArray(typeof(ILineString)))); } if (newCollection is IMultiPolygon) { return(factory.CreateMultiPolygon((IPolygon[])geometries.ToArray(typeof(IPolygon)))); } return(factory.CreateGeometryCollection((IGeometry[])geometries.ToArray(typeof(IGeometry)))); }
private static void DoTest(Type expectedType) { string name = expectedType.Name; string file = String.Format("{0}s", name.ToLowerInvariant().Substring(1)); string resname = String.Format("NetTopologySuite.Tests.NUnit.TestData.{0}.xml", file); string path = EmbeddedResourceManager.SaveEmbeddedResourceToTempFile(resname); var doc = #if !PCL new XmlDocument(); doc.Load(path); #else XDocument.Load(path); #endif GMLReader gr = new GMLReader(); IGeometryCollection gc = (IGeometryCollection)gr.Read(doc); Assert.IsTrue(gc.NumGeometries == 25); for (int i = 0; i < 25; i++) { IGeometry g = gc.GetGeometryN(i); Assert.IsNotNull(g); Assert.IsInstanceOf(expectedType, g); } }
public void LoadSourceGeometries(IGeometryCollection geomColl) { for (int i = 0; i < geomColl.NumGeometries; i++) { IGeometry geom = geomColl.GetGeometryN(i); LoadVertices(geom.Coordinates, geom.UserData); } }
/// <summary> /// /// </summary> /// <param name="gc"></param> private void AddCollection(IGeometryCollection gc) { for (int i = 0; i < gc.NumGeometries; i++) { IGeometry g = gc.GetGeometryN(i); Add(g); } }
private void AddCollection(IGeometryCollection gc) { for (int i = 0; i < gc.GetNumGeometries(); i++) { Geometry g = (Geometry)gc.GetGeometryN(i); Add(g); } } // private void AddCollection(OGC.Geometries.IGeometryCollection gc)
/// <summary> /// /// </summary> /// <param name="gc"></param> /// <returns></returns> private IGeometry WidestGeometry(IGeometryCollection gc) { if (gc.IsEmpty) { return(gc); } IGeometry widestGeometry = gc.GetGeometryN(0); for (int i = 1; i < gc.NumGeometries; i++) //Start at 1 { if (gc.GetGeometryN(i).EnvelopeInternal.Width > widestGeometry.EnvelopeInternal.Width) { widestGeometry = gc.GetGeometryN(i); } } return(widestGeometry); }
private void WriteGeometryCollection(IGeometryCollection gc, int level, StringBuilder sb) { StartLine("<MultiGeometry>\n", level, sb); for (int t = 0; t < gc.NumGeometries; t++) { WriteGeometry(gc.GetGeometryN(t), level + 1, sb); } StartLine("</MultiGeometry>\n", level, sb); }
private static IGeometry WidestGeometry(IGeometryCollection gc) { if (gc.IsEmpty) { return(gc); } var widestGeometry = gc.GetGeometryN(0); // scan remaining geom components to see if any are wider for (int i = 1; i < gc.NumGeometries; i++) //Start at 1 { if (gc.GetGeometryN(i).EnvelopeInternal.Width > widestGeometry.EnvelopeInternal.Width) { widestGeometry = gc.GetGeometryN(i); } } return(widestGeometry); }
/// <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> /// /// </summary> /// <param name="gc"></param> /// <returns></returns> public IGeometryCollection Map(IGeometryCollection gc) { IList<IGeometry> mapped = new List<IGeometry>(); for (var i = 0; i < gc.NumGeometries; i++) { var g = _mapOp(gc.GetGeometryN(i)); if (!g.IsEmpty) mapped.Add(g); } return gc.Factory.CreateGeometryCollection( GeometryFactory.ToGeometryArray(mapped)); }
/// <summary> /// /// </summary> /// <param name="gc"></param> /// <returns></returns> private bool HasRepeatedPoint(IGeometryCollection gc) { for (int i = 0; i < gc.NumGeometries; i++) { IGeometry g = gc.GetGeometryN(i); if (HasRepeatedPoint(g)) { return(true); } } return(false); }
private GraphicsPath ToShape(IGeometryCollection gc) { var shape = new GeometryCollectionGraphicsPath(); // add components to GC shape for (int i = 0; i < gc.NumGeometries; i++) { var g = gc.GetGeometryN(i); shape.Add(ToShape(g)); } return(shape.Path); }
private static void WriteCollection(IGeometryCollection geometry, PostGis2GeometryHeader pgh, BinaryWriter writer) { writer.Write((uint)geometry.OgcGeometryType.ToPostGis2()); if (geometry.IsEmpty) { writer.Write(0); return; } for (var i = 0; i < geometry.NumGeometries; i++) { Write(geometry.GetGeometryN(i), writer, pgh.Ordinates, pgh.IsGeodetic); } }
private SdoGeometry Write(IGeometryCollection geometryCollection) { var elemInfoList = new List <decimal>(); var ordinateList = new List <decimal>(); int pos = 1; int cnt = geometryCollection.NumGeometries; for (int i = 0; i < cnt; i++) { var geom = geometryCollection.GetGeometryN(i); switch (geom.OgcGeometryType) { case OgcGeometryType.Point: pos = ProcessPoint((IPoint)geom, elemInfoList, ordinateList, pos); break; case OgcGeometryType.LineString: pos = ProcessLinear((ILineString)geom, elemInfoList, ordinateList, pos); break; case OgcGeometryType.Polygon: pos = ProcessPolygon((IPolygon)geom, elemInfoList, ordinateList, pos); break; case OgcGeometryType.MultiPoint: pos = ProcessMultiPoint((IMultiPoint)geom, elemInfoList, ordinateList, pos); break; case OgcGeometryType.MultiLineString: pos = ProcessMultiLineString((IMultiLineString)geom, elemInfoList, ordinateList, pos); break; case OgcGeometryType.MultiPolygon: pos = ProcessMultiPolygon((IMultiPolygon)geom, elemInfoList, ordinateList, pos); break; default: throw new ArgumentException("Geometry not supported in GeometryCollection: " + geom); } } return(new SdoGeometry { SdoGtype = GType(geometryCollection), Sdo_Srid = geometryCollection.SRID, ElemArray = elemInfoList.ToArray(), OrdinatesArray = ordinateList.ToArray(), }); }
/// <summary> /// /// </summary> /// <param name="collection"></param> /// <returns></returns> private static ICoordinateSequence BuildSequence(IGeometryCollection collection) { var seq = collection.Factory.CoordinateSequenceFactory.Create(collection.NumPoints, DetectOrdinates(collection)); var count = 0; for (var i = 0; i < collection.Count; i++) { var tmp = collection.GetGeometryN(i); ICoordinateSequence tmpSeq = null; switch (tmp.OgcGeometryType) { case OgcGeometryType.Point: tmpSeq = ((IPoint)tmp).CoordinateSequence; break; case OgcGeometryType.LineString: tmpSeq = ((ILineString)tmp).CoordinateSequence; break; case OgcGeometryType.Polygon: var poly = (IPolygon)tmp; tmpSeq = poly.ExteriorRing.CoordinateSequence; if (poly.NumInteriorRings > 0) { CoordinateSequences.Copy(tmpSeq, 0, seq, count, tmpSeq.Count); int j; for (j = 0; j < poly.NumInteriorRings - 1; j++) { tmpSeq = poly.GetInteriorRingN(j).CoordinateSequence; CoordinateSequences.Copy(tmpSeq, 0, seq, count, tmpSeq.Count); count += tmpSeq.Count; } tmpSeq = poly.GetInteriorRingN(j).CoordinateSequence; } break; default: throw new ArgumentException("Invalid geometry type"); } if (tmpSeq != null) { CoordinateSequences.Copy(tmpSeq, 0, seq, count, tmpSeq.Count); count += tmpSeq.Count; } } return(seq); }
/// <summary> /// /// </summary> /// <param name="gc"></param> /// <returns></returns> public IGeometryCollection Map(IGeometryCollection gc) { IList <IGeometry> mapped = new List <IGeometry>(); for (var i = 0; i < gc.NumGeometries; i++) { var g = _mapOp(gc.GetGeometryN(i)); if (!g.IsEmpty) { mapped.Add(g); } } return(gc.Factory.CreateGeometryCollection( GeometryFactory.ToGeometryArray(mapped))); }
private static GeoAPIGeometryCollection FromGeometryCollection(IGeometryCollection geometry, GeoAPIGeometryFactory factory, bool copyUserData) { var dsGeometries = new GeoAPI.Geometries.IGeometry[geometry.NumGeometries]; for (var i = 0; i < dsGeometries.Length; i++) { dsGeometries[i] = FromGeometry(geometry.GetGeometryN(i), factory, copyUserData); } var result = factory.CreateGeometryCollection(dsGeometries); if (copyUserData) { result.UserData = geometry.UserData; } return(result); }
private static DSGeometryCollection FromGeometryCollection(IGeometryCollection geometry, DSGeometryFactory factory, bool setUserData) { var dsGeometries = new DotSpatial.Topology.IGeometry[geometry.NumGeometries]; for (var i = 0; i < dsGeometries.Length; i++) { dsGeometries[i] = FromGeometry(geometry.GetGeometryN(i), factory, setUserData); } var result = factory.CreateGeometryCollection(dsGeometries); if (setUserData) { result.UserData = geometry.UserData; } return(result); }
/// <summary> /// /// </summary> /// <param name="geom"></param> /// <param name="parent"></param> /// <returns></returns> protected virtual IGeometry TransformGeometryCollection(IGeometryCollection geom, IGeometry parent) { ArrayList transGeomList = new ArrayList(); for (int i = 0; i < geom.NumGeometries; i++) { IGeometry transformGeom = Transform(geom.GetGeometryN(i)); if (transformGeom == null) { continue; } if (PRUNE_EMPTY_GEOMETRY && transformGeom.IsEmpty) { continue; } transGeomList.Add(transformGeom); } return(_factory.CreateGeometryCollection(GeometryFactory.ToGeometryArray(transGeomList))); }
/// <summary> /// Converts a <c>GeometryCollection</c> to GeometryCollectionText /// format, then appends it to the writer. /// </summary> /// <param name="geometryCollection">The <c>GeometryCollection</c> to process.</param> /// <param name="level"></param> /// <param name="writer">The output writer to append to.</param> private void AppendGeometryCollectionText(IGeometryCollection geometryCollection, int level, TextWriter writer) { if (geometryCollection.IsEmpty) { writer.Write(" EMPTY"); } else { var level2 = level; writer.Write("("); for (var i = 0; i < geometryCollection.NumGeometries; i++) { if (i > 0) { writer.Write(","); level2 = level + 1; } AppendGeometryTaggedText(geometryCollection.GetGeometryN(i), level2, writer); } writer.Write(")"); } }
/// <summary> /// Writes a geometrycollection. /// </summary> /// <param name="gc">The geometrycollection to be written.</param> /// <param name="bWriter">Stream to write to.</param> /// <param name="byteorder">Byte order</param> private static void WriteGeometryCollection(IGeometryCollection gc, BinaryWriter bWriter, WkbByteOrder byteorder) { //Get the number of geometries in this geometrycollection. var num = gc.NumGeometries; //Write the number of geometries. WriteUInt32((uint)num, bWriter, byteorder); //Loop on the number of geometries. //NOTE: by contract, the first item returned // from GetEnumerator (i.e. using foreach) is the IGeometryCollection itself! for (var i = 0; i < num; i++) { IGeometry geom = gc.GetGeometryN(i); //Write the byte-order format of the following geometry. bWriter.Write((byte)byteorder); //Write the type of each geometry. WriteType(geom, bWriter, byteorder); //Write each geometry. WriteGeometry(geom, bWriter, byteorder); } }
/// <summary> /// /// </summary> /// <param name="geom"></param> /// <param name="parent"></param> /// <returns></returns> protected virtual IGeometry TransformGeometryCollection(IGeometryCollection geom, IGeometry parent) { ArrayList transGeomList = new ArrayList(); for (int i = 0; i < geom.NumGeometries; i++) { IGeometry transformGeom = Transform(geom.GetGeometryN(i)); if (transformGeom == null) { continue; } if (pruneEmptyGeometry && transformGeom.IsEmpty) { continue; } transGeomList.Add(transformGeom); } if (preserveGeometryCollectionType) { return(factory.CreateGeometryCollection(GeometryFactory.ToGeometryArray(transGeomList))); } return(factory.BuildGeometry(transGeomList)); }
/// <summary> /// /// </summary> /// <param name="gc"></param> /// <returns></returns> private static IGeometry WidestGeometry(IGeometryCollection gc) { if (gc.IsEmpty) return gc; IGeometry widestGeometry = gc.GetGeometryN(0); for (int i = 1; i < gc.NumGeometries; i++) //Start at 1 if (gc.GetGeometryN(i).EnvelopeInternal.Width > widestGeometry.EnvelopeInternal.Width) widestGeometry = gc.GetGeometryN(i); return widestGeometry; }
/// <summary> /// /// </summary> /// <param name="geom"></param> /// <param name="parent"></param> /// <returns></returns> protected virtual IGeometry TransformGeometryCollection(IGeometryCollection geom, IGeometry parent) { ArrayList transGeomList = new ArrayList(); for (int i = 0; i < geom.NumGeometries; i++) { IGeometry transformGeom = Transform(geom.GetGeometryN(i)); if (transformGeom == null) continue; if (PRUNE_EMPTY_GEOMETRY && transformGeom.IsEmpty) continue; transGeomList.Add(transformGeom); } return _factory.CreateGeometryCollection(GeometryFactory.ToGeometryArray(transGeomList)); }
/* // Obsolete (slower code) private Shape OLDtoShape(Polygon p) { ArrayList holeVertexCollection = new ArrayList(); for (int j = 0; j < p.getNumInteriorRing(); j++) { holeVertexCollection.add( toViewCoordinates(p.getInteriorRingN(j).getCoordinates())); } return new PolygonShape( toViewCoordinates(p.getExteriorRing().getCoordinates()), holeVertexCollection); } private Coordinate[] toViewCoordinates(Coordinate[] modelCoordinates) { Coordinate[] viewCoordinates = new Coordinate[modelCoordinates.length]; for (int i = 0; i < modelCoordinates.length; i++) { Point2D point2D = toPoint(modelCoordinates[i]); viewCoordinates[i] = new Coordinate(point2D.getX(), point2D.getY()); } return viewCoordinates; } */ private GraphicsPath ToShape(IGeometryCollection gc) { var shape = new GeometryCollectionGraphicsPath(); // add components to GC shape for (int i = 0; i < gc.NumGeometries; i++) { var g = gc.GetGeometryN(i); shape.Add(ToShape(g)); } return shape.Path; }
/// <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> /// /// </summary> /// <param name="gc"></param> /// <returns></returns> private bool HasRepeatedPoint(IGeometryCollection gc) { for (int i = 0; i < gc.NumGeometries; i++) { IGeometry g = gc.GetGeometryN(i); if (HasRepeatedPoint(g)) return true; } return false; }
/// <summary> /// Writes a geometrycollection. /// </summary> /// <param name="gc">The geometrycollection to be written.</param> /// <param name="bWriter">Stream to write to.</param> /// <param name="byteorder">Byte order</param> private static void WriteGeometryCollection(IGeometryCollection gc, BinaryWriter bWriter, WkbByteOrder byteorder) { //Get the number of geometries in this geometrycollection. var num = gc.NumGeometries; //Write the number of geometries. WriteUInt32((uint) num, bWriter, byteorder); //Loop on the number of geometries. //NOTE: by contract, the first item returned // from GetEnumerator (i.e. using foreach) is the IGeometryCollection itself! for (var i = 0; i < num; i++) { IGeometry geom = gc.GetGeometryN(i); //Write the byte-order format of the following geometry. bWriter.Write((byte) byteorder); //Write the type of each geometry. WriteType(geom, bWriter, byteorder); //Write each geometry. WriteGeometry(geom, bWriter, byteorder); } }
private static GeoAPIGeometryCollection FromGeometryCollection(IGeometryCollection geometry, GeoAPIGeometryFactory factory, bool copyUserData) { var dsGeometries = new GeoAPI.Geometries.IGeometry[geometry.NumGeometries]; for (var i = 0; i < dsGeometries.Length; i++) dsGeometries[i] = FromGeometry(geometry.GetGeometryN(i), factory, copyUserData); var result = factory.CreateGeometryCollection(dsGeometries); if (copyUserData) result.UserData = geometry.UserData; return result; }
private static void WriteCollection(IGeometryCollection geometry, PostGis2GeometryHeader pgh, BinaryWriter writer) { writer.Write((uint)geometry.OgcGeometryType.ToPostGis2()); if (geometry.IsEmpty) { writer.Write(0); return; } for (var i = 0; i < geometry.NumGeometries; i++) Write(geometry.GetGeometryN(i), writer, pgh.Ordinates, pgh.IsGeodetic); }
private void WriteGeometryCollection(IGeometryCollection gc, int level, StringBuilder sb) { StartLine("<MultiGeometry>\n", level, sb); for (int t = 0; t < gc.NumGeometries; t++) WriteGeometry(gc.GetGeometryN(t), level + 1, sb); StartLine("</MultiGeometry>\n", level, sb); }
/// <summary> /// /// </summary> /// <param name="collection"></param> /// <returns></returns> private static ICoordinateSequence BuildSequence(IGeometryCollection collection) { var seq = collection.Factory.CoordinateSequenceFactory.Create(collection.NumPoints, DetectOrdinates(collection)); var count = 0; for (var i = 0; i < collection.Count; i++) { var tmp = collection.GetGeometryN(i); ICoordinateSequence tmpSeq = null; switch (tmp.OgcGeometryType) { case OgcGeometryType.Point: tmpSeq = ((IPoint) tmp).CoordinateSequence; break; case OgcGeometryType.LineString: tmpSeq = ((ILineString)tmp).CoordinateSequence; break; case OgcGeometryType.Polygon: var poly = (IPolygon) tmp; tmpSeq = poly.ExteriorRing.CoordinateSequence; if (poly.NumInteriorRings > 0) { CoordinateSequences.Copy(tmpSeq, 0, seq, count, tmpSeq.Count); int j; for (j = 0; j < poly.NumInteriorRings - 1; j++) { tmpSeq = poly.GetInteriorRingN(j).CoordinateSequence; CoordinateSequences.Copy(tmpSeq, 0, seq, count, tmpSeq.Count); count += tmpSeq.Count; } tmpSeq = poly.GetInteriorRingN(j).CoordinateSequence; } break; default: throw new ArgumentException("Invalid geometry type"); } if (tmpSeq != null) { CoordinateSequences.Copy(tmpSeq, 0, seq, count, tmpSeq.Count); count += tmpSeq.Count; } } return seq; }
/// <summary> /// Converts a <c>GeometryCollection</c> to GeometryCollectionText /// format, then appends it to the writer. /// </summary> /// <param name="geometryCollection">The <c>GeometryCollection</c> to process.</param> /// <param name="level"></param> /// <param name="writer">The output writer to append to.</param> private void AppendGeometryCollectionText(IGeometryCollection geometryCollection, int level, TextWriter writer) { if (geometryCollection.IsEmpty) writer.Write(" EMPTY"); else { int level2 = level; writer.Write("("); for (int i = 0; i < geometryCollection.NumGeometries; i++) { if (i > 0) { writer.Write(","); level2 = level + 1; } AppendGeometryTaggedText(geometryCollection.GetGeometryN(i), level2, writer); } writer.Write(")"); } }
private static void DoTest(IGeometryCollection geomsWrite, Ordinates ordinates, bool testGetOrdinate = true) { string fileName = string.Empty; try { fileName = Path.GetTempFileName(); fileName = Path.ChangeExtension(fileName, "shp"); ShapefileWriter.WriteGeometryCollection(fileName, geomsWrite); var reader = new ShapefileReader(fileName, ShapeFileShapeFactory.FactoryRead); var geomsRead = reader.ReadAll(); // This tests x- and y- values if (!geomsWrite.EqualsExact(geomsRead)) { Assert.AreEqual(geomsWrite.NumGeometries, geomsRead.NumGeometries); // // This akward test is necessary since EqualsTopologically throws currently exceptions var equal = true; for (var i = 0; i < geomsRead.NumGeometries; i++) { var gw = geomsWrite.GetGeometryN(i); var gr = geomsRead.GetGeometryN(i); if (gw.IsEmpty && gr.IsEmpty) { if ((gw is ILineal && gr is ILineal) || (gw is IPolygonal && gr is IPolygonal)) { // suppose these are equal } else { Console.WriteLine(string.Format("Geometries don't match at index {0}", i)); Console.WriteLine(string.Format(" written: {0}", gw.AsText())); Console.WriteLine(string.Format(" read : {0}", gr.AsText())); equal = false; Assert.IsTrue(equal, "Differenced found in geometries written and read!"); } } else if (!gw.EqualsExact(gr)) { var hsm = new HausdorffSimilarityMeasure().Measure(gw, gr); var asm = new AreaSimilarityMeasure().Measure(gw, gr); var smc = SimilarityMeasureCombiner.Combine(hsm, asm); if (!gw.EqualsNormalized(gr) || (1d - smc) > 1e-7) { Console.WriteLine(string.Format("Geometries don't match at index {0}", i)); Console.WriteLine(string.Format(" written: {0}", gw.AsText())); Console.WriteLine(string.Format(" read : {0}", gr.AsText())); equal = false; Assert.IsTrue(equal, "Differenced found in geometries written and read!"); } } } //For polygons this has a tendency to fail, since the polygonhandler might rearrange the whole thing if (testGetOrdinate) { if ((ordinates & Ordinates.Z) == Ordinates.Z) { var writeZ = geomsWrite.GetOrdinates(Ordinate.Z); var readZ = geomsRead.GetOrdinates(Ordinate.Z); Assert.IsTrue(ArraysEqual(writeZ, readZ)); } if ((ordinates & Ordinates.M) == Ordinates.M) { var writeM = geomsWrite.GetOrdinates(Ordinate.M); var readM = geomsRead.GetOrdinates(Ordinate.M); Assert.IsTrue(ArraysEqual(writeM, readM)); } } } // delete sample files File.Delete(fileName); File.Delete(Path.ChangeExtension(fileName, "shx")); File.Delete(Path.ChangeExtension(fileName, "dbf")); } catch (AssertionException ex) { Console.WriteLine("Failed test with {0}", ordinates); Console.WriteLine(ex.Message); Console.WriteLine(" Testfile '{0}' not deleted!", fileName); throw; } }
private static DSGeometryCollection FromGeometryCollection(IGeometryCollection geometry, DSGeometryFactory factory, bool setUserData) { var dsGeometries = new DotSpatial.Topology.IGeometry[geometry.NumGeometries]; for (var i = 0; i < dsGeometries.Length; i++) dsGeometries[i] = FromGeometry(geometry.GetGeometryN(i), factory, setUserData); var result = factory.CreateGeometryCollection(dsGeometries); if (setUserData) result.UserData = geometry.UserData; return result; }
private static void DoTest(IGeometryCollection geomsWrite, Ordinates ordinates, bool testGetOrdinate = true) { string fileName = string.Empty; try { fileName = Path.GetTempFileName(); fileName = Path.ChangeExtension(fileName, "shp"); ShapefileWriter.WriteGeometryCollection(fileName, geomsWrite); var reader = new ShapefileReader(fileName, ShapeFileShapeFactory.FactoryRead); var geomsRead = reader.ReadAll(); // This tests x- and y- values if (!geomsWrite.EqualsExact(geomsRead)) { Assert.AreEqual(geomsWrite.NumGeometries, geomsRead.NumGeometries); // // This akward test is necessary since EqualsTopologically throws currently exceptions bool equal = true; for (int i = 0; i < geomsRead.NumGeometries; i++) { var gw = geomsWrite.GetGeometryN(i); var gr = geomsRead.GetGeometryN(i); if (gw.IsEmpty && gr.IsEmpty) { if ((gw is ILineal && gr is ILineal) || (gw is IPolygonal && gr is IPolygonal)) { // suppose these are equal } else { Console.WriteLine(string.Format("Geometries don't match at index {0}", i)); Console.WriteLine(string.Format(" written: {0}", gw.AsText())); Console.WriteLine(string.Format(" read : {0}", gr.AsText())); equal = false; Assert.IsTrue(equal, "Differenced found in geometries written and read!"); } } else if (!gw.EqualsExact(gr)) { double hsm = new HausdorffSimilarityMeasure().Measure(gw, gr); double asm = new AreaSimilarityMeasure().Measure(gw, gr); double smc = SimilarityMeasureCombiner.Combine(hsm, asm); if (!gw.EqualsNormalized(gr) || (1d - smc) > 1e-7) { Console.WriteLine(string.Format("Geometries don't match at index {0}", i)); Console.WriteLine(string.Format(" written: {0}", gw.AsText())); Console.WriteLine(string.Format(" read : {0}", gr.AsText())); equal = false; Assert.IsTrue(equal, "Differenced found in geometries written and read!"); } } } //For polygons this has a tendency to fail, since the polygonhandler might rearrange the whole thing if (testGetOrdinate) { if ((ordinates & Ordinates.Z) == Ordinates.Z) { double[] writeZ = geomsWrite.GetOrdinates(Ordinate.Z); double[] readZ = geomsRead.GetOrdinates(Ordinate.Z); Assert.IsTrue(ArraysEqual(writeZ, readZ)); } if ((ordinates & Ordinates.M) == Ordinates.M) { double[] writeM = geomsWrite.GetOrdinates(Ordinate.M); double[] readM = geomsRead.GetOrdinates(Ordinate.M); Assert.IsTrue(ArraysEqual(writeM, readM)); } } } // delete sample files File.Delete(fileName); File.Delete(Path.ChangeExtension(fileName, "shx")); File.Delete(Path.ChangeExtension(fileName, "dbf")); } catch (AssertionException ex) { Console.WriteLine("Failed test with {0}", ordinates); Console.WriteLine(ex.Message); Console.WriteLine(" Testfile '{0}' not deleted!", fileName); throw; } }
/// <summary> /// /// </summary> /// <param name="geom"></param> /// <param name="parent"></param> /// <returns></returns> protected virtual IGeometry TransformGeometryCollection(IGeometryCollection geom, IGeometry parent) { ArrayList transGeomList = new ArrayList(); for (int i = 0; i < geom.NumGeometries; i++) { IGeometry transformGeom = Transform(geom.GetGeometryN(i)); if (transformGeom == null) continue; if (pruneEmptyGeometry && transformGeom.IsEmpty) continue; transGeomList.Add(transformGeom); } if (preserveGeometryCollectionType) return factory.CreateGeometryCollection(GeometryFactory.ToGeometryArray(transGeomList)); return factory.BuildGeometry(transGeomList); }
private static IGeometry WidestGeometry(IGeometryCollection gc) { if (gc.IsEmpty) return gc; var widestGeometry = gc.GetGeometryN(0); // scan remaining geom components to see if any are wider for (int i = 1; i < gc.NumGeometries; i++) //Start at 1 if (gc.GetGeometryN(i).EnvelopeInternal.Width > widestGeometry.EnvelopeInternal.Width) widestGeometry = gc.GetGeometryN(i); return widestGeometry; }
private void AddCollection(IGeometryCollection gc) { for( int i = 0; i < gc.GetNumGeometries(); i++ ) { Geometry g = (Geometry)gc.GetGeometryN( i ); Add( g ); } }