public static void TestClipOfCoinciding()
{
com.epl.geometry.OperatorFactoryLocal engine = com.epl.geometry.OperatorFactoryLocal.GetInstance();
com.epl.geometry.OperatorClip clipOp = (com.epl.geometry.OperatorClip)engine.GetOperator(com.epl.geometry.Operator.Type.Clip);
com.epl.geometry.Polygon polygon = new com.epl.geometry.Polygon();
com.epl.geometry.Envelope2D envelopeCR = new com.epl.geometry.Envelope2D();
envelopeCR.xmin = -180;
envelopeCR.xmax = 180;
envelopeCR.ymin = -90;
envelopeCR.ymax = 90;
polygon.AddEnvelope(envelopeCR, false);
com.epl.geometry.SpatialReference gcsWGS84 = com.epl.geometry.SpatialReference.Create(4326);
// CR
com.epl.geometry.Polygon clippedPolygon = (com.epl.geometry.Polygon)clipOp.Execute(polygon, envelopeCR, gcsWGS84, null);
NUnit.Framework.Assert.IsTrue(clippedPolygon.GetPathCount() == 1);
NUnit.Framework.Assert.IsTrue(clippedPolygon.GetPointCount() == 4);
com.epl.geometry.OperatorDensifyByLength densifyOp = (com.epl.geometry.OperatorDensifyByLength)engine.GetOperator(com.epl.geometry.Operator.Type.DensifyByLength);
polygon.SetEmpty();
polygon.AddEnvelope(envelopeCR, false);
polygon = (com.epl.geometry.Polygon)densifyOp.Execute(polygon, 1, null);
int pc = polygon.GetPointCount();
int pathc = polygon.GetPathCount();
NUnit.Framework.Assert.IsTrue(pc == 1080);
NUnit.Framework.Assert.IsTrue(pathc == 1);
clippedPolygon = (com.epl.geometry.Polygon)clipOp.Execute(polygon, envelopeCR, gcsWGS84, null);
int _pathc = clippedPolygon.GetPathCount();
int _pc = clippedPolygon.GetPointCount();
NUnit.Framework.Assert.IsTrue(_pathc == 1);
NUnit.Framework.Assert.IsTrue(_pc == pc);
}
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);
}
internal static com.epl.geometry.Geometry PolylineMinusArea_(com.epl.geometry.Geometry geometry, com.epl.geometry.Geometry area, int area_type, com.epl.geometry.SpatialReference sr, com.epl.geometry.ProgressTracker progress_tracker)
{
// construct the complement of the Polygon (or Envelope)
com.epl.geometry.Envelope envelope = new com.epl.geometry.Envelope();
geometry.QueryEnvelope(envelope);
com.epl.geometry.Envelope2D env_2D = new com.epl.geometry.Envelope2D();
area.QueryEnvelope2D(env_2D);
envelope.Merge(env_2D);
double dw = 0.1 * envelope.GetWidth();
double dh = 0.1 * envelope.GetHeight();
envelope.Inflate(dw, dh);
com.epl.geometry.Polygon complement = new com.epl.geometry.Polygon();
complement.AddEnvelope(envelope, false);
com.epl.geometry.MultiPathImpl complementImpl = (com.epl.geometry.MultiPathImpl)(complement._getImpl());
if (area_type == com.epl.geometry.Geometry.GeometryType.Polygon)
{
com.epl.geometry.MultiPathImpl polygonImpl = (com.epl.geometry.MultiPathImpl)(area._getImpl());
complementImpl.Add(polygonImpl, true);
}
else
{
complementImpl.AddEnvelope((com.epl.geometry.Envelope)(area), true);
}
com.epl.geometry.OperatorFactoryLocal projEnv = com.epl.geometry.OperatorFactoryLocal.GetInstance();
com.epl.geometry.OperatorIntersection operatorIntersection = (com.epl.geometry.OperatorIntersection)projEnv.GetOperator(com.epl.geometry.Operator.Type.Intersection);
com.epl.geometry.Geometry difference = operatorIntersection.Execute(geometry, complement, sr, progress_tracker);
return(difference);
}
public virtual com.epl.geometry.ogc.OGCGeometry Envelope()
{
com.epl.geometry.Envelope env = new com.epl.geometry.Envelope();
GetEsriGeometry().QueryEnvelope(env);
com.epl.geometry.Polygon polygon = new com.epl.geometry.Polygon();
polygon.AddEnvelope(env, false);
return(new com.epl.geometry.ogc.OGCPolygon(polygon, esriSR));
}
public override com.epl.geometry.ogc.OGCGeometry Envelope()
{
com.epl.geometry.GeometryCursor gc = GetEsriGeometryCursor();
com.epl.geometry.Envelope env = new com.epl.geometry.Envelope();
for (com.epl.geometry.Geometry g = gc.Next(); g != null; g = gc.Next())
{
com.epl.geometry.Envelope e = new com.epl.geometry.Envelope();
g.QueryEnvelope(e);
env.Merge(e);
}
com.epl.geometry.Polygon polygon = new com.epl.geometry.Polygon();
polygon.AddEnvelope(env, false);
return(new com.epl.geometry.ogc.OGCPolygon(polygon, esriSR));
}
public static void TestArcObjectsFailureCR196492()
{
com.epl.geometry.OperatorFactoryLocal engine = com.epl.geometry.OperatorFactoryLocal.GetInstance();
com.epl.geometry.OperatorClip clipOp = (com.epl.geometry.OperatorClip)engine.GetOperator(com.epl.geometry.Operator.Type.Clip);
com.epl.geometry.Polygon polygon = new com.epl.geometry.Polygon();
polygon.AddEnvelope(new com.epl.geometry.Envelope2D(0, 0, 600, 600), false);
polygon.StartPath(30, 300);
polygon.LineTo(20, 310);
polygon.LineTo(10, 300);
com.epl.geometry.SpatialReference gcsWGS84 = com.epl.geometry.SpatialReference.Create(4326);
com.epl.geometry.Envelope2D envelopeCR = new com.epl.geometry.Envelope2D(10, 10, 500, 500);
com.epl.geometry.Polygon clippedPolygon = (com.epl.geometry.Polygon)clipOp.Execute(polygon, envelopeCR, gcsWGS84, null);
NUnit.Framework.Assert.IsTrue(clippedPolygon.GetPointCount() == 7);
}
private com.epl.geometry.Geometry DensifyEnvelope(com.epl.geometry.Envelope geom)
{
com.epl.geometry.Polygon polygon = new com.epl.geometry.Polygon(geom.GetDescription());
polygon.AddEnvelope(geom, false);
com.epl.geometry.Envelope2D env2D = new com.epl.geometry.Envelope2D();
geom.QueryEnvelope2D(env2D);
double w = env2D.GetWidth();
double h = env2D.GetHeight();
if (w <= m_maxLength && h <= m_maxLength)
{
return((com.epl.geometry.Geometry)polygon);
}
return(DensifyMultiPath((com.epl.geometry.MultiPath)polygon));
}
public static void TestLargeDeviation()
{
{
com.epl.geometry.Polygon input_polygon = new com.epl.geometry.Polygon();
input_polygon.AddEnvelope(com.epl.geometry.Envelope2D.Construct(0, 0, 20, 10), false);
com.epl.geometry.Geometry densified_geom = com.epl.geometry.OperatorDensifyByLength.Local().Execute(input_polygon, 1, null);
com.epl.geometry.Geometry geom = com.epl.geometry.OperatorGeneralize.Local().Execute(densified_geom, 1, true, null);
int pc = ((com.epl.geometry.MultiPath)geom).GetPointCount();
NUnit.Framework.Assert.IsTrue(pc == 4);
com.epl.geometry.Geometry large_dev1 = com.epl.geometry.OperatorGeneralize.Local().Execute(densified_geom, 40, true, null);
int pc1 = ((com.epl.geometry.MultiPath)large_dev1).GetPointCount();
NUnit.Framework.Assert.IsTrue(pc1 == 0);
com.epl.geometry.Geometry large_dev2 = com.epl.geometry.OperatorGeneralize.Local().Execute(densified_geom, 40, false, null);
int pc2 = ((com.epl.geometry.MultiPath)large_dev2).GetPointCount();
NUnit.Framework.Assert.IsTrue(pc2 == 3);
}
}
public virtual void TestProximity2D_2()
{
com.epl.geometry.Point point1 = new com.epl.geometry.Point(3, 2);
com.epl.geometry.Point point2 = new com.epl.geometry.Point(2, 4);
com.epl.geometry.Envelope envelope = new com.epl.geometry.Envelope();
envelope.SetCoords(4, 3, 7, 6);
com.epl.geometry.Polygon polygonToTest = new com.epl.geometry.Polygon();
polygonToTest.AddEnvelope(envelope, false);
com.epl.geometry.Proximity2DResult prxResult1 = com.epl.geometry.GeometryEngine.GetNearestVertex(envelope, point1);
com.epl.geometry.Proximity2DResult prxResult2 = com.epl.geometry.GeometryEngine.GetNearestVertex(polygonToTest, point1);
com.epl.geometry.Proximity2DResult prxResult3 = com.epl.geometry.GeometryEngine.GetNearestCoordinate(envelope, point2, false);
com.epl.geometry.Proximity2DResult prxResult4 = com.epl.geometry.GeometryEngine.GetNearestCoordinate(polygonToTest, point2, false);
com.epl.geometry.Point result1 = prxResult1.GetCoordinate();
com.epl.geometry.Point result2 = prxResult2.GetCoordinate();
NUnit.Framework.Assert.IsTrue(result1.GetX() == result2.GetX());
com.epl.geometry.Point result3 = prxResult3.GetCoordinate();
com.epl.geometry.Point result4 = prxResult4.GetCoordinate();
NUnit.Framework.Assert.IsTrue(result3.GetX() == result4.GetX());
}
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 static void Test1()
{
{
com.epl.geometry.QuadTree quad_tree = new com.epl.geometry.QuadTree(com.epl.geometry.Envelope2D.Construct(-10, -10, 10, 10), 8);
com.epl.geometry.QuadTree.QuadTreeIterator qt = quad_tree.GetIterator(true);
NUnit.Framework.Assert.IsTrue(qt.Next() == -1);
qt.ResetIterator(com.epl.geometry.Envelope2D.Construct(0, 0, 0, 0), 0);
NUnit.Framework.Assert.IsTrue(quad_tree.GetIntersectionCount(com.epl.geometry.Envelope2D.Construct(0, 0, 0, 0), 0, 10) == 0);
NUnit.Framework.Assert.IsTrue(quad_tree.GetElementCount() == 0);
}
com.epl.geometry.Polyline polyline;
polyline = MakePolyline();
com.epl.geometry.MultiPathImpl polylineImpl = (com.epl.geometry.MultiPathImpl)polyline._getImpl();
com.epl.geometry.QuadTree quadtree = BuildQuadTree_(polylineImpl, false);
com.epl.geometry.Line queryline = new com.epl.geometry.Line(34, 9, 66, 46);
com.epl.geometry.QuadTree.QuadTreeIterator qtIter = quadtree.GetIterator();
NUnit.Framework.Assert.IsTrue(qtIter.Next() == -1);
qtIter.ResetIterator(queryline, 0.0);
int element_handle = qtIter.Next();
while (element_handle > 0)
{
int index = quadtree.GetElement(element_handle);
NUnit.Framework.Assert.IsTrue(index == 6 || index == 8 || index == 14);
element_handle = qtIter.Next();
}
com.epl.geometry.Envelope2D envelope = new com.epl.geometry.Envelope2D(34, 9, 66, 46);
com.epl.geometry.Polygon queryPolygon = new com.epl.geometry.Polygon();
queryPolygon.AddEnvelope(envelope, true);
qtIter.ResetIterator(queryline, 0.0);
element_handle = qtIter.Next();
while (element_handle > 0)
{
int index = quadtree.GetElement(element_handle);
NUnit.Framework.Assert.IsTrue(index == 6 || index == 8 || index == 14);
element_handle = qtIter.Next();
}
}
/// <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 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);
}
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 static void TestClipGeometries()
{
// RandomTest();
com.epl.geometry.OperatorFactoryLocal engine = com.epl.geometry.OperatorFactoryLocal.GetInstance();
com.epl.geometry.OperatorClip clipOp = (com.epl.geometry.OperatorClip)engine.GetOperator(com.epl.geometry.Operator.Type.Clip);
com.epl.geometry.Polygon polygon = MakePolygon();
com.epl.geometry.SimpleGeometryCursor polygonCurs = new com.epl.geometry.SimpleGeometryCursor(polygon);
com.epl.geometry.Polyline polyline = MakePolyline();
com.epl.geometry.SimpleGeometryCursor polylineCurs = new com.epl.geometry.SimpleGeometryCursor(polyline);
com.epl.geometry.MultiPoint multipoint = MakeMultiPoint();
com.epl.geometry.SimpleGeometryCursor multipointCurs = new com.epl.geometry.SimpleGeometryCursor(multipoint);
com.epl.geometry.Point point = MakePoint();
com.epl.geometry.SimpleGeometryCursor pointCurs = new com.epl.geometry.SimpleGeometryCursor(point);
com.epl.geometry.SpatialReference spatialRef = com.epl.geometry.SpatialReference.Create(3857);
com.epl.geometry.Envelope2D envelope = new com.epl.geometry.Envelope2D();
envelope.xmin = 0;
envelope.xmax = 20;
envelope.ymin = 5;
envelope.ymax = 15;
// Cursor implementation
com.epl.geometry.GeometryCursor clipPolygonCurs = clipOp.Execute(polygonCurs, envelope, spatialRef, null);
com.epl.geometry.Polygon clippedPolygon = (com.epl.geometry.Polygon)clipPolygonCurs.Next();
double area = clippedPolygon.CalculateArea2D();
NUnit.Framework.Assert.IsTrue(System.Math.Abs(area - 25) < 0.00001);
// Single Geometry implementation
clippedPolygon = (com.epl.geometry.Polygon)clipOp.Execute(polygon, envelope, spatialRef, null);
area = clippedPolygon.CalculateArea2D();
NUnit.Framework.Assert.IsTrue(System.Math.Abs(area - 25) < 0.00001);
// Cursor implementation
com.epl.geometry.GeometryCursor clipPolylineCurs = clipOp.Execute(polylineCurs, envelope, spatialRef, null);
com.epl.geometry.Polyline clippedPolyline = (com.epl.geometry.Polyline)clipPolylineCurs.Next();
double length = clippedPolyline.CalculateLength2D();
NUnit.Framework.Assert.IsTrue(System.Math.Abs(length - 10 * System.Math.Sqrt(2.0)) < 1e-10);
// Single Geometry implementation
clippedPolyline = (com.epl.geometry.Polyline)clipOp.Execute(polyline, envelope, spatialRef, null);
length = clippedPolyline.CalculateLength2D();
NUnit.Framework.Assert.IsTrue(System.Math.Abs(length - 10 * System.Math.Sqrt(2.0)) < 1e-10);
// Cursor implementation
com.epl.geometry.GeometryCursor clipMulti_pointCurs = clipOp.Execute(multipointCurs, envelope, spatialRef, null);
com.epl.geometry.MultiPoint clipped_multi_point = (com.epl.geometry.MultiPoint)clipMulti_pointCurs.Next();
int pointCount = clipped_multi_point.GetPointCount();
NUnit.Framework.Assert.IsTrue(pointCount == 2);
// Cursor implementation
com.epl.geometry.GeometryCursor clipPointCurs = clipOp.Execute(pointCurs, envelope, spatialRef, null);
com.epl.geometry.Point clippedPoint = (com.epl.geometry.Point)clipPointCurs.Next();
NUnit.Framework.Assert.IsTrue(clippedPoint != null);
// RandomTest();
com.epl.geometry.Polyline _poly = new com.epl.geometry.Polyline();
_poly.StartPath(2, 2);
_poly.LineTo(0, 0);
com.epl.geometry.Envelope2D _env = new com.epl.geometry.Envelope2D();
_env.SetCoords(2, 1, 5, 3);
com.epl.geometry.Polyline _clippedPolyline = (com.epl.geometry.Polyline)clipOp.Execute(_poly, _env, spatialRef, null);
NUnit.Framework.Assert.IsTrue(_clippedPolyline.IsEmpty());
{
com.epl.geometry.Polygon poly = new com.epl.geometry.Polygon();
poly.AddEnvelope(new com.epl.geometry.Envelope2D(0, 0, 100, 100), false);
poly.AddEnvelope(new com.epl.geometry.Envelope2D(5, 5, 95, 95), true);
com.epl.geometry.Polygon clippedPoly = (com.epl.geometry.Polygon)clipOp.Execute(poly, new com.epl.geometry.Envelope2D(-10, -10, 110, 50), spatialRef, null);
NUnit.Framework.Assert.IsTrue(clippedPoly.GetPathCount() == 1);
NUnit.Framework.Assert.IsTrue(clippedPoly.GetPointCount() == 8);
}
}
