internal static double GeodesicDistanceOnWGS84Impl(com.epl.geometry.Point ptFrom, com.epl.geometry.Point ptTo)
{
double a = 6378137.0;
// radius of spheroid for WGS_1984
double e2 = 0.0066943799901413165;
// ellipticity for WGS_1984
double rpu = System.Math.PI / 180.0;
com.epl.geometry.PeDouble answer = new com.epl.geometry.PeDouble();
com.epl.geometry.GeoDist.Geodesic_distance_ngs(a, e2, ptFrom.GetX() * rpu, ptFrom.GetY() * rpu, ptTo.GetX() * rpu, ptTo.GetY() * rpu, answer, null, null);
return(answer.val);
}
internal static com.epl.geometry.Geometry PointTaggedText(int import_flags, com.epl.geometry.WktParser wkt_parser)
{
com.epl.geometry.Point point = new com.epl.geometry.Point();
int current_token = wkt_parser.NextToken();
if (current_token == com.epl.geometry.WktParser.WktToken.attribute_z)
{
point.AddAttribute(com.epl.geometry.VertexDescription.Semantics.Z);
wkt_parser.NextToken();
}
else
{
if (current_token == com.epl.geometry.WktParser.WktToken.attribute_m)
{
point.AddAttribute(com.epl.geometry.VertexDescription.Semantics.M);
wkt_parser.NextToken();
}
else
{
if (current_token == com.epl.geometry.WktParser.WktToken.attribute_zm)
{
point.AddAttribute(com.epl.geometry.VertexDescription.Semantics.Z);
point.AddAttribute(com.epl.geometry.VertexDescription.Semantics.M);
wkt_parser.NextToken();
}
}
}
// At start of PointText
current_token = wkt_parser.CurrentToken();
if (current_token != com.epl.geometry.WktParser.WktToken.empty)
{
wkt_parser.NextToken();
double x = wkt_parser.CurrentNumericLiteral();
wkt_parser.NextToken();
double y = wkt_parser.CurrentNumericLiteral();
wkt_parser.NextToken();
point.SetXY(x, y);
if (wkt_parser.HasZs())
{
double z = wkt_parser.CurrentNumericLiteral();
wkt_parser.NextToken();
point.SetZ(z);
}
if (wkt_parser.HasMs())
{
double m = wkt_parser.CurrentNumericLiteral();
wkt_parser.NextToken();
point.SetM(m);
}
}
return(point);
}
public override void InsertAttributes(int start, com.epl.geometry.Point pt, int semantics, int validSize)
{
if (m_bReadonly)
{
throw new com.epl.geometry.GeometryException("invalid_call");
}
int comp = com.epl.geometry.VertexDescription.GetComponentCount(semantics);
System.Array.Copy(m_buffer, start, m_buffer, start + comp, validSize - start);
for (int c = 0; c < comp; c++)
{
m_buffer[start + c] = (float)pt.GetAttributeAsDbl(semantics, c);
}
}
/// <summary>Creates an envelope by defining its center, width, and height.</summary>
/// <param name="center">The center point of the envelope.</param>
/// <param name="width">The width of the envelope.</param>
/// <param name="height">The height of the envelope.</param>
public Envelope(com.epl.geometry.Point center, double width, double height)
{
//We are using writeReplace instead.
//private static final long serialVersionUID = 2L;
// use doubles to store everything
m_description = com.epl.geometry.VertexDescriptionDesignerImpl.GetDefaultDescriptor2D();
m_envelope.SetEmpty();
if (center.IsEmpty())
{
return;
}
_setFromPoint(center, width, height);
}
public virtual void TestSerializePoint()
{
try
{
java.io.ByteArrayOutputStream streamOut = new java.io.ByteArrayOutputStream();
java.io.ObjectOutputStream oo = new java.io.ObjectOutputStream(streamOut);
com.epl.geometry.Point pt = new com.epl.geometry.Point(10, 40);
oo.WriteObject(pt);
System.IO.BinaryWriter streamIn = new System.IO.BinaryWriter(streamOut.ToByteArray());
java.io.ObjectInputStream ii = new java.io.ObjectInputStream(streamIn);
com.epl.geometry.Point ptRes = (com.epl.geometry.Point)ii.ReadObject();
NUnit.Framework.Assert.IsTrue(ptRes.Equals(pt));
}
catch (System.Exception)
{
Fail("Point serialization failure");
}
//try
//{
//FileOutputStream streamOut = new FileOutputStream("c:/temp/savedPoint1.txt");
//ObjectOutputStream oo = new ObjectOutputStream(streamOut);
//Point pt = new Point(10, 40, 2);
//oo.writeObject(pt);
//}
//catch(Exception ex)
//{
//fail("Point serialization failure");
//}
try
{
java.io.InputStream s = typeof(com.epl.geometry.TestSerialization).GetResourceAsStream("savedPoint.txt");
java.io.ObjectInputStream ii = new java.io.ObjectInputStream(s);
com.epl.geometry.Point ptRes = (com.epl.geometry.Point)ii.ReadObject();
NUnit.Framework.Assert.IsTrue(ptRes.GetX() == 10 && ptRes.GetY() == 40);
}
catch (System.Exception)
{
Fail("Point serialization failure");
}
try
{
java.io.InputStream s = typeof(com.epl.geometry.TestSerialization).GetResourceAsStream("savedPoint1.txt");
java.io.ObjectInputStream ii = new java.io.ObjectInputStream(s);
com.epl.geometry.Point ptRes = (com.epl.geometry.Point)ii.ReadObject();
NUnit.Framework.Assert.IsTrue(ptRes.GetX() == 10 && ptRes.GetY() == 40 && ptRes.GetZ() == 2);
}
catch (System.Exception)
{
Fail("Point serialization failure");
}
}
public virtual void TestReplaceNaNs()
{
com.epl.geometry.Envelope env = new com.epl.geometry.Envelope();
com.epl.geometry.Point pt = new com.epl.geometry.Point();
pt.SetXY(1, 2);
pt.SetZ(double.NaN);
pt.QueryEnvelope(env);
pt.ReplaceNaNs(com.epl.geometry.VertexDescription.Semantics.Z, 5);
NUnit.Framework.Assert.IsTrue(pt.Equals(new com.epl.geometry.Point(1, 2, 5)));
NUnit.Framework.Assert.IsTrue(env.HasZ());
NUnit.Framework.Assert.IsTrue(env.QueryInterval(com.epl.geometry.VertexDescription.Semantics.Z, 0).IsEmpty());
env.ReplaceNaNs(com.epl.geometry.VertexDescription.Semantics.Z, 5);
NUnit.Framework.Assert.IsTrue(env.QueryInterval(com.epl.geometry.VertexDescription.Semantics.Z, 0).Equals(new com.epl.geometry.Envelope1D(5, 5)));
}
internal static com.epl.geometry.Geometry PointMinusPoint_(com.epl.geometry.Point point_a, com.epl.geometry.Point point_b, double tolerance, com.epl.geometry.ProgressTracker progress_tracker)
{
double tolerance_cluster = tolerance * System.Math.Sqrt(2.0) * 1.00001;
double tolerance_cluster_sq = tolerance_cluster * tolerance_cluster;
com.epl.geometry.Point2D pt_a = point_a.GetXY();
com.epl.geometry.Point2D pt_b = point_b.GetXY();
if (com.epl.geometry.Point2D.SqrDistance(pt_a, pt_b) <= tolerance_cluster_sq)
{
return(point_a.CreateInstance());
}
// return empty point
return(point_a);
}
public static void TestUnion__()
{
com.epl.geometry.Point pt = new com.epl.geometry.Point(10, 20);
com.epl.geometry.Point pt2 = new com.epl.geometry.Point();
pt2.SetXY(10, 10);
com.epl.geometry.Envelope env1 = new com.epl.geometry.Envelope(10, 10, 30, 50);
com.epl.geometry.Envelope env2 = new com.epl.geometry.Envelope(30, 10, 60, 50);
com.epl.geometry.Geometry[] geomArray = new com.epl.geometry.Geometry[] { env1, env2 };
com.epl.geometry.SimpleGeometryCursor inputGeometries = new com.epl.geometry.SimpleGeometryCursor(geomArray);
com.epl.geometry.OperatorUnion union = (com.epl.geometry.OperatorUnion)com.epl.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.epl.geometry.Operator.Type.Union);
com.epl.geometry.SpatialReference sr = com.epl.geometry.SpatialReference.Create(4326);
com.epl.geometry.GeometryCursor outputCursor = union.Execute(inputGeometries, sr, null);
com.epl.geometry.Geometry result = outputCursor.Next();
}
public virtual void TestTouchesBetweenPointAndLine()
{
com.epl.geometry.SpatialReference sr = com.epl.geometry.SpatialReference.Create(4326);
com.epl.geometry.Point p = new com.epl.geometry.Point(2, 4);
com.epl.geometry.Polyline compPl = new com.epl.geometry.Polyline();
compPl.StartPath(2, 4);
compPl.LineTo(9, 4);
compPl.LineTo(9, 9);
compPl.LineTo(2, 9);
compPl.LineTo(2, 4);
bool isTouched = com.epl.geometry.GeometryEngine.Touches(p, compPl, sr);
NUnit.Framework.Assert.IsTrue(!isTouched);
}
internal static com.epl.geometry.Geometry PointSymDiffPoint_(com.epl.geometry.Point point_a, com.epl.geometry.Point point_b, double tolerance, com.epl.geometry.ProgressTracker progress_tracker)
{
double tolerance_cluster = tolerance * System.Math.Sqrt(2.0) * 1.00001;
double tolerance_cluster_sq = tolerance_cluster * tolerance_cluster;
com.epl.geometry.Point2D pt_a = point_a.GetXY();
com.epl.geometry.Point2D pt_b = point_b.GetXY();
com.epl.geometry.MultiPoint multi_point = new com.epl.geometry.MultiPoint(point_a.GetDescription());
if (com.epl.geometry.Point2D.SqrDistance(pt_a, pt_b) > tolerance_cluster_sq)
{
multi_point.Add(point_a);
multi_point.Add(point_b);
}
return(multi_point);
}
internal virtual void QueryCoord(double t, com.epl.geometry.Point point)
{
point.AssignVertexDescription(m_description);
point.SetXY(GetCoord2D(t));
for (int iattrib = 1, nattrib = m_description.GetAttributeCount(); iattrib < nattrib; iattrib++)
{
int semantics = m_description._getSemanticsImpl(iattrib);
int ncomp = com.epl.geometry.VertexDescription.GetComponentCount(semantics);
for (int iord = 0; iord < ncomp; iord++)
{
double value = GetAttributeAsDbl(t, semantics, iord);
point.SetAttribute(semantics, iord, value);
}
}
}
internal virtual void _setFromPoint(com.epl.geometry.Point centerPoint)
{
m_envelope.SetCoords(centerPoint.m_attributes[0], centerPoint.m_attributes[1]);
com.epl.geometry.VertexDescription pointVD = centerPoint.m_description;
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 = centerPoint.GetAttributeAsDbl(semantics, iord);
SetInterval(semantics, iord, v, v);
}
}
}
/// <summary>Gets the current bounding geometry.</summary>
/// <remarks>
/// Gets the current bounding geometry.
/// Returns a Geometry.
/// </remarks>
internal virtual com.epl.geometry.Geometry GetBoundingGeometry()
{
// Extracts the convex hull from the tree. Reading the tree in order from first to last is the resulting convex hull.
com.epl.geometry.Point point = new com.epl.geometry.Point();
int first = m_tree_hull.GetFirst(-1);
com.epl.geometry.Polygon hull = new com.epl.geometry.Polygon(m_shape.GetVertexDescription());
m_shape.QueryPoint(m_tree_hull.GetElement(first), point);
hull.StartPath(point);
for (int i = m_tree_hull.GetNext(first); i != -1; i = m_tree_hull.GetNext(i))
{
m_shape.QueryPoint(m_tree_hull.GetElement(i), point);
hull.LineTo(point);
}
return(hull);
}
// reset the place holder to tp
private void AddEnvelope_(com.epl.geometry.Envelope envelope)
{
com.epl.geometry.Point point = new com.epl.geometry.Point();
com.epl.geometry.Point2D pt_p = new com.epl.geometry.Point2D();
for (int i = 0; i < 4; i++)
{
envelope.QueryCorner(i, pt_p);
int p = AddPoint_(pt_p);
if (p != -1)
{
envelope.QueryCornerByVal(i, point);
int tp = m_shape.AddPoint(m_path_handle, point);
m_tree_hull.SetElement(p, tp);
}
}
}
// Dynamically inserts each geometry into the convex hull.
private void AddMultiVertexGeometry_(com.epl.geometry.MultiVertexGeometry mvg)
{
com.epl.geometry.Point point = new com.epl.geometry.Point();
com.epl.geometry.Point2D pt_p = new com.epl.geometry.Point2D();
for (int i = 0; i < mvg.GetPointCount(); i++)
{
mvg.GetXY(i, pt_p);
int p = AddPoint_(pt_p);
if (p != -1)
{
mvg.GetPointByVal(i, point);
int tp = m_shape.AddPoint(m_path_handle, point);
m_tree_hull.SetElement(p, tp);
}
}
}
public static void TestProximity2D_3()
{
com.epl.geometry.OperatorFactoryLocal factory = com.epl.geometry.OperatorFactoryLocal.GetInstance();
com.epl.geometry.OperatorProximity2D proximity = (com.epl.geometry.OperatorProximity2D)factory.GetOperator(com.epl.geometry.Operator.Type.Proximity2D);
com.epl.geometry.Polygon polygon = new com.epl.geometry.Polygon();
polygon.StartPath(new com.epl.geometry.Point(-120, 22));
polygon.LineTo(new com.epl.geometry.Point(-120, 10));
polygon.LineTo(new com.epl.geometry.Point(-110, 10));
polygon.LineTo(new com.epl.geometry.Point(-110, 22));
com.epl.geometry.Point point = new com.epl.geometry.Point();
point.SetXY(-110, 20);
com.epl.geometry.Proximity2DResult result = proximity.GetNearestCoordinate(polygon, point, false);
com.epl.geometry.Point point2 = new com.epl.geometry.Point();
point2.SetXY(-120, 12);
com.epl.geometry.Proximity2DResult[] results = proximity.GetNearestVertices(polygon, point2, 10, 12);
}
public static void TestDistanceBetweenVariousGeometries()
{
com.epl.geometry.Polygon polygon = MakePolygon();
com.epl.geometry.Polyline polyline = MakePolyline();
com.epl.geometry.MultiPoint multipoint = MakeMultiPoint();
com.epl.geometry.Point point = MakePoint();
// SpatialReference spatialRef =
// SpatialReference.create(3857);//PCS_WGS_1984_WEB_MERCATOR_AUXSPHERE
double distance;
distance = com.epl.geometry.GeometryEngine.Distance(polygon, polyline, null);
NUnit.Framework.Assert.IsTrue(System.Math.Abs(distance - 5.0) < 0.00001);
distance = com.epl.geometry.GeometryEngine.Distance(polygon, multipoint, null);
NUnit.Framework.Assert.IsTrue(System.Math.Abs(distance - 5.0) < 0.00001);
distance = com.epl.geometry.GeometryEngine.Distance(polygon, point, null);
NUnit.Framework.Assert.IsTrue(System.Math.Abs(distance - 5.0) < 0.00001);
}
public virtual void TestEqualsOnEnvelopes()
{
com.epl.geometry.SpatialReference sr = com.epl.geometry.SpatialReference.Create(4326);
com.epl.geometry.Point p = new com.epl.geometry.Point(-130, 10);
com.epl.geometry.Envelope env = new com.epl.geometry.Envelope(p, 12, 12);
com.epl.geometry.Envelope env2 = new com.epl.geometry.Envelope(-136, 4, -124, 16);
bool isEqual;
try
{
isEqual = com.epl.geometry.GeometryEngine.Equals(env, env2, sr);
}
catch (System.ArgumentException)
{
isEqual = false;
}
NUnit.Framework.Assert.IsTrue(isEqual);
}
public virtual void TestProximity2D_2()
{
com.epl.geometry.Point point1 = new com.epl.geometry.Point(3, 2);
com.epl.geometry.Point point2 = new com.epl.geometry.Point(2, 4);
com.epl.geometry.Envelope envelope = new com.epl.geometry.Envelope();
envelope.SetCoords(4, 3, 7, 6);
com.epl.geometry.Polygon polygonToTest = new com.epl.geometry.Polygon();
polygonToTest.AddEnvelope(envelope, false);
com.epl.geometry.Proximity2DResult prxResult1 = com.epl.geometry.GeometryEngine.GetNearestVertex(envelope, point1);
com.epl.geometry.Proximity2DResult prxResult2 = com.epl.geometry.GeometryEngine.GetNearestVertex(polygonToTest, point1);
com.epl.geometry.Proximity2DResult prxResult3 = com.epl.geometry.GeometryEngine.GetNearestCoordinate(envelope, point2, false);
com.epl.geometry.Proximity2DResult prxResult4 = com.epl.geometry.GeometryEngine.GetNearestCoordinate(polygonToTest, point2, false);
com.epl.geometry.Point result1 = prxResult1.GetCoordinate();
com.epl.geometry.Point result2 = prxResult2.GetCoordinate();
NUnit.Framework.Assert.IsTrue(result1.GetX() == result2.GetX());
com.epl.geometry.Point result3 = prxResult3.GetCoordinate();
com.epl.geometry.Point result4 = prxResult4.GetCoordinate();
NUnit.Framework.Assert.IsTrue(result3.GetX() == result4.GetX());
}
internal static com.epl.geometry.Point Cluster_non_empty_points(com.epl.geometry.Point pt1, com.epl.geometry.Point pt2, double w1, int rank1, double w2, int rank2)
{
if (rank1 > rank2)
{
return(pt1);
}
else
{
if (rank2 < rank1)
{
return(pt2);
}
}
int[] rank = null;
double[] w = null;
com.epl.geometry.Point pt = new com.epl.geometry.Point();
com.epl.geometry.Clusterer.MergeVertices(pt1, pt2, w1, rank1, w2, rank2, pt, w, rank);
return(pt);
}
public static void TestCopy()
{
com.epl.geometry.MultiPoint mpoint = new com.epl.geometry.MultiPoint();
com.epl.geometry.Point pt0 = new com.epl.geometry.Point(0.0, 0.0, -1.0);
com.epl.geometry.Point pt1 = new com.epl.geometry.Point(0.0, 0.0, 1.0);
com.epl.geometry.Point pt2 = new com.epl.geometry.Point(0.0, 1.0, 1.0);
mpoint.Add(pt0);
mpoint.Add(pt1);
mpoint.Add(pt2);
mpoint.RemovePoint(1);
com.epl.geometry.MultiPoint mpCopy = (com.epl.geometry.MultiPoint)mpoint.Copy();
NUnit.Framework.Assert.IsTrue(mpCopy.Equals(mpoint));
com.epl.geometry.Point pt;
pt = mpCopy.GetPoint(0);
NUnit.Framework.Assert.IsTrue(pt.GetX() == pt0.GetX() && pt.GetY() == pt0.GetY());
pt = mpCopy.GetPoint(1);
NUnit.Framework.Assert.IsTrue(pt.GetX() == pt2.GetX() && pt.GetY() == pt2.GetY());
NUnit.Framework.Assert.IsTrue(mpCopy.GetPointCount() == 2);
}
public virtual void TestIntersection()
{
com.epl.geometry.OperatorIntersects op = (com.epl.geometry.OperatorIntersects)com.epl.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.epl.geometry.Operator.Type.Intersects);
com.epl.geometry.Polygon polygon = new com.epl.geometry.Polygon();
// outer ring1
polygon.StartPath(0, 0);
polygon.LineTo(10, 10);
polygon.LineTo(20, 0);
com.epl.geometry.Point point1 = new com.epl.geometry.Point(15, 10);
com.epl.geometry.Point point2 = new com.epl.geometry.Point(2, 10);
com.epl.geometry.Point point3 = new com.epl.geometry.Point(5, 5);
bool res = op.Execute(polygon, point1, null, null);
NUnit.Framework.Assert.IsTrue(!res);
res = op.Execute(polygon, point2, null, null);
NUnit.Framework.Assert.IsTrue(!res);
res = op.Execute(polygon, point3, null, null);
NUnit.Framework.Assert.IsTrue(res);
}
public virtual void TestTouchesOnPointAndEnvelope()
{
com.epl.geometry.SpatialReference sr = com.epl.geometry.SpatialReference.Create(4326);
com.epl.geometry.Point p = new com.epl.geometry.Point(-130, 10);
// Envelope env = new Envelope(p, 12, 12);//not touched
com.epl.geometry.Envelope env = new com.epl.geometry.Envelope(-130, 10, -110, 20);
// touched
bool isTouched;
try
{
isTouched = com.epl.geometry.GeometryEngine.Touches(p, env, sr);
}
catch (System.ArgumentException)
{
isTouched = false;
}
NUnit.Framework.Assert.AreEqual(isTouched, true);
}
public virtual void TestPointAndPoint2()
{
com.epl.geometry.Point basePl = new com.epl.geometry.Point(-115, 20);
com.epl.geometry.Point compPl = new com.epl.geometry.Point(-116, 20);
int noException = 1;
// no exception
com.epl.geometry.Geometry intersectGeom = null;
try
{
intersectGeom = com.epl.geometry.GeometryEngine.Intersect(basePl, compPl, com.epl.geometry.SpatialReference.Create(4326));
}
catch (System.Exception)
{
noException = 0;
}
NUnit.Framework.Assert.AreEqual(noException, 1);
NUnit.Framework.Assert.IsTrue(intersectGeom.IsEmpty());
}
private void _set(int endPoint, com.epl.geometry.Point src)
{
_touch();
com.epl.geometry.Point point = src;
if (src.IsEmptyImpl())
{
// can not assign an empty point
throw new com.epl.geometry.GeometryException("empty_Geometry");
}
com.epl.geometry.VertexDescription vdin = point.GetDescription();
for (int attributeIndex = 0, nattrib = vdin.GetAttributeCount(); attributeIndex < nattrib; attributeIndex++)
{
int semantics = vdin._getSemanticsImpl(attributeIndex);
int ncomp = com.epl.geometry.VertexDescription.GetComponentCount(semantics);
for (int icomp = 0; icomp < ncomp; icomp++)
{
double v = point.GetAttributeAsDbl(semantics, icomp);
_setAttribute(endPoint, semantics, icomp, v);
}
}
}
public override void CopyTo(com.epl.geometry.Geometry dst)
{
if (dst.GetType() != com.epl.geometry.Geometry.Type.Point)
{
throw new System.ArgumentException();
}
com.epl.geometry.Point pointDst = (com.epl.geometry.Point)dst;
dst._touch();
if (m_attributes == null)
{
pointDst.SetEmpty();
pointDst.m_attributes = null;
pointDst.AssignVertexDescription(m_description);
}
else
{
pointDst.AssignVertexDescription(m_description);
pointDst.ResizeAttributes(m_description.GetTotalComponentCount());
AttributeCopy(m_attributes, pointDst.m_attributes, m_description.GetTotalComponentCount());
}
}
public virtual void GetCenter(com.epl.geometry.Point point_out)
{
point_out.AssignVertexDescription(m_description);
if (IsEmpty())
{
point_out.SetEmpty();
return;
}
int nattrib = m_description.GetAttributeCount();
for (int i = 1; i < nattrib; i++)
{
int semantics = m_description.GetSemantics(i);
int ncomp = com.epl.geometry.VertexDescription.GetComponentCount(semantics);
for (int iord = 0; iord < ncomp; iord++)
{
double v = 0.5 * (GetAttributeAsDblImpl_(0, semantics, iord) + GetAttributeAsDblImpl_(1, semantics, iord));
point_out.SetAttribute(semantics, iord, v);
}
}
point_out.SetXY(m_envelope.GetCenter());
}
/// <summary>Returns the center point of the envelope.</summary>
/// <returns>The center point of the envelope.</returns>
public virtual com.epl.geometry.Point GetCenter()
{
com.epl.geometry.Point pointOut = new com.epl.geometry.Point(m_description);
if (IsEmpty())
{
return(pointOut);
}
int nattrib = m_description.GetAttributeCount();
for (int i = 1; i < nattrib; i++)
{
int semantics = m_description._getSemanticsImpl(i);
int ncomp = com.epl.geometry.VertexDescription.GetComponentCount(semantics);
for (int iord = 0; iord < ncomp; iord++)
{
double v = 0.5 * (_getAttributeAsDbl(0, semantics, iord) + _getAttributeAsDbl(1, semantics, iord));
pointOut.SetAttribute(semantics, iord, v);
}
}
pointOut.SetXY(m_envelope.GetCenterX(), m_envelope.GetCenterY());
return(pointOut);
}
internal virtual com.epl.geometry.Point _RandomizeExisting()
{
if (points.Count == 0)
{
return(_GenerateNewPoint());
}
double f = random.NextDouble();
int num = (int)(f * points.Count);
com.epl.geometry.Point pt = points[num];
f = random.NextDouble();
// if (f > 0.9)
if (f > 2)
{
f = random.NextDouble();
pt.SetX(pt.GetX() + (1 - 2 * f) * 2 * tolerance);
f = random.NextDouble();
pt.SetY(pt.GetY() + (1 - 2 * f) * 2 * tolerance);
pt = _snapClip(pt, env);
}
return(pt);
}
private void _get(int endPoint, com.epl.geometry.Point outPoint)
{
if (IsEmptyImpl())
{
throw new com.epl.geometry.GeometryException("empty geometry");
}
// ._setToDefault();
outPoint.AssignVertexDescription(m_description);
if (outPoint.IsEmptyImpl())
{
outPoint._setToDefault();
}
for (int attributeIndex = 0; attributeIndex < m_description.GetAttributeCount(); attributeIndex++)
{
int semantics = m_description._getSemanticsImpl(attributeIndex);
for (int icomp = 0, ncomp = com.epl.geometry.VertexDescription.GetComponentCount(semantics); icomp < ncomp; icomp++)
{
double v = _getAttributeAsDbl(endPoint, semantics, icomp);
outPoint.SetAttribute(semantics, icomp, v);
}
}
}
