internal double CalculateZToleranceFromGeometry(com.epl.geometry.SpatialReference sr, com.epl.geometry.Geometry geometry)
{
com.epl.geometry.Envelope1D env1D = geometry.QueryInterval(com.epl.geometry.VertexDescription.Semantics.Z, 0);
double tolerance = env1D._calculateToleranceFromEnvelope();
return(System.Math.Max(sr != null ? sr.GetTolerance(com.epl.geometry.VertexDescription.Semantics.Z) : 0, tolerance));
}
/// <summary>Merges this envelope with the extent of the given envelope.</summary>
/// <remarks>
/// Merges this envelope with the extent of the given envelope. If this
/// envelope is empty, the coordinates of the given envelope
/// are assigned. If the given envelope is empty, this envelope is unchanged.
/// </remarks>
/// <param name="other">The envelope to merge.</param>
public virtual void Merge(com.epl.geometry.Envelope other)
{
_touch();
if (other.IsEmpty())
{
return;
}
com.epl.geometry.VertexDescription otherVD = other.m_description;
if (otherVD != m_description)
{
MergeVertexDescription(otherVD);
}
m_envelope.Merge(other.m_envelope);
for (int iattrib = 1, nattrib = otherVD.GetAttributeCount(); iattrib < nattrib; iattrib++)
{
int semantics = otherVD.GetSemantics(iattrib);
int ncomps = com.epl.geometry.VertexDescription.GetComponentCount(semantics);
for (int iord = 0; iord < ncomps; iord++)
{
com.epl.geometry.Envelope1D intervalOther = other.QueryInterval(semantics, iord);
com.epl.geometry.Envelope1D interval = QueryInterval(semantics, iord);
interval.Merge(intervalOther);
SetInterval(semantics, iord, interval);
}
}
}
public void Merge(com.epl.geometry.Envelope1D other)
{
if (other.IsEmpty())
{
return;
}
if (IsEmpty())
{
vmin = other.vmin;
vmax = other.vmax;
return;
}
if (vmin > other.vmin)
{
vmin = other.vmin;
}
if (vmax < other.vmax)
{
vmax = other.vmax;
}
if (vmin > vmax)
{
SetEmpty();
}
}
public virtual void SetInterval(int semantics, int ordinate, com.epl.geometry.Envelope1D env)
{
_touch();
if (semantics == com.epl.geometry.VertexDescription.Semantics.POSITION)
{
if (ordinate == 0)
{
m_envelope.xmin = env.vmin;
m_envelope.xmax = env.vmax;
}
else
{
if (ordinate == 1)
{
m_envelope.ymin = env.vmin;
m_envelope.ymax = env.vmax;
}
else
{
throw new System.IndexOutOfRangeException();
}
}
}
else
{
_setAttributeAsDbl(0, semantics, ordinate, env.vmin);
_setAttributeAsDbl(1, semantics, ordinate, env.vmax);
}
}
/// <summary>Merges this envelope with the point.</summary>
/// <remarks>
/// Merges this envelope with the point. The boundary of the envelope is
/// increased to include the point. If the envelope is empty, the coordinates
/// of the point to merge are assigned. If the point is empty, the original
/// envelope is unchanged.
/// </remarks>
/// <param name="point">The point to be merged.</param>
public virtual void Merge(com.epl.geometry.Point point)
{
_touch();
if (point.IsEmptyImpl())
{
return;
}
com.epl.geometry.VertexDescription pointVD = point.m_description;
if (m_description != pointVD)
{
MergeVertexDescription(pointVD);
}
if (IsEmpty())
{
_setFromPoint(point);
return;
}
m_envelope.Merge(point.GetXY());
for (int iattrib = 1, nattrib = pointVD.GetAttributeCount(); iattrib < nattrib; iattrib++)
{
int semantics = pointVD._getSemanticsImpl(iattrib);
int ncomps = com.epl.geometry.VertexDescription.GetComponentCount(semantics);
for (int iord = 0; iord < ncomps; iord++)
{
double v = point.GetAttributeAsDbl(semantics, iord);
com.epl.geometry.Envelope1D interval = QueryInterval(semantics, iord);
interval.Merge(v);
SetInterval(semantics, iord, interval);
}
}
}
internal SimpleEdge()
{
m_value = -1;
m_line = new com.epl.geometry.Line();
m_dxdy = 55555555;
m_b_horizontal = false;
m_b_curve = false;
m_env = new com.epl.geometry.Envelope1D();
m_env.SetCoordsNoNaN_(0, 0);
}
public void QueryIntervalY(com.epl.geometry.Envelope1D env1D)
{
if (IsEmpty())
{
env1D.SetEmpty();
}
else
{
env1D.SetCoords(ymin, ymax);
}
}
// Checked vs. Jan 11, 2011
public override com.epl.geometry.Envelope1D QueryInterval(int semantics, int ordinate)
{
com.epl.geometry.Envelope1D env = new com.epl.geometry.Envelope1D();
if (IsEmptyImpl())
{
env.SetEmpty();
return(env);
}
_updateAllDirtyIntervals(true);
return(m_envelope.QueryInterval(semantics, ordinate));
}
public void SetCoords(com.epl.geometry.Envelope1D xinterval, com.epl.geometry.Envelope1D yinterval)
{
if (xinterval.IsEmpty() || yinterval.IsEmpty())
{
SetEmpty();
return;
}
xmin = xinterval.vmin;
xmax = xinterval.vmax;
ymin = yinterval.vmin;
ymax = yinterval.vmax;
}
// Checked vs. Jan 11, 2011
/// <param name="bExact">
/// True, when the exact envelope need to be calculated and false
/// for the loose one.
/// </param>
protected internal virtual void _updateAllDirtyIntervals(bool bExact)
{
_verifyAllStreams();
if (_hasDirtyFlag(com.epl.geometry.MultiVertexGeometryImpl.DirtyFlags.DirtyIntervals))
{
if (null == m_envelope)
{
m_envelope = new com.epl.geometry.Envelope(m_description);
}
else
{
m_envelope.AssignVertexDescription(m_description);
}
if (IsEmpty())
{
m_envelope.SetEmpty();
return;
}
_updateXYImpl(bExact);
// efficient method for xy's
// now go through other attribues.
for (int attributeIndex = 1; attributeIndex < m_description.GetAttributeCount(); attributeIndex++)
{
int semantics = m_description._getSemanticsImpl(attributeIndex);
int ncomps = com.epl.geometry.VertexDescription.GetComponentCount(semantics);
com.epl.geometry.AttributeStreamBase stream = m_vertexAttributes[attributeIndex];
for (int iord = 0; iord < ncomps; iord++)
{
com.epl.geometry.Envelope1D interval = new com.epl.geometry.Envelope1D();
interval.SetEmpty();
for (int i = 0; i < m_pointCount; i++)
{
double value = stream.ReadAsDbl(i * ncomps + iord);
// some
// optimization
// is
// possible
// if
// non-virtual
// method
// is
// used
interval.Merge(value);
}
m_envelope.SetInterval(semantics, iord, interval);
}
}
if (bExact)
{
_setDirtyFlag(com.epl.geometry.MultiVertexGeometryImpl.DirtyFlags.DirtyIntervals, false);
}
}
}
internal SweepMonkierComparator(com.epl.geometry.EditShape shape, double tol)
{
m_shape = shape;
m_tolerance = tol;
m_b_intersection_detected = false;
m_vertex_1 = -1;
m_env = new com.epl.geometry.Envelope1D();
m_point_of_interest = new com.epl.geometry.Point2D();
m_point_of_interest.SetNaN();
m_line_1 = new com.epl.geometry.Line();
m_current_node = -1;
m_min_dist = com.epl.geometry.NumberUtils.DoubleMax();
}
internal static double CalculateZToleranceFromGeometry(com.epl.geometry.SpatialReference sr, com.epl.geometry.Geometry geometry, bool bConservative)
{
com.epl.geometry.Envelope1D env1D = geometry.QueryInterval(com.epl.geometry.VertexDescription.Semantics.Z, 0);
double gtolerance = env1D._calculateToleranceFromEnvelope();
double stolerance = sr != null?sr.GetTolerance(com.epl.geometry.VertexDescription.Semantics.Z) : 0;
if (bConservative)
{
gtolerance *= 4;
stolerance *= 1.1;
}
return(System.Math.Max(stolerance, gtolerance));
}
public override com.epl.geometry.Envelope1D QueryInterval(int semantics, int ordinate)
{
com.epl.geometry.Envelope1D env = new com.epl.geometry.Envelope1D();
if (IsEmptyImpl())
{
env.SetEmpty();
return(env);
}
env.vmin = _getAttributeAsDbl(0, semantics, ordinate);
env.vmax = env.vmin;
env.MergeNE(_getAttributeAsDbl(1, semantics, ordinate));
return(env);
}
private bool ProcessSegment(com.epl.geometry.Segment segment)
{
com.epl.geometry.Envelope1D yrange = segment.QueryInterval((int)com.epl.geometry.VertexDescription.Semantics.POSITION, 1);
if (yrange.vmin > m_maxy || yrange.vmax < m_miny)
{
return(false);
}
if (m_bTestBorder && _testBorder(segment))
{
return(true);
}
if (yrange.vmin > m_inputPoint.y || yrange.vmax < m_inputPoint.y)
{
return(false);
}
if (m_monotoneParts == null)
{
m_monotoneParts = new com.epl.geometry.SegmentBuffer[5];
}
if (m_xOrds == null)
{
m_xOrds = new double[3];
}
int nparts = segment.GetYMonotonicParts(m_monotoneParts);
if (nparts > 0)
{
// the segment is a curve and has been broken in
// ymonotone parts
for (int i = 0; i < nparts; i++)
{
com.epl.geometry.Segment part = m_monotoneParts[i].Get();
DoOne(part);
if (m_bBreak)
{
return(true);
}
}
}
else
{
// the segment is a line or it is y monotone curve
DoOne(segment);
if (m_bBreak)
{
return(true);
}
}
return(false);
}
public void Construct(com.epl.geometry.Envelope1D xinterval, com.epl.geometry.Envelope1D yinterval, com.epl.geometry.Envelope1D zinterval)
{
if (xinterval.IsEmpty() || yinterval.IsEmpty())
{
SetEmpty();
return;
}
xmin = xinterval.vmin;
xmax = xinterval.vmax;
ymin = yinterval.vmin;
ymax = yinterval.vmax;
zmin = zinterval.vmin;
zmax = zinterval.vmax;
}
public override com.epl.geometry.Envelope1D QueryInterval(int semantics, int ordinate)
{
com.epl.geometry.Envelope1D env = new com.epl.geometry.Envelope1D();
if (IsEmptyImpl())
{
env.SetEmpty();
return(env);
}
double s = GetAttributeAsDbl(semantics, ordinate);
env.vmin = s;
env.vmax = s;
return(env);
}
public override void QueryEnvelope(com.epl.geometry.Envelope env)
{
env.SetEmpty();
env.AssignVertexDescription(m_description);
com.epl.geometry.Envelope2D env2D = new com.epl.geometry.Envelope2D();
QueryEnvelope2D(env2D);
env.SetEnvelope2D(env2D);
for (int i = 1, n = m_description.GetAttributeCount(); i < n; i++)
{
int semantics = m_description.GetSemantics(i);
for (int iord = 0, nord = com.epl.geometry.VertexDescription.GetComponentCount(semantics); i < nord; i++)
{
com.epl.geometry.Envelope1D interval = QueryInterval(semantics, iord);
env.SetInterval(semantics, iord, interval);
}
}
}
public void Intersect(com.epl.geometry.Envelope1D other)
{
if (IsEmpty() || other.IsEmpty())
{
SetEmpty();
return;
}
if (vmin < other.vmin)
{
vmin = other.vmin;
}
if (vmax > other.vmax)
{
vmax = other.vmax;
}
if (vmin > vmax)
{
SetEmpty();
}
}
public override void ReplaceNaNs(int semantics, double value)
{
AddAttribute(semantics);
if (IsEmpty())
{
return;
}
int ncomps = com.epl.geometry.VertexDescription.GetComponentCount(semantics);
for (int i = 0; i < ncomps; i++)
{
com.epl.geometry.Envelope1D interval = QueryInterval(semantics, i);
if (interval.IsEmpty())
{
interval.vmin = value;
interval.vmax = value;
SetInterval(semantics, i, interval);
}
}
}
public override bool Equals(object _other)
{
if (_other == this)
{
return(true);
}
if (!(_other is com.epl.geometry.Envelope1D))
{
return(false);
}
com.epl.geometry.Envelope1D other = (com.epl.geometry.Envelope1D)_other;
if (IsEmpty() && other.IsEmpty())
{
return(true);
}
if (vmin != other.vmin || vmax != other.vmax)
{
return(false);
}
return(true);
}
/// <exception cref="java.io.ObjectStreamException"/>
public virtual void SetGeometryByValue(com.epl.geometry.Envelope env)
{
try
{
attribs = null;
if (env == null)
{
descriptionBitMask = -1;
}
com.epl.geometry.VertexDescription vd = env.GetDescription();
descriptionBitMask = vd.m_semanticsBitArray;
if (env.IsEmpty())
{
return;
}
attribs = new double[vd.GetTotalComponentCount() * 2];
attribs[0] = env.GetXMin();
attribs[1] = env.GetYMin();
attribs[2] = env.GetXMax();
attribs[3] = env.GetYMax();
int index = 4;
for (int i = 1, n = vd.GetAttributeCount(); i < n; i++)
{
int semantics = vd.GetSemantics(i);
int comps = com.epl.geometry.VertexDescription.GetComponentCount(semantics);
for (int ord = 0; ord < comps; ord++)
{
com.epl.geometry.Envelope1D e = env.QueryInterval(semantics, ord);
attribs[index++] = e.vmin;
attribs[index++] = e.vmax;
}
}
}
catch (System.Exception)
{
throw new System.IO.InvalidDataException("Cannot serialize this geometry");
}
}
public Envelope1D(com.epl.geometry.Envelope1D other)
{
SetCoords(other);
}
public virtual double MaxMeasure()
{
com.epl.geometry.Envelope1D e = GetEsriGeometry().QueryInterval(com.epl.geometry.VertexDescription.Semantics.M, 0);
return(e.vmax);
}
/// <summary>
/// Returns True if the envelope contains the other envelope (boundary
/// inclusive).
/// </summary>
/// <remarks>
/// Returns True if the envelope contains the other envelope (boundary
/// inclusive). Note: Will return false if either envelope is empty.
/// </remarks>
public bool Contains(com.epl.geometry.Envelope1D other)
{
/* const */
/* const */
return(other.vmin >= vmin && other.vmax <= vmax);
}
internal virtual int CompareSegments_(int left, int right, com.epl.geometry.SweepComparator.SimpleEdge segLeft, com.epl.geometry.SweepComparator.SimpleEdge segRight)
{
if (m_b_intersection_detected)
{
return(-1);
}
bool sameY = m_prev_y == m_sweep_y && m_prev_x == m_sweep_x;
double xleft;
if (sameY && left == m_prev_1)
{
xleft = m_prevx_1;
}
else
{
xleft = com.epl.geometry.NumberUtils.NaN();
m_prev_1 = -1;
}
double xright;
if (sameY && right == m_prev_2)
{
xright = m_prevx_2;
}
else
{
xright = com.epl.geometry.NumberUtils.NaN();
m_prev_2 = -1;
}
// Quickly compare x projections.
com.epl.geometry.Envelope1D envLeft = segLeft.m_segment.QueryInterval(com.epl.geometry.VertexDescription.Semantics.POSITION, 0);
com.epl.geometry.Envelope1D envRight = segRight.m_segment.QueryInterval(com.epl.geometry.VertexDescription.Semantics.POSITION, 0);
if (envLeft.vmax < envRight.vmin)
{
return(-1);
}
if (envRight.vmax < envLeft.vmin)
{
return(1);
}
m_prev_y = m_sweep_y;
m_prev_x = m_sweep_x;
// Now do intersection with the sweep line (it is a line parallel to the
// axis x.)
if (com.epl.geometry.NumberUtils.IsNaN(xleft))
{
m_prev_1 = left;
double x = segLeft.m_segment.IntersectionOfYMonotonicWithAxisX(m_sweep_y, m_sweep_x);
xleft = x;
m_prevx_1 = x;
}
if (com.epl.geometry.NumberUtils.IsNaN(xright))
{
m_prev_2 = right;
double x = segRight.m_segment.IntersectionOfYMonotonicWithAxisX(m_sweep_y, m_sweep_x);
xright = x;
m_prevx_2 = x;
}
if (System.Math.Abs(xleft - xright) <= m_tolerance)
{
// special processing as we cannot decide in a simple way.
return(CompareTwoSegments_(segLeft.m_segment, segRight.m_segment));
}
else
{
return(xleft <xright ? -1 : xleft> xright ? 1 : 0);
}
}
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);
}
}
}
}
private static int ExportMultiPathToESRIShape(bool bPolygon, int exportFlags, com.epl.geometry.MultiPath multipath, System.IO.BinaryWriter shapeBuffer)
{
com.epl.geometry.MultiPathImpl multipathImpl = (com.epl.geometry.MultiPathImpl)multipath._getImpl();
bool bExportZs = multipathImpl.HasAttribute(com.epl.geometry.VertexDescription.Semantics.Z) && (exportFlags & com.epl.geometry.ShapeExportFlags.ShapeExportStripZs) == 0;
bool bExportMs = multipathImpl.HasAttribute(com.epl.geometry.VertexDescription.Semantics.M) && (exportFlags & com.epl.geometry.ShapeExportFlags.ShapeExportStripMs) == 0;
bool bExportIDs = multipathImpl.HasAttribute(com.epl.geometry.VertexDescription.Semantics.ID) && (exportFlags & com.epl.geometry.ShapeExportFlags.ShapeExportStripIDs) == 0;
bool bHasCurves = multipathImpl.HasNonLinearSegments();
bool bArcViewNaNs = (exportFlags & com.epl.geometry.ShapeExportFlags.ShapeExportTrueNaNs) == 0;
int partCount = multipathImpl.GetPathCount();
int pointCount = multipathImpl.GetPointCount();
if (!bPolygon)
{
for (int ipart = 0; ipart < partCount; ipart++)
{
if (multipath.IsClosedPath(ipart))
{
pointCount++;
}
}
}
else
{
pointCount += partCount;
}
int size = (4) + (4 * 8) + (4) + (4) + (partCount * 4) + pointCount * 2 * 8;
/* type */
/* envelope */
/* part count */
/* point count */
/* start indices */
/* xy coordinates */
if (bExportZs)
{
size += (2 * 8) + (pointCount * 8);
}
/* min max */
/* zs */
if (bExportMs)
{
size += (2 * 8) + (pointCount * 8);
}
/* min max */
/* ms */
if (bExportIDs)
{
size += pointCount * 4;
}
/* ids */
if (bHasCurves)
{
}
// to-do: curves
if (size >= com.epl.geometry.NumberUtils.IntMax())
{
throw new com.epl.geometry.GeometryException("invalid call");
}
if (shapeBuffer == null)
{
return(size);
}
else
{
if (((System.IO.MemoryStream)shapeBuffer.BaseStream).Capacity < size)
{
throw new com.epl.geometry.GeometryException("buffer is too small");
}
}
int offset = 0;
// Determine the shape type
int type;
if (!bExportZs && !bExportMs)
{
if (bExportIDs || bHasCurves)
{
type = bPolygon ? com.epl.geometry.ShapeType.ShapeGeneralPolygon : com.epl.geometry.ShapeType.ShapeGeneralPolyline;
if (bExportIDs)
{
type |= com.epl.geometry.ShapeModifiers.ShapeHasIDs;
}
if (bHasCurves)
{
type |= com.epl.geometry.ShapeModifiers.ShapeHasCurves;
}
}
else
{
type = bPolygon ? com.epl.geometry.ShapeType.ShapePolygon : com.epl.geometry.ShapeType.ShapePolyline;
}
}
else
{
if (bExportZs && !bExportMs)
{
if (bExportIDs || bHasCurves)
{
type = bPolygon ? com.epl.geometry.ShapeType.ShapeGeneralPolygon : com.epl.geometry.ShapeType.ShapeGeneralPolyline;
type |= com.epl.geometry.ShapeModifiers.ShapeHasZs;
if (bExportIDs)
{
type |= com.epl.geometry.ShapeModifiers.ShapeHasIDs;
}
if (bHasCurves)
{
type |= com.epl.geometry.ShapeModifiers.ShapeHasCurves;
}
}
else
{
type = bPolygon ? com.epl.geometry.ShapeType.ShapePolygonZ : com.epl.geometry.ShapeType.ShapePolylineZ;
}
}
else
{
if (bExportMs && !bExportZs)
{
if (bExportIDs || bHasCurves)
{
type = bPolygon ? com.epl.geometry.ShapeType.ShapeGeneralPolygon : com.epl.geometry.ShapeType.ShapeGeneralPolyline;
type |= com.epl.geometry.ShapeModifiers.ShapeHasMs;
if (bExportIDs)
{
type |= com.epl.geometry.ShapeModifiers.ShapeHasIDs;
}
if (bHasCurves)
{
type |= com.epl.geometry.ShapeModifiers.ShapeHasCurves;
}
}
else
{
type = bPolygon ? com.epl.geometry.ShapeType.ShapePolygonM : com.epl.geometry.ShapeType.ShapePolylineM;
}
}
else
{
if (bExportIDs || bHasCurves)
{
type = bPolygon ? com.epl.geometry.ShapeType.ShapeGeneralPolygon : com.epl.geometry.ShapeType.ShapeGeneralPolyline;
type |= com.epl.geometry.ShapeModifiers.ShapeHasZs | com.epl.geometry.ShapeModifiers.ShapeHasMs;
if (bExportIDs)
{
type |= com.epl.geometry.ShapeModifiers.ShapeHasIDs;
}
if (bHasCurves)
{
type |= com.epl.geometry.ShapeModifiers.ShapeHasCurves;
}
}
else
{
type = bPolygon ? com.epl.geometry.ShapeType.ShapePolygonZM : com.epl.geometry.ShapeType.ShapePolylineZM;
}
}
}
}
// write type
shapeBuffer.Write(type);
offset += 4;
// write Envelope
com.epl.geometry.Envelope2D env = new com.epl.geometry.Envelope2D();
multipathImpl.QueryEnvelope2D(env);
// calls _VerifyAllStreams
shapeBuffer.Write(env.xmin);
offset += 8;
shapeBuffer.Write(env.ymin);
offset += 8;
shapeBuffer.Write(env.xmax);
offset += 8;
shapeBuffer.Write(env.ymax);
offset += 8;
// write part count
shapeBuffer.Write(partCount);
offset += 4;
// to-do: return error if larger than 2^32 - 1
// write pointCount
shapeBuffer.Write(pointCount);
offset += 4;
// write start indices for each part
int pointIndexDelta = 0;
for (int ipart = 0; ipart < partCount; ipart++)
{
int istart = multipathImpl.GetPathStart(ipart) + pointIndexDelta;
shapeBuffer.Write(istart);
offset += 4;
if (bPolygon || multipathImpl.IsClosedPath(ipart))
{
pointIndexDelta++;
}
}
if (pointCount > 0)
{
// write xy coordinates
com.epl.geometry.AttributeStreamBase positionStream = multipathImpl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION);
com.epl.geometry.AttributeStreamOfDbl position = (com.epl.geometry.AttributeStreamOfDbl)positionStream;
for (int ipart = 0; ipart < partCount; ipart++)
{
int partStart = multipathImpl.GetPathStart(ipart);
int partEnd = multipathImpl.GetPathEnd(ipart);
for (int i = partStart; i < partEnd; i++)
{
double x = position.Read(2 * i);
double y = position.Read(2 * i + 1);
shapeBuffer.Write(x);
offset += 8;
shapeBuffer.Write(y);
offset += 8;
}
// If the part is closed, then we need to duplicate the start
// point
if (bPolygon || multipathImpl.IsClosedPath(ipart))
{
double x = position.Read(2 * partStart);
double y = position.Read(2 * partStart + 1);
shapeBuffer.Write(x);
offset += 8;
shapeBuffer.Write(y);
offset += 8;
}
}
}
// write Zs
if (bExportZs)
{
com.epl.geometry.Envelope1D zInterval = multipathImpl.QueryInterval(com.epl.geometry.VertexDescription.Semantics.Z, 0);
shapeBuffer.Write(bArcViewNaNs ? com.epl.geometry.Interop.TranslateToAVNaN(zInterval.vmin) : zInterval.vmin);
offset += 8;
shapeBuffer.Write(bArcViewNaNs ? com.epl.geometry.Interop.TranslateToAVNaN(zInterval.vmax) : zInterval.vmax);
offset += 8;
if (pointCount > 0)
{
if (multipathImpl._attributeStreamIsAllocated(com.epl.geometry.VertexDescription.Semantics.Z))
{
com.epl.geometry.AttributeStreamOfDbl zs = (com.epl.geometry.AttributeStreamOfDbl)multipathImpl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.Z);
for (int ipart = 0; ipart < partCount; ipart++)
{
int partStart = multipathImpl.GetPathStart(ipart);
int partEnd = multipathImpl.GetPathEnd(ipart);
for (int i = partStart; i < partEnd; i++)
{
double z = zs.Read(i);
shapeBuffer.Write(bArcViewNaNs ? com.epl.geometry.Interop.TranslateToAVNaN(z) : z);
offset += 8;
}
// If the part is closed, then we need to duplicate the
// start z
if (bPolygon || multipathImpl.IsClosedPath(ipart))
{
double z = zs.Read(partStart);
shapeBuffer.Write(z);
offset += 8;
}
}
}
else
{
double z = com.epl.geometry.VertexDescription.GetDefaultValue(com.epl.geometry.VertexDescription.Semantics.Z);
if (bArcViewNaNs)
{
z = com.epl.geometry.Interop.TranslateToAVNaN(z);
}
for (int i = 0; i < pointCount; i++)
{
shapeBuffer.Write(z);
}
offset += 8;
}
}
}
// write Ms
if (bExportMs)
{
com.epl.geometry.Envelope1D mInterval = multipathImpl.QueryInterval(com.epl.geometry.VertexDescription.Semantics.M, 0);
shapeBuffer.Write(bArcViewNaNs ? com.epl.geometry.Interop.TranslateToAVNaN(mInterval.vmin) : mInterval.vmin);
offset += 8;
shapeBuffer.Write(bArcViewNaNs ? com.epl.geometry.Interop.TranslateToAVNaN(mInterval.vmax) : mInterval.vmax);
offset += 8;
if (pointCount > 0)
{
if (multipathImpl._attributeStreamIsAllocated(com.epl.geometry.VertexDescription.Semantics.M))
{
com.epl.geometry.AttributeStreamOfDbl ms = (com.epl.geometry.AttributeStreamOfDbl)multipathImpl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.M);
for (int ipart = 0; ipart < partCount; ipart++)
{
int partStart = multipathImpl.GetPathStart(ipart);
int partEnd = multipathImpl.GetPathEnd(ipart);
for (int i = partStart; i < partEnd; i++)
{
double m = ms.Read(i);
shapeBuffer.Write(bArcViewNaNs ? com.epl.geometry.Interop.TranslateToAVNaN(m) : m);
offset += 8;
}
// If the part is closed, then we need to duplicate the
// start m
if (bPolygon || multipathImpl.IsClosedPath(ipart))
{
double m = ms.Read(partStart);
shapeBuffer.Write(m);
offset += 8;
}
}
}
else
{
double m = com.epl.geometry.VertexDescription.GetDefaultValue(com.epl.geometry.VertexDescription.Semantics.M);
if (bArcViewNaNs)
{
m = com.epl.geometry.Interop.TranslateToAVNaN(m);
}
for (int i = 0; i < pointCount; i++)
{
shapeBuffer.Write(m);
}
offset += 8;
}
}
}
// write Curves
if (bHasCurves)
{
}
// to-do: We'll finish this later
// write IDs
if (bExportIDs)
{
if (pointCount > 0)
{
if (multipathImpl._attributeStreamIsAllocated(com.epl.geometry.VertexDescription.Semantics.ID))
{
com.epl.geometry.AttributeStreamOfInt32 ids = (com.epl.geometry.AttributeStreamOfInt32)multipathImpl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.ID);
for (int ipart = 0; ipart < partCount; ipart++)
{
int partStart = multipathImpl.GetPathStart(ipart);
int partEnd = multipathImpl.GetPathEnd(ipart);
for (int i = partStart; i < partEnd; i++)
{
int id = ids.Read(i);
shapeBuffer.Write(id);
offset += 4;
}
// If the part is closed, then we need to duplicate the
// start id
if (bPolygon || multipathImpl.IsClosedPath(ipart))
{
int id = ids.Read(partStart);
shapeBuffer.Write(id);
offset += 4;
}
}
}
else
{
int id = (int)com.epl.geometry.VertexDescription.GetDefaultValue(com.epl.geometry.VertexDescription.Semantics.ID);
for (int i = 0; i < pointCount; i++)
{
shapeBuffer.Write(id);
}
offset += 4;
}
}
}
return(offset);
}
private static int ExportMultiPointToESRIShape(int exportFlags, com.epl.geometry.MultiPoint multipoint, System.IO.BinaryWriter shapeBuffer)
{
com.epl.geometry.MultiPointImpl multipointImpl = (com.epl.geometry.MultiPointImpl)multipoint._getImpl();
bool bExportZs = multipointImpl.HasAttribute(com.epl.geometry.VertexDescription.Semantics.Z) && (exportFlags & com.epl.geometry.ShapeExportFlags.ShapeExportStripZs) == 0;
bool bExportMs = multipointImpl.HasAttribute(com.epl.geometry.VertexDescription.Semantics.M) && (exportFlags & com.epl.geometry.ShapeExportFlags.ShapeExportStripMs) == 0;
bool bExportIDs = multipointImpl.HasAttribute(com.epl.geometry.VertexDescription.Semantics.ID) && (exportFlags & com.epl.geometry.ShapeExportFlags.ShapeExportStripIDs) == 0;
bool bArcViewNaNs = (exportFlags & com.epl.geometry.ShapeExportFlags.ShapeExportTrueNaNs) == 0;
int pointCount = multipointImpl.GetPointCount();
int size = (4) + (4 * 8) + (4) + (pointCount * 2 * 8);
/* type */
/* envelope */
/* point count */
/* xy coordinates */
if (bExportZs)
{
size += (2 * 8) + (pointCount * 8);
}
/* min max */
/* zs */
if (bExportMs)
{
size += (2 * 8) + (pointCount * 8);
}
/* min max */
/* ms */
if (bExportIDs)
{
size += pointCount * 4;
}
/* ids */
if (size >= com.epl.geometry.NumberUtils.IntMax())
{
throw new com.epl.geometry.GeometryException("invalid call");
}
if (shapeBuffer == null)
{
return(size);
}
else
{
if (((System.IO.MemoryStream)shapeBuffer.BaseStream).Capacity < size)
{
throw new com.epl.geometry.GeometryException("buffer is too small");
}
}
int type;
// Determine the shape type
if (!bExportZs && !bExportMs)
{
if (bExportIDs)
{
type = com.epl.geometry.ShapeType.ShapeGeneralMultiPoint | com.epl.geometry.ShapeModifiers.ShapeHasIDs;
}
else
{
type = com.epl.geometry.ShapeType.ShapeMultiPoint;
}
}
else
{
if (bExportZs && !bExportMs)
{
if (bExportIDs)
{
type = com.epl.geometry.ShapeType.ShapeGeneralMultiPoint | com.epl.geometry.ShapeModifiers.ShapeHasZs | com.epl.geometry.ShapeModifiers.ShapeHasIDs;
}
else
{
type = com.epl.geometry.ShapeType.ShapeMultiPointZ;
}
}
else
{
if (bExportMs && !bExportZs)
{
if (bExportIDs)
{
type = com.epl.geometry.ShapeType.ShapeGeneralMultiPoint | com.epl.geometry.ShapeModifiers.ShapeHasMs | com.epl.geometry.ShapeModifiers.ShapeHasIDs;
}
else
{
type = com.epl.geometry.ShapeType.ShapeMultiPointM;
}
}
else
{
if (bExportIDs)
{
type = com.epl.geometry.ShapeType.ShapeGeneralMultiPoint | com.epl.geometry.ShapeModifiers.ShapeHasZs | com.epl.geometry.ShapeModifiers.ShapeHasMs | com.epl.geometry.ShapeModifiers.ShapeHasIDs;
}
else
{
type = com.epl.geometry.ShapeType.ShapeMultiPointZM;
}
}
}
}
// write type
int offset = 0;
shapeBuffer.Write(type);
offset += 4;
// write Envelope
com.epl.geometry.Envelope2D env = new com.epl.geometry.Envelope2D();
multipointImpl.QueryEnvelope2D(env);
// calls _VerifyAllStreams
shapeBuffer.Write(env.xmin);
offset += 8;
shapeBuffer.Write(env.ymin);
offset += 8;
shapeBuffer.Write(env.xmax);
offset += 8;
shapeBuffer.Write(env.ymax);
offset += 8;
// write point count
shapeBuffer.Write(pointCount);
offset += 4;
if (pointCount > 0)
{
// write xy coordinates
com.epl.geometry.AttributeStreamBase positionStream = multipointImpl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION);
com.epl.geometry.AttributeStreamOfDbl position = (com.epl.geometry.AttributeStreamOfDbl)positionStream;
for (int i = 0; i < pointCount; i++)
{
double x = position.Read(2 * i);
double y = position.Read(2 * i + 1);
shapeBuffer.Write(x);
offset += 8;
shapeBuffer.Write(y);
offset += 8;
}
}
// write Zs
if (bExportZs)
{
com.epl.geometry.Envelope1D zInterval = multipointImpl.QueryInterval(com.epl.geometry.VertexDescription.Semantics.Z, 0);
shapeBuffer.Write(bArcViewNaNs ? com.epl.geometry.Interop.TranslateToAVNaN(zInterval.vmin) : zInterval.vmin);
offset += 8;
shapeBuffer.Write(bArcViewNaNs ? com.epl.geometry.Interop.TranslateToAVNaN(zInterval.vmax) : zInterval.vmax);
offset += 8;
if (pointCount > 0)
{
if (multipointImpl._attributeStreamIsAllocated(com.epl.geometry.VertexDescription.Semantics.Z))
{
com.epl.geometry.AttributeStreamOfDbl zs = (com.epl.geometry.AttributeStreamOfDbl)multipointImpl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.Z);
for (int i = 0; i < pointCount; i++)
{
double z = zs.Read(i);
shapeBuffer.Write(bArcViewNaNs ? com.epl.geometry.Interop.TranslateToAVNaN(z) : z);
offset += 8;
}
}
else
{
double z = com.epl.geometry.VertexDescription.GetDefaultValue(com.epl.geometry.VertexDescription.Semantics.Z);
if (bArcViewNaNs)
{
z = com.epl.geometry.Interop.TranslateToAVNaN(z);
}
// Can we write a function that writes all these values at
// once instead of doing a for loop?
for (int i = 0; i < pointCount; i++)
{
shapeBuffer.Write(z);
}
offset += 8;
}
}
}
// write Ms
if (bExportMs)
{
com.epl.geometry.Envelope1D mInterval = multipointImpl.QueryInterval(com.epl.geometry.VertexDescription.Semantics.M, 0);
shapeBuffer.Write(bArcViewNaNs ? com.epl.geometry.Interop.TranslateToAVNaN(mInterval.vmin) : mInterval.vmin);
offset += 8;
shapeBuffer.Write(bArcViewNaNs ? com.epl.geometry.Interop.TranslateToAVNaN(mInterval.vmax) : mInterval.vmax);
offset += 8;
if (pointCount > 0)
{
if (multipointImpl._attributeStreamIsAllocated(com.epl.geometry.VertexDescription.Semantics.M))
{
com.epl.geometry.AttributeStreamOfDbl ms = (com.epl.geometry.AttributeStreamOfDbl)multipointImpl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.M);
for (int i = 0; i < pointCount; i++)
{
double m = ms.Read(i);
shapeBuffer.Write(bArcViewNaNs ? com.epl.geometry.Interop.TranslateToAVNaN(m) : m);
offset += 8;
}
}
else
{
double m = com.epl.geometry.VertexDescription.GetDefaultValue(com.epl.geometry.VertexDescription.Semantics.M);
if (bArcViewNaNs)
{
m = com.epl.geometry.Interop.TranslateToAVNaN(m);
}
for (int i = 0; i < pointCount; i++)
{
shapeBuffer.Write(m);
}
offset += 8;
}
}
}
// write IDs
if (bExportIDs)
{
if (pointCount > 0)
{
if (multipointImpl._attributeStreamIsAllocated(com.epl.geometry.VertexDescription.Semantics.ID))
{
com.epl.geometry.AttributeStreamOfInt32 ids = (com.epl.geometry.AttributeStreamOfInt32)multipointImpl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.ID);
for (int i = 0; i < pointCount; i++)
{
int id = ids.Read(i);
shapeBuffer.Write(id);
offset += 4;
}
}
else
{
int id = (int)com.epl.geometry.VertexDescription.GetDefaultValue(com.epl.geometry.VertexDescription.Semantics.ID);
for (int i = 0; i < pointCount; i++)
{
shapeBuffer.Write(id);
}
offset += 4;
}
}
}
return(offset);
}
public static void TestIntervalTree__1()
{
System.Collections.Generic.List <com.epl.geometry.Envelope1D> intervals = new System.Collections.Generic.List <com.epl.geometry.Envelope1D>(0);
com.epl.geometry.Envelope1D env0 = new com.epl.geometry.Envelope1D(2, 3);
com.epl.geometry.Envelope1D env1 = new com.epl.geometry.Envelope1D(5, 13);
com.epl.geometry.Envelope1D env2 = new com.epl.geometry.Envelope1D(6, 9);
com.epl.geometry.Envelope1D env3 = new com.epl.geometry.Envelope1D(8, 10);
com.epl.geometry.Envelope1D env4 = new com.epl.geometry.Envelope1D(11, 12);
com.epl.geometry.Envelope1D env5 = new com.epl.geometry.Envelope1D(1, 3);
com.epl.geometry.Envelope1D env6 = new com.epl.geometry.Envelope1D(0, 2);
com.epl.geometry.Envelope1D env7 = new com.epl.geometry.Envelope1D(4, 7);
com.epl.geometry.Envelope1D env8;
intervals.Add(env0);
intervals.Add(env1);
intervals.Add(env2);
intervals.Add(env3);
intervals.Add(env4);
intervals.Add(env5);
intervals.Add(env6);
intervals.Add(env7);
int counter;
com.epl.geometry.IntervalTreeImpl intervalTree = new com.epl.geometry.IntervalTreeImpl(false);
Construct(intervalTree, intervals);
com.epl.geometry.IntervalTreeImpl.IntervalTreeIteratorImpl iterator = intervalTree.GetIterator(new com.epl.geometry.Envelope1D(-1, 14), 0.0);
counter = 0;
while (iterator.Next() != -1)
{
counter++;
}
NUnit.Framework.Assert.IsTrue(counter == 8);
iterator.ResetIterator(new com.epl.geometry.Envelope1D(2.5, 10.5), 0.0);
counter = 0;
while (iterator.Next() != -1)
{
counter++;
}
NUnit.Framework.Assert.IsTrue(counter == 6);
iterator.ResetIterator(5.0, 0.0);
counter = 0;
while (iterator.Next() != -1)
{
counter++;
}
NUnit.Framework.Assert.IsTrue(counter == 2);
iterator.ResetIterator(7, 0.0);
counter = 0;
while (iterator.Next() != -1)
{
counter++;
}
NUnit.Framework.Assert.IsTrue(counter == 3);
iterator.ResetIterator(new com.epl.geometry.Envelope1D(2.0, 10.5), 0.0);
counter = 0;
while (iterator.Next() != -1)
{
counter++;
}
NUnit.Framework.Assert.IsTrue(counter == 7);
iterator.ResetIterator(new com.epl.geometry.Envelope1D(2.5, 11), 0.0);
counter = 0;
while (iterator.Next() != -1)
{
counter++;
}
NUnit.Framework.Assert.IsTrue(counter == 7);
iterator.ResetIterator(new com.epl.geometry.Envelope1D(2.1, 2.5), 0.0);
counter = 0;
while (iterator.Next() != -1)
{
counter++;
}
NUnit.Framework.Assert.IsTrue(counter == 2);
iterator.ResetIterator(new com.epl.geometry.Envelope1D(2.1, 5), 0.0);
counter = 0;
while (iterator.Next() != -1)
{
counter++;
}
NUnit.Framework.Assert.IsTrue(counter == 4);
iterator.ResetIterator(new com.epl.geometry.Envelope1D(2.0, 5), 0.0);
counter = 0;
while (iterator.Next() != -1)
{
counter++;
}
NUnit.Framework.Assert.IsTrue(counter == 5);
iterator.ResetIterator(new com.epl.geometry.Envelope1D(5.0, 11), 0.0);
counter = 0;
while (iterator.Next() != -1)
{
counter++;
}
NUnit.Framework.Assert.IsTrue(counter == 5);
iterator.ResetIterator(new com.epl.geometry.Envelope1D(8, 10.5), 0.0);
counter = 0;
while (iterator.Next() != -1)
{
counter++;
}
NUnit.Framework.Assert.IsTrue(counter == 3);
iterator.ResetIterator(new com.epl.geometry.Envelope1D(10, 11), 0.0);
counter = 0;
while (iterator.Next() != -1)
{
counter++;
}
NUnit.Framework.Assert.IsTrue(counter == 3);
iterator.ResetIterator(new com.epl.geometry.Envelope1D(10, 10.9), 0.0);
counter = 0;
while (iterator.Next() != -1)
{
counter++;
}
NUnit.Framework.Assert.IsTrue(counter == 2);
iterator.ResetIterator(new com.epl.geometry.Envelope1D(11.5, 12), 0.0);
counter = 0;
while (iterator.Next() != -1)
{
counter++;
}
NUnit.Framework.Assert.IsTrue(counter == 2);
env0 = new com.epl.geometry.Envelope1D(0, 4);
env1 = new com.epl.geometry.Envelope1D(6, 7);
env2 = new com.epl.geometry.Envelope1D(9, 10);
env3 = new com.epl.geometry.Envelope1D(9, 11);
env4 = new com.epl.geometry.Envelope1D(7, 12);
env5 = new com.epl.geometry.Envelope1D(13, 15);
env6 = new com.epl.geometry.Envelope1D(1, 6);
env7 = new com.epl.geometry.Envelope1D(3, 3);
env8 = new com.epl.geometry.Envelope1D(8, 8);
intervals.Clear();
intervals.Add(env0);
intervals.Add(env1);
intervals.Add(env2);
intervals.Add(env3);
intervals.Add(env4);
intervals.Add(env5);
intervals.Add(env6);
intervals.Add(env7);
intervals.Add(env8);
com.epl.geometry.IntervalTreeImpl intervalTree2 = new com.epl.geometry.IntervalTreeImpl(true);
Construct(intervalTree2, intervals);
intervalTree2.Insert(0);
intervalTree2.Insert(1);
intervalTree2.Insert(2);
intervalTree2.Insert(3);
intervalTree2.Insert(4);
intervalTree2.Insert(5);
intervalTree2.Insert(6);
intervalTree2.Insert(7);
intervalTree2.Insert(8);
iterator = intervalTree2.GetIterator(new com.epl.geometry.Envelope1D(8, 8), 0.0);
counter = 0;
while (iterator.Next() != -1)
{
counter++;
}
NUnit.Framework.Assert.IsTrue(counter == 2);
iterator.ResetIterator(new com.epl.geometry.Envelope1D(3, 7), 0.0);
counter = 0;
while (iterator.Next() != -1)
{
counter++;
}
NUnit.Framework.Assert.IsTrue(counter == 5);
iterator.ResetIterator(new com.epl.geometry.Envelope1D(1, 3), 0.0);
counter = 0;
while (iterator.Next() != -1)
{
counter++;
}
NUnit.Framework.Assert.IsTrue(counter == 3);
iterator.ResetIterator(new com.epl.geometry.Envelope1D(6, 9), 0.0);
counter = 0;
while (iterator.Next() != -1)
{
counter++;
}
NUnit.Framework.Assert.IsTrue(counter == 6);
iterator.ResetIterator(new com.epl.geometry.Envelope1D(10, 14), 0.0);
counter = 0;
while (iterator.Next() != -1)
{
counter++;
}
NUnit.Framework.Assert.IsTrue(counter == 4);
env0 = new com.epl.geometry.Envelope1D(11, 14);
env1 = new com.epl.geometry.Envelope1D(21, 36);
env2 = new com.epl.geometry.Envelope1D(15, 19);
env3 = new com.epl.geometry.Envelope1D(3, 8);
env4 = new com.epl.geometry.Envelope1D(34, 38);
env5 = new com.epl.geometry.Envelope1D(23, 27);
env6 = new com.epl.geometry.Envelope1D(6, 36);
intervals.Clear();
intervals.Add(env0);
intervals.Add(env1);
intervals.Add(env2);
intervals.Add(env3);
intervals.Add(env4);
intervals.Add(env5);
intervals.Add(env6);
com.epl.geometry.IntervalTreeImpl intervalTree3 = new com.epl.geometry.IntervalTreeImpl(false);
Construct(intervalTree3, intervals);
iterator = intervalTree3.GetIterator(new com.epl.geometry.Envelope1D(50, 50), 0.0);
System.Diagnostics.Debug.Assert((iterator.Next() == -1));
}
public void SetCoords(com.epl.geometry.Envelope1D other)
{
SetCoords(other.vmin, other.vmax);
}
