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);
}
// Tests if Ring1 is inside Ring2.
// We assume here that the Polygon is Weak Simple. That is if one point of
// Ring1 is found to be inside of Ring2, then
// we assume that all of Ring1 is inside Ring2.
internal static bool _isRingInRing2D(com.epl.geometry.MultiPath polygon, int iRing1, int iRing2, double tolerance, com.epl.geometry.QuadTree quadTree)
{
com.epl.geometry.MultiPathImpl polygonImpl = (com.epl.geometry.MultiPathImpl)polygon._getImpl();
com.epl.geometry.SegmentIteratorImpl segIter = polygonImpl.QuerySegmentIterator();
segIter.ResetToPath(iRing1);
if (!segIter.NextPath() || !segIter.HasNextSegment())
{
throw new com.epl.geometry.GeometryException("corrupted geometry");
}
int res = 2;
while (res == 2 && segIter.HasNextSegment())
{
com.epl.geometry.Segment segment = segIter.NextSegment();
com.epl.geometry.Point2D point = segment.GetCoord2D(0.5);
res = com.epl.geometry.PointInPolygonHelper.IsPointInRing(polygonImpl, iRing2, point, tolerance, quadTree);
}
if (res == 2)
{
throw com.epl.geometry.GeometryException.GeometryInternalError();
}
if (res == 1)
{
return(true);
}
return(false);
}
/// <summary>Creates a polygon.</summary>
public Polygon()
{
// TODO:remove as we use
// writeReplace and
// GeometrySerializer
m_impl = new com.epl.geometry.MultiPathImpl(true);
}
private static int _isPointInPolygonInternalWithQuadTree(com.epl.geometry.Polygon inputPolygon, com.epl.geometry.QuadTreeImpl quadTree, com.epl.geometry.Point2D inputPoint, double tolerance)
{
com.epl.geometry.Envelope2D envPoly = new com.epl.geometry.Envelope2D();
inputPolygon.QueryLooseEnvelope(envPoly);
envPoly.Inflate(tolerance, tolerance);
bool bAltenate = inputPolygon.GetFillRule() == com.epl.geometry.Polygon.FillRule.enumFillRuleOddEven;
com.epl.geometry.PointInPolygonHelper helper = new com.epl.geometry.PointInPolygonHelper(bAltenate, inputPoint, tolerance);
com.epl.geometry.MultiPathImpl mpImpl = (com.epl.geometry.MultiPathImpl)inputPolygon._getImpl();
com.epl.geometry.SegmentIteratorImpl iter = mpImpl.QuerySegmentIterator();
com.epl.geometry.Envelope2D queryEnv = new com.epl.geometry.Envelope2D();
queryEnv.SetCoords(envPoly);
queryEnv.xmax = inputPoint.x + tolerance;
// no need to query segments to
// the right of the point.
// Only segments to the left
// matter.
queryEnv.ymin = inputPoint.y - tolerance;
queryEnv.ymax = inputPoint.y + tolerance;
com.epl.geometry.QuadTreeImpl.QuadTreeIteratorImpl qiter = quadTree.GetIterator(queryEnv, tolerance);
for (int qhandle = qiter.Next(); qhandle != -1; qhandle = qiter.Next())
{
iter.ResetToVertex(quadTree.GetElement(qhandle));
if (iter.HasNextSegment())
{
com.epl.geometry.Segment segment = iter.NextSegment();
if (helper.ProcessSegment(segment))
{
return(-1);
}
}
}
// point on boundary
return(helper.Result());
}
/// <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");
}
}
private static int QuickTest2DPolylinePoint(com.epl.geometry.Polyline geomA, com.epl.geometry.Point2D ptB, double tolerance, int testType)
{
int mask = com.epl.geometry.OperatorInternalRelationUtils.Relation.Touches | com.epl.geometry.OperatorInternalRelationUtils.Relation.Contains | com.epl.geometry.OperatorInternalRelationUtils.Relation.Within | com.epl.geometry.OperatorInternalRelationUtils.Relation.Disjoint | com.epl.geometry.OperatorInternalRelationUtils.Relation
.Intersects;
if ((testType & mask) == 0)
{
return(com.epl.geometry.OperatorInternalRelationUtils.Relation.NoThisRelation);
}
int res = QuickTest2DMVPointRasterOnly(geomA, ptB, tolerance);
if (res > 0)
{
return(res);
}
// Go through the segments:
double toleranceSqr = tolerance * tolerance;
com.epl.geometry.MultiPathImpl mpImpl = (com.epl.geometry.MultiPathImpl)geomA._getImpl();
com.epl.geometry.SegmentIteratorImpl iter = mpImpl.QuerySegmentIterator();
while (iter.NextPath())
{
int pathIndex = iter.GetPathIndex();
if (!geomA.IsClosedPath(pathIndex))
{
int pathSize = geomA.GetPathSize(pathIndex);
int pathStart = geomA.GetPathStart(pathIndex);
if (pathSize == 0)
{
continue;
}
if (com.epl.geometry.Point2D.SqrDistance(geomA.GetXY(pathStart), ptB) <= toleranceSqr || (pathSize > 1 && com.epl.geometry.Point2D.SqrDistance(geomA.GetXY(pathStart + pathSize - 1), ptB) <= toleranceSqr))
{
return((int)com.epl.geometry.OperatorInternalRelationUtils.Relation.Touches);
}
}
if (testType != com.epl.geometry.OperatorInternalRelationUtils.Relation.Touches)
{
while (iter.HasNextSegment())
{
com.epl.geometry.Segment segment = iter.NextSegment();
double t = segment.GetClosestCoordinate(ptB, false);
com.epl.geometry.Point2D pt = segment.GetCoord2D(t);
if (com.epl.geometry.Point2D.SqrDistance(pt, ptB) <= toleranceSqr)
{
if ((testType & com.epl.geometry.OperatorInternalRelationUtils.Relation.IntersectsOrDisjoint) != 0)
{
return(com.epl.geometry.OperatorInternalRelationUtils.Relation.Intersects);
}
return((int)com.epl.geometry.OperatorInternalRelationUtils.Relation.Contains);
}
}
}
}
return((testType & com.epl.geometry.OperatorInternalRelationUtils.Relation.IntersectsOrDisjoint) != 0 ? com.epl.geometry.OperatorInternalRelationUtils.Relation.Disjoint : com.epl.geometry.OperatorInternalRelationUtils.Relation.NoThisRelation);
}
internal static void TestPointsOnPolyline2D_(com.epl.geometry.Polyline poly, com.epl.geometry.Point2D[] input_points, int count, double tolerance, com.epl.geometry.PolygonUtils.PiPResult[] test_results)
{
com.epl.geometry.MultiPathImpl mp_impl = (com.epl.geometry.MultiPathImpl)poly._getImpl();
com.epl.geometry.GeometryAccelerators accel = mp_impl._getAccelerators();
com.epl.geometry.RasterizedGeometry2D rgeom = null;
if (accel != null)
{
rgeom = accel.GetRasterizedGeometry();
}
int pointsLeft = count;
for (int i = 0; i < count; i++)
{
test_results[i] = com.epl.geometry.PolygonUtils.PiPResult.PiPInside;
// set to impossible value
if (rgeom != null)
{
com.epl.geometry.Point2D input_point = input_points[i];
com.epl.geometry.RasterizedGeometry2D.HitType hit = rgeom.QueryPointInGeometry(input_point.x, input_point.y);
if (hit == com.epl.geometry.RasterizedGeometry2D.HitType.Outside)
{
test_results[i] = com.epl.geometry.PolygonUtils.PiPResult.PiPOutside;
pointsLeft--;
}
}
}
if (pointsLeft != 0)
{
com.epl.geometry.SegmentIteratorImpl iter = mp_impl.QuerySegmentIterator();
while (iter.NextPath() && pointsLeft != 0)
{
while (iter.HasNextSegment() && pointsLeft != 0)
{
com.epl.geometry.Segment segment = iter.NextSegment();
for (int i_1 = 0; i_1 < count && pointsLeft != 0; i_1++)
{
if (test_results[i_1] == com.epl.geometry.PolygonUtils.PiPResult.PiPInside)
{
if (segment.IsIntersecting(input_points[i_1], tolerance))
{
test_results[i_1] = com.epl.geometry.PolygonUtils.PiPResult.PiPBoundary;
pointsLeft--;
}
}
}
}
}
}
for (int i_2 = 0; i_2 < count; i_2++)
{
if (test_results[i_2] == com.epl.geometry.PolygonUtils.PiPResult.PiPInside)
{
test_results[i_2] = com.epl.geometry.PolygonUtils.PiPResult.PiPOutside;
}
}
}
// Mirrors wkt
private static void ExportPolylineToGeoJson_(int export_flags, com.epl.geometry.Polyline polyline, com.epl.geometry.JsonWriter json_writer)
{
com.epl.geometry.MultiPathImpl polyline_impl = (com.epl.geometry.MultiPathImpl)polyline._getImpl();
int point_count = polyline_impl.GetPointCount();
int path_count = polyline_impl.GetPathCount();
if (point_count > 0 && path_count == 0)
{
throw new com.epl.geometry.GeometryException("corrupted geometry");
}
int precision = 17 - (31 & (export_flags >> 13));
bool bFixedPoint = (com.epl.geometry.GeoJsonExportFlags.geoJsonExportPrecisionFixedPoint & export_flags) != 0;
bool b_export_zs = polyline_impl.HasAttribute(com.epl.geometry.VertexDescription.Semantics.Z) && (export_flags & com.epl.geometry.GeoJsonExportFlags.geoJsonExportStripZs) == 0;
bool b_export_ms = polyline_impl.HasAttribute(com.epl.geometry.VertexDescription.Semantics.M) && (export_flags & com.epl.geometry.GeoJsonExportFlags.geoJsonExportStripMs) == 0;
if (!b_export_zs && b_export_ms)
{
throw new System.ArgumentException("invalid argument");
}
com.epl.geometry.AttributeStreamOfDbl position = null;
com.epl.geometry.AttributeStreamOfDbl zs = null;
com.epl.geometry.AttributeStreamOfDbl ms = null;
com.epl.geometry.AttributeStreamOfInt8 path_flags = null;
com.epl.geometry.AttributeStreamOfInt32 paths = null;
if (point_count > 0)
{
position = (com.epl.geometry.AttributeStreamOfDbl)polyline_impl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION);
path_flags = polyline_impl.GetPathFlagsStreamRef();
paths = polyline_impl.GetPathStreamRef();
if (b_export_zs)
{
if (polyline_impl._attributeStreamIsAllocated(com.epl.geometry.VertexDescription.Semantics.Z))
{
zs = (com.epl.geometry.AttributeStreamOfDbl)polyline_impl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.Z);
}
}
if (b_export_ms)
{
if (polyline_impl._attributeStreamIsAllocated(com.epl.geometry.VertexDescription.Semantics.M))
{
ms = (com.epl.geometry.AttributeStreamOfDbl)polyline_impl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.M);
}
}
}
if ((export_flags & com.epl.geometry.GeoJsonExportFlags.geoJsonExportPreferMultiGeometry) == 0 && path_count <= 1)
{
LineStringTaggedText_(precision, bFixedPoint, b_export_zs, b_export_ms, zs, ms, position, path_flags, paths, json_writer);
}
else
{
MultiLineStringTaggedText_(precision, bFixedPoint, b_export_zs, b_export_ms, zs, ms, position, path_flags, paths, path_count, json_writer);
}
}
public static int IsPointInAnyOuterRing(com.epl.geometry.Polygon inputPolygon, com.epl.geometry.Point2D inputPoint, double tolerance)
{
com.epl.geometry.Envelope2D env = new com.epl.geometry.Envelope2D();
inputPolygon.QueryLooseEnvelope(env);
env.Inflate(tolerance, tolerance);
if (!env.Contains(inputPoint))
{
return(0);
}
// Note:
// Wolfgang had noted that this could be optimized if the exterior rings
// have positive area:
// Only test the positive rings and bail out immediately when in a
// positive ring.
// The worst case complexity is still O(n), but on average for polygons
// with holes, that would be faster.
// However, that method would not work if polygon is reversed, while the
// one here works fine same as PointInPolygon.
bool bAltenate = false;
// use winding in this test
com.epl.geometry.PointInPolygonHelper helper = new com.epl.geometry.PointInPolygonHelper(bAltenate, inputPoint, tolerance);
com.epl.geometry.MultiPathImpl mpImpl = (com.epl.geometry.MultiPathImpl)inputPolygon._getImpl();
com.epl.geometry.SegmentIteratorImpl iter = mpImpl.QuerySegmentIterator();
while (iter.NextPath())
{
double ringArea = mpImpl.CalculateRingArea2D(iter.GetPathIndex());
bool bIsHole = ringArea < 0;
if (!bIsHole)
{
helper.m_windnum = 0;
while (iter.HasNextSegment())
{
com.epl.geometry.Segment segment = iter.NextSegment();
if (helper.ProcessSegment(segment))
{
return(-1);
}
}
// point on boundary
if (helper.m_windnum != 0)
{
return(1);
}
}
}
return(helper.Result());
}
/// <summary>Tests if Point is inside the Polygon's ring.</summary>
/// <remarks>
/// Tests if Point is inside the Polygon's ring. Returns PiPOutside if not in
/// ring, PiPInside if in the ring, PiPBoundary is if on the border. It tests
/// border only if the tolerance is greater than 0, otherwise PiPBoundary cannot be
/// returned. Note: If the tolerance is not 0, the test is more expensive
/// because it calculates closest distance from a point to each segment.
/// O(n) complexity, where n is the number of ring segments.
/// </remarks>
public static com.epl.geometry.PolygonUtils.PiPResult IsPointInRing2D(com.epl.geometry.Polygon polygon, int iRing, com.epl.geometry.Point2D inputPoint, double tolerance)
{
com.epl.geometry.MultiPathImpl polygonImpl = (com.epl.geometry.MultiPathImpl)polygon._getImpl();
int res = com.epl.geometry.PointInPolygonHelper.IsPointInRing(polygonImpl, iRing, inputPoint, tolerance, null);
if (res == 0)
{
return(com.epl.geometry.PolygonUtils.PiPResult.PiPOutside);
}
if (res == 1)
{
return(com.epl.geometry.PolygonUtils.PiPResult.PiPInside);
}
// return PiPResult.PiPBoundary;
return(com.epl.geometry.PolygonUtils.PiPResult.PiPInside);
}
public SegmentIteratorImpl(com.epl.geometry.MultiPathImpl parent)
{
// Bezier m_bezier:
// Arc m_arc;
// parent of the iterator.
// If true, the iterator circulates around
// the current Path.
m_currentSegmentIndex = -1;
m_nextSegmentIndex = 0;
m_nextPathIndex = 0;
m_currentPathIndex = -1;
m_parent = parent;
m_segmentCount = _getSegmentCount(m_nextPathIndex);
m_bCirculator = false;
m_currentSegment = null;
m_pathBegin = -1;
m_dummyPoint = new com.epl.geometry.Point2D();
}
public SegmentIteratorImpl(com.epl.geometry.MultiPathImpl parent, int pointIndex)
{
if (pointIndex < 0 || pointIndex >= parent.GetPointCount())
{
throw new System.IndexOutOfRangeException();
}
m_currentSegmentIndex = -1;
int path = parent.GetPathIndexFromPointIndex(pointIndex);
m_nextSegmentIndex = pointIndex - parent.GetPathStart(path);
m_nextPathIndex = path + 1;
m_currentPathIndex = path;
m_parent = parent;
m_segmentCount = _getSegmentCount(m_currentPathIndex);
m_bCirculator = false;
m_currentSegment = null;
m_pathBegin = m_parent.GetPathStart(m_currentPathIndex);
m_dummyPoint = new com.epl.geometry.Point2D();
}
public static int IsPointInPolygon(com.epl.geometry.Polygon inputPolygon, com.epl.geometry.Point2D inputPoint, double tolerance)
{
if (inputPolygon.IsEmpty())
{
return(0);
}
com.epl.geometry.Envelope2D env = new com.epl.geometry.Envelope2D();
inputPolygon.QueryLooseEnvelope(env);
env.Inflate(tolerance, tolerance);
if (!env.Contains(inputPoint))
{
return(0);
}
com.epl.geometry.MultiPathImpl mpImpl = (com.epl.geometry.MultiPathImpl)inputPolygon._getImpl();
com.epl.geometry.GeometryAccelerators accel = mpImpl._getAccelerators();
if (accel != null)
{
// geometry has spatial indices built. Try using them.
com.epl.geometry.RasterizedGeometry2D rgeom = accel.GetRasterizedGeometry();
if (rgeom != null)
{
com.epl.geometry.RasterizedGeometry2D.HitType hit = rgeom.QueryPointInGeometry(inputPoint.x, inputPoint.y);
if (hit == com.epl.geometry.RasterizedGeometry2D.HitType.Inside)
{
return(1);
}
else
{
if (hit == com.epl.geometry.RasterizedGeometry2D.HitType.Outside)
{
return(0);
}
}
}
com.epl.geometry.QuadTreeImpl qtree = accel.GetQuadTree();
if (qtree != null)
{
return(_isPointInPolygonInternalWithQuadTree(inputPolygon, qtree, inputPoint, tolerance));
}
}
return(_isPointInPolygonInternal(inputPolygon, inputPoint, tolerance));
}
internal static com.epl.geometry.QuadTree BuildQuadTree_(com.epl.geometry.MultiPathImpl multipathImpl, bool bStoreDuplicates)
{
com.epl.geometry.Envelope2D extent = new com.epl.geometry.Envelope2D();
multipathImpl.QueryEnvelope2D(extent);
com.epl.geometry.QuadTree quadTree = new com.epl.geometry.QuadTree(extent, 8, bStoreDuplicates);
int hint_index = -1;
com.epl.geometry.Envelope2D boundingbox = new com.epl.geometry.Envelope2D();
com.epl.geometry.SegmentIteratorImpl seg_iter = multipathImpl.QuerySegmentIterator();
while (seg_iter.NextPath())
{
while (seg_iter.HasNextSegment())
{
com.epl.geometry.Segment segment = seg_iter.NextSegment();
int index = seg_iter.GetStartPointIndex();
segment.QueryEnvelope2D(boundingbox);
hint_index = quadTree.Insert(index, boundingbox, hint_index);
}
}
return(quadTree);
}
private static int _isPointInPolygonInternal(com.epl.geometry.Polygon inputPolygon, com.epl.geometry.Point2D inputPoint, double tolerance)
{
bool bAltenate = inputPolygon.GetFillRule() == com.epl.geometry.Polygon.FillRule.enumFillRuleOddEven;
com.epl.geometry.PointInPolygonHelper helper = new com.epl.geometry.PointInPolygonHelper(bAltenate, inputPoint, tolerance);
com.epl.geometry.MultiPathImpl mpImpl = (com.epl.geometry.MultiPathImpl)inputPolygon._getImpl();
com.epl.geometry.SegmentIteratorImpl iter = mpImpl.QuerySegmentIterator();
while (iter.NextPath())
{
while (iter.HasNextSegment())
{
com.epl.geometry.Segment segment = iter.NextSegment();
if (helper.ProcessSegment(segment))
{
return(-1);
}
}
}
// point on boundary
return(helper.Result());
}
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();
}
}
public SegmentIteratorImpl(com.epl.geometry.MultiPathImpl parent, int pathIndex, int segmentIndex)
{
if (pathIndex < 0 || pathIndex >= parent.GetPathCount() || segmentIndex < 0)
{
throw new System.IndexOutOfRangeException();
}
int d = parent.IsClosedPath(pathIndex) ? 0 : 1;
if (segmentIndex >= parent.GetPathSize(pathIndex) - d)
{
throw new System.IndexOutOfRangeException();
}
m_currentSegmentIndex = -1;
m_nextSegmentIndex = segmentIndex;
m_currentPathIndex = pathIndex;
m_nextPathIndex = m_nextSegmentIndex + 1;
m_parent = parent;
m_segmentCount = _getSegmentCount(m_nextPathIndex);
m_bCirculator = false;
m_currentSegment = null;
m_pathBegin = m_parent.GetPathStart(m_currentPathIndex);
m_dummyPoint = new com.epl.geometry.Point2D();
}
internal static int IsPointInPolygon(com.epl.geometry.Polygon inputPolygon, double inputPointXVal, double inputPointYVal, double tolerance)
{
if (inputPolygon.IsEmpty())
{
return(0);
}
com.epl.geometry.Envelope2D env = new com.epl.geometry.Envelope2D();
inputPolygon.QueryLooseEnvelope(env);
env.Inflate(tolerance, tolerance);
if (!env.Contains(inputPointXVal, inputPointYVal))
{
return(0);
}
com.epl.geometry.MultiPathImpl mpImpl = (com.epl.geometry.MultiPathImpl)inputPolygon._getImpl();
com.epl.geometry.GeometryAccelerators accel = mpImpl._getAccelerators();
if (accel != null)
{
com.epl.geometry.RasterizedGeometry2D rgeom = accel.GetRasterizedGeometry();
if (rgeom != null)
{
com.epl.geometry.RasterizedGeometry2D.HitType hit = rgeom.QueryPointInGeometry(inputPointXVal, inputPointYVal);
if (hit == com.epl.geometry.RasterizedGeometry2D.HitType.Inside)
{
return(1);
}
else
{
if (hit == com.epl.geometry.RasterizedGeometry2D.HitType.Outside)
{
return(0);
}
}
}
}
return(_isPointInPolygonInternal(inputPolygon, new com.epl.geometry.Point2D(inputPointXVal, inputPointYVal), tolerance));
}