internal virtual com.epl.geometry.GeometryCursor IntersectEx(com.epl.geometry.Geometry input_geom)
{
System.Diagnostics.Debug.Assert((m_dimensionMask != -1));
com.epl.geometry.Geometry dst_geom = TryNativeImplementation_(input_geom);
if (dst_geom != null)
{
com.epl.geometry.Geometry[] res_vec = new com.epl.geometry.Geometry[3];
res_vec[dst_geom.GetDimension()] = dst_geom;
return PrepareVector_(input_geom.GetDescription(), m_dimensionMask, res_vec);
}
com.epl.geometry.Envelope2D commonExtent = com.epl.geometry.InternalUtils.GetMergedExtent(m_geomIntersector, input_geom);
double t = com.epl.geometry.InternalUtils.CalculateToleranceFromGeometry(m_spatial_reference, commonExtent, true);
// Preprocess geometries to be clipped to the extent of intersection to
// get rid of extra segments.
com.epl.geometry.Envelope2D env = new com.epl.geometry.Envelope2D();
m_geomIntersector.QueryEnvelope2D(env);
env.Inflate(2 * t, 2 * t);
com.epl.geometry.Envelope2D env1 = new com.epl.geometry.Envelope2D();
input_geom.QueryEnvelope2D(env1);
env.Intersect(env1);
System.Diagnostics.Debug.Assert((!env.IsEmpty()));
env.Inflate(100 * t, 100 * t);
double tol = 0;
com.epl.geometry.Geometry clippedIntersector = com.epl.geometry.Clipper.Clip(m_geomIntersector, env, tol, 0.0);
com.epl.geometry.Geometry clippedInputGeom = com.epl.geometry.Clipper.Clip(input_geom, env, tol, 0.0);
// perform the clip
com.epl.geometry.Geometry[] res_vec_1;
res_vec_1 = com.epl.geometry.TopologicalOperations.IntersectionEx(clippedInputGeom, clippedIntersector, m_spatial_reference, m_progress_tracker);
return PrepareVector_(input_geom.GetDescription(), m_dimensionMask, res_vec_1);
}
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 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();
}
internal static com.epl.geometry.Geometry Calculate_boundary(com.epl.geometry.Geometry geom, com.epl.geometry.ProgressTracker progress_tracker)
{
com.epl.geometry.Geometry res = com.epl.geometry.Boundary.Calculate(geom, progress_tracker);
if (res == null)
{
return(new com.epl.geometry.Point(geom.GetDescription()));
}
else
{
// cannot return null
return(res);
}
}
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;
}
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));
}
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();
}
}
}
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);
}
