public virtual void TestBufferPoint() { com.epl.geometry.SpatialReference sr = com.epl.geometry.SpatialReference.Create(4326); com.epl.geometry.Point inputGeom = new com.epl.geometry.Point(12, 120); com.epl.geometry.OperatorBuffer buffer = (com.epl.geometry.OperatorBuffer)com.epl.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.epl.geometry.Operator.Type.Buffer); com.epl.geometry.OperatorSimplify simplify = (com.epl.geometry.OperatorSimplify)com.epl.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.epl.geometry.Operator.Type.Simplify); com.epl.geometry.Geometry result = buffer.Execute(inputGeom, sr, 40.0, null); NUnit.Framework.Assert.IsTrue(result.GetType().Value() == com.epl.geometry.Geometry.GeometryType.Polygon); com.epl.geometry.Polygon poly = (com.epl.geometry.Polygon)result; int pathCount = poly.GetPathCount(); NUnit.Framework.Assert.IsTrue(pathCount == 1); int pointCount = poly.GetPointCount(); NUnit.Framework.Assert.IsTrue(System.Math.Abs(pointCount - 100.0) < 10); com.epl.geometry.Envelope2D env2D = new com.epl.geometry.Envelope2D(); result.QueryEnvelope2D(env2D); NUnit.Framework.Assert.IsTrue(System.Math.Abs(env2D.GetWidth() - 80) < 0.01 && System.Math.Abs(env2D.GetHeight() - 80) < 0.01); NUnit.Framework.Assert.IsTrue(System.Math.Abs(env2D.GetCenterX() - 12) < 0.001 && System.Math.Abs(env2D.GetCenterY() - 120) < 0.001); com.epl.geometry.NonSimpleResult nsr = new com.epl.geometry.NonSimpleResult(); bool is_simple = simplify.IsSimpleAsFeature(result, sr, true, nsr, null); NUnit.Framework.Assert.IsTrue(is_simple); { result = buffer.Execute(inputGeom, sr, 0, null); NUnit.Framework.Assert.IsTrue(result.GetType().Value() == com.epl.geometry.Geometry.GeometryType.Polygon); NUnit.Framework.Assert.IsTrue(result.IsEmpty()); } { result = buffer.Execute(inputGeom, sr, -1, null); NUnit.Framework.Assert.IsTrue(result.GetType().Value() == com.epl.geometry.Geometry.GeometryType.Polygon); NUnit.Framework.Assert.IsTrue(result.IsEmpty()); } }
internal static com.epl.geometry.Geometry Calculate(com.epl.geometry.Geometry geom, com.epl.geometry.ProgressTracker progress_tracker) { int gt = geom.GetType().Value(); if (gt == com.epl.geometry.Geometry.GeometryType.Polygon) { com.epl.geometry.Polyline dst = new com.epl.geometry.Polyline(geom.GetDescription()); if (!geom.IsEmpty()) { ((com.epl.geometry.MultiPathImpl)geom._getImpl())._copyToUnsafe((com.epl.geometry.MultiPathImpl)dst._getImpl()); } return(dst); } else { if (gt == com.epl.geometry.Geometry.GeometryType.Polyline) { return(CalculatePolylineBoundary_(geom._getImpl(), progress_tracker, false, null)); } else { if (gt == com.epl.geometry.Geometry.GeometryType.Envelope) { com.epl.geometry.Polyline dst = new com.epl.geometry.Polyline(geom.GetDescription()); if (!geom.IsEmpty()) { dst.AddEnvelope((com.epl.geometry.Envelope)geom, false); } return(dst); } else { if (com.epl.geometry.Geometry.IsSegment(gt)) { com.epl.geometry.MultiPoint mp = new com.epl.geometry.MultiPoint(geom.GetDescription()); if (!geom.IsEmpty() && !((com.epl.geometry.Segment)geom).IsClosed()) { com.epl.geometry.Point pt = new com.epl.geometry.Point(); ((com.epl.geometry.Segment)geom).QueryStart(pt); mp.Add(pt); ((com.epl.geometry.Segment)geom).QueryEnd(pt); mp.Add(pt); } return(mp); } else { if (com.epl.geometry.Geometry.IsPoint(gt)) { // returns empty point for points and multipoints. return(null); } } } } } throw new System.ArgumentException(); }
private com.epl.geometry.Geometry Generalize(com.epl.geometry.Geometry geom) { com.epl.geometry.Geometry.Type gt = geom.GetType(); if (com.epl.geometry.Geometry.IsPoint(gt.Value())) { return(geom); } if (gt == com.epl.geometry.Geometry.Type.Envelope) { com.epl.geometry.Polygon poly = new com.epl.geometry.Polygon(geom.GetDescription()); poly.AddEnvelope((com.epl.geometry.Envelope)geom, false); return(Generalize(poly)); } if (geom.IsEmpty()) { return(geom); } com.epl.geometry.MultiPath mp = (com.epl.geometry.MultiPath)geom; com.epl.geometry.MultiPath dstmp = (com.epl.geometry.MultiPath)geom.CreateInstance(); com.epl.geometry.Line line = new com.epl.geometry.Line(); for (int ipath = 0, npath = mp.GetPathCount(); ipath < npath; ipath++) { GeneralizePath((com.epl.geometry.MultiPathImpl)mp._getImpl(), ipath, (com.epl.geometry.MultiPathImpl)dstmp._getImpl(), line); } return(dstmp); }
public virtual void TestWKB2() { // JSON -> GEOM -> WKB // String strPolygon1 = // "{\"xmin\":-1.16605115291E7,\"ymin\":4925189.941699997,\"xmax\":-1.16567772126E7,\"ymax\":4928658.771399997,\"spatialReference\":{\"wkid\":102100}}"; string strPolygon1 = "{\"rings\" : [ [ [-1.16605115291E7,4925189.941699997], [-1.16567772126E7,4925189.941699997], [-1.16567772126E7,4928658.771399997], [-1.16605115291E7,4928658.771399997], [-1.16605115291E7,4925189.941699997] ] ], \"spatialReference\" : {\"wkid\" : 102100}}"; com.epl.geometry.MapGeometry mapGeom = com.epl.geometry.GeometryEngine.JsonToGeometry(strPolygon1); com.epl.geometry.Geometry geom = mapGeom.GetGeometry(); // simplifying geom com.epl.geometry.OperatorSimplify operatorSimplify = (com.epl.geometry.OperatorSimplify)com.epl.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.epl.geometry.Operator.Type.Simplify); com.epl.geometry.SpatialReference sr = com.epl.geometry.SpatialReference.Create(102100); geom = operatorSimplify.Execute(geom, sr, true, null); com.epl.geometry.OperatorExportToWkb operatorExport = (com.epl.geometry.OperatorExportToWkb)com.epl.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.epl.geometry.Operator.Type.ExportToWkb); System.IO.MemoryStream byteBuffer = operatorExport.Execute(0, geom, null); byte[] wkb = ((byte[])byteBuffer.Array()); // // checking WKB correctness // WKBReader jtsReader = new WKBReader(); // com.vividsolutions.jts.geom.Geometry jtsGeom = jtsReader.read(wkb); // System.out.println("jtsGeom = " + jtsGeom); // WKB -> GEOM -> JSON com.epl.geometry.OperatorImportFromWkb operatorImport = (com.epl.geometry.OperatorImportFromWkb)com.epl.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.epl.geometry.Operator.Type.ImportFromWkb); geom = operatorImport.Execute(0, com.epl.geometry.Geometry.Type.Polygon, System.IO.MemoryStream.Wrap(wkb), null); NUnit.Framework.Assert.IsTrue(!geom.IsEmpty()); }
/// <exception cref="java.io.ObjectStreamException"/> internal object ReadResolve() { com.epl.geometry.Geometry geometry = null; try { geometry = com.epl.geometry.GeometryEngine.GeometryFromEsriShape(geometryData.esriShape, geometryData.geometryType); if (com.epl.geometry.Geometry.IsMultiVertex(geometry.GetType().Value())) { com.epl.geometry.GeometrySerializer.MultiVertexData mvd = (com.epl.geometry.GeometrySerializer.MultiVertexData)geometryData; com.epl.geometry.MultiVertexGeometryImpl mvImpl = (com.epl.geometry.MultiVertexGeometryImpl)geometry._getImpl(); if (!geometry.IsEmpty() && com.epl.geometry.Geometry.IsMultiPath(geometry.GetType().Value())) { com.epl.geometry.GeometrySerializer.MultiPathData mpd = (com.epl.geometry.GeometrySerializer.MultiPathData)geometryData; com.epl.geometry.MultiPathImpl mpImpl = (com.epl.geometry.MultiPathImpl)geometry._getImpl(); com.epl.geometry.AttributeStreamOfInt8 pathFlags = mpImpl.GetPathFlagsStreamRef(); for (int i = 0, n = mpImpl.GetPathCount(); i < n; i++) { if (mpd.ogcFlags[i]) { pathFlags.SetBits(i, unchecked ((byte)com.epl.geometry.PathFlags.enumOGCStartPolygon)); } } } mvImpl.SetIsSimple(mvd.simpleFlag, mvd.tolerance, false); } } catch (System.Exception) { throw new System.IO.InvalidDataException("Cannot read geometry from stream"); } return(geometry); }
// /// <exception cref="java.io.ObjectStreamException"/> // internal virtual object WriteReplace() // { // com.epl.geometry.Geometry.Type gt = GetType(); // if (gt == com.epl.geometry.Geometry.Type.Point) // { // com.epl.geometry.PtSrlzr pt = new com.epl.geometry.PtSrlzr(); // pt.SetGeometryByValue((com.epl.geometry.Point)this); // return pt; // } // else // { // if (gt == com.epl.geometry.Geometry.Type.Envelope) // { // com.epl.geometry.EnvSrlzr e = new com.epl.geometry.EnvSrlzr(); // e.SetGeometryByValue((com.epl.geometry.Envelope)this); // return e; // } // else // { // if (gt == com.epl.geometry.Geometry.Type.Line) // { // com.epl.geometry.LnSrlzr ln = new com.epl.geometry.LnSrlzr(); // ln.SetGeometryByValue((com.epl.geometry.Line)this); // return ln; // } // } // } // com.epl.geometry.GenericGeometrySerializer geomSerializer = new com.epl.geometry.GenericGeometrySerializer(); // geomSerializer.SetGeometryByValue(this); // return geomSerializer; // } // // /// <summary>The output of this method can be only used for debugging.</summary> // /// <remarks>The output of this method can be only used for debugging. It is subject to change without notice.</remarks> // public override string ToString() // { // string snippet = com.epl.geometry.OperatorExportToJson.Local().Execute(null, this); // if (snippet.Length > 200) // { // return snippet.Substring(0, 197 - 0) + "... (" + snippet.Length + " characters)"; // } // else // { // return snippet; // } // } /// <summary> /// Returns count of geometry vertices: /// 1 for Point, 4 for Envelope, get_point_count for MultiVertexGeometry types, /// 2 for segment types /// Returns 0 if geometry is empty. /// </summary> public static int Vertex_count(com.epl.geometry.Geometry geom) { com.epl.geometry.Geometry.Type gt = geom.GetType(); if (com.epl.geometry.Geometry.IsMultiVertex(gt.Value())) { return(((com.epl.geometry.MultiVertexGeometry)geom).GetPointCount()); } if (geom.IsEmpty()) { return(0); } if (gt == com.epl.geometry.Geometry.Type.Envelope) { return(4); } if (gt == com.epl.geometry.Geometry.Type.Point) { return(1); } if (com.epl.geometry.Geometry.IsSegment(gt.Value())) { return(2); } throw new com.epl.geometry.GeometryException("missing type"); }
public virtual void TestMultiPointAndMultiPoint3() { com.epl.geometry.MultiPoint basePl = new com.epl.geometry.MultiPoint(); basePl.Add(new com.epl.geometry.Point(-116, 21)); basePl.Add(new com.epl.geometry.Point(-117, 20)); com.epl.geometry.MultiPoint compPl = new com.epl.geometry.MultiPoint(); compPl.Add(new com.epl.geometry.Point(-116, 20)); compPl.Add(new com.epl.geometry.Point(-117, 21)); compPl.Add(new com.epl.geometry.Point(-118, 20)); compPl.Add(new com.epl.geometry.Point(-119, 21)); int noException = 1; // no exception com.epl.geometry.Geometry intersectGeom = null; try { intersectGeom = com.epl.geometry.GeometryEngine.Intersect(basePl, compPl, com.epl.geometry.SpatialReference.Create(4326)); } catch (System.Exception) { noException = 0; } NUnit.Framework.Assert.AreEqual(noException, 1); NUnit.Framework.Assert.IsTrue(intersectGeom.IsEmpty()); }
public static com.epl.geometry.ogc.OGCGeometry CreateFromEsriCursor(com.epl.geometry.GeometryCursor gc, com.epl.geometry.SpatialReference sr, bool skipEmpty) { System.Collections.Generic.List <com.epl.geometry.ogc.OGCGeometry> geoms = new System.Collections.Generic.List <com.epl.geometry.ogc.OGCGeometry>(10); com.epl.geometry.Geometry emptyGeom = null; for (com.epl.geometry.Geometry g = gc.Next(); g != null; g = gc.Next()) { emptyGeom = g; if (!skipEmpty || !g.IsEmpty()) { geoms.Add(CreateFromEsriGeometry(g, sr)); } } if (geoms.Count == 1) { return(geoms[0]); } else { if (geoms.Count == 0) { return(CreateFromEsriGeometry(emptyGeom, sr)); } else { return(new com.epl.geometry.ogc.OGCConcreteGeometryCollection(geoms, sr)); } } }
/// <exception cref="java.io.ObjectStreamException"/> public virtual void SetGeometryByValue(com.epl.geometry.Geometry geometry) { try { esriShape = com.epl.geometry.GeometryEngine.GeometryToEsriShape(geometry); geometryType = geometry.GetType().Value(); if (com.epl.geometry.Geometry.IsMultiVertex(geometryType)) { com.epl.geometry.MultiVertexGeometryImpl mvImpl = (com.epl.geometry.MultiVertexGeometryImpl)geometry._getImpl(); tolerance = mvImpl.m_simpleTolerance; simpleFlag = mvImpl.GetIsSimple(0); if (!geometry.IsEmpty() && com.epl.geometry.Geometry.IsMultiPath(geometryType)) { com.epl.geometry.MultiPathImpl mpImpl = (com.epl.geometry.MultiPathImpl)geometry._getImpl(); ogcFlags = new bool[mpImpl.GetPathCount()]; com.epl.geometry.AttributeStreamOfInt8 pathFlags = mpImpl.GetPathFlagsStreamRef(); for (int i = 0, n = mpImpl.GetPathCount(); i < n; i++) { ogcFlags[i] = (pathFlags.Read(i) & unchecked ((byte)com.epl.geometry.PathFlags.enumOGCStartPolygon)) != 0; } } } } catch (System.Exception) { throw new System.IO.InvalidDataException("Cannot serialize this geometry"); } }
internal static com.epl.geometry.Geometry SymmetricDifference(com.epl.geometry.Geometry geometry_a, com.epl.geometry.Geometry geometry_b, com.epl.geometry.SpatialReference spatial_reference, com.epl.geometry.ProgressTracker progress_tracker) { int dim_a = geometry_a.GetDimension(); int dim_b = geometry_b.GetDimension(); if (geometry_a.IsEmpty() && geometry_b.IsEmpty()) { return(dim_a > dim_b ? geometry_a : geometry_b); } if (geometry_a.IsEmpty()) { return(geometry_b); } if (geometry_b.IsEmpty()) { return(geometry_a); } com.epl.geometry.Envelope2D env_a = new com.epl.geometry.Envelope2D(); com.epl.geometry.Envelope2D env_b = new com.epl.geometry.Envelope2D(); com.epl.geometry.Envelope2D env_merged = new com.epl.geometry.Envelope2D(); geometry_a.QueryEnvelope2D(env_a); geometry_b.QueryEnvelope2D(env_b); env_merged.SetCoords(env_a); env_merged.Merge(env_b); double tolerance = com.epl.geometry.InternalUtils.CalculateToleranceFromGeometry(spatial_reference, env_merged, false); int type_a = geometry_a.GetType().Value(); int type_b = geometry_b.GetType().Value(); if (type_a == com.epl.geometry.Geometry.GeometryType.Point && type_b == com.epl.geometry.Geometry.GeometryType.Point) { return(PointSymDiffPoint_((com.epl.geometry.Point)(geometry_a), (com.epl.geometry.Point)(geometry_b), tolerance, progress_tracker)); } if (type_a != type_b) { if (dim_a > 0 || dim_b > 0) { return(dim_a > dim_b ? geometry_a : geometry_b); } // Multi_point/Point case if (type_a == com.epl.geometry.Geometry.GeometryType.MultiPoint) { return(MultiPointSymDiffPoint_((com.epl.geometry.MultiPoint)(geometry_a), (com.epl.geometry.Point)(geometry_b), tolerance, progress_tracker)); } return(MultiPointSymDiffPoint_((com.epl.geometry.MultiPoint)(geometry_b), (com.epl.geometry.Point)(geometry_a), tolerance, progress_tracker)); } return(com.epl.geometry.TopologicalOperations.SymmetricDifference(geometry_a, geometry_b, spatial_reference, progress_tracker)); }
/// <summary> /// Checks whether the RasterizedGeometry2D accelerator can be used with the /// given geometry. /// </summary> internal static bool CanUseAccelerator(com.epl.geometry.Geometry geom) { if (geom.IsEmpty() || !(geom.GetType() == com.epl.geometry.Geometry.Type.Polyline || geom.GetType() == com.epl.geometry.Geometry.Type.Polygon)) { return(false); } return(true); }
internal virtual double Calculate(com.epl.geometry.Geometry geometryA, com.epl.geometry.Geometry geometryB) { /* const */ /* const */ if (geometryA.IsEmpty() || geometryB.IsEmpty()) { return(com.epl.geometry.NumberUtils.TheNaN); } geometryA.QueryEnvelope2D(this.m_env2DgeometryA); geometryB.QueryEnvelope2D(this.m_env2DgeometryB); return(this.ExecuteBruteForce_(geometryA, geometryB)); }
internal static bool CanUseQuadTreeForPaths(com.epl.geometry.Geometry geom) { if (geom.IsEmpty() || !(geom.GetType() == com.epl.geometry.Geometry.Type.Polyline || geom.GetType() == com.epl.geometry.Geometry.Type.Polygon)) { return(false); } if (((com.epl.geometry.MultiVertexGeometry)geom).GetPointCount() < 20) { return(false); } return(true); }
internal static bool HasNonEmptyBoundary(com.epl.geometry.Geometry geom, com.epl.geometry.ProgressTracker progress_tracker) { if (geom.IsEmpty()) { return(false); } com.epl.geometry.Geometry.Type gt = geom.GetType(); if (gt == com.epl.geometry.Geometry.Type.Polygon) { if (geom.CalculateArea2D() == 0) { return(false); } return(true); } else { if (gt == com.epl.geometry.Geometry.Type.Polyline) { bool[] b = new bool[1]; b[0] = false; CalculatePolylineBoundary_(geom._getImpl(), progress_tracker, true, b); return(b[0]); } else { if (gt == com.epl.geometry.Geometry.Type.Envelope) { return(true); } else { if (com.epl.geometry.Geometry.IsSegment(gt.Value())) { if (!((com.epl.geometry.Segment)geom).IsClosed()) { return(true); } return(false); } else { if (com.epl.geometry.Geometry.IsPoint(gt.Value())) { return(false); } } } } } return(false); }
private com.epl.geometry.Geometry DensifyByLength(com.epl.geometry.Geometry geom) { if (geom.IsEmpty() || geom.GetDimension() < 1) { return(geom); } int geometryType = geom.GetType().Value(); // TODO implement IsMultiPath and remove Polygon and Polyline call to // match Native // if (Geometry.IsMultiPath(geometryType)) if (geometryType == com.epl.geometry.Geometry.GeometryType.Polygon) { return(DensifyMultiPath((com.epl.geometry.MultiPath)geom)); } else { if (com.epl.geometry.Geometry.GeometryType.Polyline == geometryType) { return(DensifyMultiPath((com.epl.geometry.MultiPath)geom)); } else { if (com.epl.geometry.Geometry.IsSegment(geometryType)) { return(DensifySegment((com.epl.geometry.Segment)geom)); } else { if (geometryType == com.epl.geometry.Geometry.GeometryType.Envelope) { return(DensifyEnvelope((com.epl.geometry.Envelope)geom)); } else { // TODO fix geometry exception to match native implementation throw com.epl.geometry.GeometryException.GeometryInternalError(); } } } } }
internal virtual com.epl.geometry.Geometry NormalizeIntersectionOutput(com.epl.geometry.Geometry geom, int GT_1, int GT_2) { if (GT_1 == com.epl.geometry.Geometry.GeometryType.Point || GT_2 == com.epl.geometry.Geometry.GeometryType.Point) { System.Diagnostics.Debug.Assert((geom.GetType().Value() == com.epl.geometry.Geometry.GeometryType.Point)); } if (GT_1 == com.epl.geometry.Geometry.GeometryType.MultiPoint) { if (geom.GetType().Value() == com.epl.geometry.Geometry.GeometryType.Point) { com.epl.geometry.MultiPoint mp = new com.epl.geometry.MultiPoint(geom.GetDescription()); if (!geom.IsEmpty()) { mp.Add((com.epl.geometry.Point)geom); } return mp; } } return geom; }
public override com.epl.geometry.Proximity2DResult[] GetNearestVertices(com.epl.geometry.Geometry geom, com.epl.geometry.Point inputPoint, double searchRadius, int maxVertexCountToReturn) { if (maxVertexCountToReturn < 0) { throw new System.ArgumentException(); } if (geom.IsEmpty()) { return(new com.epl.geometry.Proximity2DResult[] { }); } com.epl.geometry.Point2D inputPoint2D = inputPoint.GetXY(); com.epl.geometry.Geometry proxmityTestGeom = geom; int gt = geom.GetType().Value(); if (gt == com.epl.geometry.Geometry.GeometryType.Envelope) { com.epl.geometry.Polygon polygon = new com.epl.geometry.Polygon(); polygon.AddEnvelope((com.epl.geometry.Envelope)geom, false); proxmityTestGeom = polygon; gt = com.epl.geometry.Geometry.GeometryType.Polygon; } switch (gt) { case com.epl.geometry.Geometry.GeometryType.Point: { return(PointGetNearestVertices((com.epl.geometry.Point)proxmityTestGeom, inputPoint2D, searchRadius, maxVertexCountToReturn)); } case com.epl.geometry.Geometry.GeometryType.MultiPoint: case com.epl.geometry.Geometry.GeometryType.Polyline: case com.epl.geometry.Geometry.GeometryType.Polygon: { return(MultiVertexGetNearestVertices((com.epl.geometry.MultiVertexGeometry)proxmityTestGeom, inputPoint2D, searchRadius, maxVertexCountToReturn)); } default: { throw new com.epl.geometry.GeometryException("not implemented"); } } }
public override com.epl.geometry.Proximity2DResult GetNearestCoordinate(com.epl.geometry.Geometry geom, com.epl.geometry.Point inputPoint, bool bTestPolygonInterior, bool bCalculateLeftRightSide) { if (geom.IsEmpty()) { return(new com.epl.geometry.Proximity2DResult()); } com.epl.geometry.Point2D inputPoint2D = inputPoint.GetXY(); com.epl.geometry.Geometry proxmityTestGeom = geom; int gt = geom.GetType().Value(); if (gt == com.epl.geometry.Geometry.GeometryType.Envelope) { com.epl.geometry.Polygon polygon = new com.epl.geometry.Polygon(); polygon.AddEnvelope((com.epl.geometry.Envelope)geom, false); proxmityTestGeom = polygon; gt = com.epl.geometry.Geometry.GeometryType.Polygon; } switch (gt) { case com.epl.geometry.Geometry.GeometryType.Point: { return(PointGetNearestVertex((com.epl.geometry.Point)proxmityTestGeom, inputPoint2D)); } case com.epl.geometry.Geometry.GeometryType.MultiPoint: { return(MultiVertexGetNearestVertex((com.epl.geometry.MultiVertexGeometry)proxmityTestGeom, inputPoint2D)); } case com.epl.geometry.Geometry.GeometryType.Polyline: case com.epl.geometry.Geometry.GeometryType.Polygon: { return(MultiPathGetNearestCoordinate((com.epl.geometry.MultiPath)proxmityTestGeom, inputPoint2D, bTestPolygonInterior, bCalculateLeftRightSide)); } default: { throw new com.epl.geometry.GeometryException("not implemented"); } } }
public virtual void TestPointAndPolygon2() { com.epl.geometry.Point basePl = new com.epl.geometry.Point(-115, 20); com.epl.geometry.Polygon compPl = new com.epl.geometry.Polygon(); compPl.StartPath(new com.epl.geometry.Point(-116, 20)); compPl.LineTo(new com.epl.geometry.Point(-131, 10)); compPl.LineTo(new com.epl.geometry.Point(-121, 50)); int noException = 1; // no exception com.epl.geometry.Geometry intersectGeom = null; try { intersectGeom = com.epl.geometry.GeometryEngine.Intersect(basePl, compPl, com.epl.geometry.SpatialReference.Create(4326)); } catch (System.Exception) { noException = 0; } NUnit.Framework.Assert.AreEqual(noException, 1); NUnit.Framework.Assert.IsTrue(intersectGeom.IsEmpty()); }
public virtual void OffsetPolygon_(double distance, com.epl.geometry.OperatorOffset.JoinType joins) { com.epl.geometry.Polygon polygon = new com.epl.geometry.Polygon(); polygon.StartPath(0, 0); polygon.LineTo(0, 16); polygon.LineTo(16, 16); polygon.LineTo(16, 11); polygon.LineTo(10, 10); polygon.LineTo(10, 12); polygon.LineTo(3, 12); polygon.LineTo(3, 4); polygon.LineTo(10, 4); polygon.LineTo(10, 6); polygon.LineTo(16, 5); polygon.LineTo(16, 0); com.epl.geometry.OperatorOffset offset = (com.epl.geometry.OperatorOffset)com.epl.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.epl.geometry.Operator.Type.Offset); com.epl.geometry.Geometry outputGeom = offset.Execute(polygon, null, distance, joins, 2, 0, null); NUnit.Framework.Assert.IsNotNull(outputGeom); if (distance > 2) { NUnit.Framework.Assert.IsTrue(outputGeom.IsEmpty()); } }
internal static bool IsConvex_(com.epl.geometry.Geometry geom, com.epl.geometry.ProgressTracker progress_tracker) { if (geom.IsEmpty()) { return(true); } // vacuously true com.epl.geometry.Geometry.Type type = geom.GetType(); if (type == com.epl.geometry.Geometry.Type.Point) { return(true); } // vacuously true if (type == com.epl.geometry.Geometry.Type.Envelope) { com.epl.geometry.Envelope envelope = (com.epl.geometry.Envelope)geom; if (envelope.GetXMin() == envelope.GetXMax() || envelope.GetYMin() == envelope.GetYMax()) { return(false); } return(true); } if (com.epl.geometry.MultiPath.IsSegment(type.Value())) { com.epl.geometry.Segment segment = (com.epl.geometry.Segment)geom; if (segment.GetStartXY().Equals(segment.GetEndXY())) { return(false); } return(true); } // true, but we will upgrade to a Polyline for the ConvexHull operation if (type == com.epl.geometry.Geometry.Type.MultiPoint) { com.epl.geometry.MultiPoint multi_point = (com.epl.geometry.MultiPoint)geom; if (multi_point.GetPointCount() == 1) { return(true); } // vacuously true, but we will downgrade to a Point for the ConvexHull operation return(false); } if (type == com.epl.geometry.Geometry.Type.Polyline) { com.epl.geometry.Polyline polyline = (com.epl.geometry.Polyline)geom; if (polyline.GetPathCount() == 1 && polyline.GetPointCount() == 2) { if (!polyline.GetXY(0).Equals(polyline.GetXY(1))) { return(true); } } // vacuously true return(false); } // create convex hull com.epl.geometry.Polygon polygon = (com.epl.geometry.Polygon)geom; if (polygon.GetPathCount() != 1 || polygon.GetPointCount() < 3) { return(false); } return(com.epl.geometry.ConvexHull.IsPathConvex(polygon, 0, progress_tracker)); }
public static int QuickTest2D(com.epl.geometry.Geometry geomA, com.epl.geometry.Geometry geomB, double tolerance, int testType) { if (geomB.IsEmpty() || geomA.IsEmpty()) { return((int)com.epl.geometry.OperatorInternalRelationUtils.Relation.Disjoint); } int geomAtype = geomA.GetType().Value(); int geomBtype = geomB.GetType().Value(); // We do not support segments directly for now. Convert to Polyline com.epl.geometry.Polyline autoPolyA; if (com.epl.geometry.Geometry.IsSegment(geomAtype)) { autoPolyA = new com.epl.geometry.Polyline(geomA.GetDescription()); geomA = (com.epl.geometry.Geometry)autoPolyA; autoPolyA.AddSegment((com.epl.geometry.Segment)geomA, true); } com.epl.geometry.Polyline autoPolyB; if (com.epl.geometry.Geometry.IsSegment(geomBtype)) { autoPolyB = new com.epl.geometry.Polyline(geomB.GetDescription()); geomB = (com.epl.geometry.Geometry)autoPolyB; autoPolyB.AddSegment((com.epl.geometry.Segment)geomB, true); } switch (geomAtype) { case com.epl.geometry.Geometry.GeometryType.Point: { switch (geomBtype) { case com.epl.geometry.Geometry.GeometryType.Point: { // Now process GeometryxGeometry case by case return(QuickTest2DPointPoint((com.epl.geometry.Point)geomA, (com.epl.geometry.Point)geomB, tolerance)); } case com.epl.geometry.Geometry.GeometryType.Envelope: { return(ReverseResult(QuickTest2DEnvelopePoint((com.epl.geometry.Envelope)geomB, (com.epl.geometry.Point)geomA, tolerance))); } case com.epl.geometry.Geometry.GeometryType.MultiPoint: { return(ReverseResult(QuickTest2DMultiPointPoint((com.epl.geometry.MultiPoint)geomB, (com.epl.geometry.Point)geomA, tolerance))); } case com.epl.geometry.Geometry.GeometryType.Polyline: { return(ReverseResult(QuickTest2DPolylinePoint((com.epl.geometry.Polyline)geomB, (com.epl.geometry.Point)geomA, tolerance, testType))); } case com.epl.geometry.Geometry.GeometryType.Polygon: { return(ReverseResult(QuickTest2DPolygonPoint((com.epl.geometry.Polygon)geomB, (com.epl.geometry.Point)geomA, tolerance))); } } throw com.epl.geometry.GeometryException.GeometryInternalError(); } case com.epl.geometry.Geometry.GeometryType.Envelope: { switch (geomBtype) { case com.epl.geometry.Geometry.GeometryType.Point: { // GEOMTHROW(internal_error);//what // else? return(QuickTest2DEnvelopePoint((com.epl.geometry.Envelope)geomA, (com.epl.geometry.Point)geomB, tolerance)); } case com.epl.geometry.Geometry.GeometryType.Envelope: { return(QuickTest2DEnvelopeEnvelope((com.epl.geometry.Envelope)geomA, (com.epl.geometry.Envelope)geomB, tolerance)); } case com.epl.geometry.Geometry.GeometryType.MultiPoint: { return(ReverseResult(QuickTest2DMultiPointEnvelope((com.epl.geometry.MultiPoint)geomB, (com.epl.geometry.Envelope)geomA, tolerance, testType))); } case com.epl.geometry.Geometry.GeometryType.Polyline: { return(ReverseResult(QuickTest2DPolylineEnvelope((com.epl.geometry.Polyline)geomB, (com.epl.geometry.Envelope)geomA, tolerance))); } case com.epl.geometry.Geometry.GeometryType.Polygon: { return(ReverseResult(QuickTest2DPolygonEnvelope((com.epl.geometry.Polygon)geomB, (com.epl.geometry.Envelope)geomA, tolerance))); } } throw com.epl.geometry.GeometryException.GeometryInternalError(); } case com.epl.geometry.Geometry.GeometryType.MultiPoint: { switch (geomBtype) { case com.epl.geometry.Geometry.GeometryType.Point: { // GEOMTHROW(internal_error);//what // else? return(QuickTest2DMultiPointPoint((com.epl.geometry.MultiPoint)geomA, (com.epl.geometry.Point)geomB, tolerance)); } case com.epl.geometry.Geometry.GeometryType.Envelope: { return(QuickTest2DMultiPointEnvelope((com.epl.geometry.MultiPoint)geomA, (com.epl.geometry.Envelope)geomB, tolerance, testType)); } case com.epl.geometry.Geometry.GeometryType.MultiPoint: { return(QuickTest2DMultiPointMultiPoint((com.epl.geometry.MultiPoint)geomA, (com.epl.geometry.MultiPoint)geomB, tolerance, testType)); } case com.epl.geometry.Geometry.GeometryType.Polyline: { return(ReverseResult(QuickTest2DPolylineMultiPoint((com.epl.geometry.Polyline)geomB, (com.epl.geometry.MultiPoint)geomA, tolerance))); } case com.epl.geometry.Geometry.GeometryType.Polygon: { return(ReverseResult(QuickTest2DPolygonMultiPoint((com.epl.geometry.Polygon)geomB, (com.epl.geometry.MultiPoint)geomA, tolerance))); } } throw com.epl.geometry.GeometryException.GeometryInternalError(); } case com.epl.geometry.Geometry.GeometryType.Polyline: { switch (geomBtype) { case com.epl.geometry.Geometry.GeometryType.Point: { // GEOMTHROW(internal_error);//what // else? return(QuickTest2DPolylinePoint((com.epl.geometry.Polyline)geomA, (com.epl.geometry.Point)geomB, tolerance, testType)); } case com.epl.geometry.Geometry.GeometryType.Envelope: { return(QuickTest2DPolylineEnvelope((com.epl.geometry.Polyline)geomA, (com.epl.geometry.Envelope)geomB, tolerance)); } case com.epl.geometry.Geometry.GeometryType.MultiPoint: { return(QuickTest2DPolylineMultiPoint((com.epl.geometry.Polyline)geomA, (com.epl.geometry.MultiPoint)geomB, tolerance)); } case com.epl.geometry.Geometry.GeometryType.Polyline: { return(QuickTest2DPolylinePolyline((com.epl.geometry.Polyline)geomA, (com.epl.geometry.Polyline)geomB, tolerance)); } case com.epl.geometry.Geometry.GeometryType.Polygon: { return(ReverseResult(QuickTest2DPolygonPolyline((com.epl.geometry.Polygon)geomB, (com.epl.geometry.Polyline)geomA, tolerance))); } } throw com.epl.geometry.GeometryException.GeometryInternalError(); } case com.epl.geometry.Geometry.GeometryType.Polygon: { switch (geomBtype) { case com.epl.geometry.Geometry.GeometryType.Point: { // GEOMTHROW(internal_error);//what // else? return(QuickTest2DPolygonPoint((com.epl.geometry.Polygon)geomA, (com.epl.geometry.Point)geomB, tolerance)); } case com.epl.geometry.Geometry.GeometryType.Envelope: { return(QuickTest2DPolygonEnvelope((com.epl.geometry.Polygon)geomA, (com.epl.geometry.Envelope)geomB, tolerance)); } case com.epl.geometry.Geometry.GeometryType.MultiPoint: { return(QuickTest2DPolygonMultiPoint((com.epl.geometry.Polygon)geomA, (com.epl.geometry.MultiPoint)geomB, tolerance)); } case com.epl.geometry.Geometry.GeometryType.Polyline: { return(QuickTest2DPolygonPolyline((com.epl.geometry.Polygon)geomA, (com.epl.geometry.Polyline)geomB, tolerance)); } case com.epl.geometry.Geometry.GeometryType.Polygon: { return(QuickTest2DPolygonPolygon((com.epl.geometry.Polygon)geomA, (com.epl.geometry.Polygon)geomB, tolerance)); } } throw com.epl.geometry.GeometryException.GeometryInternalError(); } default: { // GEOMTHROW(internal_error);//what // else? throw com.epl.geometry.GeometryException.GeometryInternalError(); } } }
public static com.epl.geometry.ogc.OGCGeometry CreateFromEsriGeometry(com.epl.geometry.Geometry geom, com.epl.geometry.SpatialReference sr, bool multiType) { if (geom == null) { return(null); } com.epl.geometry.Geometry.Type t = geom.GetType(); if (t == com.epl.geometry.Geometry.Type.Polygon) { if (!multiType && ((com.epl.geometry.Polygon)geom).GetExteriorRingCount() == 1) { return(new com.epl.geometry.ogc.OGCPolygon((com.epl.geometry.Polygon)geom, sr)); } else { return(new com.epl.geometry.ogc.OGCMultiPolygon((com.epl.geometry.Polygon)geom, sr)); } } if (t == com.epl.geometry.Geometry.Type.Polyline) { if (!multiType && ((com.epl.geometry.Polyline)geom).GetPathCount() == 1) { return(new com.epl.geometry.ogc.OGCLineString((com.epl.geometry.Polyline)geom, 0, sr)); } else { return(new com.epl.geometry.ogc.OGCMultiLineString((com.epl.geometry.Polyline)geom, sr)); } } if (t == com.epl.geometry.Geometry.Type.MultiPoint) { if (!multiType && ((com.epl.geometry.MultiPoint)geom).GetPointCount() <= 1) { if (geom.IsEmpty()) { return(new com.epl.geometry.ogc.OGCPoint(new com.epl.geometry.Point(), sr)); } else { return(new com.epl.geometry.ogc.OGCPoint(((com.epl.geometry.MultiPoint)geom).GetPoint(0), sr)); } } else { return(new com.epl.geometry.ogc.OGCMultiPoint((com.epl.geometry.MultiPoint)geom, sr)); } } if (t == com.epl.geometry.Geometry.Type.Point) { if (!multiType) { return(new com.epl.geometry.ogc.OGCPoint((com.epl.geometry.Point)geom, sr)); } else { return(new com.epl.geometry.ogc.OGCMultiPoint((com.epl.geometry.Point)geom, sr)); } } if (t == com.epl.geometry.Geometry.Type.Envelope) { com.epl.geometry.Polygon p = new com.epl.geometry.Polygon(); p.AddEnvelope((com.epl.geometry.Envelope)geom, false); return(CreateFromEsriGeometry(p, sr, multiType)); } throw new System.NotSupportedException(); }
public virtual void TestBufferPolyline() { com.epl.geometry.SpatialReference sr = com.epl.geometry.SpatialReference.Create(4326); com.epl.geometry.Polyline inputGeom = new com.epl.geometry.Polyline(); com.epl.geometry.OperatorBuffer buffer = (com.epl.geometry.OperatorBuffer)com.epl.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.epl.geometry.Operator.Type.Buffer); com.epl.geometry.OperatorSimplify simplify = (com.epl.geometry.OperatorSimplify)com.epl.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.epl.geometry.Operator.Type.Simplify); inputGeom.StartPath(0, 0); inputGeom.LineTo(50, 50); inputGeom.LineTo(50, 0); inputGeom.LineTo(0, 50); { com.epl.geometry.Geometry result = buffer.Execute(inputGeom, sr, 0, null); NUnit.Framework.Assert.IsTrue(result.GetType().Value() == com.epl.geometry.Geometry.GeometryType.Polygon); NUnit.Framework.Assert.IsTrue(result.IsEmpty()); } { com.epl.geometry.Geometry result = buffer.Execute(inputGeom, sr, -1, null); NUnit.Framework.Assert.IsTrue(result.GetType().Value() == com.epl.geometry.Geometry.GeometryType.Polygon); NUnit.Framework.Assert.IsTrue(result.IsEmpty()); } { com.epl.geometry.Geometry result = buffer.Execute(inputGeom, sr, 40.0, null); NUnit.Framework.Assert.IsTrue(result.GetType().Value() == com.epl.geometry.Geometry.GeometryType.Polygon); com.epl.geometry.Polygon poly = (com.epl.geometry.Polygon)(result); com.epl.geometry.Envelope2D env2D = new com.epl.geometry.Envelope2D(); result.QueryEnvelope2D(env2D); NUnit.Framework.Assert.IsTrue(System.Math.Abs(env2D.GetWidth() - 80 - 50) < 0.1 && System.Math.Abs(env2D.GetHeight() - 80 - 50) < 0.1); NUnit.Framework.Assert.IsTrue(System.Math.Abs(env2D.GetCenterX() - 25) < 0.1 && System.Math.Abs(env2D.GetCenterY() - 25) < 0.1); int pathCount = poly.GetPathCount(); NUnit.Framework.Assert.IsTrue(pathCount == 1); int pointCount = poly.GetPointCount(); NUnit.Framework.Assert.IsTrue(System.Math.Abs(pointCount - 171.0) < 10); NUnit.Framework.Assert.IsTrue(simplify.IsSimpleAsFeature(result, sr, null)); } { com.epl.geometry.Geometry result = buffer.Execute(inputGeom, sr, 4.0, null); NUnit.Framework.Assert.IsTrue(result.GetType().Value() == com.epl.geometry.Geometry.GeometryType.Polygon); com.epl.geometry.Polygon poly = (com.epl.geometry.Polygon)(result); com.epl.geometry.Envelope2D env2D = new com.epl.geometry.Envelope2D(); result.QueryEnvelope2D(env2D); NUnit.Framework.Assert.IsTrue(System.Math.Abs(env2D.GetWidth() - 8 - 50) < 0.1 && System.Math.Abs(env2D.GetHeight() - 8 - 50) < 0.1); NUnit.Framework.Assert.IsTrue(System.Math.Abs(env2D.GetCenterX() - 25) < 0.1 && System.Math.Abs(env2D.GetCenterY() - 25) < 0.1); int pathCount = poly.GetPathCount(); NUnit.Framework.Assert.IsTrue(pathCount == 2); int pointCount = poly.GetPointCount(); NUnit.Framework.Assert.IsTrue(System.Math.Abs(pointCount - 186.0) < 10); NUnit.Framework.Assert.IsTrue(simplify.IsSimpleAsFeature(result, sr, null)); } { inputGeom = new com.epl.geometry.Polyline(); inputGeom.StartPath(0, 0); inputGeom.LineTo(50, 50); inputGeom.StartPath(50, 0); inputGeom.LineTo(0, 50); com.epl.geometry.Geometry result = buffer.Execute(inputGeom, sr, 4.0, null); NUnit.Framework.Assert.IsTrue(result.GetType().Value() == com.epl.geometry.Geometry.GeometryType.Polygon); com.epl.geometry.Polygon poly = (com.epl.geometry.Polygon)(result); com.epl.geometry.Envelope2D env2D = new com.epl.geometry.Envelope2D(); result.QueryEnvelope2D(env2D); NUnit.Framework.Assert.IsTrue(System.Math.Abs(env2D.GetWidth() - 8 - 50) < 0.1 && System.Math.Abs(env2D.GetHeight() - 8 - 50) < 0.1); NUnit.Framework.Assert.IsTrue(System.Math.Abs(env2D.GetCenterX() - 25) < 0.1 && System.Math.Abs(env2D.GetCenterY() - 25) < 0.1); int pathCount = poly.GetPathCount(); NUnit.Framework.Assert.IsTrue(pathCount == 1); int pointCount = poly.GetPointCount(); NUnit.Framework.Assert.IsTrue(System.Math.Abs(pointCount - 208.0) < 10); NUnit.Framework.Assert.IsTrue(simplify.IsSimpleAsFeature(result, sr, null)); } { inputGeom = new com.epl.geometry.Polyline(); inputGeom.StartPath(1.762614, 0.607368); inputGeom.LineTo(1.762414, 0.606655); inputGeom.LineTo(1.763006, 0.607034); inputGeom.LineTo(1.762548, 0.607135); com.epl.geometry.Geometry result = buffer.Execute(inputGeom, sr, 0.005, null); NUnit.Framework.Assert.IsTrue(simplify.IsSimpleAsFeature(result, sr, null)); } }
internal static com.epl.geometry.Geometry Difference(com.epl.geometry.Geometry geometry_a, com.epl.geometry.Geometry geometry_b, com.epl.geometry.SpatialReference spatial_reference, com.epl.geometry.ProgressTracker progress_tracker) { if (geometry_a.IsEmpty() || geometry_b.IsEmpty()) { return(geometry_a); } int dimension_a = geometry_a.GetDimension(); int dimension_b = geometry_b.GetDimension(); if (dimension_a > dimension_b) { return(geometry_a); } int type_a = geometry_a.GetType().Value(); int type_b = geometry_b.GetType().Value(); com.epl.geometry.Envelope2D env_a = new com.epl.geometry.Envelope2D(); com.epl.geometry.Envelope2D env_b = new com.epl.geometry.Envelope2D(); com.epl.geometry.Envelope2D env_merged = new com.epl.geometry.Envelope2D(); geometry_a.QueryEnvelope2D(env_a); geometry_b.QueryEnvelope2D(env_b); env_merged.SetCoords(env_a); env_merged.Merge(env_b); double tolerance = com.epl.geometry.InternalUtils.CalculateToleranceFromGeometry(spatial_reference, env_merged, false); double tolerance_cluster = tolerance * System.Math.Sqrt(2.0) * 1.00001; com.epl.geometry.Envelope2D env_a_inflated = new com.epl.geometry.Envelope2D(); env_a_inflated.SetCoords(env_a); env_a_inflated.Inflate(tolerance_cluster, tolerance_cluster); // inflate // by // cluster // tolerance if (!env_a_inflated.IsIntersecting(env_b)) { return(geometry_a); } if (dimension_a == 1 && dimension_b == 2) { return(PolylineMinusArea_(geometry_a, geometry_b, type_b, spatial_reference, progress_tracker)); } if (type_a == com.epl.geometry.Geometry.GeometryType.Point) { com.epl.geometry.Geometry geometry_b_; if (com.epl.geometry.MultiPath.IsSegment(type_b)) { geometry_b_ = new com.epl.geometry.Polyline(geometry_b.GetDescription()); ((com.epl.geometry.Polyline)(geometry_b_)).AddSegment((com.epl.geometry.Segment)(geometry_b), true); } else { geometry_b_ = geometry_b; } switch (type_b) { case com.epl.geometry.Geometry.GeometryType.Polygon: { return(PointMinusPolygon_((com.epl.geometry.Point)(geometry_a), (com.epl.geometry.Polygon)(geometry_b_), tolerance, progress_tracker)); } case com.epl.geometry.Geometry.GeometryType.Polyline: { return(PointMinusPolyline_((com.epl.geometry.Point)(geometry_a), (com.epl.geometry.Polyline)(geometry_b_), tolerance, progress_tracker)); } case com.epl.geometry.Geometry.GeometryType.MultiPoint: { return(PointMinusMultiPoint_((com.epl.geometry.Point)(geometry_a), (com.epl.geometry.MultiPoint)(geometry_b_), tolerance, progress_tracker)); } case com.epl.geometry.Geometry.GeometryType.Envelope: { return(PointMinusEnvelope_((com.epl.geometry.Point)(geometry_a), (com.epl.geometry.Envelope)(geometry_b_), tolerance, progress_tracker)); } case com.epl.geometry.Geometry.GeometryType.Point: { return(PointMinusPoint_((com.epl.geometry.Point)(geometry_a), (com.epl.geometry.Point)(geometry_b_), tolerance, progress_tracker)); } default: { throw new System.ArgumentException(); } } } else { if (type_a == com.epl.geometry.Geometry.GeometryType.MultiPoint) { switch (type_b) { case com.epl.geometry.Geometry.GeometryType.Polygon: { return(MultiPointMinusPolygon_((com.epl.geometry.MultiPoint)(geometry_a), (com.epl.geometry.Polygon)(geometry_b), tolerance, progress_tracker)); } case com.epl.geometry.Geometry.GeometryType.Envelope: { return(MultiPointMinusEnvelope_((com.epl.geometry.MultiPoint)(geometry_a), (com.epl.geometry.Envelope)(geometry_b), tolerance, progress_tracker)); } case com.epl.geometry.Geometry.GeometryType.Point: { return(MultiPointMinusPoint_((com.epl.geometry.MultiPoint)(geometry_a), (com.epl.geometry.Point)(geometry_b), tolerance, progress_tracker)); } default: { break; } } } } return(com.epl.geometry.TopologicalOperations.Difference(geometry_a, geometry_b, spatial_reference, progress_tracker)); }
/// <summary>Performs the Distance operation on two geometries</summary> /// <returns>Returns a double.</returns> public override double Execute(com.epl.geometry.Geometry geom1, com.epl.geometry.Geometry geom2, com.epl.geometry.ProgressTracker progressTracker) { if (null == geom1 || null == geom2) { throw new System.ArgumentException(); } com.epl.geometry.Geometry geometryA = geom1; com.epl.geometry.Geometry geometryB = geom2; if (geometryA.IsEmpty() || geometryB.IsEmpty()) { return(com.epl.geometry.NumberUtils.TheNaN); } com.epl.geometry.Polygon polygonA; com.epl.geometry.Polygon polygonB; com.epl.geometry.MultiPoint multiPointA; com.epl.geometry.MultiPoint multiPointB; // if geometryA is an envelope use a polygon instead (if geom1 was // folded, then geometryA will already be a polygon) // if geometryA is a point use a multipoint instead com.epl.geometry.Geometry.Type gtA = geometryA.GetType(); com.epl.geometry.Geometry.Type gtB = geometryB.GetType(); if (gtA == com.epl.geometry.Geometry.Type.Point) { if (gtB == com.epl.geometry.Geometry.Type.Point) { return(com.epl.geometry.Point2D.Distance(((com.epl.geometry.Point)geometryA).GetXY(), ((com.epl.geometry.Point)geometryB).GetXY())); } else { if (gtB == com.epl.geometry.Geometry.Type.Envelope) { com.epl.geometry.Envelope2D envB = new com.epl.geometry.Envelope2D(); geometryB.QueryEnvelope2D(envB); return(envB.Distance(((com.epl.geometry.Point)geometryA).GetXY())); } } multiPointA = new com.epl.geometry.MultiPoint(); multiPointA.Add((com.epl.geometry.Point)geometryA); geometryA = multiPointA; } else { if (gtA == com.epl.geometry.Geometry.Type.Envelope) { if (gtB == com.epl.geometry.Geometry.Type.Envelope) { com.epl.geometry.Envelope2D envA = new com.epl.geometry.Envelope2D(); geometryA.QueryEnvelope2D(envA); com.epl.geometry.Envelope2D envB = new com.epl.geometry.Envelope2D(); geometryB.QueryEnvelope2D(envB); return(envB.Distance(envA)); } polygonA = new com.epl.geometry.Polygon(); polygonA.AddEnvelope((com.epl.geometry.Envelope)geometryA, false); geometryA = polygonA; } } // if geom_2 is an envelope use a polygon instead // if geom_2 is a point use a multipoint instead if (gtB == com.epl.geometry.Geometry.Type.Point) { multiPointB = new com.epl.geometry.MultiPoint(); multiPointB.Add((com.epl.geometry.Point)geometryB); geometryB = multiPointB; } else { if (gtB == com.epl.geometry.Geometry.Type.Envelope) { polygonB = new com.epl.geometry.Polygon(); polygonB.AddEnvelope((com.epl.geometry.Envelope)geometryB, false); geometryB = polygonB; } } com.epl.geometry.OperatorDistanceLocal.DistanceCalculator distanceCalculator = new com.epl.geometry.OperatorDistanceLocal.DistanceCalculator(this, progressTracker); double distance = distanceCalculator.Calculate(geometryA, geometryB); return(distance); }
internal virtual com.epl.geometry.Geometry TryNativeImplementation_(com.epl.geometry.Geometry input_geom) { // A note on attributes: // 1. The geometry with lower dimension wins in regard to the // attributes. // 2. If the dimensions are the same, the input_geometry attributes win. // 3. The exception to the 2. is when the input is an Envelope, and the // intersector is a polygon, then the intersector wins. // A note on the tolerance: // This operator performs a simple intersection operation. Should it use // the tolerance? // Example: Point is intersected by the envelope. // If it is slightly outside of the envelope, should we still return it // if it is closer than the tolerance? // Should we do crack and cluster and snap the point coordinates to the // envelope boundary? // // Consider floating point arithmetics approach. When you compare // doubles, you should use an epsilon (equals means ::fabs(a - b) < // eps), however when you add/subtract, etc them, you do not use // epsilon. // Shouldn't we do same here? Relational operators use tolerance, but // the action operators don't. com.epl.geometry.Envelope2D mergedExtent = com.epl.geometry.InternalUtils.GetMergedExtent(input_geom, m_geomIntersector); double tolerance = com.epl.geometry.InternalUtils.CalculateToleranceFromGeometry(m_spatial_reference, mergedExtent, false); int gtInput = input_geom.GetType().Value(); bool bInputEmpty = input_geom.IsEmpty(); bool bGeomIntersectorEmpty = m_geomIntersector.IsEmpty(); bool bResultIsEmpty = bInputEmpty || bGeomIntersectorEmpty; if (!bResultIsEmpty) { // test envelopes com.epl.geometry.Envelope2D env2D1 = new com.epl.geometry.Envelope2D(); input_geom.QueryEnvelope2D(env2D1); com.epl.geometry.Envelope2D env2D2 = new com.epl.geometry.Envelope2D(); m_geomIntersector.QueryEnvelope2D(env2D2); env2D2.Inflate(2.0 * tolerance, 2.0 * tolerance); bResultIsEmpty = !env2D1.IsIntersecting(env2D2); } if (!bResultIsEmpty) { // try accelerated test int res = com.epl.geometry.OperatorInternalRelationUtils.QuickTest2D_Accelerated_DisjointOrContains(m_geomIntersector, input_geom, tolerance); if (res == com.epl.geometry.OperatorInternalRelationUtils.Relation.Disjoint) { // disjoint bResultIsEmpty = true; } else { if ((res & com.epl.geometry.OperatorInternalRelationUtils.Relation.Within) != 0) { // intersector // is // within // the // input_geom // TODO: // assign // input_geom // attributes // first return m_geomIntersector; } else { if ((res & com.epl.geometry.OperatorInternalRelationUtils.Relation.Contains) != 0) { // intersector // contains // input_geom return input_geom; } } } } if (bResultIsEmpty) { // When one geometry or both are empty, we need to // return an empty geometry. // Here we do that end also ensure the type is // correct. // That is the lower dimension need to be // returned. Also, for Point vs Multi_point, an // empty Point need to be returned. int dim1 = com.epl.geometry.Geometry.GetDimensionFromType(gtInput); int dim2 = com.epl.geometry.Geometry.GetDimensionFromType(m_geomIntersectorType); if (dim1 < dim2) { return ReturnEmpty_(input_geom, bInputEmpty); } else { if (dim1 > dim2) { return ReturnEmptyIntersector_(); } else { if (dim1 == 0) { if (gtInput == com.epl.geometry.Geometry.GeometryType.MultiPoint && m_geomIntersectorType == com.epl.geometry.Geometry.GeometryType.Point) { // point // vs // Multi_point // need // special // treatment // to // ensure // Point // is // returned // always. return ReturnEmptyIntersector_(); } else { // Both input and intersector have same gtype, or input is // Point. return ReturnEmpty_(input_geom, bInputEmpty); } } else { return ReturnEmpty_(input_geom, bInputEmpty); } } } } // Note: No empty geometries after this point! // Warning: Do not try clip for polylines and polygons. // Try clip of Envelope with Envelope. if ((m_dimensionMask == -1 || m_dimensionMask == (1 << 2)) && gtInput == com.epl.geometry.Geometry.GeometryType.Envelope && m_geomIntersectorType == com.epl.geometry.Geometry.GeometryType.Envelope) { com.epl.geometry.Envelope env1 = (com.epl.geometry.Envelope)input_geom; com.epl.geometry.Envelope env2 = (com.epl.geometry.Envelope)m_geomIntersector; com.epl.geometry.Envelope2D env2D_1 = new com.epl.geometry.Envelope2D(); env1.QueryEnvelope2D(env2D_1); com.epl.geometry.Envelope2D env2D_2 = new com.epl.geometry.Envelope2D(); env2.QueryEnvelope2D(env2D_2); env2D_1.Intersect(env2D_2); com.epl.geometry.Envelope result_env = new com.epl.geometry.Envelope(); env1.CopyTo(result_env); result_env.SetEnvelope2D(env2D_1); return result_env; } // Use clip for Point and Multi_point with Envelope if ((gtInput == com.epl.geometry.Geometry.GeometryType.Envelope && com.epl.geometry.Geometry.GetDimensionFromType(m_geomIntersectorType) == 0) || (m_geomIntersectorType == com.epl.geometry.Geometry.GeometryType.Envelope && com.epl.geometry.Geometry.GetDimensionFromType(gtInput ) == 0)) { com.epl.geometry.Envelope env = gtInput == com.epl.geometry.Geometry.GeometryType.Envelope ? (com.epl.geometry.Envelope)input_geom : (com.epl.geometry.Envelope)m_geomIntersector; com.epl.geometry.Geometry other = gtInput == com.epl.geometry.Geometry.GeometryType.Envelope ? m_geomIntersector : input_geom; com.epl.geometry.Envelope2D env_2D = new com.epl.geometry.Envelope2D(); env.QueryEnvelope2D(env_2D); return com.epl.geometry.Clipper.Clip(other, env_2D, tolerance, 0); } if ((com.epl.geometry.Geometry.GetDimensionFromType(gtInput) == 0 && com.epl.geometry.Geometry.GetDimensionFromType(m_geomIntersectorType) > 0) || (com.epl.geometry.Geometry.GetDimensionFromType(gtInput) > 0 && com.epl.geometry.Geometry.GetDimensionFromType(m_geomIntersectorType ) == 0)) { // multipoint // intersection double tolerance1 = com.epl.geometry.InternalUtils.CalculateToleranceFromGeometry(m_spatial_reference, input_geom, false); if (gtInput == com.epl.geometry.Geometry.GeometryType.MultiPoint) { return com.epl.geometry.TopologicalOperations.Intersection((com.epl.geometry.MultiPoint)input_geom, m_geomIntersector, tolerance1); } if (gtInput == com.epl.geometry.Geometry.GeometryType.Point) { return com.epl.geometry.TopologicalOperations.Intersection((com.epl.geometry.Point)input_geom, m_geomIntersector, tolerance1); } if (m_geomIntersectorType == com.epl.geometry.Geometry.GeometryType.MultiPoint) { return com.epl.geometry.TopologicalOperations.Intersection((com.epl.geometry.MultiPoint)m_geomIntersector, input_geom, tolerance1); } if (m_geomIntersectorType == com.epl.geometry.Geometry.GeometryType.Point) { return com.epl.geometry.TopologicalOperations.Intersection((com.epl.geometry.Point)m_geomIntersector, input_geom, tolerance1); } throw com.epl.geometry.GeometryException.GeometryInternalError(); } // Try Polyline vs Polygon if ((m_dimensionMask == -1 || m_dimensionMask == (1 << 1)) && (gtInput == com.epl.geometry.Geometry.GeometryType.Polyline) && (m_geomIntersectorType == com.epl.geometry.Geometry.GeometryType.Polygon)) { return TryFastIntersectPolylinePolygon_((com.epl.geometry.Polyline)(input_geom), (com.epl.geometry.Polygon)(m_geomIntersector)); } // Try Polygon vs Polyline if ((m_dimensionMask == -1 || m_dimensionMask == (1 << 1)) && (gtInput == com.epl.geometry.Geometry.GeometryType.Polygon) && (m_geomIntersectorType == com.epl.geometry.Geometry.GeometryType.Polyline)) { return TryFastIntersectPolylinePolygon_((com.epl.geometry.Polyline)(m_geomIntersector), (com.epl.geometry.Polygon)(input_geom)); } return null; }
internal static com.epl.geometry.Geometry CalculateConvexHull_(com.epl.geometry.Geometry geom, com.epl.geometry.ProgressTracker progress_tracker) { if (geom.IsEmpty()) { return(geom.CreateInstance()); } com.epl.geometry.Geometry.Type type = geom.GetType(); if (com.epl.geometry.Geometry.IsSegment(type.Value())) { // Segments are always returned either as a Point or Polyline com.epl.geometry.Segment segment = (com.epl.geometry.Segment)geom; if (segment.GetStartXY().Equals(segment.GetEndXY())) { com.epl.geometry.Point point = new com.epl.geometry.Point(); segment.QueryStart(point); return(point); } else { com.epl.geometry.Point pt = new com.epl.geometry.Point(); com.epl.geometry.Polyline polyline = new com.epl.geometry.Polyline(geom.GetDescription()); segment.QueryStart(pt); polyline.StartPath(pt); segment.QueryEnd(pt); polyline.LineTo(pt); return(polyline); } } else { if (type == com.epl.geometry.Geometry.Type.Envelope) { com.epl.geometry.Envelope envelope = (com.epl.geometry.Envelope)geom; com.epl.geometry.Envelope2D env = new com.epl.geometry.Envelope2D(); envelope.QueryEnvelope2D(env); if (env.xmin == env.xmax && env.ymin == env.ymax) { com.epl.geometry.Point point = new com.epl.geometry.Point(); envelope.QueryCornerByVal(0, point); return(point); } else { if (env.xmin == env.xmax || env.ymin == env.ymax) { com.epl.geometry.Point pt = new com.epl.geometry.Point(); com.epl.geometry.Polyline polyline = new com.epl.geometry.Polyline(geom.GetDescription()); envelope.QueryCornerByVal(0, pt); polyline.StartPath(pt); envelope.QueryCornerByVal(1, pt); polyline.LineTo(pt); return(polyline); } else { com.epl.geometry.Polygon polygon = new com.epl.geometry.Polygon(geom.GetDescription()); polygon.AddEnvelope(envelope, false); return(polygon); } } } } if (IsConvex_(geom, progress_tracker)) { if (type == com.epl.geometry.Geometry.Type.MultiPoint) { // Downgrade to a Point for simplistic output com.epl.geometry.MultiPoint multi_point = (com.epl.geometry.MultiPoint)geom; com.epl.geometry.Point point = new com.epl.geometry.Point(); multi_point.GetPointByVal(0, point); return(point); } return(geom); } System.Diagnostics.Debug.Assert((com.epl.geometry.Geometry.IsMultiVertex(type.Value()))); com.epl.geometry.Geometry convex_hull = com.epl.geometry.ConvexHull.Construct((com.epl.geometry.MultiVertexGeometry)geom); return(convex_hull); }