internal static int PolygonText(com.epl.geometry.AttributeStreamOfDbl zs, com.epl.geometry.AttributeStreamOfDbl ms, com.epl.geometry.AttributeStreamOfDbl position, com.epl.geometry.AttributeStreamOfInt32 paths, com.epl.geometry.AttributeStreamOfInt8 path_flags, int total_point_count
, com.epl.geometry.WktParser wkt_parser)
{
// At start of PolygonText
int current_token = wkt_parser.CurrentToken();
if (current_token == com.epl.geometry.WktParser.WktToken.empty)
{
return(total_point_count);
}
bool b_first_line_string = true;
current_token = wkt_parser.NextToken();
while (current_token != com.epl.geometry.WktParser.WktToken.right_paren)
{
// At start of LineStringText
int point_count = LineStringText(true, zs, ms, position, paths, path_flags, wkt_parser);
if (point_count != 0)
{
if (b_first_line_string)
{
b_first_line_string = false;
path_flags.SetBits(path_flags.Size() - 2, unchecked ((byte)com.epl.geometry.PathFlags.enumOGCStartPolygon));
}
path_flags.SetBits(path_flags.Size() - 2, unchecked ((byte)com.epl.geometry.PathFlags.enumClosed));
total_point_count += point_count;
}
current_token = wkt_parser.NextToken();
}
return(total_point_count);
}
internal override void ApplyTransformation(com.epl.geometry.Transformation3D transform)
{
if (IsEmpty())
{
return;
}
_verifyAllStreams();
AddAttribute(com.epl.geometry.VertexDescription.Semantics.Z);
_verifyAllStreams();
com.epl.geometry.AttributeStreamOfDbl points = (com.epl.geometry.AttributeStreamOfDbl)m_vertexAttributes[0];
com.epl.geometry.AttributeStreamOfDbl zs = (com.epl.geometry.AttributeStreamOfDbl)m_vertexAttributes[1];
com.epl.geometry.Point3D pt3 = new com.epl.geometry.Point3D();
for (int ipoint = 0; ipoint < m_pointCount; ipoint++)
{
pt3.x = points.Read(ipoint * 2);
pt3.y = points.Read(ipoint * 2 + 1);
pt3.z = zs.Read(ipoint);
com.epl.geometry.Point3D res = transform.Transform(pt3);
points.Write(ipoint * 2, res.x);
points.Write(ipoint * 2 + 1, res.y);
zs.Write(ipoint, res.z);
}
// REFACTOR: reset the exact envelope only and transform the loose
// envelope
NotifyModified(com.epl.geometry.MultiVertexGeometryImpl.DirtyFlags.DirtyCoordinates);
}
public override bool Equals(com.epl.geometry.AttributeStreamBase other, int start, int end)
{
if (other == null)
{
return(false);
}
if (!(other is com.epl.geometry.AttributeStreamOfDbl))
{
return(false);
}
com.epl.geometry.AttributeStreamOfDbl _other = (com.epl.geometry.AttributeStreamOfDbl)other;
int size = Size();
int sizeOther = _other.Size();
if (end > size || end > sizeOther && (size != sizeOther))
{
return(false);
}
if (end > size)
{
end = size;
}
for (int i = start; i < end; i++)
{
if (Read(i) != _other.Read(i))
{
return(false);
}
}
return(true);
}
internal static int MultiPointText(com.epl.geometry.AttributeStreamOfDbl zs, com.epl.geometry.AttributeStreamOfDbl ms, com.epl.geometry.AttributeStreamOfDbl position, com.epl.geometry.WktParser wkt_parser)
{
// At start of MultiPointText
int current_token = wkt_parser.CurrentToken();
int point_count = 0;
if (current_token == com.epl.geometry.WktParser.WktToken.empty)
{
return(point_count);
}
current_token = wkt_parser.NextToken();
while (current_token != com.epl.geometry.WktParser.WktToken.right_paren)
{
// At start of PointText
point_count += PointText(zs, ms, position, wkt_parser);
if (current_token == com.epl.geometry.WktParser.WktToken.left_paren || current_token == com.epl.geometry.WktParser.WktToken.empty)
{
current_token = wkt_parser.NextToken();
}
else
{
// ogc standard
current_token = wkt_parser.CurrentToken();
}
}
// not ogc standard.
// treat as
// linestring
return(point_count);
}
// Checked vs. Jan 11, 2011
internal virtual int QueryCoordinates(com.epl.geometry.Point3D[] dst, int dstSize, int beginIndex, int endIndex)
{
int endIndexC = endIndex < 0 ? m_pointCount : endIndex;
endIndexC = System.Math.Min(endIndexC, beginIndex + dstSize);
if (beginIndex < 0 || beginIndex >= m_pointCount || endIndexC < beginIndex)
{
// TODO replace geometry exc
throw new System.ArgumentException();
}
com.epl.geometry.AttributeStreamOfDbl xy = (com.epl.geometry.AttributeStreamOfDbl)GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION);
com.epl.geometry.AttributeStreamOfDbl z = null;
double v = com.epl.geometry.VertexDescription.GetDefaultValue(com.epl.geometry.VertexDescription.Semantics.Z);
bool bHasZ = HasAttribute(com.epl.geometry.VertexDescription.Semantics.Z);
if (bHasZ)
{
z = (com.epl.geometry.AttributeStreamOfDbl)GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.Z);
}
int j = 0;
for (int i = beginIndex; i < endIndexC; i++, j++)
{
dst[j].x = xy.Read(2 * i);
dst[j].y = xy.Read(2 * i + 1);
dst[j].z = bHasZ ? z.Read(i) : v;
dst[j] = GetXYZ(i);
}
return(endIndexC);
}
internal virtual com.epl.geometry.Proximity2DResult MultiVertexGetNearestVertex(com.epl.geometry.MultiVertexGeometry geom, com.epl.geometry.Point2D inputPoint)
{
com.epl.geometry.MultiVertexGeometryImpl mpImpl = (com.epl.geometry.MultiVertexGeometryImpl)geom._getImpl();
com.epl.geometry.AttributeStreamOfDbl position = (com.epl.geometry.AttributeStreamOfDbl)mpImpl.GetAttributeStreamRef((com.epl.geometry.VertexDescription.Semantics.POSITION));
int pointCount = geom.GetPointCount();
int closestIndex = 0;
double closestx = 0.0;
double closesty = 0.0;
double closestDistanceSq = com.epl.geometry.NumberUtils.DoubleMax();
for (int i = 0; i < pointCount; i++)
{
com.epl.geometry.Point2D pt = new com.epl.geometry.Point2D();
position.Read(2 * i, pt);
double distanceSq = com.epl.geometry.Point2D.SqrDistance(pt, inputPoint);
if (distanceSq < closestDistanceSq)
{
closestx = pt.x;
closesty = pt.y;
closestIndex = i;
closestDistanceSq = distanceSq;
}
}
com.epl.geometry.Proximity2DResult result = new com.epl.geometry.Proximity2DResult();
result._setParams(closestx, closesty, closestIndex, System.Math.Sqrt(closestDistanceSq));
return(result);
}
private ConvexHull(com.epl.geometry.AttributeStreamOfDbl stream, int n)
{
m_tree_hull = new com.epl.geometry.Treap();
m_tree_hull.SetCapacity(System.Math.Min(20, n));
m_stream = stream;
m_call_back = new com.epl.geometry.ConvexHull.CallBackStream(this);
}
internal static com.epl.geometry.Geometry MultiPointTaggedText(int import_flags, com.epl.geometry.WktParser wkt_parser)
{
com.epl.geometry.MultiPoint multi_point;
com.epl.geometry.MultiPointImpl multi_point_impl;
com.epl.geometry.AttributeStreamOfDbl zs = null;
com.epl.geometry.AttributeStreamOfDbl ms = null;
com.epl.geometry.AttributeStreamOfDbl position;
position = (com.epl.geometry.AttributeStreamOfDbl)com.epl.geometry.AttributeStreamBase.CreateDoubleStream(0);
multi_point = new com.epl.geometry.MultiPoint();
multi_point_impl = (com.epl.geometry.MultiPointImpl)multi_point._getImpl();
int current_token = wkt_parser.NextToken();
if (current_token == com.epl.geometry.WktParser.WktToken.attribute_z)
{
zs = (com.epl.geometry.AttributeStreamOfDbl)com.epl.geometry.AttributeStreamBase.CreateDoubleStream(0, com.epl.geometry.NumberUtils.TheNaN);
multi_point_impl.AddAttribute(com.epl.geometry.VertexDescription.Semantics.Z);
wkt_parser.NextToken();
}
else
{
if (current_token == com.epl.geometry.WktParser.WktToken.attribute_m)
{
ms = (com.epl.geometry.AttributeStreamOfDbl)com.epl.geometry.AttributeStreamBase.CreateDoubleStream(0, com.epl.geometry.NumberUtils.TheNaN);
multi_point_impl.AddAttribute(com.epl.geometry.VertexDescription.Semantics.M);
wkt_parser.NextToken();
}
else
{
if (current_token == com.epl.geometry.WktParser.WktToken.attribute_zm)
{
zs = (com.epl.geometry.AttributeStreamOfDbl)com.epl.geometry.AttributeStreamBase.CreateDoubleStream(0, com.epl.geometry.NumberUtils.TheNaN);
ms = (com.epl.geometry.AttributeStreamOfDbl)com.epl.geometry.AttributeStreamBase.CreateDoubleStream(0, com.epl.geometry.NumberUtils.TheNaN);
multi_point_impl.AddAttribute(com.epl.geometry.VertexDescription.Semantics.Z);
multi_point_impl.AddAttribute(com.epl.geometry.VertexDescription.Semantics.M);
wkt_parser.NextToken();
}
}
}
int point_count = MultiPointText(zs, ms, position, wkt_parser);
if (point_count != 0)
{
System.Diagnostics.Debug.Assert((2 * point_count == position.Size()));
multi_point_impl.Resize(point_count);
multi_point_impl.SetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION, position);
if (zs != null)
{
multi_point_impl.SetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.Z, zs);
}
if (ms != null)
{
multi_point_impl.SetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.M, ms);
}
multi_point_impl.NotifyModified(com.epl.geometry.MultiVertexGeometryImpl.DirtyFlags.DirtyAll);
}
return(multi_point);
}
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);
}
// Checked vs. Jan 11, 2011
/// <summary>\internal Updates x, y intervals.</summary>
public virtual void _updateXYImpl(bool bExact)
{
m_envelope.SetEmpty();
com.epl.geometry.AttributeStreamOfDbl stream = (com.epl.geometry.AttributeStreamOfDbl)m_vertexAttributes[0];
com.epl.geometry.Point2D pt = new com.epl.geometry.Point2D();
for (int i = 0; i < m_pointCount; i++)
{
stream.Read(2 * i, pt);
m_envelope.Merge(pt);
}
}
internal virtual void CalculateEnvelope2D(com.epl.geometry.Envelope2D env, bool bExact)
{
env.SetEmpty();
com.epl.geometry.AttributeStreamOfDbl stream = (com.epl.geometry.AttributeStreamOfDbl)m_vertexAttributes[0];
com.epl.geometry.Point2D pt = new com.epl.geometry.Point2D();
for (int i = 0; i < m_pointCount; i++)
{
stream.Read(2 * i, pt);
env.Merge(pt);
}
}
// 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 override void GetXY(int index, com.epl.geometry.Point2D pt)
{
if (index < 0 || index >= GetPointCount())
{
throw new System.IndexOutOfRangeException();
}
_verifyAllStreams();
// AttributeStreamOfDbl v = (AttributeStreamOfDbl)
// m_vertexAttributes[0];
com.epl.geometry.AttributeStreamOfDbl v = (com.epl.geometry.AttributeStreamOfDbl)m_vertexAttributes[0];
v.Read(index * 2, pt);
}
internal static void ExportPolylineToWkt(int export_flags, com.epl.geometry.Polyline polyline, System.Text.StringBuilder @string)
{
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 - (7 & (export_flags >> 13));
bool b_export_zs = polyline_impl.HasAttribute(com.epl.geometry.VertexDescription.Semantics.Z) && (export_flags & com.epl.geometry.WktExportFlags.wktExportStripZs) == 0;
bool b_export_ms = polyline_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;
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.WktExportFlags.wktExportLineString) != 0)
{
if (path_count > 1)
{
throw new System.ArgumentException("Cannot export a LineString with specified export flags: " + export_flags);
}
LineStringTaggedText_(precision, b_export_zs, b_export_ms, zs, ms, position, path_flags, paths, @string);
}
else
{
MultiLineStringTaggedText_(precision, b_export_zs, b_export_ms, zs, ms, position, path_flags, paths, path_count, @string);
}
}
internal static void AddToStreams(com.epl.geometry.AttributeStreamOfDbl zs, com.epl.geometry.AttributeStreamOfDbl ms, com.epl.geometry.AttributeStreamOfDbl position, double x, double y, double z, double m)
{
position.Add(x);
position.Add(y);
if (zs != null)
{
zs.Add(z);
}
if (ms != null)
{
ms.Add(m);
}
}
// Checked vs. Jan 11, 2011
public override void SetXY(int index, com.epl.geometry.Point2D pt)
{
if (index < 0 || index >= m_pointCount)
{
// TODO exception
throw new System.IndexOutOfRangeException();
}
_verifyAllStreams();
// AttributeStreamOfDbl v = (AttributeStreamOfDbl)
// m_vertexAttributes[0];
com.epl.geometry.AttributeStreamOfDbl v = (com.epl.geometry.AttributeStreamOfDbl)m_vertexAttributes[0];
v.Write(index * 2, pt);
NotifyModified(com.epl.geometry.MultiVertexGeometryImpl.DirtyFlags.DirtyCoordinates);
}
// Checked vs. Jan 11, 2011
internal override void SetXYZ(int index, com.epl.geometry.Point3D pt)
{
if (index < 0 || index >= GetPointCount())
{
throw new System.IndexOutOfRangeException();
}
AddAttribute(com.epl.geometry.VertexDescription.Semantics.Z);
_verifyAllStreams();
NotifyModified(com.epl.geometry.MultiVertexGeometryImpl.DirtyFlags.DirtyCoordinates);
com.epl.geometry.AttributeStreamOfDbl v = (com.epl.geometry.AttributeStreamOfDbl)m_vertexAttributes[0];
v.Write(index * 2, pt.x);
v.Write(index * 2 + 1, pt.y);
m_vertexAttributes[1].WriteAsDbl(index, pt.z);
}
/// <summary>Creates a new attribute stream of given persistence type and size.</summary>
/// <param name="persistence">The persistence type of the stream (see VertexDescription).</param>
/// <param name="size">
/// The number of elements (floats, doubles, or 32 bit integers)
/// of the given type in the stream.
/// </param>
/// <param name="defaultValue">The default value to fill the stream with.</param>
public static com.epl.geometry.AttributeStreamBase CreateAttributeStreamWithPersistence(int persistence, int size, double defaultValue)
{
com.epl.geometry.AttributeStreamBase newStream;
switch (persistence)
{
case (com.epl.geometry.VertexDescription.Persistence.enumFloat):
{
newStream = new com.epl.geometry.AttributeStreamOfFloat(size, (float)defaultValue);
break;
}
case (com.epl.geometry.VertexDescription.Persistence.enumDouble):
{
newStream = new com.epl.geometry.AttributeStreamOfDbl(size, (double)defaultValue);
break;
}
case (com.epl.geometry.VertexDescription.Persistence.enumInt32):
{
newStream = new com.epl.geometry.AttributeStreamOfInt32(size, (int)defaultValue);
break;
}
case (com.epl.geometry.VertexDescription.Persistence.enumInt64):
{
newStream = new com.epl.geometry.AttributeStreamOfInt64(size, (long)defaultValue);
break;
}
case (com.epl.geometry.VertexDescription.Persistence.enumInt8):
{
newStream = new com.epl.geometry.AttributeStreamOfInt8(size, unchecked ((byte)defaultValue));
break;
}
case (com.epl.geometry.VertexDescription.Persistence.enumInt16):
{
newStream = new com.epl.geometry.AttributeStreamOfInt16(size, (short)defaultValue);
break;
}
default:
{
throw new com.epl.geometry.GeometryException("Internal Error");
}
}
return(newStream);
}
public AttributeStreamOfDbl(com.epl.geometry.AttributeStreamOfDbl other, int maxSize)
{
m_size = other.Size();
if (m_size > maxSize)
{
m_size = maxSize;
}
int sz = m_size;
if (sz < 2)
{
sz = 2;
}
m_buffer = new double[sz];
System.Array.Copy(other.m_buffer, 0, m_buffer, 0, m_size);
}
internal void ShiftPath(com.epl.geometry.MultiPath inputGeom, int iPath, double shift)
{
com.epl.geometry.MultiVertexGeometryImpl vertexGeometryImpl = (com.epl.geometry.MultiVertexGeometryImpl)inputGeom._getImpl();
com.epl.geometry.AttributeStreamOfDbl xyStream = (com.epl.geometry.AttributeStreamOfDbl)vertexGeometryImpl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION);
int i1 = inputGeom.GetPathStart(iPath);
int i2 = inputGeom.GetPathEnd(iPath);
com.epl.geometry.Point2D pt = new com.epl.geometry.Point2D();
while (i1 < i2)
{
xyStream.Read(i1, pt);
pt.x += shift;
xyStream.Write(i1, pt);
i1++;
}
}
// Checked vs. Jan 11, 2011
public virtual void SetXY(int index, double x, double y)
{
if (index < 0 || index >= m_pointCount)
{
// TODO exc
throw new System.IndexOutOfRangeException();
}
_verifyAllStreams();
// AttributeStreamOfDbl v = (AttributeStreamOfDbl)
// m_vertexAttributes[0];
// TODO ask sergey about casts
com.epl.geometry.AttributeStreamOfDbl v = (com.epl.geometry.AttributeStreamOfDbl)m_vertexAttributes[0];
v.Write(index * 2, x);
v.Write(index * 2 + 1, y);
NotifyModified(com.epl.geometry.MultiVertexGeometryImpl.DirtyFlags.DirtyCoordinates);
}
public override void ReplaceNaNs(int semantics, double value)
{
AddAttribute(semantics);
if (IsEmpty())
{
return;
}
bool modified = false;
int ncomps = com.epl.geometry.VertexDescription.GetComponentCount(semantics);
for (int i = 0; i < ncomps; i++)
{
com.epl.geometry.AttributeStreamBase streamBase = GetAttributeStreamRef(semantics);
if (streamBase is com.epl.geometry.AttributeStreamOfDbl)
{
com.epl.geometry.AttributeStreamOfDbl dblStream = (com.epl.geometry.AttributeStreamOfDbl)streamBase;
for (int ivert = 0, n = m_pointCount * ncomps; ivert < n; ivert++)
{
double v = dblStream.Read(ivert);
if (double.IsNaN(v))
{
dblStream.Write(ivert, value);
modified = true;
}
}
}
else
{
for (int ivert = 0, n = m_pointCount * ncomps; ivert < n; ivert++)
{
double v = streamBase.ReadAsDbl(ivert);
if (double.IsNaN(v))
{
streamBase.WriteAsDbl(ivert, value);
modified = true;
}
}
}
}
if (modified)
{
NotifyModified(com.epl.geometry.MultiVertexGeometryImpl.DirtyFlags.DirtyCoordinates);
}
}
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);
}
}
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 int MultiPolygonText(com.epl.geometry.AttributeStreamOfDbl zs, com.epl.geometry.AttributeStreamOfDbl ms, com.epl.geometry.AttributeStreamOfDbl position, com.epl.geometry.AttributeStreamOfInt32 paths, com.epl.geometry.AttributeStreamOfInt8 path_flags, com.epl.geometry.WktParser
wkt_parser)
{
// At start of MultiPolygonText
int current_token = wkt_parser.CurrentToken();
int total_point_count = 0;
if (current_token == com.epl.geometry.WktParser.WktToken.empty)
{
return(total_point_count);
}
current_token = wkt_parser.NextToken();
while (current_token != com.epl.geometry.WktParser.WktToken.right_paren)
{
// At start of PolygonText
total_point_count = PolygonText(zs, ms, position, paths, path_flags, total_point_count, wkt_parser);
current_token = wkt_parser.NextToken();
}
return(total_point_count);
}
public override void ApplyTransformation(com.epl.geometry.Transformation2D transform)
{
if (IsEmpty())
{
return;
}
_verifyAllStreams();
com.epl.geometry.AttributeStreamOfDbl points = (com.epl.geometry.AttributeStreamOfDbl)m_vertexAttributes[0];
com.epl.geometry.Point2D pt2 = new com.epl.geometry.Point2D();
for (int ipoint = 0; ipoint < m_pointCount; ipoint++)
{
pt2.x = points.Read(ipoint * 2);
pt2.y = points.Read(ipoint * 2 + 1);
transform.Transform(pt2, pt2);
points.Write(ipoint * 2, pt2.x);
points.Write(ipoint * 2 + 1, pt2.y);
}
// REFACTOR: reset the exact envelope only and transform the loose
// envelope
NotifyModified(com.epl.geometry.MultiVertexGeometryImpl.DirtyFlags.DirtyCoordinates);
}
internal override int QueryCoordinates(com.epl.geometry.Point2D[] dst, int dstSize, int beginIndex, int endIndex)
{
int endIndexC = endIndex < 0 ? m_pointCount : endIndex;
endIndexC = System.Math.Min(endIndexC, beginIndex + dstSize);
if (beginIndex < 0 || beginIndex >= m_pointCount || endIndexC < beginIndex || dst.Length != dstSize)
{
throw new System.ArgumentException();
}
// GEOMTHROW(invalid_argument);
com.epl.geometry.AttributeStreamOfDbl xy = (com.epl.geometry.AttributeStreamOfDbl)GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION);
int pointCountToRead = endIndexC - beginIndex;
double[] dstArray = new double[pointCountToRead * 2];
xy.ReadRange(2 * beginIndex, pointCountToRead * 2, dstArray, 0, true);
for (int i = 0; i < pointCountToRead; i++)
{
dst[i] = new com.epl.geometry.Point2D(dstArray[i * 2], dstArray[i * 2 + 1]);
}
return(endIndexC);
}
internal virtual com.epl.geometry.Proximity2DResult[] MultiVertexGetNearestVertices(com.epl.geometry.MultiVertexGeometry geom, com.epl.geometry.Point2D inputPoint, double searchRadius, int maxVertexCountToReturn)
{
com.epl.geometry.Proximity2DResult[] resultArray;
if (maxVertexCountToReturn == 0)
{
resultArray = new com.epl.geometry.Proximity2DResult[0];
return(resultArray);
}
com.epl.geometry.MultiVertexGeometryImpl mpImpl = (com.epl.geometry.MultiVertexGeometryImpl)geom._getImpl();
com.epl.geometry.AttributeStreamOfDbl position = (com.epl.geometry.AttributeStreamOfDbl)mpImpl.GetAttributeStreamRef((com.epl.geometry.VertexDescription.Semantics.POSITION));
int pointCount = geom.GetPointCount();
System.Collections.Generic.List <com.epl.geometry.Proximity2DResult> v = new System.Collections.Generic.List <com.epl.geometry.Proximity2DResult>(maxVertexCountToReturn);
int count = 0;
double searchRadiusSq = searchRadius * searchRadius;
for (int i = 0; i < pointCount; i++)
{
double x = position.Read(2 * i);
double y = position.Read(2 * i + 1);
double xDiff = inputPoint.x - x;
double yDiff = inputPoint.y - y;
double distanceSq = xDiff * xDiff + yDiff * yDiff;
if (distanceSq <= searchRadiusSq)
{
com.epl.geometry.Proximity2DResult result = new com.epl.geometry.Proximity2DResult();
result._setParams(x, y, i, System.Math.Sqrt(distanceSq));
count++;
v.Add(result);
}
}
int vsize = v.Count;
v.Sort(new com.epl.geometry.Proximity2DResultComparator());
if (maxVertexCountToReturn >= vsize)
{
return(v.ToArray());
}
return(v.GetRange(0, maxVertexCountToReturn - 0).ToArray());
}
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);
}
// Checked vs. Jan 11, 2011
internal override com.epl.geometry.Point3D GetXYZ(int index)
{
if (index < 0 || index >= GetPointCount())
{
throw new System.IndexOutOfRangeException();
}
_verifyAllStreams();
com.epl.geometry.AttributeStreamOfDbl v = (com.epl.geometry.AttributeStreamOfDbl)m_vertexAttributes[0];
com.epl.geometry.Point3D pt = new com.epl.geometry.Point3D();
pt.x = v.Read(index * 2);
pt.y = v.Read(index * 2 + 1);
// TODO check excluded if statement componenet
if (HasAttribute(com.epl.geometry.VertexDescription.Semantics.Z))
{
// && (m_vertexAttributes[1] != null))
pt.z = m_vertexAttributes[1].ReadAsDbl(index);
}
else
{
pt.z = com.epl.geometry.VertexDescription.GetDefaultValue(com.epl.geometry.VertexDescription.Semantics.Z);
}
return(pt);
}
