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 bool Step_()
{
if (m_b_done)
{
return(true);
}
com.epl.geometry.Geometry geom = null;
if (m_inputGeoms != null)
{
geom = m_inputGeoms.Next();
if (geom == null)
{
m_b_done = true;
m_inputGeoms = null;
}
}
com.epl.geometry.ProgressTracker.CheckAndThrow(m_progress_tracker);
if (geom != null)
{
int dim = geom.GetDimension();
m_had_geometry[dim] = true;
if (dim >= m_max_dimension && !m_b_union_all_dimensions)
{
Add_geom(dim, false, geom);
if (dim > m_max_dimension && !m_b_union_all_dimensions)
{
//this geometry has higher dimension than the previously processed one
//Therefore we delete all lower dimensions (unless m_b_union_all_dimensions is true).
Remove_all_bins_with_lower_dimension(dim);
}
}
}
//this geometry is skipped
//geom is null. do nothing
if (m_added_geoms > 0)
{
for (int dim = 0; dim <= m_max_dimension; dim++)
{
while (m_dim_geom_counts[dim] > 1)
{
System.Collections.Generic.List <com.epl.geometry.Geometry> batch_to_union = Collect_geometries_to_union(dim);
bool serial_execution = true;
if (serial_execution)
{
if (batch_to_union.Count != 0)
{
com.epl.geometry.Geometry geomRes = com.epl.geometry.TopologicalOperations.DissolveDirty(batch_to_union, m_spatial_reference, m_progress_tracker);
Add_geom(dim, true, geomRes);
}
else
{
break;
}
}
}
}
}
return(m_b_done);
}
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));
}
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 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));
}
