/// <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");
}
}
/// <exception cref="java.io.ObjectStreamException"/>
internal object ReadResolve()
{
com.epl.geometry.Geometry geometry = null;
try
{
geometry = com.epl.geometry.GeometryEngine.GeometryFromEsriShape(geometryData.esriShape, geometryData.geometryType);
if (com.epl.geometry.Geometry.IsMultiVertex(geometry.GetType().Value()))
{
com.epl.geometry.GeometrySerializer.MultiVertexData mvd = (com.epl.geometry.GeometrySerializer.MultiVertexData)geometryData;
com.epl.geometry.MultiVertexGeometryImpl mvImpl = (com.epl.geometry.MultiVertexGeometryImpl)geometry._getImpl();
if (!geometry.IsEmpty() && com.epl.geometry.Geometry.IsMultiPath(geometry.GetType().Value()))
{
com.epl.geometry.GeometrySerializer.MultiPathData mpd = (com.epl.geometry.GeometrySerializer.MultiPathData)geometryData;
com.epl.geometry.MultiPathImpl mpImpl = (com.epl.geometry.MultiPathImpl)geometry._getImpl();
com.epl.geometry.AttributeStreamOfInt8 pathFlags = mpImpl.GetPathFlagsStreamRef();
for (int i = 0, n = mpImpl.GetPathCount(); i < n; i++)
{
if (mpd.ogcFlags[i])
{
pathFlags.SetBits(i, unchecked ((byte)com.epl.geometry.PathFlags.enumOGCStartPolygon));
}
}
}
mvImpl.SetIsSimple(mvd.simpleFlag, mvd.tolerance, false);
}
}
catch (System.Exception)
{
throw new System.IO.InvalidDataException("Cannot read geometry from stream");
}
return(geometry);
}
public override bool Equals(com.epl.geometry.AttributeStreamBase other, int start, int end)
{
if (other == null)
{
return(false);
}
if (!(other is com.epl.geometry.AttributeStreamOfInt8))
{
return(false);
}
com.epl.geometry.AttributeStreamOfInt8 _other = (com.epl.geometry.AttributeStreamOfInt8)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);
}
// 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);
}
}
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);
}
}
/// <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 AttributeStreamOfInt8(com.epl.geometry.AttributeStreamOfInt8 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 byte[sz];
System.Array.Copy(other.m_buffer, 0, m_buffer, 0, m_size);
}
internal static int MultiLineStringText(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 MultiLineStringText
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 LineStringText
int point_count = LineStringText(false, zs, ms, position, paths, path_flags, wkt_parser);
total_point_count += point_count;
current_token = wkt_parser.NextToken();
}
return(total_point_count);
}
// Mirrors wkt
private static void MultiLineStringText_(int precision, bool bFixedPoint, bool b_export_zs, bool b_export_ms, com.epl.geometry.AttributeStreamOfDbl zs, com.epl.geometry.AttributeStreamOfDbl ms, com.epl.geometry.AttributeStreamOfDbl position, com.epl.geometry.AttributeStreamOfInt8
path_flags, com.epl.geometry.AttributeStreamOfInt32 paths, int path_count, com.epl.geometry.JsonWriter json_writer)
{
bool b_closed = ((path_flags.Read(0) & com.epl.geometry.PathFlags.enumClosed) != 0);
LineStringText_(false, b_closed, precision, bFixedPoint, b_export_zs, b_export_ms, zs, ms, position, 0, paths.Read(1), json_writer);
for (int path = 1; path < path_count; path++)
{
b_closed = ((path_flags.Read(path) & com.epl.geometry.PathFlags.enumClosed) != 0);
int istart = paths.Read(path);
int iend = paths.Read(path + 1);
LineStringText_(false, b_closed, precision, bFixedPoint, b_export_zs, b_export_ms, zs, ms, position, istart, iend, json_writer);
}
}
// Mirrors wkt
private static void MultiPolygonText_(int precision, bool bFixedPoint, bool b_export_zs, bool b_export_ms, com.epl.geometry.AttributeStreamOfDbl zs, com.epl.geometry.AttributeStreamOfDbl ms, com.epl.geometry.AttributeStreamOfDbl position, com.epl.geometry.AttributeStreamOfInt8
path_flags, com.epl.geometry.AttributeStreamOfInt32 paths, int polygon_count, int path_count, com.epl.geometry.JsonWriter json_writer)
{
int polygon_start = 0;
int polygon_end = 1;
while (polygon_end < path_count && ((int)path_flags.Read(polygon_end) & com.epl.geometry.PathFlags.enumOGCStartPolygon) == 0)
{
polygon_end++;
}
PolygonText_(precision, bFixedPoint, b_export_zs, b_export_ms, zs, ms, position, paths, polygon_start, polygon_end, json_writer);
for (int ipolygon = 1; ipolygon < polygon_count; ipolygon++)
{
polygon_start = polygon_end;
polygon_end++;
while (polygon_end < path_count && ((int)path_flags.Read(polygon_end) & com.epl.geometry.PathFlags.enumOGCStartPolygon) == 0)
{
polygon_end++;
}
PolygonText_(precision, bFixedPoint, b_export_zs, b_export_ms, zs, ms, position, paths, polygon_start, polygon_end, json_writer);
}
}
public override void WriteRange(int startElement, int count, com.epl.geometry.AttributeStreamBase _src, int srcStart, bool bForward, int stride)
{
if (startElement < 0 || count < 0 || srcStart < 0)
{
throw new System.ArgumentException();
}
if (!bForward && (stride <= 0 || (count % stride != 0)))
{
throw new System.ArgumentException();
}
com.epl.geometry.AttributeStreamOfInt8 src = (com.epl.geometry.AttributeStreamOfInt8)_src;
// the input
// type must
// match
if (src.Size() < (int)(srcStart + count))
{
throw new System.ArgumentException();
}
if (count == 0)
{
return;
}
if (Size() < count + startElement)
{
Resize(count + startElement);
}
if (_src == (com.epl.geometry.AttributeStreamBase) this)
{
_selfWriteRangeImpl(startElement, count, srcStart, bForward, stride);
return;
}
if (bForward)
{
int j = startElement;
int offset = srcStart;
for (int i = 0; i < count; i++)
{
m_buffer[j] = src.m_buffer[offset];
j++;
offset++;
}
}
else
{
int j = startElement;
int offset = srcStart + count - stride;
if (stride == 1)
{
for (int i = 0; i < count; i++)
{
m_buffer[j] = src.m_buffer[offset];
j++;
offset--;
}
}
else
{
for (int i = 0, n = count / stride; i < n; i++)
{
for (int k = 0; k < stride; k++)
{
m_buffer[j + k] = src.m_buffer[offset + k];
}
j += stride;
offset -= stride;
}
}
}
}
public AttributeStreamOfInt8(com.epl.geometry.AttributeStreamOfInt8 other)
{
m_buffer = (byte[])other.m_buffer.Clone();
m_size = other.m_size;
}
internal static void MultiLineStringText_(int precision, bool b_export_zs, bool b_export_ms, com.epl.geometry.AttributeStreamOfDbl zs, com.epl.geometry.AttributeStreamOfDbl ms, com.epl.geometry.AttributeStreamOfDbl position, com.epl.geometry.AttributeStreamOfInt8 path_flags, com.epl.geometry.AttributeStreamOfInt32
paths, int path_count, System.Text.StringBuilder @string)
{
bool b_closed = ((path_flags.Read(0) & com.epl.geometry.PathFlags.enumClosed) != 0);
LineStringText_(false, b_closed, precision, b_export_zs, b_export_ms, zs, ms, position, paths, 0, @string);
for (int path = 1; path < path_count; path++)
{
@string.Append(", ");
b_closed = ((path_flags.Read(path) & com.epl.geometry.PathFlags.enumClosed) != 0);
LineStringText_(false, b_closed, precision, b_export_zs, b_export_ms, zs, ms, position, paths, path, @string);
}
}
internal static void LineStringTaggedText_(int precision, bool b_export_zs, bool b_export_ms, com.epl.geometry.AttributeStreamOfDbl zs, com.epl.geometry.AttributeStreamOfDbl ms, com.epl.geometry.AttributeStreamOfDbl position, com.epl.geometry.AttributeStreamOfInt8 path_flags,
com.epl.geometry.AttributeStreamOfInt32 paths, System.Text.StringBuilder @string)
{
@string.Append("LINESTRING ");
if (b_export_zs && b_export_ms)
{
@string.Append("ZM ");
}
else
{
if (b_export_zs && !b_export_ms)
{
@string.Append("Z ");
}
else
{
if (!b_export_zs && b_export_ms)
{
@string.Append("M ");
}
}
}
if (position == null)
{
@string.Append("EMPTY");
return;
}
bool b_closed = ((path_flags.Read(0) & com.epl.geometry.PathFlags.enumClosed) != 0);
LineStringText_(false, b_closed, precision, b_export_zs, b_export_ms, zs, ms, position, paths, 0, @string);
}
internal static void MultiLineStringTaggedText_(int precision, bool b_export_zs, bool b_export_ms, com.epl.geometry.AttributeStreamOfDbl zs, com.epl.geometry.AttributeStreamOfDbl ms, com.epl.geometry.AttributeStreamOfDbl position, com.epl.geometry.AttributeStreamOfInt8 path_flags
, com.epl.geometry.AttributeStreamOfInt32 paths, int path_count, System.Text.StringBuilder @string)
{
@string.Append("MULTILINESTRING ");
if (b_export_zs && b_export_ms)
{
@string.Append("ZM ");
}
else
{
if (b_export_zs && !b_export_ms)
{
@string.Append("Z ");
}
else
{
if (!b_export_zs && b_export_ms)
{
@string.Append("M ");
}
}
}
if (position == null)
{
@string.Append("EMPTY");
return;
}
@string.Append('(');
MultiLineStringText_(precision, b_export_zs, b_export_ms, zs, ms, position, path_flags, paths, path_count, @string);
@string.Append(')');
}
internal static com.epl.geometry.Geometry PolygonTaggedText(bool b_multi_polygon, int import_flags, com.epl.geometry.WktParser wkt_parser)
{
com.epl.geometry.MultiPath multi_path;
com.epl.geometry.MultiPathImpl multi_path_impl;
com.epl.geometry.AttributeStreamOfDbl zs = null;
com.epl.geometry.AttributeStreamOfDbl ms = null;
com.epl.geometry.AttributeStreamOfDbl position;
com.epl.geometry.AttributeStreamOfInt32 paths;
com.epl.geometry.AttributeStreamOfInt8 path_flags;
position = (com.epl.geometry.AttributeStreamOfDbl)com.epl.geometry.AttributeStreamBase.CreateDoubleStream(0);
paths = (com.epl.geometry.AttributeStreamOfInt32)com.epl.geometry.AttributeStreamBase.CreateIndexStream(1, 0);
path_flags = (com.epl.geometry.AttributeStreamOfInt8)com.epl.geometry.AttributeStreamBase.CreateByteStream(1, unchecked ((byte)0));
multi_path = new com.epl.geometry.Polygon();
multi_path_impl = (com.epl.geometry.MultiPathImpl)multi_path._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_path_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_path_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_path_impl.AddAttribute(com.epl.geometry.VertexDescription.Semantics.Z);
multi_path_impl.AddAttribute(com.epl.geometry.VertexDescription.Semantics.M);
wkt_parser.NextToken();
}
}
}
int point_count;
if (b_multi_polygon)
{
point_count = MultiPolygonText(zs, ms, position, paths, path_flags, wkt_parser);
}
else
{
point_count = PolygonText(zs, ms, position, paths, path_flags, 0, wkt_parser);
}
if (point_count != 0)
{
System.Diagnostics.Debug.Assert((2 * point_count == position.Size()));
multi_path_impl.SetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION, position);
multi_path_impl.SetPathStreamRef(paths);
multi_path_impl.SetPathFlagsStreamRef(path_flags);
if (zs != null)
{
multi_path_impl.SetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.Z, zs);
}
if (ms != null)
{
multi_path_impl.SetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.M, ms);
}
multi_path_impl.NotifyModified(com.epl.geometry.MultiVertexGeometryImpl.DirtyFlags.DirtyAll);
com.epl.geometry.AttributeStreamOfInt8 path_flags_clone = new com.epl.geometry.AttributeStreamOfInt8(path_flags);
for (int i = 0; i < path_flags_clone.Size() - 1; i++)
{
if (((int)path_flags_clone.Read(i) & (int)com.epl.geometry.PathFlags.enumOGCStartPolygon) != 0)
{
// Should
// be
// clockwise
if (!com.epl.geometry.InternalUtils.IsClockwiseRing(multi_path_impl, i))
{
multi_path_impl.ReversePath(i);
}
}
else
{
// make clockwise
// Should be counter-clockwise
if (com.epl.geometry.InternalUtils.IsClockwiseRing(multi_path_impl, i))
{
multi_path_impl.ReversePath(i);
}
}
}
// make
// counter-clockwise
multi_path_impl.SetPathFlagsStreamRef(path_flags_clone);
}
if ((import_flags & (int)com.epl.geometry.WktImportFlags.wktImportNonTrusted) == 0)
{
multi_path_impl.SetIsSimple(com.epl.geometry.MultiVertexGeometryImpl.GeometryXSimple.Weak, 0.0, false);
}
multi_path_impl.SetDirtyOGCFlags(false);
return(multi_path);
}
public void _updateSegment()
{
if (m_nextSegmentIndex < 0 || m_nextSegmentIndex >= m_segmentCount)
{
throw new System.IndexOutOfRangeException();
}
m_currentSegmentIndex = m_nextSegmentIndex;
int startVertexIndex = GetStartPointIndex();
m_parent._verifyAllStreams();
com.epl.geometry.AttributeStreamOfInt8 segFlagStream = m_parent.GetSegmentFlagsStreamRef();
int segFlag = com.epl.geometry.SegmentFlags.enumLineSeg;
if (segFlagStream != null)
{
segFlag = (segFlagStream.Read(startVertexIndex) & com.epl.geometry.SegmentFlags.enumSegmentMask);
}
com.epl.geometry.VertexDescription vertexDescr = m_parent.GetDescription();
switch (segFlag)
{
case com.epl.geometry.SegmentFlags.enumLineSeg:
{
if (m_line == null)
{
m_line = new com.epl.geometry.Line();
}
m_currentSegment = (com.epl.geometry.Line)m_line;
break;
}
case com.epl.geometry.SegmentFlags.enumBezierSeg:
{
throw com.epl.geometry.GeometryException.GeometryInternalError();
}
case com.epl.geometry.SegmentFlags.enumArcSeg:
{
// break;
throw com.epl.geometry.GeometryException.GeometryInternalError();
}
default:
{
// break;
throw com.epl.geometry.GeometryException.GeometryInternalError();
}
}
m_currentSegment.AssignVertexDescription(vertexDescr);
int endVertexIndex = GetEndPointIndex();
m_parent.GetXY(startVertexIndex, m_dummyPoint);
m_currentSegment.SetStartXY(m_dummyPoint);
m_parent.GetXY(endVertexIndex, m_dummyPoint);
m_currentSegment.SetEndXY(m_dummyPoint);
for (int i = 1, nattr = vertexDescr.GetAttributeCount(); i < nattr; i++)
{
int semantics = vertexDescr.GetSemantics(i);
int ncomp = com.epl.geometry.VertexDescription.GetComponentCount(semantics);
for (int ord = 0; ord < ncomp; ord++)
{
double vs = m_parent.GetAttributeAsDbl(semantics, startVertexIndex, ord);
m_currentSegment.SetStartAttribute(semantics, ord, vs);
double ve = m_parent.GetAttributeAsDbl(semantics, endVertexIndex, ord);
m_currentSegment.SetEndAttribute(semantics, ord, ve);
}
}
}
internal static void PolygonTaggedText_(int precision, bool b_export_zs, bool b_export_ms, com.epl.geometry.AttributeStreamOfDbl zs, com.epl.geometry.AttributeStreamOfDbl ms, com.epl.geometry.AttributeStreamOfDbl position, com.epl.geometry.AttributeStreamOfInt8 path_flags, com.epl.geometry.AttributeStreamOfInt32
paths, int path_count, System.Text.StringBuilder @string)
{
@string.Append("POLYGON ");
if (b_export_zs && b_export_ms)
{
@string.Append("ZM ");
}
else
{
if (b_export_zs && !b_export_ms)
{
@string.Append("Z ");
}
else
{
if (!b_export_zs && b_export_ms)
{
@string.Append("M ");
}
}
}
if (position == null)
{
@string.Append("EMPTY");
return;
}
PolygonText_(precision, b_export_zs, b_export_ms, zs, ms, position, path_flags, paths, 0, path_count, @string);
}
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 static void MultiPolygonText_(int precision, bool b_export_zs, bool b_export_ms, com.epl.geometry.AttributeStreamOfDbl zs, com.epl.geometry.AttributeStreamOfDbl ms, com.epl.geometry.AttributeStreamOfDbl position, com.epl.geometry.AttributeStreamOfInt8 path_flags, com.epl.geometry.AttributeStreamOfInt32
paths, int polygon_count, int path_count, System.Text.StringBuilder @string)
{
int polygon_start = 0;
int polygon_end = 1;
while (polygon_end < path_count && (path_flags.Read(polygon_end) & com.epl.geometry.PathFlags.enumOGCStartPolygon) == 0)
{
polygon_end++;
}
PolygonText_(precision, b_export_zs, b_export_ms, zs, ms, position, path_flags, paths, polygon_start, polygon_end, @string);
for (int ipolygon = 1; ipolygon < polygon_count; ipolygon++)
{
polygon_start = polygon_end;
polygon_end++;
while (polygon_end < path_count && (path_flags.Read(polygon_end) & com.epl.geometry.PathFlags.enumOGCStartPolygon) == 0)
{
polygon_end++;
}
@string.Append(", ");
PolygonText_(precision, b_export_zs, b_export_ms, zs, ms, position, path_flags, paths, polygon_start, polygon_end, @string);
}
}
internal static int LineStringText(bool b_ring, 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 LineStringText
int current_token = wkt_parser.CurrentToken();
int point_count = 0;
if (current_token == com.epl.geometry.WktParser.WktToken.empty)
{
return(point_count);
}
bool b_start_path = true;
double startx = com.epl.geometry.NumberUtils.TheNaN;
double starty = com.epl.geometry.NumberUtils.TheNaN;
double startz = com.epl.geometry.NumberUtils.TheNaN;
double startm = com.epl.geometry.NumberUtils.TheNaN;
current_token = wkt_parser.NextToken();
while (current_token != com.epl.geometry.WktParser.WktToken.right_paren)
{
// At start of x
double x = wkt_parser.CurrentNumericLiteral();
wkt_parser.NextToken();
double y = wkt_parser.CurrentNumericLiteral();
wkt_parser.NextToken();
double z = com.epl.geometry.NumberUtils.TheNaN;
double m = com.epl.geometry.NumberUtils.TheNaN;
if (wkt_parser.HasZs())
{
z = wkt_parser.CurrentNumericLiteral();
wkt_parser.NextToken();
}
if (wkt_parser.HasMs())
{
m = wkt_parser.CurrentNumericLiteral();
wkt_parser.NextToken();
}
current_token = wkt_parser.CurrentToken();
bool b_add_point = true;
if (b_ring && point_count >= 2 && current_token == com.epl.geometry.WktParser.WktToken.right_paren)
{
// If the last point in the ring is not equal to the start
// point, then let's add it.
if ((startx == x || (com.epl.geometry.NumberUtils.IsNaN(startx) && com.epl.geometry.NumberUtils.IsNaN(x))) && (starty == y || (com.epl.geometry.NumberUtils.IsNaN(starty) && com.epl.geometry.NumberUtils.IsNaN(y))) && (!wkt_parser.HasZs() || startz == z || (com.epl.geometry.NumberUtils
.IsNaN(startz) && com.epl.geometry.NumberUtils.IsNaN(z))) && (!wkt_parser.HasMs() || startm == m || (com.epl.geometry.NumberUtils.IsNaN(startm) && com.epl.geometry.NumberUtils.IsNaN(m))))
{
b_add_point = false;
}
}
if (b_add_point)
{
if (b_start_path)
{
b_start_path = false;
startx = x;
starty = y;
startz = z;
startm = m;
}
point_count++;
AddToStreams(zs, ms, position, x, y, z, m);
}
}
if (point_count == 1)
{
point_count++;
AddToStreams(zs, ms, position, startx, starty, startz, startm);
}
paths.Add(position.Size() / 2);
path_flags.Add(unchecked ((byte)0));
return(point_count);
}
internal static void PolygonText_(int precision, bool b_export_zs, bool b_export_ms, com.epl.geometry.AttributeStreamOfDbl zs, com.epl.geometry.AttributeStreamOfDbl ms, com.epl.geometry.AttributeStreamOfDbl position, com.epl.geometry.AttributeStreamOfInt8 path_flags, com.epl.geometry.AttributeStreamOfInt32
paths, int polygon_start, int polygon_end, System.Text.StringBuilder @string)
{
@string.Append('(');
LineStringText_(true, true, precision, b_export_zs, b_export_ms, zs, ms, position, paths, polygon_start, @string);
for (int path = polygon_start + 1; path < polygon_end; path++)
{
@string.Append(", ");
LineStringText_(true, true, precision, b_export_zs, b_export_ms, zs, ms, position, paths, path, @string);
}
@string.Append(')');
}
// Mirrors wkt
private static void MultiLineStringTaggedText_(int precision, bool bFixedPoint, bool b_export_zs, bool b_export_ms, com.epl.geometry.AttributeStreamOfDbl zs, com.epl.geometry.AttributeStreamOfDbl ms, com.epl.geometry.AttributeStreamOfDbl position, com.epl.geometry.AttributeStreamOfInt8
path_flags, com.epl.geometry.AttributeStreamOfInt32 paths, int path_count, com.epl.geometry.JsonWriter json_writer)
{
json_writer.AddFieldName("type");
json_writer.AddValueString("MultiLineString");
json_writer.AddFieldName("coordinates");
if (position == null)
{
json_writer.StartArray();
json_writer.EndArray();
return;
}
json_writer.StartArray();
MultiLineStringText_(precision, bFixedPoint, b_export_zs, b_export_ms, zs, ms, position, path_flags, paths, path_count, json_writer);
json_writer.EndArray();
}
/// <summary>Creates a new attribute stream for storing bytes.</summary>
/// <param name="size">The number of elements in the stream.</param>
/// <param name="defaultValue">The default value to fill the stream with.</param>
public static com.epl.geometry.AttributeStreamBase CreateByteStream(int size, byte defaultValue)
{
com.epl.geometry.AttributeStreamBase newStream = new com.epl.geometry.AttributeStreamOfInt8(size, defaultValue);
return(newStream);
}
// Mirrors wkt
private static void LineStringTaggedText_(int precision, bool bFixedPoint, bool b_export_zs, bool b_export_ms, com.epl.geometry.AttributeStreamOfDbl zs, com.epl.geometry.AttributeStreamOfDbl ms, com.epl.geometry.AttributeStreamOfDbl position, com.epl.geometry.AttributeStreamOfInt8
path_flags, com.epl.geometry.AttributeStreamOfInt32 paths, com.epl.geometry.JsonWriter json_writer)
{
json_writer.AddFieldName("type");
json_writer.AddValueString("LineString");
json_writer.AddFieldName("coordinates");
if (position == null)
{
json_writer.StartArray();
json_writer.EndArray();
return;
}
bool b_closed = ((path_flags.Read(0) & com.epl.geometry.PathFlags.enumClosed) != 0);
LineStringText_(false, b_closed, precision, bFixedPoint, b_export_zs, b_export_ms, zs, ms, position, 0, paths.Read(1), json_writer);
}
public static void TestIntervalTree_RandomConstruction()
{
int pointcount = 0;
int passcount = 1000;
int figureSize = 50;
com.epl.geometry.Envelope env = new com.epl.geometry.Envelope();
env.SetCoords(-10000, -10000, 10000, 10000);
com.epl.geometry.RandomCoordinateGenerator generator = new com.epl.geometry.RandomCoordinateGenerator(System.Math.Max(figureSize, 10000), env, 0.001);
System.Random random = new System.Random(2013);
int rand_max = 98765;
System.Collections.Generic.List <com.epl.geometry.Envelope1D> intervals = new System.Collections.Generic.List <com.epl.geometry.Envelope1D>();
com.epl.geometry.AttributeStreamOfInt8 intervalsFound = new com.epl.geometry.AttributeStreamOfInt8(0);
for (int i = 0; i < passcount; i++)
{
int r = figureSize;
if (r < 3)
{
continue;
}
com.epl.geometry.Polygon poly = new com.epl.geometry.Polygon();
com.epl.geometry.Point pt;
for (int j = 0; j < r; j++)
{
int rand = random.Next(rand_max);
bool bRandomNew = (r > 10) && ((1.0 * rand) / rand_max > 0.95);
pt = generator.GetRandomCoord();
if (j == 0 || bRandomNew)
{
poly.StartPath(pt);
}
else
{
poly.LineTo(pt);
}
}
{
intervals.Clear();
com.epl.geometry.SegmentIterator seg_iter = poly.QuerySegmentIterator();
com.epl.geometry.Envelope1D interval;
com.epl.geometry.Envelope1D range = poly.QueryInterval(com.epl.geometry.VertexDescription.Semantics.POSITION, 0);
range.vmin -= 0.01;
range.vmax += 0.01;
while (seg_iter.NextPath())
{
while (seg_iter.HasNextSegment())
{
com.epl.geometry.Segment segment = seg_iter.NextSegment();
interval = segment.QueryInterval(com.epl.geometry.VertexDescription.Semantics.POSITION, 0);
intervals.Add(interval);
}
}
intervalsFound.Resize(intervals.Count, 0);
// Just test construction for assertions
com.epl.geometry.IntervalTreeImpl intervalTree = new com.epl.geometry.IntervalTreeImpl(true);
Construct(intervalTree, intervals);
for (int j_1 = 0; j_1 < intervals.Count; j_1++)
{
intervalTree.Insert(j_1);
}
com.epl.geometry.IntervalTreeImpl.IntervalTreeIteratorImpl iterator = intervalTree.GetIterator(range, 0.0);
int count = 0;
int handle;
while ((handle = iterator.Next()) != -1)
{
count++;
intervalsFound.Write(handle, unchecked ((byte)1));
}
NUnit.Framework.Assert.IsTrue(count == intervals.Count);
for (int j_2 = 0; j_2 < intervalsFound.Size(); j_2++)
{
interval = intervals[j_2];
NUnit.Framework.Assert.IsTrue(intervalsFound.Read(j_2) == 1);
}
for (int j_3 = 0; j_3 < intervals.Count >> 1; j_3++)
{
intervalTree.Remove(j_3);
}
iterator.ResetIterator(range, 0.0);
count = 0;
while ((handle = iterator.Next()) != -1)
{
count++;
intervalsFound.Write(handle, unchecked ((byte)1));
}
NUnit.Framework.Assert.IsTrue(count == intervals.Count - (intervals.Count >> 1));
for (int j_4 = (intervals.Count >> 1); j_4 < intervals.Count; j_4++)
{
intervalTree.Remove(j_4);
}
}
}
}
/// <exception cref="System.Exception"/>
private static com.epl.geometry.Geometry ImportFromJsonMultiPath(bool b_polygon, 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 multipath: array of array of vertices is expected");
}
com.epl.geometry.MultiPath multipath;
if (b_polygon)
{
multipath = new com.epl.geometry.Polygon();
}
else
{
multipath = new com.epl.geometry.Polyline();
}
com.epl.geometry.AttributeStreamOfInt32 parts = (com.epl.geometry.AttributeStreamOfInt32)com.epl.geometry.AttributeStreamBase.CreateIndexStream(0);
com.epl.geometry.AttributeStreamOfDbl position = (com.epl.geometry.AttributeStreamOfDbl)com.epl.geometry.AttributeStreamBase.CreateDoubleStream(2, 0);
com.epl.geometry.AttributeStreamOfInt8 pathFlags = (com.epl.geometry.AttributeStreamOfInt8)com.epl.geometry.AttributeStreamBase.CreateByteStream(0);
// set up min max variables
double[] buf = new double[4];
double[] start = new double[4];
int point_count = 0;
int path_count = 0;
byte pathFlag = b_polygon ? unchecked ((byte)com.epl.geometry.PathFlags.enumClosed) : 0;
int requiredSize = b_polygon ? 3 : 2;
// At start of rings
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 multipath: ring/path array is expected");
}
int pathPointCount = 0;
bool b_first = true;
int sz = 0;
int szstart = 0;
parser.NextToken();
while (parser.CurrentToken() != 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 multipath: array is expected, rings/paths 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 multipath: each vertex array has to have at least 2 elements");
}
parser.NextToken();
do
{
if (position.Size() == point_count * 2)
{
int c = point_count * 3;
if (c % 2 != 0)
{
c++;
}
// have to be even
if (c < 8)
{
c = 8;
}
else
{
if (c < 32)
{
c = 32;
}
}
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;
// have to be even
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;
// have to be even
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());
}
if (b_first)
{
path_count++;
parts.Add(point_count);
pathFlags.Add(pathFlag);
b_first = false;
szstart = sz;
start[0] = buf[0];
start[1] = buf[1];
start[2] = buf[2];
start[3] = buf[3];
}
point_count++;
pathPointCount++;
}while (pathPointCount < requiredSize && parser.CurrentToken() == com.epl.geometry.JsonReader.Token.END_ARRAY);
}
if (b_polygon && pathPointCount > requiredSize && sz == szstart && start[0] == buf[0] && start[1] == buf[1] && start[2] == buf[2] && start[3] == buf[3])
{
// remove the end point that is equal to the start point.
point_count--;
pathPointCount--;
}
if (pathPointCount == 0)
{
continue;
}
}
// skip empty paths
if (point_count != 0)
{
parts.Resize(path_count);
pathFlags.Resize(path_count);
if (point_count > 0)
{
parts.Add(point_count);
pathFlags.Add(unchecked ((byte)0));
}
com.epl.geometry.MultiPathImpl mp_impl = (com.epl.geometry.MultiPathImpl)multipath._getImpl();
mp_impl.SetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION, position);
mp_impl.SetPathFlagsStreamRef(pathFlags);
mp_impl.SetPathStreamRef(parts);
}
return(multipath);
}
