internal static com.epl.geometry.QuadTreeImpl BuildQuadTree(com.epl.geometry.MultiPointImpl multipointImpl)
{
com.epl.geometry.Envelope2D extent = new com.epl.geometry.Envelope2D();
multipointImpl.QueryLooseEnvelope2D(extent);
com.epl.geometry.QuadTreeImpl quad_tree_impl = new com.epl.geometry.QuadTreeImpl(extent, 8);
com.epl.geometry.Point2D pt = new com.epl.geometry.Point2D();
com.epl.geometry.Envelope2D boundingbox = new com.epl.geometry.Envelope2D();
bool resized_extent = false;
for (int i = 0; i < multipointImpl.GetPointCount(); i++)
{
multipointImpl.GetXY(i, pt);
boundingbox.SetCoords(pt);
int element_handle = quad_tree_impl.Insert(i, boundingbox);
if (element_handle == -1)
{
if (resized_extent)
{
throw com.epl.geometry.GeometryException.GeometryInternalError();
}
// resize extent
multipointImpl.CalculateEnvelope2D(extent, false);
resized_extent = true;
quad_tree_impl.Reset(extent, 8);
i = -1;
// resets the for-loop
continue;
}
}
return(quad_tree_impl);
}
internal static com.epl.geometry.Geometry MultiPointSymDiffPoint_(com.epl.geometry.MultiPoint multi_point, com.epl.geometry.Point point, double tolerance, com.epl.geometry.ProgressTracker progress_tracker)
{
com.epl.geometry.MultiPointImpl multipointImpl = (com.epl.geometry.MultiPointImpl)(multi_point._getImpl());
com.epl.geometry.AttributeStreamOfDbl position = (com.epl.geometry.AttributeStreamOfDbl)(multipointImpl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION));
int point_count = multi_point.GetPointCount();
com.epl.geometry.Point2D point2D = point.GetXY();
com.epl.geometry.MultiPoint new_multipoint = (com.epl.geometry.MultiPoint)(multi_point.CreateInstance());
double tolerance_cluster = tolerance * System.Math.Sqrt(2.0) * 1.00001;
com.epl.geometry.Envelope2D env = new com.epl.geometry.Envelope2D();
multi_point.QueryEnvelope2D(env);
env.Inflate(tolerance_cluster, tolerance_cluster);
if (env.Contains(point2D))
{
double tolerance_cluster_sq = tolerance_cluster * tolerance_cluster;
bool b_found_covered = false;
bool[] covered = new bool[point_count];
for (int i = 0; i < point_count; i++)
{
covered[i] = false;
}
for (int i_1 = 0; i_1 < point_count; i_1++)
{
double x = position.Read(2 * i_1);
double y = position.Read(2 * i_1 + 1);
double dx = x - point2D.x;
double dy = y - point2D.y;
if (dx * dx + dy * dy <= tolerance_cluster_sq)
{
b_found_covered = true;
covered[i_1] = true;
}
}
if (!b_found_covered)
{
new_multipoint.Add(multi_point, 0, point_count);
new_multipoint.Add(point);
}
else
{
for (int i_2 = 0; i_2 < point_count; i_2++)
{
if (!covered[i_2])
{
new_multipoint.Add(multi_point, i_2, i_2 + 1);
}
}
}
}
else
{
new_multipoint.Add(multi_point, 0, point_count);
new_multipoint.Add(point);
}
return(new_multipoint);
}
internal static com.epl.geometry.QuadTree BuildQuadTree_(com.epl.geometry.MultiPointImpl multipointImpl)
{
com.epl.geometry.Envelope2D extent = new com.epl.geometry.Envelope2D();
multipointImpl.QueryEnvelope2D(extent);
com.epl.geometry.QuadTree quadTree = new com.epl.geometry.QuadTree(extent, 8);
com.epl.geometry.Envelope2D boundingbox = new com.epl.geometry.Envelope2D();
com.epl.geometry.Point2D pt;
for (int i = 0; i < multipointImpl.GetPointCount(); i++)
{
pt = multipointImpl.GetXY(i);
boundingbox.SetCoords(pt.x, pt.y, pt.x, pt.y);
quadTree.Insert(i, boundingbox, -1);
}
return(quadTree);
}
internal static void ExportMultiPointToWkt(int export_flags, com.epl.geometry.MultiPoint multipoint, System.Text.StringBuilder @string)
{
com.epl.geometry.MultiPointImpl multipoint_impl = (com.epl.geometry.MultiPointImpl)multipoint._getImpl();
int point_count = multipoint_impl.GetPointCount();
int precision = 17 - (7 & (export_flags >> 13));
bool b_export_zs = multipoint_impl.HasAttribute(com.epl.geometry.VertexDescription.Semantics.Z) && (export_flags & com.epl.geometry.WktExportFlags.wktExportStripZs) == 0;
bool b_export_ms = multipoint_impl.HasAttribute(com.epl.geometry.VertexDescription.Semantics.M) && (export_flags & com.epl.geometry.WktExportFlags.wktExportStripMs) == 0;
com.epl.geometry.AttributeStreamOfDbl position = null;
com.epl.geometry.AttributeStreamOfDbl zs = null;
com.epl.geometry.AttributeStreamOfDbl ms = null;
if (point_count > 0)
{
position = (com.epl.geometry.AttributeStreamOfDbl)(multipoint_impl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION));
if (b_export_zs)
{
if (multipoint_impl._attributeStreamIsAllocated(com.epl.geometry.VertexDescription.Semantics.Z))
{
zs = (com.epl.geometry.AttributeStreamOfDbl)(multipoint_impl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.Z));
}
}
if (b_export_ms)
{
if (multipoint_impl._attributeStreamIsAllocated(com.epl.geometry.VertexDescription.Semantics.M))
{
ms = (com.epl.geometry.AttributeStreamOfDbl)(multipoint_impl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.M));
}
}
}
if ((export_flags & com.epl.geometry.WktExportFlags.wktExportPoint) != 0)
{
if (point_count > 1)
{
throw new System.ArgumentException("Cannot export a Point with specified export flags: " + export_flags);
}
PointTaggedTextFromMultiPoint_(precision, b_export_zs, b_export_ms, zs, ms, position, @string);
}
else
{
MultiPointTaggedText_(precision, b_export_zs, b_export_ms, zs, ms, position, point_count, @string);
}
}
private double BruteForceMultiPointMultiPoint_(com.epl.geometry.MultiPoint geometryA, com.epl.geometry.MultiPoint geometryB, bool geometriesAreDisjoint)
{
/* const */
/* const */
double minSqrDistance = com.epl.geometry.NumberUtils.DoubleMax();
com.epl.geometry.Point2D pointA = new com.epl.geometry.Point2D();
com.epl.geometry.Point2D pointB = new com.epl.geometry.Point2D();
double sqrDistance = minSqrDistance;
/* const */
com.epl.geometry.MultiPointImpl multiPointImplA = (com.epl.geometry.MultiPointImpl)geometryA._getImpl();
/* const */
/* const */
com.epl.geometry.MultiPointImpl multiPointImplB = (com.epl.geometry.MultiPointImpl)geometryB._getImpl();
/* const */
int pointCountA = multiPointImplA.GetPointCount();
int pointCountB = multiPointImplB.GetPointCount();
for (int i = 0; i < pointCountA; i++)
{
multiPointImplA.GetXY(i, pointA);
if (pointCountB > 1 && this.m_env2DgeometryB.SqrDistance(pointA) > minSqrDistance)
{
continue;
}
for (int j = 0; j < pointCountB; j++)
{
multiPointImplB.GetXY(j, pointB);
sqrDistance = com.epl.geometry.Point2D.SqrDistance(pointA, pointB);
if (sqrDistance < minSqrDistance)
{
if (sqrDistance == 0.0)
{
return(0.0);
}
minSqrDistance = sqrDistance;
}
}
}
return(System.Math.Sqrt(minSqrDistance));
}
internal static com.epl.geometry.Geometry MultiPointMinusPoint_(com.epl.geometry.MultiPoint multi_point, com.epl.geometry.Point point, double tolerance, com.epl.geometry.ProgressTracker progress_tracker)
{
com.epl.geometry.MultiPointImpl multipointImpl = (com.epl.geometry.MultiPointImpl)(multi_point._getImpl());
com.epl.geometry.AttributeStreamOfDbl position = (com.epl.geometry.AttributeStreamOfDbl)(multipointImpl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION));
int point_count = multi_point.GetPointCount();
com.epl.geometry.Point2D point2D = point.GetXY();
com.epl.geometry.Point2D pt = new com.epl.geometry.Point2D();
bool b_found_covered = false;
bool[] covered = new bool[point_count];
for (int i = 0; i < point_count; i++)
{
covered[i] = false;
}
double tolerance_cluster = tolerance * System.Math.Sqrt(2.0) * 1.00001;
double tolerance_cluster_sq = tolerance_cluster * tolerance_cluster;
for (int i_1 = 0; i_1 < point_count; i_1++)
{
position.Read(2 * i_1, pt);
double sqr_dist = com.epl.geometry.Point2D.SqrDistance(pt, point2D);
if (sqr_dist <= tolerance_cluster_sq)
{
b_found_covered = true;
covered[i_1] = true;
}
}
if (!b_found_covered)
{
return(multi_point);
}
com.epl.geometry.MultiPoint new_multipoint = (com.epl.geometry.MultiPoint)(multi_point.CreateInstance());
for (int i_2 = 0; i_2 < point_count; i_2++)
{
if (!covered[i_2])
{
new_multipoint.Add(multi_point, i_2, i_2 + 1);
}
}
return(new_multipoint);
}
internal static com.epl.geometry.Geometry PointMinusMultiPoint_(com.epl.geometry.Point point, com.epl.geometry.MultiPoint multi_point, double tolerance, com.epl.geometry.ProgressTracker progress_tracker)
{
com.epl.geometry.MultiPointImpl multipointImpl = (com.epl.geometry.MultiPointImpl)(multi_point._getImpl());
com.epl.geometry.AttributeStreamOfDbl position = (com.epl.geometry.AttributeStreamOfDbl)multipointImpl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION);
int point_count = multi_point.GetPointCount();
com.epl.geometry.Point2D point2D = point.GetXY();
com.epl.geometry.Point2D pt = new com.epl.geometry.Point2D();
double tolerance_cluster = tolerance * System.Math.Sqrt(2.0) * 1.00001;
double tolerance_cluster_sq = tolerance_cluster * tolerance_cluster;
for (int i = 0; i < point_count; i++)
{
position.Read(2 * i, pt);
double sqr_dist = com.epl.geometry.Point2D.SqrDistance(pt, point2D);
if (sqr_dist <= tolerance_cluster_sq)
{
return(point.CreateInstance());
}
}
// return an empty point.
return(point);
}
// Mirrors wkt
private static void ExportMultiPointToGeoJson_(int export_flags, com.epl.geometry.MultiPoint multipoint, com.epl.geometry.JsonWriter json_writer)
{
com.epl.geometry.MultiPointImpl multipoint_impl = (com.epl.geometry.MultiPointImpl)multipoint._getImpl();
int point_count = multipoint_impl.GetPointCount();
int precision = 17 - (31 & (export_flags >> 13));
bool bFixedPoint = (com.epl.geometry.GeoJsonExportFlags.geoJsonExportPrecisionFixedPoint & export_flags) != 0;
bool b_export_zs = multipoint_impl.HasAttribute(com.epl.geometry.VertexDescription.Semantics.Z) && (export_flags & com.epl.geometry.GeoJsonExportFlags.geoJsonExportStripZs) == 0;
bool b_export_ms = multipoint_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;
if (point_count > 0)
{
position = (com.epl.geometry.AttributeStreamOfDbl)multipoint_impl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION);
if (b_export_zs)
{
if (multipoint_impl._attributeStreamIsAllocated(com.epl.geometry.VertexDescription.Semantics.Z))
{
zs = (com.epl.geometry.AttributeStreamOfDbl)multipoint_impl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.Z);
}
}
if (b_export_ms)
{
if (multipoint_impl._attributeStreamIsAllocated(com.epl.geometry.VertexDescription.Semantics.M))
{
ms = (com.epl.geometry.AttributeStreamOfDbl)multipoint_impl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.M);
}
}
}
MultiPointTaggedText_(precision, bFixedPoint, b_export_zs, b_export_ms, zs, ms, position, point_count, json_writer);
}
private static int ExportMultiPointToESRIShape(int exportFlags, com.epl.geometry.MultiPoint multipoint, System.IO.BinaryWriter shapeBuffer)
{
com.epl.geometry.MultiPointImpl multipointImpl = (com.epl.geometry.MultiPointImpl)multipoint._getImpl();
bool bExportZs = multipointImpl.HasAttribute(com.epl.geometry.VertexDescription.Semantics.Z) && (exportFlags & com.epl.geometry.ShapeExportFlags.ShapeExportStripZs) == 0;
bool bExportMs = multipointImpl.HasAttribute(com.epl.geometry.VertexDescription.Semantics.M) && (exportFlags & com.epl.geometry.ShapeExportFlags.ShapeExportStripMs) == 0;
bool bExportIDs = multipointImpl.HasAttribute(com.epl.geometry.VertexDescription.Semantics.ID) && (exportFlags & com.epl.geometry.ShapeExportFlags.ShapeExportStripIDs) == 0;
bool bArcViewNaNs = (exportFlags & com.epl.geometry.ShapeExportFlags.ShapeExportTrueNaNs) == 0;
int pointCount = multipointImpl.GetPointCount();
int size = (4) + (4 * 8) + (4) + (pointCount * 2 * 8);
/* type */
/* envelope */
/* point count */
/* xy coordinates */
if (bExportZs)
{
size += (2 * 8) + (pointCount * 8);
}
/* min max */
/* zs */
if (bExportMs)
{
size += (2 * 8) + (pointCount * 8);
}
/* min max */
/* ms */
if (bExportIDs)
{
size += pointCount * 4;
}
/* ids */
if (size >= com.epl.geometry.NumberUtils.IntMax())
{
throw new com.epl.geometry.GeometryException("invalid call");
}
if (shapeBuffer == null)
{
return(size);
}
else
{
if (((System.IO.MemoryStream)shapeBuffer.BaseStream).Capacity < size)
{
throw new com.epl.geometry.GeometryException("buffer is too small");
}
}
int type;
// Determine the shape type
if (!bExportZs && !bExportMs)
{
if (bExportIDs)
{
type = com.epl.geometry.ShapeType.ShapeGeneralMultiPoint | com.epl.geometry.ShapeModifiers.ShapeHasIDs;
}
else
{
type = com.epl.geometry.ShapeType.ShapeMultiPoint;
}
}
else
{
if (bExportZs && !bExportMs)
{
if (bExportIDs)
{
type = com.epl.geometry.ShapeType.ShapeGeneralMultiPoint | com.epl.geometry.ShapeModifiers.ShapeHasZs | com.epl.geometry.ShapeModifiers.ShapeHasIDs;
}
else
{
type = com.epl.geometry.ShapeType.ShapeMultiPointZ;
}
}
else
{
if (bExportMs && !bExportZs)
{
if (bExportIDs)
{
type = com.epl.geometry.ShapeType.ShapeGeneralMultiPoint | com.epl.geometry.ShapeModifiers.ShapeHasMs | com.epl.geometry.ShapeModifiers.ShapeHasIDs;
}
else
{
type = com.epl.geometry.ShapeType.ShapeMultiPointM;
}
}
else
{
if (bExportIDs)
{
type = com.epl.geometry.ShapeType.ShapeGeneralMultiPoint | com.epl.geometry.ShapeModifiers.ShapeHasZs | com.epl.geometry.ShapeModifiers.ShapeHasMs | com.epl.geometry.ShapeModifiers.ShapeHasIDs;
}
else
{
type = com.epl.geometry.ShapeType.ShapeMultiPointZM;
}
}
}
}
// write type
int offset = 0;
shapeBuffer.Write(type);
offset += 4;
// write Envelope
com.epl.geometry.Envelope2D env = new com.epl.geometry.Envelope2D();
multipointImpl.QueryEnvelope2D(env);
// calls _VerifyAllStreams
shapeBuffer.Write(env.xmin);
offset += 8;
shapeBuffer.Write(env.ymin);
offset += 8;
shapeBuffer.Write(env.xmax);
offset += 8;
shapeBuffer.Write(env.ymax);
offset += 8;
// write point count
shapeBuffer.Write(pointCount);
offset += 4;
if (pointCount > 0)
{
// write xy coordinates
com.epl.geometry.AttributeStreamBase positionStream = multipointImpl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION);
com.epl.geometry.AttributeStreamOfDbl position = (com.epl.geometry.AttributeStreamOfDbl)positionStream;
for (int i = 0; i < pointCount; i++)
{
double x = position.Read(2 * i);
double y = position.Read(2 * i + 1);
shapeBuffer.Write(x);
offset += 8;
shapeBuffer.Write(y);
offset += 8;
}
}
// write Zs
if (bExportZs)
{
com.epl.geometry.Envelope1D zInterval = multipointImpl.QueryInterval(com.epl.geometry.VertexDescription.Semantics.Z, 0);
shapeBuffer.Write(bArcViewNaNs ? com.epl.geometry.Interop.TranslateToAVNaN(zInterval.vmin) : zInterval.vmin);
offset += 8;
shapeBuffer.Write(bArcViewNaNs ? com.epl.geometry.Interop.TranslateToAVNaN(zInterval.vmax) : zInterval.vmax);
offset += 8;
if (pointCount > 0)
{
if (multipointImpl._attributeStreamIsAllocated(com.epl.geometry.VertexDescription.Semantics.Z))
{
com.epl.geometry.AttributeStreamOfDbl zs = (com.epl.geometry.AttributeStreamOfDbl)multipointImpl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.Z);
for (int i = 0; i < pointCount; i++)
{
double z = zs.Read(i);
shapeBuffer.Write(bArcViewNaNs ? com.epl.geometry.Interop.TranslateToAVNaN(z) : z);
offset += 8;
}
}
else
{
double z = com.epl.geometry.VertexDescription.GetDefaultValue(com.epl.geometry.VertexDescription.Semantics.Z);
if (bArcViewNaNs)
{
z = com.epl.geometry.Interop.TranslateToAVNaN(z);
}
// Can we write a function that writes all these values at
// once instead of doing a for loop?
for (int i = 0; i < pointCount; i++)
{
shapeBuffer.Write(z);
}
offset += 8;
}
}
}
// write Ms
if (bExportMs)
{
com.epl.geometry.Envelope1D mInterval = multipointImpl.QueryInterval(com.epl.geometry.VertexDescription.Semantics.M, 0);
shapeBuffer.Write(bArcViewNaNs ? com.epl.geometry.Interop.TranslateToAVNaN(mInterval.vmin) : mInterval.vmin);
offset += 8;
shapeBuffer.Write(bArcViewNaNs ? com.epl.geometry.Interop.TranslateToAVNaN(mInterval.vmax) : mInterval.vmax);
offset += 8;
if (pointCount > 0)
{
if (multipointImpl._attributeStreamIsAllocated(com.epl.geometry.VertexDescription.Semantics.M))
{
com.epl.geometry.AttributeStreamOfDbl ms = (com.epl.geometry.AttributeStreamOfDbl)multipointImpl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.M);
for (int i = 0; i < pointCount; i++)
{
double m = ms.Read(i);
shapeBuffer.Write(bArcViewNaNs ? com.epl.geometry.Interop.TranslateToAVNaN(m) : m);
offset += 8;
}
}
else
{
double m = com.epl.geometry.VertexDescription.GetDefaultValue(com.epl.geometry.VertexDescription.Semantics.M);
if (bArcViewNaNs)
{
m = com.epl.geometry.Interop.TranslateToAVNaN(m);
}
for (int i = 0; i < pointCount; i++)
{
shapeBuffer.Write(m);
}
offset += 8;
}
}
}
// write IDs
if (bExportIDs)
{
if (pointCount > 0)
{
if (multipointImpl._attributeStreamIsAllocated(com.epl.geometry.VertexDescription.Semantics.ID))
{
com.epl.geometry.AttributeStreamOfInt32 ids = (com.epl.geometry.AttributeStreamOfInt32)multipointImpl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.ID);
for (int i = 0; i < pointCount; i++)
{
int id = ids.Read(i);
shapeBuffer.Write(id);
offset += 4;
}
}
else
{
int id = (int)com.epl.geometry.VertexDescription.GetDefaultValue(com.epl.geometry.VertexDescription.Semantics.ID);
for (int i = 0; i < pointCount; i++)
{
shapeBuffer.Write(id);
}
offset += 4;
}
}
}
return(offset);
}
internal void FillPoints(com.epl.geometry.SimpleRasterizer rasterizer, com.epl.geometry.MultiPointImpl geom, double stroke_half_width)
{
throw com.epl.geometry.GeometryException.GeometryInternalError();
}
private double BruteForceMultiPathMultiPoint_(com.epl.geometry.MultiPath geometryA, com.epl.geometry.MultiPoint geometryB, bool geometriesAreDisjoint)
{
/* const */
/* const */
com.epl.geometry.SegmentIterator segIterA = geometryA.QuerySegmentIterator();
com.epl.geometry.Envelope2D env2DSegmentA = new com.epl.geometry.Envelope2D();
double minSqrDistance = com.epl.geometry.NumberUtils.DoubleMax();
com.epl.geometry.Point2D inputPoint = new com.epl.geometry.Point2D();
double t = -1;
double sqrDistance = minSqrDistance;
/* const */
com.epl.geometry.MultiPointImpl multiPointImplB = (com.epl.geometry.MultiPointImpl)geometryB._getImpl();
int pointCountB = multiPointImplB.GetPointCount();
bool bDoPiPTest = !geometriesAreDisjoint && (geometryA.GetType() == com.epl.geometry.Geometry.Type.Polygon);
while (segIterA.NextPath())
{
while (segIterA.HasNextSegment())
{
/* const */
com.epl.geometry.Segment segmentA = segIterA.NextSegment();
segmentA.QueryEnvelope2D(env2DSegmentA);
// if multipointB has only 1 vertex then it is faster to not
// test for
// env2DSegmentA.distance(env2DgeometryB)
if (pointCountB > 1 && env2DSegmentA.SqrDistance(this.m_env2DgeometryB) > minSqrDistance)
{
continue;
}
for (int i = 0; i < pointCountB; i++)
{
multiPointImplB.GetXY(i, inputPoint);
if (bDoPiPTest)
{
// Test for polygon containment. This takes the
// place of a more general intersection test at the
// beginning of the operator
if (com.epl.geometry.PolygonUtils.IsPointInPolygon2D((com.epl.geometry.Polygon)geometryA, inputPoint, 0) != com.epl.geometry.PolygonUtils.PiPResult.PiPOutside)
{
return(0.0);
}
}
t = segmentA.GetClosestCoordinate(inputPoint, false);
inputPoint.Sub(segmentA.GetCoord2D(t));
sqrDistance = inputPoint.SqrLength();
if (sqrDistance < minSqrDistance)
{
if (sqrDistance == 0.0)
{
return(0.0);
}
minSqrDistance = sqrDistance;
}
}
// No need to do point-in-polygon anymore (if it is a
// polygon vs polyline)
bDoPiPTest = false;
}
}
return(System.Math.Sqrt(minSqrDistance));
}
/// <exception cref="System.Exception"/>
private static com.epl.geometry.Geometry ImportFromJsonMultiPoint(com.epl.geometry.JsonReader parser, com.epl.geometry.AttributeStreamOfDbl @as, com.epl.geometry.AttributeStreamOfDbl bs)
{
if (parser.CurrentToken() != com.epl.geometry.JsonReader.Token.START_ARRAY)
{
throw new com.epl.geometry.GeometryException("failed to parse multipoint: array of vertices is expected");
}
int point_count = 0;
com.epl.geometry.MultiPoint multipoint;
multipoint = new com.epl.geometry.MultiPoint();
com.epl.geometry.AttributeStreamOfDbl position = (com.epl.geometry.AttributeStreamOfDbl)(com.epl.geometry.AttributeStreamBase.CreateDoubleStream(2, 0));
// At start of rings
int sz;
double[] buf = new double[4];
while (parser.NextToken() != com.epl.geometry.JsonReader.Token.END_ARRAY)
{
if (parser.CurrentToken() != com.epl.geometry.JsonReader.Token.START_ARRAY)
{
throw new com.epl.geometry.GeometryException("failed to parse multipoint: array is expected, multipoint vertices consist of arrays of cooridinates");
}
sz = 0;
while (parser.NextToken() != com.epl.geometry.JsonReader.Token.END_ARRAY)
{
buf[sz++] = ReadDouble(parser);
}
if (sz < 2)
{
throw new com.epl.geometry.GeometryException("failed to parse multipoint: each vertex array has to have at least 2 elements");
}
if (position.Size() == 2 * point_count)
{
int c = point_count * 3;
if (c % 2 != 0)
{
c++;
}
// have to be even
position.Resize(c);
}
position.Write(2 * point_count, buf[0]);
position.Write(2 * point_count + 1, buf[1]);
if (@as.Size() == point_count)
{
int c = (point_count * 3) / 2;
if (c < 4)
{
c = 4;
}
else
{
if (c < 16)
{
c = 16;
}
}
@as.Resize(c);
}
if (sz > 2)
{
@as.Write(point_count, buf[2]);
}
else
{
@as.Write(point_count, com.epl.geometry.NumberUtils.NaN());
}
if (bs.Size() == point_count)
{
int c = (point_count * 3) / 2;
if (c < 4)
{
c = 4;
}
else
{
if (c < 16)
{
c = 16;
}
}
bs.Resize(c);
}
if (sz > 3)
{
bs.Write(point_count, buf[3]);
}
else
{
bs.Write(point_count, com.epl.geometry.NumberUtils.NaN());
}
point_count++;
}
if (point_count != 0)
{
com.epl.geometry.MultiPointImpl mp_impl = (com.epl.geometry.MultiPointImpl)multipoint._getImpl();
mp_impl.Resize(point_count);
mp_impl.SetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION, position);
}
return(multipoint);
}
private static void ExportMultiPointToJson(com.epl.geometry.MultiPoint mpt, com.epl.geometry.SpatialReference spatialReference, com.epl.geometry.JsonWriter jsonWriter, System.Collections.Generic.IDictionary <string, object> exportProperties)
{
bool bExportZs = mpt.HasAttribute(com.epl.geometry.VertexDescription.Semantics.Z);
bool bExportMs = mpt.HasAttribute(com.epl.geometry.VertexDescription.Semantics.M);
bool bPositionAsF = false;
int decimals = 17;
if (exportProperties != null)
{
object numberOfDecimalsXY = exportProperties["numberOfDecimalsXY"];
if (numberOfDecimalsXY != null && numberOfDecimalsXY is java.lang.Number)
{
bPositionAsF = true;
decimals = ((java.lang.Number)numberOfDecimalsXY);
}
}
jsonWriter.StartObject();
if (bExportZs)
{
jsonWriter.AddPairBoolean("hasZ", true);
}
if (bExportMs)
{
jsonWriter.AddPairBoolean("hasM", true);
}
jsonWriter.AddPairArray("points");
if (!mpt.IsEmpty())
{
com.epl.geometry.MultiPointImpl mpImpl = (com.epl.geometry.MultiPointImpl)mpt._getImpl();
// get impl
// for
// faster
// access
com.epl.geometry.AttributeStreamOfDbl zs = null;
com.epl.geometry.AttributeStreamOfDbl ms = null;
if (bExportZs)
{
zs = (com.epl.geometry.AttributeStreamOfDbl)mpImpl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.Z);
}
if (bExportMs)
{
ms = (com.epl.geometry.AttributeStreamOfDbl)mpImpl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.M);
}
com.epl.geometry.Point2D pt = new com.epl.geometry.Point2D();
int n = mpt.GetPointCount();
for (int i = 0; i < n; i++)
{
mpt.GetXY(i, pt);
jsonWriter.AddValueArray();
if (bPositionAsF)
{
jsonWriter.AddValueDouble(pt.x, decimals, true);
jsonWriter.AddValueDouble(pt.y, decimals, true);
}
else
{
jsonWriter.AddValueDouble(pt.x);
jsonWriter.AddValueDouble(pt.y);
}
if (bExportZs)
{
double z = zs.Get(i);
jsonWriter.AddValueDouble(z);
}
if (bExportMs)
{
double m = ms.Get(i);
jsonWriter.AddValueDouble(m);
}
jsonWriter.EndArray();
}
}
jsonWriter.EndArray();
if (spatialReference != null)
{
WriteSR(spatialReference, jsonWriter);
}
jsonWriter.EndObject();
}
public MultiPoint(com.epl.geometry.VertexDescription description)
{
m_impl = new com.epl.geometry.MultiPointImpl(description);
}
/// <summary>Creates a new empty multipoint.</summary>
public MultiPoint()
{
m_impl = new com.epl.geometry.MultiPointImpl();
}
