/// <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);
}
/// <summary>
/// Appends points from another MultiVertexGeometryImpl at the end of this
/// one.
/// </summary>
/// <param name="src">The source MultiVertexGeometryImpl</param>
public void Add(com.epl.geometry.MultiVertexGeometryImpl src, int beginIndex, int endIndex)
{
int endIndexC = endIndex < 0 ? src.GetPointCount() : endIndex;
if (beginIndex < 0 || beginIndex > src.GetPointCount() || endIndexC < beginIndex)
{
throw new System.ArgumentException();
}
if (beginIndex == endIndexC)
{
return;
}
MergeVertexDescription(src.GetDescription());
int count = endIndexC - beginIndex;
int oldPointCount = m_pointCount;
Resize(m_pointCount + count);
_verifyAllStreams();
for (int iattrib = 0, nattrib = src.GetDescription().GetAttributeCount(); iattrib < nattrib; iattrib++)
{
int semantics = src.GetDescription()._getSemanticsImpl(iattrib);
int ncomps = com.epl.geometry.VertexDescription.GetComponentCount(semantics);
com.epl.geometry.AttributeStreamBase stream = GetAttributeStreamRef(semantics);
com.epl.geometry.AttributeStreamBase srcStream = src.GetAttributeStreamRef(semantics);
stream.InsertRange(oldPointCount * ncomps, srcStream, beginIndex * ncomps, count * ncomps, true, 1, oldPointCount * ncomps);
}
}
private static int QuickTest2DMVEnvelopeRasterOnly(com.epl.geometry.MultiVertexGeometry geomA, com.epl.geometry.Envelope2D geomBEnv, double tolerance)
{
// Use rasterized Geometry only:
com.epl.geometry.RasterizedGeometry2D rgeomA;
com.epl.geometry.MultiVertexGeometryImpl mpImpl = (com.epl.geometry.MultiVertexGeometryImpl)geomA._getImpl();
com.epl.geometry.GeometryAccelerators gaccel = mpImpl._getAccelerators();
if (gaccel != null)
{
rgeomA = gaccel.GetRasterizedGeometry();
}
else
{
return(-1);
}
if (rgeomA != null)
{
com.epl.geometry.RasterizedGeometry2D.HitType hitres = rgeomA.QueryEnvelopeInGeometry(geomBEnv);
if (hitres == com.epl.geometry.RasterizedGeometry2D.HitType.Outside)
{
return((int)com.epl.geometry.OperatorInternalRelationUtils.Relation.Disjoint);
}
if (hitres == com.epl.geometry.RasterizedGeometry2D.HitType.Inside)
{
return((int)com.epl.geometry.OperatorInternalRelationUtils.Relation.Contains);
}
}
else
{
return(-1);
}
return(0);
}
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);
}
/// <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");
}
}
public override void CopyTo(com.epl.geometry.Geometry dstGeom)
{
com.epl.geometry.MultiVertexGeometryImpl dst = (com.epl.geometry.MultiVertexGeometryImpl)dstGeom;
if (dst.GetType() != GetType())
{
throw new System.ArgumentException();
}
_copyToUnsafe(dst);
}
internal static com.epl.geometry.RasterizedGeometry2D Create(com.epl.geometry.MultiVertexGeometryImpl geom, double toleranceXY, int rasterSizeBytes)
{
if (!CanUseAccelerator(geom))
{
throw new System.ArgumentException();
}
com.epl.geometry.RasterizedGeometry2DImpl gc = com.epl.geometry.RasterizedGeometry2DImpl.CreateImpl(geom, toleranceXY, rasterSizeBytes);
return((com.epl.geometry.RasterizedGeometry2D)gc);
}
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 override bool Equals(object other)
{
// Java checks
if (other == this)
{
return(true);
}
if (!(other is com.epl.geometry.MultiVertexGeometryImpl))
{
return(false);
}
com.epl.geometry.MultiVertexGeometryImpl otherMulti = (com.epl.geometry.MultiVertexGeometryImpl)other;
if (!(m_description.Equals(otherMulti.m_description)))
{
return(false);
}
if (IsEmptyImpl() != otherMulti.IsEmptyImpl())
{
return(false);
}
if (IsEmptyImpl())
{
return(true);
}
// both geometries are empty
int pointCount = GetPointCount();
int pointCountOther = otherMulti.GetPointCount();
if (pointCount != pointCountOther)
{
return(false);
}
for (int i = 0; i < m_description.GetAttributeCount(); i++)
{
int semantics = m_description.GetSemantics(i);
com.epl.geometry.AttributeStreamBase stream = GetAttributeStreamRef(semantics);
com.epl.geometry.AttributeStreamBase streamOther = otherMulti.GetAttributeStreamRef(semantics);
int components = com.epl.geometry.VertexDescription.GetComponentCount(semantics);
if (!stream.Equals(streamOther, 0, pointCount * components))
{
return(false);
}
}
return(true);
}
//Does not check geometry type. Used to copy Polygon to Polyline
internal virtual void _copyToUnsafe(com.epl.geometry.MultiVertexGeometryImpl dst)
{
_verifyAllStreams();
dst.m_description = m_description;
dst.m_vertexAttributes = null;
int nattrib = m_description.GetAttributeCount();
com.epl.geometry.AttributeStreamBase[] cloneAttributes = null;
if (m_vertexAttributes != null)
{
cloneAttributes = new com.epl.geometry.AttributeStreamBase[nattrib];
for (int i = 0; i < nattrib; i++)
{
if (m_vertexAttributes[i] != null)
{
int ncomps = com.epl.geometry.VertexDescription.GetComponentCount(m_description._getSemanticsImpl(i));
cloneAttributes[i] = m_vertexAttributes[i].RestrictedClone(GetPointCount() * ncomps);
}
}
}
if (m_envelope != null)
{
dst.m_envelope = (com.epl.geometry.Envelope)m_envelope.CreateInstance();
m_envelope.CopyTo(dst.m_envelope);
}
else
{
// dst.m_envelope = (Envelope) m_envelope.clone();
dst.m_envelope = null;
}
dst.m_pointCount = m_pointCount;
dst.m_flagsMask = m_flagsMask;
dst.m_vertexAttributes = cloneAttributes;
try
{
_copyToImpl(dst);
}
catch (System.Exception ex)
{
// copy child props
dst.SetEmpty();
throw new System.Exception("", ex);
}
}
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());
}
// TODO Remove? /// <summary>\internal CHildren implement this method to copy additional information</summary> internal abstract void _copyToImpl(com.epl.geometry.MultiVertexGeometryImpl mvg);
internal void Init(com.epl.geometry.MultiVertexGeometryImpl geom, double toleranceXY, int rasterSizeBytes)
{
// _ASSERT(CanUseAccelerator(geom));
m_width = System.Math.Max((int)(System.Math.Sqrt(rasterSizeBytes) * 2 + 0.5), 64);
m_scanLineSize = (m_width * 2 + 31) / 32;
// 2 bits per pixel
m_geomEnv = new com.epl.geometry.Envelope2D();
m_toleranceXY = toleranceXY;
// calculate bitmap size
int size = 0;
int width = m_width;
int scanLineSize = m_scanLineSize;
while (width >= 8)
{
size += width * scanLineSize;
width /= 2;
scanLineSize = (width * 2 + 31) / 32;
}
// allocate the bitmap, that contains the base and the mip-levels
m_bitmap = new int[size];
for (int i = 0; i < size; i++)
{
m_bitmap[i] = 0;
}
m_rasterizer = new com.epl.geometry.SimpleRasterizer();
com.epl.geometry.RasterizedGeometry2DImpl.ScanCallbackImpl callback = new com.epl.geometry.RasterizedGeometry2DImpl.ScanCallbackImpl(this, m_bitmap, m_scanLineSize);
m_callback = callback;
m_rasterizer.Setup(m_width, m_width, callback);
geom.QueryEnvelope2D(m_geomEnv);
if (m_geomEnv.GetWidth() > m_width * m_geomEnv.GetHeight() || m_geomEnv.GetHeight() > m_geomEnv.GetWidth() * m_width)
{
}
// the geometry is thin and the rasterizer is not needed.
m_geomEnv.Inflate(toleranceXY, toleranceXY);
com.epl.geometry.Envelope2D worldEnv = new com.epl.geometry.Envelope2D();
com.epl.geometry.Envelope2D pixEnv = com.epl.geometry.Envelope2D.Construct(1, 1, m_width - 2, m_width - 2);
double minWidth = toleranceXY * pixEnv.GetWidth();
// min width is such
// that the size of
// one pixel is
// equal to the
// tolerance
double minHeight = toleranceXY * pixEnv.GetHeight();
worldEnv.SetCoords(m_geomEnv.GetCenter(), System.Math.Max(minWidth, m_geomEnv.GetWidth()), System.Math.Max(minHeight, m_geomEnv.GetHeight()));
m_stroke_half_widthX_pix = worldEnv.GetWidth() / pixEnv.GetWidth();
m_stroke_half_widthY_pix = worldEnv.GetHeight() / pixEnv.GetHeight();
// The stroke half width. Later it will be inflated to account for
// pixels size.
m_stroke_half_width = m_toleranceXY;
m_transform = new com.epl.geometry.Transformation2D();
m_transform.InitializeFromRect(worldEnv, pixEnv);
// geom to pixels
com.epl.geometry.Transformation2D identityTransform = new com.epl.geometry.Transformation2D();
switch (geom.GetType().Value())
{
case com.epl.geometry.Geometry.GeometryType.MultiPoint:
{
callback.SetColor(m_rasterizer, 2);
FillPoints(m_rasterizer, (com.epl.geometry.MultiPointImpl)geom, m_stroke_half_width);
break;
}
case com.epl.geometry.Geometry.GeometryType.Polyline:
{
callback.SetColor(m_rasterizer, 2);
StrokeDrawPolyPath(m_rasterizer, (com.epl.geometry.MultiPathImpl)geom._getImpl(), m_stroke_half_width);
break;
}
case com.epl.geometry.Geometry.GeometryType.Polygon:
{
bool isWinding = false;
// NOTE: change when winding is supported
callback.SetColor(m_rasterizer, 1);
FillMultiPath(m_rasterizer, m_transform, (com.epl.geometry.MultiPathImpl)geom, isWinding);
callback.SetColor(m_rasterizer, 2);
StrokeDrawPolyPath(m_rasterizer, (com.epl.geometry.MultiPathImpl)geom._getImpl(), m_stroke_half_width);
break;
}
}
m_dx = m_transform.xx;
m_dy = m_transform.yy;
m_x0 = m_transform.xd;
m_y0 = m_transform.yd;
BuildLevels();
}
public static int QuickTest2D_Accelerated_DisjointOrContains(com.epl.geometry.Geometry geomA, com.epl.geometry.Geometry geomB, double tolerance)
{
int gtA = geomA.GetType().Value();
int gtB = geomB.GetType().Value();
com.epl.geometry.GeometryAccelerators accel;
bool endWhileStatement = false;
do
{
if (com.epl.geometry.Geometry.IsMultiVertex(gtA))
{
com.epl.geometry.MultiVertexGeometryImpl impl = (com.epl.geometry.MultiVertexGeometryImpl)geomA._getImpl();
accel = impl._getAccelerators();
if (accel != null)
{
com.epl.geometry.RasterizedGeometry2D rgeom = accel.GetRasterizedGeometry();
if (rgeom != null)
{
if (gtB == com.epl.geometry.Geometry.GeometryType.Point)
{
com.epl.geometry.Point2D ptB = ((com.epl.geometry.Point)geomB).GetXY();
com.epl.geometry.RasterizedGeometry2D.HitType hit = rgeom.QueryPointInGeometry(ptB.x, ptB.y);
if (hit == com.epl.geometry.RasterizedGeometry2D.HitType.Inside)
{
return((int)com.epl.geometry.OperatorInternalRelationUtils.Relation.Contains);
}
else
{
if (hit == com.epl.geometry.RasterizedGeometry2D.HitType.Outside)
{
return((int)com.epl.geometry.OperatorInternalRelationUtils.Relation.Disjoint);
}
}
break;
}
com.epl.geometry.Envelope2D envB = new com.epl.geometry.Envelope2D();
geomB.QueryEnvelope2D(envB);
com.epl.geometry.RasterizedGeometry2D.HitType hit_1 = rgeom.QueryEnvelopeInGeometry(envB);
if (hit_1 == com.epl.geometry.RasterizedGeometry2D.HitType.Inside)
{
return((int)com.epl.geometry.OperatorInternalRelationUtils.Relation.Contains);
}
else
{
if (hit_1 == com.epl.geometry.RasterizedGeometry2D.HitType.Outside)
{
return((int)com.epl.geometry.OperatorInternalRelationUtils.Relation.Disjoint);
}
}
break;
}
}
}
}while (endWhileStatement);
accel = null;
do
{
if (com.epl.geometry.Geometry.IsMultiVertex(gtB))
{
com.epl.geometry.MultiVertexGeometryImpl impl = (com.epl.geometry.MultiVertexGeometryImpl)geomB._getImpl();
accel = impl._getAccelerators();
if (accel != null)
{
com.epl.geometry.RasterizedGeometry2D rgeom = accel.GetRasterizedGeometry();
if (rgeom != null)
{
if (gtA == com.epl.geometry.Geometry.GeometryType.Point)
{
com.epl.geometry.Point2D ptA = ((com.epl.geometry.Point)geomA).GetXY();
com.epl.geometry.RasterizedGeometry2D.HitType hit = rgeom.QueryPointInGeometry(ptA.x, ptA.y);
if (hit == com.epl.geometry.RasterizedGeometry2D.HitType.Inside)
{
return((int)com.epl.geometry.OperatorInternalRelationUtils.Relation.Within);
}
else
{
if (hit == com.epl.geometry.RasterizedGeometry2D.HitType.Outside)
{
return((int)com.epl.geometry.OperatorInternalRelationUtils.Relation.Disjoint);
}
}
break;
}
com.epl.geometry.Envelope2D envA = new com.epl.geometry.Envelope2D();
geomA.QueryEnvelope2D(envA);
com.epl.geometry.RasterizedGeometry2D.HitType hit_1 = rgeom.QueryEnvelopeInGeometry(envA);
if (hit_1 == com.epl.geometry.RasterizedGeometry2D.HitType.Inside)
{
return((int)com.epl.geometry.OperatorInternalRelationUtils.Relation.Within);
}
else
{
if (hit_1 == com.epl.geometry.RasterizedGeometry2D.HitType.Outside)
{
return((int)com.epl.geometry.OperatorInternalRelationUtils.Relation.Disjoint);
}
}
break;
}
}
}
}while (endWhileStatement);
return(0);
}
internal static com.epl.geometry.MapGeometry ImportFromJsonParser(int gt, com.epl.geometry.JsonReader parser)
{
com.epl.geometry.MapGeometry mp;
try
{
if (!com.epl.geometry.JSONUtils.IsObjectStart(parser))
{
return(null);
}
bool bFoundSpatial_reference = false;
bool bFoundHasZ = false;
bool bFoundHasM = false;
bool bFoundPolygon = false;
bool bFoundPolyline = false;
bool bFoundMultiPoint = false;
bool bFoundX = false;
bool bFoundY = false;
bool bFoundZ = false;
bool bFoundM = false;
bool bFoundXMin = false;
bool bFoundYMin = false;
bool bFoundXMax = false;
bool bFoundYMax = false;
bool bFoundZMin = false;
bool bFoundZMax = false;
bool bFoundMMin = false;
bool bFoundMMax = false;
double x = com.epl.geometry.NumberUtils.NaN();
double y = com.epl.geometry.NumberUtils.NaN();
double z = com.epl.geometry.NumberUtils.NaN();
double m = com.epl.geometry.NumberUtils.NaN();
double xmin = com.epl.geometry.NumberUtils.NaN();
double ymin = com.epl.geometry.NumberUtils.NaN();
double xmax = com.epl.geometry.NumberUtils.NaN();
double ymax = com.epl.geometry.NumberUtils.NaN();
double zmin = com.epl.geometry.NumberUtils.NaN();
double zmax = com.epl.geometry.NumberUtils.NaN();
double mmin = com.epl.geometry.NumberUtils.NaN();
double mmax = com.epl.geometry.NumberUtils.NaN();
bool bHasZ = false;
bool bHasM = false;
com.epl.geometry.AttributeStreamOfDbl @as = (com.epl.geometry.AttributeStreamOfDbl)com.epl.geometry.AttributeStreamBase.CreateDoubleStream(0);
com.epl.geometry.AttributeStreamOfDbl bs = (com.epl.geometry.AttributeStreamOfDbl)com.epl.geometry.AttributeStreamBase.CreateDoubleStream(0);
com.epl.geometry.Geometry geometry = null;
com.epl.geometry.SpatialReference spatial_reference = null;
while (parser.NextToken() != com.epl.geometry.JsonReader.Token.END_OBJECT)
{
string name = parser.CurrentString();
parser.NextToken();
if (!bFoundSpatial_reference && name.Equals("spatialReference"))
{
bFoundSpatial_reference = true;
if (parser.CurrentToken() == com.epl.geometry.JsonReader.Token.START_OBJECT)
{
spatial_reference = com.epl.geometry.SpatialReference.FromJson(parser);
}
else
{
if (parser.CurrentToken() != com.epl.geometry.JsonReader.Token.VALUE_NULL)
{
throw new com.epl.geometry.GeometryException("failed to parse spatial reference: object or null is expected");
}
}
}
else
{
if (!bFoundHasZ && name.Equals("hasZ"))
{
bFoundHasZ = true;
bHasZ = (parser.CurrentToken() == com.epl.geometry.JsonReader.Token.VALUE_TRUE);
}
else
{
if (!bFoundHasM && name.Equals("hasM"))
{
bFoundHasM = true;
bHasM = (parser.CurrentToken() == com.epl.geometry.JsonReader.Token.VALUE_TRUE);
}
else
{
if (!bFoundPolygon && name.Equals("rings") && (gt == com.epl.geometry.Geometry.GeometryType.Unknown || gt == com.epl.geometry.Geometry.GeometryType.Polygon))
{
bFoundPolygon = true;
geometry = ImportFromJsonMultiPath(true, parser, @as, bs);
continue;
}
else
{
if (!bFoundPolyline && name.Equals("paths") && (gt == com.epl.geometry.Geometry.GeometryType.Unknown || gt == com.epl.geometry.Geometry.GeometryType.Polyline))
{
bFoundPolyline = true;
geometry = ImportFromJsonMultiPath(false, parser, @as, bs);
continue;
}
else
{
if (!bFoundMultiPoint && name.Equals("points") && (gt == com.epl.geometry.Geometry.GeometryType.Unknown || gt == com.epl.geometry.Geometry.GeometryType.MultiPoint))
{
bFoundMultiPoint = true;
geometry = ImportFromJsonMultiPoint(parser, @as, bs);
continue;
}
else
{
if (!bFoundX && name.Equals("x") && (gt == com.epl.geometry.Geometry.GeometryType.Unknown || gt == com.epl.geometry.Geometry.GeometryType.Point))
{
bFoundX = true;
x = ReadDouble(parser);
}
else
{
if (!bFoundY && name.Equals("y") && (gt == com.epl.geometry.Geometry.GeometryType.Unknown || gt == com.epl.geometry.Geometry.GeometryType.Point))
{
bFoundY = true;
y = ReadDouble(parser);
}
else
{
if (!bFoundZ && name.Equals("z") && (gt == com.epl.geometry.Geometry.GeometryType.Unknown || gt == com.epl.geometry.Geometry.GeometryType.Point))
{
bFoundZ = true;
z = ReadDouble(parser);
}
else
{
if (!bFoundM && name.Equals("m") && (gt == com.epl.geometry.Geometry.GeometryType.Unknown || gt == com.epl.geometry.Geometry.GeometryType.Point))
{
bFoundM = true;
m = ReadDouble(parser);
}
}
}
}
}
}
}
}
}
}
if (!bFoundXMin && name.Equals("xmin") && (gt == com.epl.geometry.Geometry.GeometryType.Unknown || gt == com.epl.geometry.Geometry.GeometryType.Envelope))
{
bFoundXMin = true;
xmin = ReadDouble(parser);
}
else
{
if (!bFoundYMin && name.Equals("ymin") && (gt == com.epl.geometry.Geometry.GeometryType.Unknown || gt == com.epl.geometry.Geometry.GeometryType.Envelope))
{
bFoundYMin = true;
ymin = ReadDouble(parser);
}
else
{
if (!bFoundMMin && name.Equals("mmin") && (gt == com.epl.geometry.Geometry.GeometryType.Unknown || gt == com.epl.geometry.Geometry.GeometryType.Envelope))
{
bFoundMMin = true;
mmin = ReadDouble(parser);
}
else
{
if (!bFoundZMin && name.Equals("zmin") && (gt == com.epl.geometry.Geometry.GeometryType.Unknown || gt == com.epl.geometry.Geometry.GeometryType.Envelope))
{
bFoundZMin = true;
zmin = ReadDouble(parser);
}
else
{
if (!bFoundXMax && name.Equals("xmax") && (gt == com.epl.geometry.Geometry.GeometryType.Unknown || gt == com.epl.geometry.Geometry.GeometryType.Envelope))
{
bFoundXMax = true;
xmax = ReadDouble(parser);
}
else
{
if (!bFoundYMax && name.Equals("ymax") && (gt == com.epl.geometry.Geometry.GeometryType.Unknown || gt == com.epl.geometry.Geometry.GeometryType.Envelope))
{
bFoundYMax = true;
ymax = ReadDouble(parser);
}
else
{
if (!bFoundMMax && name.Equals("mmax") && (gt == com.epl.geometry.Geometry.GeometryType.Unknown || gt == com.epl.geometry.Geometry.GeometryType.Envelope))
{
bFoundMMax = true;
mmax = ReadDouble(parser);
}
else
{
if (!bFoundZMax && name.Equals("zmax") && (gt == com.epl.geometry.Geometry.GeometryType.Unknown || gt == com.epl.geometry.Geometry.GeometryType.Envelope))
{
bFoundZMax = true;
zmax = ReadDouble(parser);
}
else
{
Windup(parser);
}
}
}
}
}
}
}
}
}
if (bFoundPolygon || bFoundPolyline || bFoundMultiPoint)
{
System.Diagnostics.Debug.Assert((geometry != null));
com.epl.geometry.MultiVertexGeometryImpl mvImpl = (com.epl.geometry.MultiVertexGeometryImpl)geometry._getImpl();
com.epl.geometry.AttributeStreamBase zs = null;
com.epl.geometry.AttributeStreamBase ms = null;
if (bHasZ)
{
geometry.AddAttribute(com.epl.geometry.VertexDescription.Semantics.Z);
zs = @as;
}
if (bHasM)
{
geometry.AddAttribute(com.epl.geometry.VertexDescription.Semantics.M);
ms = !bHasZ ? @as : bs;
}
if (bHasZ && zs != null)
{
mvImpl.SetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.Z, zs);
}
if (bHasM && ms != null)
{
mvImpl.SetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.M, ms);
}
mvImpl.NotifyModified(com.epl.geometry.MultiVertexGeometryImpl.DirtyFlags.DirtyAll);
}
else
{
if (bFoundX || bFoundY || bFoundY || bFoundZ)
{
if (com.epl.geometry.NumberUtils.IsNaN(y))
{
x = com.epl.geometry.NumberUtils.NaN();
}
com.epl.geometry.Point p = new com.epl.geometry.Point(x, y);
if (bFoundZ)
{
p.SetZ(z);
}
if (bFoundM)
{
p.SetM(m);
}
geometry = p;
}
else
{
if (bFoundXMin || bFoundYMin || bFoundXMax || bFoundYMax || bFoundZMin || bFoundZMax || bFoundMMin || bFoundMMax)
{
if (com.epl.geometry.NumberUtils.IsNaN(ymin) || com.epl.geometry.NumberUtils.IsNaN(xmax) || com.epl.geometry.NumberUtils.IsNaN(ymax))
{
xmin = com.epl.geometry.NumberUtils.NaN();
}
com.epl.geometry.Envelope e = new com.epl.geometry.Envelope(xmin, ymin, xmax, ymax);
if (bFoundZMin && bFoundZMax)
{
e.SetInterval(com.epl.geometry.VertexDescription.Semantics.Z, 0, zmin, zmax);
}
if (bFoundMMin && bFoundMMax)
{
e.SetInterval(com.epl.geometry.VertexDescription.Semantics.M, 0, mmin, mmax);
}
geometry = e;
}
}
}
mp = new com.epl.geometry.MapGeometry(geometry, spatial_reference);
}
catch (System.Exception)
{
return(null);
}
return(mp);
}
private RasterizedGeometry2DImpl(com.epl.geometry.MultiVertexGeometryImpl geom, double toleranceXY, int rasterSizeBytes)
{
Init(geom, toleranceXY, rasterSizeBytes);
}
internal static com.epl.geometry.RasterizedGeometry2DImpl CreateImpl(com.epl.geometry.MultiVertexGeometryImpl geom, double toleranceXY, int rasterSizeBytes)
{
com.epl.geometry.RasterizedGeometry2DImpl rgImpl = new com.epl.geometry.RasterizedGeometry2DImpl(geom, toleranceXY, rasterSizeBytes);
return(rgImpl);
}
/// <summary>Static method to construct the convex hull of a Multi_vertex_geometry.</summary>
/// <remarks>
/// Static method to construct the convex hull of a Multi_vertex_geometry.
/// Returns a Geometry.
/// \param mvg The geometry used to create the convex hull.
/// </remarks>
internal static com.epl.geometry.Geometry Construct(com.epl.geometry.MultiVertexGeometry mvg)
{
if (mvg.IsEmpty())
{
return(new com.epl.geometry.Polygon(mvg.GetDescription()));
}
com.epl.geometry.MultiVertexGeometryImpl mvg_impl = (com.epl.geometry.MultiVertexGeometryImpl)mvg._getImpl();
int N = mvg_impl.GetPointCount();
if (N <= 2)
{
if (N == 1 || mvg_impl.GetXY(0).Equals(mvg_impl.GetXY(1)))
{
com.epl.geometry.Point point = new com.epl.geometry.Point(mvg_impl.GetDescription());
mvg_impl.GetPointByVal(0, point);
return(point);
}
else
{
com.epl.geometry.Point pt = new com.epl.geometry.Point();
com.epl.geometry.Polyline polyline = new com.epl.geometry.Polyline(mvg_impl.GetDescription());
mvg_impl.GetPointByVal(0, pt);
polyline.StartPath(pt);
mvg_impl.GetPointByVal(1, pt);
polyline.LineTo(pt);
return(polyline);
}
}
com.epl.geometry.AttributeStreamOfDbl stream = (com.epl.geometry.AttributeStreamOfDbl)mvg_impl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION);
com.epl.geometry.ConvexHull convex_hull = new com.epl.geometry.ConvexHull(stream, N);
int t0 = 0;
int tm = 1;
com.epl.geometry.Point2D pt_0 = new com.epl.geometry.Point2D();
com.epl.geometry.Point2D pt_m = new com.epl.geometry.Point2D();
com.epl.geometry.Point2D pt_p = new com.epl.geometry.Point2D();
stream.Read(t0 << 1, pt_0);
while (true)
{
if (tm >= N)
{
break;
}
stream.Read(tm << 1, pt_m);
if (!pt_m.IsEqual(pt_0, com.epl.geometry.NumberUtils.DoubleEps()))
{
break;
}
tm++;
}
// We don't want to close the gap between t0 and tm.
convex_hull.m_tree_hull.AddElement(t0, -1);
if (tm < N)
{
convex_hull.m_tree_hull.AddBiggestElement(tm, -1);
for (int tp = tm + 1; tp < mvg_impl.GetPointCount(); tp++)
{
// Dynamically insert into the current convex hull
stream.Read(tp << 1, pt_p);
int p = convex_hull.TreeHull_(pt_p);
if (p != -1)
{
convex_hull.m_tree_hull.SetElement(p, tp);
}
}
}
// reset the place holder to the point index.
// Extracts the convex hull from the tree. Reading the tree in order from first to last is the resulting convex hull.
com.epl.geometry.VertexDescription description = mvg_impl.GetDescription();
bool b_has_attributes = (description.GetAttributeCount() > 1);
int point_count = convex_hull.m_tree_hull.Size(-1);
com.epl.geometry.Geometry hull;
if (point_count >= 2)
{
if (point_count >= 3)
{
hull = new com.epl.geometry.Polygon(description);
}
else
{
hull = new com.epl.geometry.Polyline(description);
}
com.epl.geometry.MultiPathImpl hull_impl = (com.epl.geometry.MultiPathImpl)hull._getImpl();
hull_impl.AddPath((com.epl.geometry.Point2D[])null, 0, true);
com.epl.geometry.Point point = null;
if (b_has_attributes)
{
point = new com.epl.geometry.Point();
}
for (int i = convex_hull.m_tree_hull.GetFirst(-1); i != -1; i = convex_hull.m_tree_hull.GetNext(i))
{
if (b_has_attributes)
{
mvg_impl.GetPointByVal(convex_hull.m_tree_hull.GetElement(i), point);
hull_impl.InsertPoint(0, -1, point);
}
else
{
stream.Read(convex_hull.m_tree_hull.GetElement(i) << 1, pt_p);
hull_impl.InsertPoint(0, -1, pt_p);
}
}
}
else
{
System.Diagnostics.Debug.Assert((point_count == 1));
if (b_has_attributes)
{
com.epl.geometry.Point point = new com.epl.geometry.Point(description);
mvg_impl.GetPointByVal(convex_hull.m_tree_hull.GetElement(convex_hull.m_tree_hull.GetFirst(-1)), point);
hull = point;
}
else
{
stream.Read(convex_hull.m_tree_hull.GetElement(convex_hull.m_tree_hull.GetFirst(-1)) << 1, pt_p);
hull = new com.epl.geometry.Point(pt_p);
}
}
return(hull);
}
internal override void _copyToImpl(com.epl.geometry.MultiVertexGeometryImpl mvg)
{
}
