public virtual void TestEqualsOnMultiPoints()
{
com.epl.geometry.SpatialReference sr = com.epl.geometry.SpatialReference.Create(4326);
com.epl.geometry.MultiPoint baseMp = new com.epl.geometry.MultiPoint();
com.epl.geometry.MultiPoint compMp = new com.epl.geometry.MultiPoint();
baseMp.Add(new com.epl.geometry.Point(-116, 40));
baseMp.Add(new com.epl.geometry.Point(-120, 39));
baseMp.Add(new com.epl.geometry.Point(-121, 10));
baseMp.Add(new com.epl.geometry.Point(-130, 12));
baseMp.Add(new com.epl.geometry.Point(-108, 25));
compMp.Add(new com.epl.geometry.Point(-116, 40));
compMp.Add(new com.epl.geometry.Point(-120, 39));
compMp.Add(new com.epl.geometry.Point(-121, 10));
compMp.Add(new com.epl.geometry.Point(-130, 12));
compMp.Add(new com.epl.geometry.Point(-108, 25));
bool isEqual;
try
{
isEqual = com.epl.geometry.GeometryEngine.Equals(baseMp, compMp, sr);
}
catch (System.ArgumentException)
{
isEqual = false;
}
NUnit.Framework.Assert.IsTrue(isEqual);
}
public virtual void TestBufferMultiPoint()
{
com.epl.geometry.SpatialReference sr = com.epl.geometry.SpatialReference.Create(4326);
com.epl.geometry.OperatorBuffer buffer = (com.epl.geometry.OperatorBuffer)com.epl.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.epl.geometry.Operator.Type.Buffer);
com.epl.geometry.OperatorSimplify simplify = (com.epl.geometry.OperatorSimplify)com.epl.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.epl.geometry.Operator.Type.Simplify);
com.epl.geometry.MultiPoint inputGeom = new com.epl.geometry.MultiPoint();
inputGeom.Add(12, 120);
inputGeom.Add(20, 120);
com.epl.geometry.Geometry result = buffer.Execute(inputGeom, sr, 40.0, null);
NUnit.Framework.Assert.IsTrue(result.GetType().Value() == com.epl.geometry.Geometry.GeometryType.Polygon);
com.epl.geometry.Polygon poly = (com.epl.geometry.Polygon)(result);
com.epl.geometry.Envelope2D env2D = new com.epl.geometry.Envelope2D();
result.QueryEnvelope2D(env2D);
NUnit.Framework.Assert.IsTrue(System.Math.Abs(env2D.GetWidth() - 80 - 8) < 0.001 && System.Math.Abs(env2D.GetHeight() - 80) < 0.001);
NUnit.Framework.Assert.IsTrue(System.Math.Abs(env2D.GetCenterX() - 16) < 0.001 && System.Math.Abs(env2D.GetCenterY() - 120) < 0.001);
int pathCount = poly.GetPathCount();
NUnit.Framework.Assert.IsTrue(pathCount == 1);
int pointCount = poly.GetPointCount();
NUnit.Framework.Assert.IsTrue(System.Math.Abs(pointCount - 108.0) < 10);
NUnit.Framework.Assert.IsTrue(simplify.IsSimpleAsFeature(result, sr, null));
{
result = buffer.Execute(inputGeom, sr, 0, null);
NUnit.Framework.Assert.IsTrue(result.GetType().Value() == com.epl.geometry.Geometry.GeometryType.Polygon);
NUnit.Framework.Assert.IsTrue(result.IsEmpty());
}
{
result = buffer.Execute(inputGeom, sr, -1, null);
NUnit.Framework.Assert.IsTrue(result.GetType().Value() == com.epl.geometry.Geometry.GeometryType.Polygon);
NUnit.Framework.Assert.IsTrue(result.IsEmpty());
}
}
public virtual void TestMultiPointAndMultiPoint2()
{
com.epl.geometry.MultiPoint basePl = new com.epl.geometry.MultiPoint();
basePl.Add(new com.epl.geometry.Point(-116, 20));
basePl.Add(new com.epl.geometry.Point(-118, 21));
com.epl.geometry.MultiPoint compPl = new com.epl.geometry.MultiPoint();
compPl.Add(new com.epl.geometry.Point(-116, 20));
compPl.Add(new com.epl.geometry.Point(-118, 21));
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.IsNotNull(intersectGeom);
NUnit.Framework.Assert.IsTrue(intersectGeom.GetType() == com.epl.geometry.Geometry.Type.MultiPoint);
com.epl.geometry.MultiPoint ip = (com.epl.geometry.MultiPoint)intersectGeom;
NUnit.Framework.Assert.AreEqual(ip.GetPoint(0).GetX(), -116, 0.1E7);
NUnit.Framework.Assert.AreEqual(ip.GetPoint(0).GetY(), 20, 0.1E7);
NUnit.Framework.Assert.AreEqual(ip.GetPoint(0).GetX(), -118, 0.1E7);
NUnit.Framework.Assert.AreEqual(ip.GetPoint(0).GetY(), 21, 0.1E7);
}
public virtual void TestOffsetPoint()
{
try
{
com.epl.geometry.Point point = new com.epl.geometry.Point();
point.SetXY(0, 0);
com.epl.geometry.OperatorOffset offset = (com.epl.geometry.OperatorOffset)com.epl.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.epl.geometry.Operator.Type.Offset);
com.epl.geometry.Geometry outputGeom = offset.Execute(point, null, 2, com.epl.geometry.OperatorOffset.JoinType.Round, 2, 0, null);
NUnit.Framework.Assert.IsNull(outputGeom);
}
catch (System.Exception)
{
}
try
{
com.epl.geometry.MultiPoint mp = new com.epl.geometry.MultiPoint();
mp.Add(0, 0);
mp.Add(10, 10);
com.epl.geometry.OperatorOffset offset = (com.epl.geometry.OperatorOffset)com.epl.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.epl.geometry.Operator.Type.Offset);
com.epl.geometry.Geometry outputGeom = offset.Execute(mp, null, 2, com.epl.geometry.OperatorOffset.JoinType.Round, 2, 0, null);
NUnit.Framework.Assert.IsNull(outputGeom);
}
catch (System.Exception)
{
}
}
public virtual void TestMultiPoint()
{
com.epl.geometry.MultiPoint multiPoint1 = new com.epl.geometry.MultiPoint();
multiPoint1.Add(-97.06138, 32.837);
multiPoint1.Add(-97.06133, 32.836);
multiPoint1.Add(-97.06124, 32.834);
multiPoint1.Add(-97.06127, 32.832);
{
com.fasterxml.jackson.core.JsonParser mPointWgs84Parser = factory.CreateJsonParser(com.epl.geometry.GeometryEngine.GeometryToJson(spatialReferenceWGS84, multiPoint1));
com.epl.geometry.MapGeometry mPointWgs84MP = com.epl.geometry.GeometryEngine.JsonToGeometry(mPointWgs84Parser);
NUnit.Framework.Assert.IsTrue(multiPoint1.GetPointCount() == ((com.epl.geometry.MultiPoint)mPointWgs84MP.GetGeometry()).GetPointCount());
NUnit.Framework.Assert.IsTrue(multiPoint1.GetPoint(0).GetX() == ((com.epl.geometry.MultiPoint)mPointWgs84MP.GetGeometry()).GetPoint(0).GetX());
NUnit.Framework.Assert.IsTrue(multiPoint1.GetPoint(0).GetY() == ((com.epl.geometry.MultiPoint)mPointWgs84MP.GetGeometry()).GetPoint(0).GetY());
int lastIndex = multiPoint1.GetPointCount() - 1;
NUnit.Framework.Assert.IsTrue(multiPoint1.GetPoint(lastIndex).GetX() == ((com.epl.geometry.MultiPoint)mPointWgs84MP.GetGeometry()).GetPoint(lastIndex).GetX());
NUnit.Framework.Assert.IsTrue(multiPoint1.GetPoint(lastIndex).GetY() == ((com.epl.geometry.MultiPoint)mPointWgs84MP.GetGeometry()).GetPoint(lastIndex).GetY());
NUnit.Framework.Assert.IsTrue(spatialReferenceWGS84.GetID() == mPointWgs84MP.GetSpatialReference().GetID());
com.epl.geometry.MultiPoint mPointEmpty = new com.epl.geometry.MultiPoint();
string mPointEmptyString = com.epl.geometry.GeometryEngine.GeometryToJson(spatialReferenceWGS84, mPointEmpty);
mPointWgs84Parser = factory.CreateJsonParser(mPointEmptyString);
mPointWgs84MP = com.epl.geometry.GeometryEngine.JsonToGeometry(mPointWgs84Parser);
NUnit.Framework.Assert.IsTrue(mPointWgs84MP.GetGeometry().IsEmpty());
NUnit.Framework.Assert.IsTrue(spatialReferenceWGS84.GetID() == mPointWgs84MP.GetSpatialReference().GetID());
}
}
public OGCMultiPoint(com.epl.geometry.ogc.OGCPoint startPoint, com.epl.geometry.ogc.OGCPoint endPoint)
{
multiPoint = new com.epl.geometry.MultiPoint();
multiPoint.Add((com.epl.geometry.Point)startPoint.GetEsriGeometry());
multiPoint.Add((com.epl.geometry.Point)endPoint.GetEsriGeometry());
esriSR = startPoint.esriSR;
}
public virtual void TestMultiPointAndMultiPoint3()
{
com.epl.geometry.MultiPoint basePl = new com.epl.geometry.MultiPoint();
basePl.Add(new com.epl.geometry.Point(-116, 21));
basePl.Add(new com.epl.geometry.Point(-117, 20));
com.epl.geometry.MultiPoint compPl = new com.epl.geometry.MultiPoint();
compPl.Add(new com.epl.geometry.Point(-116, 20));
compPl.Add(new com.epl.geometry.Point(-117, 21));
compPl.Add(new com.epl.geometry.Point(-118, 20));
compPl.Add(new com.epl.geometry.Point(-119, 21));
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());
}
/// <exception cref="com.fasterxml.jackson.core.JsonParseException"/>
/// <exception cref="System.IO.IOException"/>
internal virtual bool TestMultiPoint()
{
bool bAnswer = true;
com.epl.geometry.MultiPoint multiPoint1 = new com.epl.geometry.MultiPoint();
multiPoint1.Add(-97.06138, 32.837);
multiPoint1.Add(-97.06133, 32.836);
multiPoint1.Add(-97.06124, 32.834);
multiPoint1.Add(-97.06127, 32.832);
{
string s = com.epl.geometry.GeometryEngine.GeometryToJson(spatialReferenceWGS84, multiPoint1);
com.fasterxml.jackson.core.JsonParser mPointWgs84Parser = factory.CreateParser(s);
com.epl.geometry.MapGeometry mPointWgs84MP = com.epl.geometry.GeometryEngine.JsonToGeometry(mPointWgs84Parser);
NUnit.Framework.Assert.IsTrue(multiPoint1.GetPointCount() == ((com.epl.geometry.MultiPoint)mPointWgs84MP.GetGeometry()).GetPointCount());
NUnit.Framework.Assert.IsTrue(multiPoint1.GetPoint(0).GetX() == ((com.epl.geometry.MultiPoint)mPointWgs84MP.GetGeometry()).GetPoint(0).GetX());
NUnit.Framework.Assert.IsTrue(multiPoint1.GetPoint(0).GetY() == ((com.epl.geometry.MultiPoint)mPointWgs84MP.GetGeometry()).GetPoint(0).GetY());
int lastIndex = multiPoint1.GetPointCount() - 1;
NUnit.Framework.Assert.IsTrue(multiPoint1.GetPoint(lastIndex).GetX() == ((com.epl.geometry.MultiPoint)mPointWgs84MP.GetGeometry()).GetPoint(lastIndex).GetX());
NUnit.Framework.Assert.IsTrue(multiPoint1.GetPoint(lastIndex).GetY() == ((com.epl.geometry.MultiPoint)mPointWgs84MP.GetGeometry()).GetPoint(lastIndex).GetY());
NUnit.Framework.Assert.IsTrue(spatialReferenceWGS84.GetID() == mPointWgs84MP.GetSpatialReference().GetID());
if (!CheckResultSpatialRef(mPointWgs84MP, 4326, 0))
{
bAnswer = false;
}
}
{
com.epl.geometry.MultiPoint p = new com.epl.geometry.MultiPoint();
p.AddAttribute(com.epl.geometry.VertexDescription.Semantics.Z);
p.AddAttribute(com.epl.geometry.VertexDescription.Semantics.M);
string s = com.epl.geometry.GeometryEngine.GeometryToJson(spatialReferenceWebMerc1, p);
NUnit.Framework.Assert.IsTrue(s.Equals("{\"hasZ\":true,\"hasM\":true,\"points\":[],\"spatialReference\":{\"wkid\":102100,\"latestWkid\":3857}}"));
p.Add(10.0, 20.0, 30.0);
p.Add(20.0, 40.0, 60.0);
s = com.epl.geometry.GeometryEngine.GeometryToJson(spatialReferenceWebMerc1, p);
NUnit.Framework.Assert.IsTrue(s.Equals("{\"hasZ\":true,\"hasM\":true,\"points\":[[10,20,30,null],[20,40,60,null]],\"spatialReference\":{\"wkid\":102100,\"latestWkid\":3857}}"));
}
{
string points = "{\"hasM\" : false, \"hasZ\" : true, \"uncle remus\" : null, \"points\" : [ [0,0,1], [0.0,10.0,1], [10.0,10.0,1], [10.0,0.0,1, 6666] ],\"spatialReference\" : {\"wkid\" : 4326}}";
com.epl.geometry.MapGeometry mp = com.epl.geometry.GeometryEngine.JsonToGeometry(factory.CreateParser(points));
com.epl.geometry.MultiPoint multipoint = (com.epl.geometry.MultiPoint)mp.GetGeometry();
NUnit.Framework.Assert.IsTrue(multipoint.GetPointCount() == 4);
com.epl.geometry.Point2D point2d;
point2d = multipoint.GetXY(0);
NUnit.Framework.Assert.IsTrue(point2d.x == 0.0 && point2d.y == 0.0);
point2d = multipoint.GetXY(1);
NUnit.Framework.Assert.IsTrue(point2d.x == 0.0 && point2d.y == 10.0);
point2d = multipoint.GetXY(2);
NUnit.Framework.Assert.IsTrue(point2d.x == 10.0 && point2d.y == 10.0);
point2d = multipoint.GetXY(3);
NUnit.Framework.Assert.IsTrue(point2d.x == 10.0 && point2d.y == 0.0);
NUnit.Framework.Assert.IsTrue(multipoint.HasAttribute(com.epl.geometry.VertexDescription.Semantics.Z));
NUnit.Framework.Assert.IsTrue(!multipoint.HasAttribute(com.epl.geometry.VertexDescription.Semantics.M));
double z = multipoint.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.Z, 0, 0);
NUnit.Framework.Assert.IsTrue(z == 1);
com.epl.geometry.SpatialReference spatial_reference = mp.GetSpatialReference();
NUnit.Framework.Assert.IsTrue(spatial_reference.GetID() == 4326);
}
return(bAnswer);
}
private static com.epl.geometry.MultiPoint MakeMultiPoint()
{
com.epl.geometry.MultiPoint mpoint = new com.epl.geometry.MultiPoint();
mpoint.Add(0, 30);
mpoint.Add(15, 15);
mpoint.Add(0, 15);
return(mpoint);
}
internal static com.epl.geometry.Geometry Calculate(com.epl.geometry.Geometry geom, com.epl.geometry.ProgressTracker progress_tracker)
{
int gt = geom.GetType().Value();
if (gt == com.epl.geometry.Geometry.GeometryType.Polygon)
{
com.epl.geometry.Polyline dst = new com.epl.geometry.Polyline(geom.GetDescription());
if (!geom.IsEmpty())
{
((com.epl.geometry.MultiPathImpl)geom._getImpl())._copyToUnsafe((com.epl.geometry.MultiPathImpl)dst._getImpl());
}
return(dst);
}
else
{
if (gt == com.epl.geometry.Geometry.GeometryType.Polyline)
{
return(CalculatePolylineBoundary_(geom._getImpl(), progress_tracker, false, null));
}
else
{
if (gt == com.epl.geometry.Geometry.GeometryType.Envelope)
{
com.epl.geometry.Polyline dst = new com.epl.geometry.Polyline(geom.GetDescription());
if (!geom.IsEmpty())
{
dst.AddEnvelope((com.epl.geometry.Envelope)geom, false);
}
return(dst);
}
else
{
if (com.epl.geometry.Geometry.IsSegment(gt))
{
com.epl.geometry.MultiPoint mp = new com.epl.geometry.MultiPoint(geom.GetDescription());
if (!geom.IsEmpty() && !((com.epl.geometry.Segment)geom).IsClosed())
{
com.epl.geometry.Point pt = new com.epl.geometry.Point();
((com.epl.geometry.Segment)geom).QueryStart(pt);
mp.Add(pt);
((com.epl.geometry.Segment)geom).QueryEnd(pt);
mp.Add(pt);
}
return(mp);
}
else
{
if (com.epl.geometry.Geometry.IsPoint(gt))
{
// returns empty point for points and multipoints.
return(null);
}
}
}
}
}
throw new System.ArgumentException();
}
internal static com.epl.geometry.Geometry MultiPointSymDiffPoint_(com.epl.geometry.MultiPoint multi_point, com.epl.geometry.Point point, double tolerance, com.epl.geometry.ProgressTracker progress_tracker)
{
com.epl.geometry.MultiPointImpl multipointImpl = (com.epl.geometry.MultiPointImpl)(multi_point._getImpl());
com.epl.geometry.AttributeStreamOfDbl position = (com.epl.geometry.AttributeStreamOfDbl)(multipointImpl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION));
int point_count = multi_point.GetPointCount();
com.epl.geometry.Point2D point2D = point.GetXY();
com.epl.geometry.MultiPoint new_multipoint = (com.epl.geometry.MultiPoint)(multi_point.CreateInstance());
double tolerance_cluster = tolerance * System.Math.Sqrt(2.0) * 1.00001;
com.epl.geometry.Envelope2D env = new com.epl.geometry.Envelope2D();
multi_point.QueryEnvelope2D(env);
env.Inflate(tolerance_cluster, tolerance_cluster);
if (env.Contains(point2D))
{
double tolerance_cluster_sq = tolerance_cluster * tolerance_cluster;
bool b_found_covered = false;
bool[] covered = new bool[point_count];
for (int i = 0; i < point_count; i++)
{
covered[i] = false;
}
for (int i_1 = 0; i_1 < point_count; i_1++)
{
double x = position.Read(2 * i_1);
double y = position.Read(2 * i_1 + 1);
double dx = x - point2D.x;
double dy = y - point2D.y;
if (dx * dx + dy * dy <= tolerance_cluster_sq)
{
b_found_covered = true;
covered[i_1] = true;
}
}
if (!b_found_covered)
{
new_multipoint.Add(multi_point, 0, point_count);
new_multipoint.Add(point);
}
else
{
for (int i_2 = 0; i_2 < point_count; i_2++)
{
if (!covered[i_2])
{
new_multipoint.Add(multi_point, i_2, i_2 + 1);
}
}
}
}
else
{
new_multipoint.Add(multi_point, 0, point_count);
new_multipoint.Add(point);
}
return(new_multipoint);
}
public virtual void TestMultiPointGeometryEngine()
{
com.epl.geometry.MultiPoint mp = new com.epl.geometry.MultiPoint();
mp.Add(10.0, 20.0);
mp.Add(20.0, 30.0);
string result = com.epl.geometry.GeometryEngine.GeometryToGeoJson(mp);
NUnit.Framework.Assert.AreEqual("{\"type\":\"MultiPoint\",\"coordinates\":[[10,20],[20,30]]}", result);
}
public virtual void TestMultiPoint()
{
com.epl.geometry.MultiPoint mp = new com.epl.geometry.MultiPoint();
mp.Add(10.0, 20.0);
mp.Add(20.0, 30.0);
com.epl.geometry.OperatorExportToGeoJson exporter = (com.epl.geometry.OperatorExportToGeoJson)factory.GetOperator(com.epl.geometry.Operator.Type.ExportToGeoJson);
string result = exporter.Execute(mp);
NUnit.Framework.Assert.AreEqual("{\"type\":\"MultiPoint\",\"coordinates\":[[10,20],[20,30]]}", result);
}
public virtual void TestOGCMultiPoint()
{
com.epl.geometry.MultiPoint mp = new com.epl.geometry.MultiPoint();
mp.Add(10.0, 20.0);
mp.Add(20.0, 30.0);
com.epl.geometry.ogc.OGCMultiPoint ogcMultiPoint = new com.epl.geometry.ogc.OGCMultiPoint(mp, null);
string result = ogcMultiPoint.AsGeoJson();
NUnit.Framework.Assert.AreEqual("{\"type\":\"MultiPoint\",\"coordinates\":[[10,20],[20,30]],\"crs\":null}", result);
}
public virtual void TestSerializeMultiPoint()
{
try
{
java.io.ByteArrayOutputStream streamOut = new java.io.ByteArrayOutputStream();
java.io.ObjectOutputStream oo = new java.io.ObjectOutputStream(streamOut);
com.epl.geometry.MultiPoint pt = new com.epl.geometry.MultiPoint();
pt.Add(10, 30);
pt.Add(120, 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.MultiPoint ptRes = (com.epl.geometry.MultiPoint)ii.ReadObject();
NUnit.Framework.Assert.IsTrue(ptRes.Equals(pt));
}
catch (System.Exception)
{
Fail("MultiPoint serialization failure");
}
//try
//{
//FileOutputStream streamOut = new FileOutputStream("c:/temp/savedMultiPoint1.txt");
//ObjectOutputStream oo = new ObjectOutputStream(streamOut);
//MultiPoint pt = new MultiPoint();
//pt.add(10, 30);
//pt.add(120, 40);
//oo.writeObject(pt);
//}
//catch(Exception ex)
//{
//fail("MultiPoint serialization failure");
//}
try
{
java.io.InputStream s = typeof(com.epl.geometry.TestSerialization).GetResourceAsStream("savedMultiPoint.txt");
java.io.ObjectInputStream ii = new java.io.ObjectInputStream(s);
com.epl.geometry.MultiPoint ptRes = (com.epl.geometry.MultiPoint)ii.ReadObject();
NUnit.Framework.Assert.IsTrue(ptRes.GetPoint(1).GetY() == 40);
}
catch (System.Exception)
{
Fail("MultiPoint serialization failure");
}
try
{
java.io.InputStream s = typeof(com.epl.geometry.TestSerialization).GetResourceAsStream("savedMultiPoint1.txt");
java.io.ObjectInputStream ii = new java.io.ObjectInputStream(s);
com.epl.geometry.MultiPoint ptRes = (com.epl.geometry.MultiPoint)ii.ReadObject();
NUnit.Framework.Assert.IsTrue(ptRes.GetPoint(1).GetY() == 40);
}
catch (System.Exception)
{
Fail("MultiPoint serialization failure");
}
}
public static com.epl.geometry.MultiPoint MakeMultiPoint3()
{
com.epl.geometry.MultiPoint mpoint = new com.epl.geometry.MultiPoint();
com.epl.geometry.Point2D pt1 = new com.epl.geometry.Point2D();
pt1.x = 1.0;
pt1.y = 1.0;
com.epl.geometry.Point2D pt2 = new com.epl.geometry.Point2D();
pt2.x = 5.0;
pt2.y = 5.0;
mpoint.Add(pt1.x, pt1.y);
mpoint.Add(pt2.x, pt2.y);
return(mpoint);
}
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);
}
private com.epl.geometry.Geometry Get_result_geometry(int dim)
{
System.Diagnostics.Debug.Assert((m_dim_geom_counts[dim] > 0));
System.Collections.Generic.SortedDictionary <int, com.epl.geometry.OperatorUnionCursor.Bin_type> map = m_union_bins[dim];
System.Collections.Generic.KeyValuePair <int, com.epl.geometry.OperatorUnionCursor.Bin_type> e = map.First();
com.epl.geometry.OperatorUnionCursor.Bin_type bin = e.Value;
com.epl.geometry.Geometry resG;
resG = bin.Back_pair().geom;
bool unioned = bin.Back_pair().unioned;
map.Remove(e.Key);
if (unioned)
{
resG = com.epl.geometry.OperatorSimplify.Local().Execute(resG, m_spatial_reference, false, m_progress_tracker);
if (dim == 0 && resG.GetType() == com.epl.geometry.Geometry.Type.Point)
{
// must
// return
// multipoint
// for
// points
com.epl.geometry.MultiPoint mp = new com.epl.geometry.MultiPoint(resG.GetDescription());
if (!resG.IsEmpty())
{
mp.Add((com.epl.geometry.Point)resG);
}
resG = mp;
}
}
return(resG);
}
public static void Test2()
{
com.epl.geometry.MultiPoint multipoint = new com.epl.geometry.MultiPoint();
for (int i = 0; i < 100; i++)
{
for (int j = 0; j < 100; j++)
{
multipoint.Add(i, j);
}
}
com.epl.geometry.Envelope2D extent = new com.epl.geometry.Envelope2D();
multipoint.QueryEnvelope2D(extent);
com.epl.geometry.MultiPointImpl multipointImpl = (com.epl.geometry.MultiPointImpl)multipoint._getImpl();
com.epl.geometry.QuadTree quadtree = BuildQuadTree_(multipointImpl);
com.epl.geometry.QuadTree.QuadTreeIterator qtIter = quadtree.GetIterator();
NUnit.Framework.Assert.IsTrue(qtIter.Next() == -1);
int count = 0;
qtIter.ResetIterator(extent, 0.0);
while (qtIter.Next() != -1)
{
count++;
}
NUnit.Framework.Assert.IsTrue(count == 10000);
}
internal static com.epl.geometry.MultiPoint MakeMultiPoint()
{
com.epl.geometry.MultiPoint mpoint = new com.epl.geometry.MultiPoint();
com.epl.geometry.Point2D pt1 = new com.epl.geometry.Point2D();
pt1.x = 10;
pt1.y = 10;
com.epl.geometry.Point2D pt2 = new com.epl.geometry.Point2D();
pt2.x = 15;
pt2.y = 10;
com.epl.geometry.Point2D pt3 = new com.epl.geometry.Point2D();
pt3.x = 10;
pt3.y = 20;
mpoint.Add(pt1.x, pt1.y);
mpoint.Add(pt2.x, pt2.y);
mpoint.Add(pt3.x, pt3.y);
return(mpoint);
}
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);
}
internal static com.epl.geometry.Geometry MultiPointMinusPolygon_(com.epl.geometry.MultiPoint multi_point, com.epl.geometry.Polygon polygon, double tolerance, com.epl.geometry.ProgressTracker progress_tracker)
{
com.epl.geometry.Envelope2D env = new com.epl.geometry.Envelope2D();
polygon.QueryEnvelope2D(env);
env.Inflate(tolerance, tolerance);
int point_count = multi_point.GetPointCount();
bool b_found_covered = false;
bool[] covered = new bool[point_count];
for (int i = 0; i < point_count; i++)
{
covered[i] = false;
}
com.epl.geometry.Point2D pt = new com.epl.geometry.Point2D();
for (int i_1 = 0; i_1 < point_count; i_1++)
{
multi_point.GetXY(i_1, pt);
if (!env.Contains(pt))
{
continue;
}
com.epl.geometry.PolygonUtils.PiPResult result = com.epl.geometry.PolygonUtils.IsPointInPolygon2D(polygon, pt, tolerance);
if (result == com.epl.geometry.PolygonUtils.PiPResult.PiPOutside)
{
continue;
}
b_found_covered = true;
covered[i_1] = true;
}
if (!b_found_covered)
{
return(multi_point);
}
com.epl.geometry.MultiPoint new_multipoint = (com.epl.geometry.MultiPoint)multi_point.CreateInstance();
for (int i_2 = 0; i_2 < point_count; i_2++)
{
if (!covered[i_2])
{
new_multipoint.Add(multi_point, i_2, i_2 + 1);
}
}
return(new_multipoint);
}
internal static com.epl.geometry.Geometry MultiPointMinusPoint_(com.epl.geometry.MultiPoint multi_point, com.epl.geometry.Point point, double tolerance, com.epl.geometry.ProgressTracker progress_tracker)
{
com.epl.geometry.MultiPointImpl multipointImpl = (com.epl.geometry.MultiPointImpl)(multi_point._getImpl());
com.epl.geometry.AttributeStreamOfDbl position = (com.epl.geometry.AttributeStreamOfDbl)(multipointImpl.GetAttributeStreamRef(com.epl.geometry.VertexDescription.Semantics.POSITION));
int point_count = multi_point.GetPointCount();
com.epl.geometry.Point2D point2D = point.GetXY();
com.epl.geometry.Point2D pt = new com.epl.geometry.Point2D();
bool b_found_covered = false;
bool[] covered = new bool[point_count];
for (int i = 0; i < point_count; i++)
{
covered[i] = false;
}
double tolerance_cluster = tolerance * System.Math.Sqrt(2.0) * 1.00001;
double tolerance_cluster_sq = tolerance_cluster * tolerance_cluster;
for (int i_1 = 0; i_1 < point_count; i_1++)
{
position.Read(2 * i_1, pt);
double sqr_dist = com.epl.geometry.Point2D.SqrDistance(pt, point2D);
if (sqr_dist <= tolerance_cluster_sq)
{
b_found_covered = true;
covered[i_1] = true;
}
}
if (!b_found_covered)
{
return(multi_point);
}
com.epl.geometry.MultiPoint new_multipoint = (com.epl.geometry.MultiPoint)(multi_point.CreateInstance());
for (int i_2 = 0; i_2 < point_count; i_2++)
{
if (!covered[i_2])
{
new_multipoint.Add(multi_point, i_2, i_2 + 1);
}
}
return(new_multipoint);
}
internal virtual com.epl.geometry.Geometry NormalizeIntersectionOutput(com.epl.geometry.Geometry geom, int GT_1, int GT_2)
{
if (GT_1 == com.epl.geometry.Geometry.GeometryType.Point || GT_2 == com.epl.geometry.Geometry.GeometryType.Point)
{
System.Diagnostics.Debug.Assert((geom.GetType().Value() == com.epl.geometry.Geometry.GeometryType.Point));
}
if (GT_1 == com.epl.geometry.Geometry.GeometryType.MultiPoint)
{
if (geom.GetType().Value() == com.epl.geometry.Geometry.GeometryType.Point)
{
com.epl.geometry.MultiPoint mp = new com.epl.geometry.MultiPoint(geom.GetDescription());
if (!geom.IsEmpty())
{
mp.Add((com.epl.geometry.Point)geom);
}
return mp;
}
}
return geom;
}
public OGCMultiPoint(com.epl.geometry.Point startPoint, com.epl.geometry.SpatialReference sr)
{
multiPoint = new com.epl.geometry.MultiPoint();
multiPoint.Add((com.epl.geometry.Point)startPoint);
esriSR = sr;
}
public static void TestCreation()
{
{
// simple create
com.epl.geometry.MultiPoint mpoint = new com.epl.geometry.MultiPoint();
NUnit.Framework.Assert.IsTrue(mpoint.GetType() == Geometry.Type.MultiPoint);
// assertFalse(mpoint.getClass() == Polyline.class);
NUnit.Framework.Assert.IsTrue(mpoint != null);
NUnit.Framework.Assert.IsTrue(mpoint.GetType() == com.epl.geometry.Geometry.Type.MultiPoint);
NUnit.Framework.Assert.IsTrue(mpoint.IsEmpty());
NUnit.Framework.Assert.IsTrue(mpoint.GetPointCount() == 0);
mpoint = null;
NUnit.Framework.Assert.IsFalse(mpoint != null);
}
{
// play with default attributes
com.epl.geometry.MultiPoint mpoint = new com.epl.geometry.MultiPoint();
SimpleTest(mpoint);
}
{
// simple create 2D
com.epl.geometry.MultiPoint mpoint = new com.epl.geometry.MultiPoint();
NUnit.Framework.Assert.IsTrue(mpoint != null);
com.epl.geometry.MultiPoint mpoint1 = new com.epl.geometry.MultiPoint();
NUnit.Framework.Assert.IsTrue(mpoint1 != null);
mpoint.SetEmpty();
com.epl.geometry.Point pt = new com.epl.geometry.Point(0, 0);
mpoint.Add(pt);
com.epl.geometry.Point pt3 = mpoint.GetPoint(0);
NUnit.Framework.Assert.IsTrue(pt3.GetX() == 0 && pt3.GetY() == 0);
// assertFalse(mpoint->HasAttribute(VertexDescription::Semantics::Z));
// pt3.setZ(115.0);
mpoint.SetPoint(0, pt3);
pt3 = mpoint.GetPoint(0);
NUnit.Framework.Assert.IsTrue(pt3.GetX() == 0 && pt3.GetY() == 0);
}
{
/* && pt3.getZ() == 115 */
// assertTrue(mpoint->HasAttribute(VertexDescription::Semantics::Z));
// CompareGeometryContent(mpoint, &pt, 1);
// move 3d
com.epl.geometry.MultiPoint mpoint = new com.epl.geometry.MultiPoint();
NUnit.Framework.Assert.IsTrue(mpoint != null);
com.epl.geometry.Point pt = new com.epl.geometry.Point(0, 0);
mpoint.Add(pt);
com.epl.geometry.Point pt3 = mpoint.GetPoint(0);
NUnit.Framework.Assert.IsTrue(pt3.GetX() == 0 && pt3.GetY() == 0);
}
{
/* && pt3.getZ() == 0 */
// test QueryInterval
com.epl.geometry.MultiPoint mpoint = new com.epl.geometry.MultiPoint();
com.epl.geometry.Point pt1 = new com.epl.geometry.Point(0.0, 0.0);
// pt1.setZ(-1.0);
com.epl.geometry.Point pt2 = new com.epl.geometry.Point(0.0, 0.0);
// pt2.setZ(1.0);
mpoint.Add(pt1);
mpoint.Add(pt2);
// Envelope1D e =
// mpoint->QueryInterval(enum_value2(VertexDescription, Semantics,
// Z), 0);
com.epl.geometry.Envelope e = new com.epl.geometry.Envelope();
mpoint.QueryEnvelope(e);
}
{
// assertTrue(e.get == -1.0 && e.vmax == 1.0);
com.epl.geometry.MultiPoint geom = new com.epl.geometry.MultiPoint();
}
{
// int sz = sizeof(openString) / sizeof(openString[0]);
// for (int i = 0; i < sz; i++)
// geom.add(openString[i]);
// CompareGeometryContent(geom, openString, sz);
com.epl.geometry.MultiPoint geom = new com.epl.geometry.MultiPoint();
}
{
// int sz = sizeof(openString) / sizeof(openString[0]);
// Point point = GCNEW Point;
// for (int i = 0; i < sz; i++)
// {
// point.setXY(openString[i]);
// geom.add(point);
// }
// CompareGeometryContent(geom, openString, sz);
// Test AddPoints
com.epl.geometry.MultiPoint geom = new com.epl.geometry.MultiPoint();
}
{
// int sz = sizeof(openString) / sizeof(openString[0]);
// geom.addPoints(openString, sz, 0, -1);
// CompareGeometryContent((MultiVertexGeometry)geom, openString,
// sz);
// Test InsertPoint(Point2D)
com.epl.geometry.MultiPoint mpoint = new com.epl.geometry.MultiPoint();
com.epl.geometry.Point pt0 = new com.epl.geometry.Point(0.0, 0.0);
// pt0.setZ(-1.0);
// pt0.setID(7);
com.epl.geometry.Point pt1 = new com.epl.geometry.Point(0.0, 0.0);
// pt1.setZ(1.0);
// pt1.setID(11);
com.epl.geometry.Point pt2 = new com.epl.geometry.Point(0.0, 1.0);
// pt2.setZ(1.0);
// pt2.setID(13);
mpoint.Add(pt0);
mpoint.Add(pt1);
mpoint.Add(pt2);
com.epl.geometry.Point pt3 = new com.epl.geometry.Point(-11.0, -13.0);
mpoint.Add(pt3);
mpoint.InsertPoint(1, pt3);
NUnit.Framework.Assert.IsTrue(mpoint.GetPointCount() == 5);
com.epl.geometry.Point pt;
pt = mpoint.GetPoint(0);
NUnit.Framework.Assert.IsTrue(pt.GetX() == pt0.GetX() && pt.GetY() == pt0.GetY());
/*
* &&
* pt.
* getZ
* () ==
* pt0
* .getZ
* ()
*/
pt = mpoint.GetPoint(1);
NUnit.Framework.Assert.IsTrue(pt.GetX() == pt3.GetX() && pt.GetY() == pt3.GetY());
pt = mpoint.GetPoint(2);
NUnit.Framework.Assert.IsTrue(pt.GetX() == pt1.GetX() && pt.GetY() == pt1.GetY());
/*
* &&
* pt.
* getZ
* () ==
* pt1
* .getZ
* ()
*/
pt = mpoint.GetPoint(3);
NUnit.Framework.Assert.IsTrue(pt.GetX() == pt2.GetX() && pt.GetY() == pt2.GetY());
/*
* &&
* pt.
* getZ
* () ==
* pt2
* .getZ
* ()
*/
com.epl.geometry.Point point = new com.epl.geometry.Point();
point.SetXY(17.0, 19.0);
// point.setID(12);
// point.setM(5);
mpoint.InsertPoint(2, point);
mpoint.Add(point);
NUnit.Framework.Assert.IsTrue(mpoint.GetPointCount() == 7);
}
// double m;
// int id;
// pt = mpoint.getXYZ(2);
// assertTrue(pt.x == 17.0 && pt.y == 19.0 && pt.z == defaultZ);
// m = mpoint.getAttributeAsDbl(enum_value2(VertexDescription,
// Semantics, M), 2, 0);
// assertTrue(m == 5);
// id = mpoint.getAttributeAsInt(enum_value2(VertexDescription,
// Semantics, ID), 2, 0);
// assertTrue(id == 23);
//
// pt = mpoint.getXYZ(3);
// assertTrue(pt.x == pt1.x && pt.y == pt1.y && pt.z == pt1.z);
// m = mpoint.getAttributeAsDbl(enum_value2(VertexDescription,
// Semantics, M), 3, 0);
// assertTrue(NumberUtils::IsNaN(m));
// id = mpoint.getAttributeAsInt(enum_value2(VertexDescription,
// Semantics, ID), 3, 0);
// assertTrue(id == 11);
com.epl.geometry.MultiPoint mpoint_1 = new com.epl.geometry.MultiPoint();
com.epl.geometry.Point pt0_1 = new com.epl.geometry.Point(0.0, 0.0, -1.0);
com.epl.geometry.Point pt1_1 = new com.epl.geometry.Point(0.0, 0.0, 1.0);
com.epl.geometry.Point pt2_1 = new com.epl.geometry.Point(0.0, 1.0, 1.0);
mpoint_1.Add(pt0_1);
mpoint_1.Add(pt1_1);
mpoint_1.Add(pt2_1);
mpoint_1.RemovePoint(1);
com.epl.geometry.Point pt_1;
pt_1 = mpoint_1.GetPoint(0);
NUnit.Framework.Assert.IsTrue(pt_1.GetX() == pt0_1.GetX() && pt_1.GetY() == pt0_1.GetY());
pt_1 = mpoint_1.GetPoint(1);
NUnit.Framework.Assert.IsTrue(pt_1.GetX() == pt2_1.GetX() && pt_1.GetY() == pt2_1.GetY());
NUnit.Framework.Assert.IsTrue(mpoint_1.GetPointCount() == 2);
}
/// <summary>Performs the Distance operation on two geometries</summary>
/// <returns>Returns a double.</returns>
public override double Execute(com.epl.geometry.Geometry geom1, com.epl.geometry.Geometry geom2, com.epl.geometry.ProgressTracker progressTracker)
{
if (null == geom1 || null == geom2)
{
throw new System.ArgumentException();
}
com.epl.geometry.Geometry geometryA = geom1;
com.epl.geometry.Geometry geometryB = geom2;
if (geometryA.IsEmpty() || geometryB.IsEmpty())
{
return(com.epl.geometry.NumberUtils.TheNaN);
}
com.epl.geometry.Polygon polygonA;
com.epl.geometry.Polygon polygonB;
com.epl.geometry.MultiPoint multiPointA;
com.epl.geometry.MultiPoint multiPointB;
// if geometryA is an envelope use a polygon instead (if geom1 was
// folded, then geometryA will already be a polygon)
// if geometryA is a point use a multipoint instead
com.epl.geometry.Geometry.Type gtA = geometryA.GetType();
com.epl.geometry.Geometry.Type gtB = geometryB.GetType();
if (gtA == com.epl.geometry.Geometry.Type.Point)
{
if (gtB == com.epl.geometry.Geometry.Type.Point)
{
return(com.epl.geometry.Point2D.Distance(((com.epl.geometry.Point)geometryA).GetXY(), ((com.epl.geometry.Point)geometryB).GetXY()));
}
else
{
if (gtB == com.epl.geometry.Geometry.Type.Envelope)
{
com.epl.geometry.Envelope2D envB = new com.epl.geometry.Envelope2D();
geometryB.QueryEnvelope2D(envB);
return(envB.Distance(((com.epl.geometry.Point)geometryA).GetXY()));
}
}
multiPointA = new com.epl.geometry.MultiPoint();
multiPointA.Add((com.epl.geometry.Point)geometryA);
geometryA = multiPointA;
}
else
{
if (gtA == com.epl.geometry.Geometry.Type.Envelope)
{
if (gtB == com.epl.geometry.Geometry.Type.Envelope)
{
com.epl.geometry.Envelope2D envA = new com.epl.geometry.Envelope2D();
geometryA.QueryEnvelope2D(envA);
com.epl.geometry.Envelope2D envB = new com.epl.geometry.Envelope2D();
geometryB.QueryEnvelope2D(envB);
return(envB.Distance(envA));
}
polygonA = new com.epl.geometry.Polygon();
polygonA.AddEnvelope((com.epl.geometry.Envelope)geometryA, false);
geometryA = polygonA;
}
}
// if geom_2 is an envelope use a polygon instead
// if geom_2 is a point use a multipoint instead
if (gtB == com.epl.geometry.Geometry.Type.Point)
{
multiPointB = new com.epl.geometry.MultiPoint();
multiPointB.Add((com.epl.geometry.Point)geometryB);
geometryB = multiPointB;
}
else
{
if (gtB == com.epl.geometry.Geometry.Type.Envelope)
{
polygonB = new com.epl.geometry.Polygon();
polygonB.AddEnvelope((com.epl.geometry.Envelope)geometryB, false);
geometryB = polygonB;
}
}
com.epl.geometry.OperatorDistanceLocal.DistanceCalculator distanceCalculator = new com.epl.geometry.OperatorDistanceLocal.DistanceCalculator(this, progressTracker);
double distance = distanceCalculator.Calculate(geometryA, geometryB);
return(distance);
}
public static void TestPointTypes()
{
com.epl.geometry.OperatorFactoryLocal engine = com.epl.geometry.OperatorFactoryLocal.GetInstance();
com.epl.geometry.OperatorDifference difference = (com.epl.geometry.OperatorDifference)engine.GetOperator(com.epl.geometry.Operator.Type.Difference);
com.epl.geometry.OperatorSymmetricDifference sym_difference = (com.epl.geometry.OperatorSymmetricDifference)engine.GetOperator(com.epl.geometry.Operator.Type.SymmetricDifference);
{
// point/point
com.epl.geometry.Point point_1 = new com.epl.geometry.Point();
com.epl.geometry.Point point_2 = new com.epl.geometry.Point();
point_1.SetXY(0, 0);
point_2.SetXY(0.000000009, 0.000000009);
com.epl.geometry.Point differenced = (com.epl.geometry.Point)(difference.Execute(point_1, point_2, com.epl.geometry.SpatialReference.Create(4326), null));
NUnit.Framework.Assert.IsTrue(differenced.IsEmpty());
com.epl.geometry.MultiPoint sym_differenced = (com.epl.geometry.MultiPoint)(sym_difference.Execute(point_1, point_2, com.epl.geometry.SpatialReference.Create(4326), null));
NUnit.Framework.Assert.IsTrue(sym_differenced.IsEmpty());
}
{
// point/point
com.epl.geometry.Point point_1 = new com.epl.geometry.Point();
com.epl.geometry.Point point_2 = new com.epl.geometry.Point();
point_1.SetXY(0, 0);
point_2.SetXY(0.000000009, 0.0);
com.epl.geometry.Point differenced = (com.epl.geometry.Point)(difference.Execute(point_1, point_2, com.epl.geometry.SpatialReference.Create(4326), null));
NUnit.Framework.Assert.IsTrue(differenced.IsEmpty());
com.epl.geometry.MultiPoint sym_differenced = (com.epl.geometry.MultiPoint)(sym_difference.Execute(point_1, point_2, com.epl.geometry.SpatialReference.Create(4326), null));
NUnit.Framework.Assert.IsTrue(sym_differenced.IsEmpty());
}
{
// point/point
com.epl.geometry.Point point_1 = new com.epl.geometry.Point();
com.epl.geometry.Point point_2 = new com.epl.geometry.Point();
point_1.SetXY(0, 0);
point_2.SetXY(0.00000002, 0.00000002);
com.epl.geometry.Point differenced_1 = (com.epl.geometry.Point)(difference.Execute(point_1, point_2, com.epl.geometry.SpatialReference.Create(4326), null));
NUnit.Framework.Assert.IsTrue(!differenced_1.IsEmpty());
com.epl.geometry.Point differenced_2 = (com.epl.geometry.Point)(difference.Execute(point_2, point_1, com.epl.geometry.SpatialReference.Create(4326), null));
NUnit.Framework.Assert.IsTrue(!differenced_2.IsEmpty());
com.epl.geometry.MultiPoint sym_differenced = (com.epl.geometry.MultiPoint)(sym_difference.Execute(point_1, point_2, com.epl.geometry.SpatialReference.Create(4326), null));
NUnit.Framework.Assert.IsTrue(!sym_differenced.IsEmpty());
NUnit.Framework.Assert.IsTrue(sym_differenced.GetXY(0).x == 0 && sym_differenced.GetXY(0).y == 0);
NUnit.Framework.Assert.IsTrue(sym_differenced.GetXY(1).x == 0.00000002 && sym_differenced.GetXY(1).y == 0.00000002);
}
{
// multi_point/point
com.epl.geometry.MultiPoint multi_point_1 = new com.epl.geometry.MultiPoint();
com.epl.geometry.Point point_2 = new com.epl.geometry.Point();
multi_point_1.Add(0, 0);
multi_point_1.Add(1, 1);
point_2.SetXY(0.000000009, 0.000000009);
com.epl.geometry.MultiPoint differenced_1 = (com.epl.geometry.MultiPoint)(difference.Execute(multi_point_1, point_2, com.epl.geometry.SpatialReference.Create(4326), null));
NUnit.Framework.Assert.IsTrue(!differenced_1.IsEmpty());
NUnit.Framework.Assert.IsTrue(differenced_1.GetPointCount() == 1);
NUnit.Framework.Assert.IsTrue(differenced_1.GetXY(0).x == 1 && differenced_1.GetXY(0).y == 1);
com.epl.geometry.Point differenced_2 = (com.epl.geometry.Point)(difference.Execute(point_2, multi_point_1, com.epl.geometry.SpatialReference.Create(4326), null));
NUnit.Framework.Assert.IsTrue(differenced_2.IsEmpty());
}
{
// multi_point/point
com.epl.geometry.MultiPoint multi_point_1 = new com.epl.geometry.MultiPoint();
com.epl.geometry.Point point_2 = new com.epl.geometry.Point();
multi_point_1.Add(0, 0);
multi_point_1.Add(1, 1);
point_2.SetXY(0.000000009, 0.0);
com.epl.geometry.MultiPoint differenced_1 = (com.epl.geometry.MultiPoint)(difference.Execute(multi_point_1, point_2, com.epl.geometry.SpatialReference.Create(4326), null));
NUnit.Framework.Assert.IsTrue(!differenced_1.IsEmpty());
NUnit.Framework.Assert.IsTrue(differenced_1.GetXY(0).x == 1.0 && differenced_1.GetXY(0).y == 1.0);
com.epl.geometry.Point differenced_2 = (com.epl.geometry.Point)(difference.Execute(point_2, multi_point_1, com.epl.geometry.SpatialReference.Create(4326), null));
NUnit.Framework.Assert.IsTrue(differenced_2.IsEmpty());
com.epl.geometry.MultiPoint sym_differenced = (com.epl.geometry.MultiPoint)(sym_difference.Execute(multi_point_1, point_2, com.epl.geometry.SpatialReference.Create(4326), null));
NUnit.Framework.Assert.IsTrue(!sym_differenced.IsEmpty());
NUnit.Framework.Assert.IsTrue(sym_differenced.GetPointCount() == 1);
NUnit.Framework.Assert.IsTrue(sym_differenced.GetXY(0).x == 1 && sym_differenced.GetXY(0).y == 1);
}
{
// multi_point/point
com.epl.geometry.MultiPoint multi_point_1 = new com.epl.geometry.MultiPoint();
com.epl.geometry.Point point_2 = new com.epl.geometry.Point();
multi_point_1.Add(0, 0);
multi_point_1.Add(0, 0);
point_2.SetXY(0.000000009, 0.0);
com.epl.geometry.MultiPoint differenced_1 = (com.epl.geometry.MultiPoint)(difference.Execute(multi_point_1, point_2, com.epl.geometry.SpatialReference.Create(4326), null));
NUnit.Framework.Assert.IsTrue(differenced_1.IsEmpty());
com.epl.geometry.MultiPoint sym_differenced = (com.epl.geometry.MultiPoint)(sym_difference.Execute(multi_point_1, point_2, com.epl.geometry.SpatialReference.Create(4326), null));
NUnit.Framework.Assert.IsTrue(sym_differenced.IsEmpty());
}
{
// multi_point/polygon
com.epl.geometry.MultiPoint multi_point_1 = new com.epl.geometry.MultiPoint();
com.epl.geometry.Polygon polygon_2 = new com.epl.geometry.Polygon();
multi_point_1.Add(0, 0);
multi_point_1.Add(0, 0);
multi_point_1.Add(2, 2);
polygon_2.StartPath(-1, -1);
polygon_2.LineTo(-1, 1);
polygon_2.LineTo(1, 1);
polygon_2.LineTo(1, -1);
com.epl.geometry.MultiPoint differenced_1 = (com.epl.geometry.MultiPoint)(difference.Execute(multi_point_1, polygon_2, com.epl.geometry.SpatialReference.Create(4326), null));
NUnit.Framework.Assert.IsTrue(!differenced_1.IsEmpty());
NUnit.Framework.Assert.IsTrue(differenced_1.GetPointCount() == 1);
NUnit.Framework.Assert.IsTrue(differenced_1.GetXY(0).x == 2 && differenced_1.GetXY(0).y == 2);
}
{
// multi_point/polygon
com.epl.geometry.MultiPoint multi_point_1 = new com.epl.geometry.MultiPoint();
com.epl.geometry.Polygon polygon_2 = new com.epl.geometry.Polygon();
multi_point_1.Add(0, 0);
multi_point_1.Add(0, 0);
multi_point_1.Add(1, 1);
polygon_2.StartPath(-1, -1);
polygon_2.LineTo(-1, 1);
polygon_2.LineTo(1, 1);
polygon_2.LineTo(1, -1);
com.epl.geometry.MultiPoint differenced_1 = (com.epl.geometry.MultiPoint)(difference.Execute(multi_point_1, polygon_2, com.epl.geometry.SpatialReference.Create(4326), null));
NUnit.Framework.Assert.IsTrue(differenced_1.IsEmpty());
}
{
// multi_point/envelope
com.epl.geometry.MultiPoint multi_point_1 = new com.epl.geometry.MultiPoint();
com.epl.geometry.Envelope envelope_2 = new com.epl.geometry.Envelope();
multi_point_1.Add(-2, 0);
multi_point_1.Add(0, 2);
multi_point_1.Add(2, 0);
multi_point_1.Add(0, -2);
envelope_2.SetCoords(-1, -1, 1, 1);
com.epl.geometry.MultiPoint differenced_1 = (com.epl.geometry.MultiPoint)(difference.Execute(multi_point_1, envelope_2, com.epl.geometry.SpatialReference.Create(4326), null));
NUnit.Framework.Assert.IsTrue(!differenced_1.IsEmpty() && differenced_1 == multi_point_1);
}
{
// multi_point/polygon
com.epl.geometry.MultiPoint multi_point_1 = new com.epl.geometry.MultiPoint();
com.epl.geometry.Polygon polygon_2 = new com.epl.geometry.Polygon();
multi_point_1.Add(2, 2);
multi_point_1.Add(2, 2);
multi_point_1.Add(-2, -2);
polygon_2.StartPath(-1, -1);
polygon_2.LineTo(-1, 1);
polygon_2.LineTo(1, 1);
polygon_2.LineTo(1, -1);
com.epl.geometry.MultiPoint differenced_1 = (com.epl.geometry.MultiPoint)(difference.Execute(multi_point_1, polygon_2, com.epl.geometry.SpatialReference.Create(4326), null));
NUnit.Framework.Assert.IsTrue(!differenced_1.IsEmpty() && differenced_1 == multi_point_1);
}
{
// point/polygon
com.epl.geometry.Point point_1 = new com.epl.geometry.Point();
com.epl.geometry.Polygon polygon_2 = new com.epl.geometry.Polygon();
point_1.SetXY(0, 0);
polygon_2.StartPath(-1, -1);
polygon_2.LineTo(-1, 1);
polygon_2.LineTo(1, 1);
polygon_2.LineTo(1, -1);
com.epl.geometry.Point differenced_1 = (com.epl.geometry.Point)(difference.Execute(point_1, polygon_2, com.epl.geometry.SpatialReference.Create(4326), null));
NUnit.Framework.Assert.IsTrue(differenced_1.IsEmpty());
polygon_2.SetEmpty();
polygon_2.StartPath(1, 1);
polygon_2.LineTo(1, 2);
polygon_2.LineTo(2, 2);
polygon_2.LineTo(2, 1);
differenced_1 = (com.epl.geometry.Point)(difference.Execute(point_1, polygon_2, com.epl.geometry.SpatialReference.Create(4326), null));
NUnit.Framework.Assert.IsTrue(!differenced_1.IsEmpty());
NUnit.Framework.Assert.IsTrue(differenced_1 == point_1);
}
{
// point/polygon
com.epl.geometry.Point point_1 = new com.epl.geometry.Point();
com.epl.geometry.Polygon polygon_2 = new com.epl.geometry.Polygon();
point_1.SetXY(0, 0);
polygon_2.StartPath(1, 0);
polygon_2.LineTo(0, 1);
polygon_2.LineTo(1, 1);
com.epl.geometry.Point differenced_1 = (com.epl.geometry.Point)(difference.Execute(point_1, polygon_2, com.epl.geometry.SpatialReference.Create(4326), null));
NUnit.Framework.Assert.IsTrue(!differenced_1.IsEmpty());
NUnit.Framework.Assert.IsTrue(differenced_1 == point_1);
point_1.SetEmpty();
point_1.SetXY(0.5, 0.5);
polygon_2.SetEmpty();
polygon_2.StartPath(1, 0);
polygon_2.LineTo(0, 1);
polygon_2.LineTo(1, 1);
differenced_1 = (com.epl.geometry.Point)(difference.Execute(point_1, polygon_2, com.epl.geometry.SpatialReference.Create(4326), null));
NUnit.Framework.Assert.IsTrue(differenced_1.IsEmpty());
}
{
// point/envelope
com.epl.geometry.Point point_1 = new com.epl.geometry.Point();
com.epl.geometry.Envelope envelope_2 = new com.epl.geometry.Envelope();
point_1.SetXY(0, 0);
envelope_2.SetCoords(-1, -1, 1, 1);
com.epl.geometry.Point differenced_1 = (com.epl.geometry.Point)(difference.Execute(point_1, envelope_2, com.epl.geometry.SpatialReference.Create(4326), null));
NUnit.Framework.Assert.IsTrue(differenced_1.IsEmpty());
envelope_2.SetEmpty();
envelope_2.SetCoords(1, 1, 2, 2);
differenced_1 = (com.epl.geometry.Point)(difference.Execute(point_1, envelope_2, com.epl.geometry.SpatialReference.Create(4326), null));
NUnit.Framework.Assert.IsTrue(!differenced_1.IsEmpty());
NUnit.Framework.Assert.IsTrue(differenced_1 == point_1);
}
{
// point/polyline
com.epl.geometry.Point point_1 = new com.epl.geometry.Point();
com.epl.geometry.Polyline polyline_2 = new com.epl.geometry.Polyline();
point_1.SetXY(0, 0);
polyline_2.StartPath(-1, 0);
polyline_2.LineTo(1, 0);
com.epl.geometry.Point differenced_1 = (com.epl.geometry.Point)(difference.Execute(point_1, polyline_2, com.epl.geometry.SpatialReference.Create(4326), null));
NUnit.Framework.Assert.IsTrue(differenced_1.IsEmpty());
polyline_2.SetEmpty();
polyline_2.StartPath(1, 0);
polyline_2.LineTo(2, 0);
differenced_1 = (com.epl.geometry.Point)(difference.Execute(point_1, polyline_2, com.epl.geometry.SpatialReference.Create(4326), null));
NUnit.Framework.Assert.IsTrue(!differenced_1.IsEmpty());
NUnit.Framework.Assert.IsTrue(differenced_1 == point_1);
polyline_2.SetEmpty();
polyline_2.StartPath(-1, -1);
polyline_2.LineTo(-1, 1);
polyline_2.LineTo(1, 1);
polyline_2.LineTo(1, -1);
differenced_1 = (com.epl.geometry.Point)(difference.Execute(point_1, polyline_2, com.epl.geometry.SpatialReference.Create(4326), null));
NUnit.Framework.Assert.IsTrue(!differenced_1.IsEmpty());
NUnit.Framework.Assert.IsTrue(differenced_1 == point_1);
}
}
public virtual void TestMultiPoint()
{
com.epl.geometry.MultiPoint mp = new com.epl.geometry.MultiPoint();
mp.Add(new com.epl.geometry.Point(100, 200));
mp.Add(new com.epl.geometry.Point(101, 201));
mp.Add(new com.epl.geometry.Point(102, 202));
NUnit.Framework.Assert.IsFalse(mp.HasAttribute(com.epl.geometry.VertexDescription.Semantics.M));
mp.AddAttribute(com.epl.geometry.VertexDescription.Semantics.M);
NUnit.Framework.Assert.IsTrue(mp.HasAttribute(com.epl.geometry.VertexDescription.Semantics.M));
NUnit.Framework.Assert.IsTrue(double.IsNaN(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.M, 0, 0)));
NUnit.Framework.Assert.IsTrue(double.IsNaN(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.M, 1, 0)));
NUnit.Framework.Assert.IsTrue(double.IsNaN(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.M, 2, 0)));
mp.SetAttribute(com.epl.geometry.VertexDescription.Semantics.M, 0, 0, 1);
mp.SetAttribute(com.epl.geometry.VertexDescription.Semantics.M, 1, 0, 2);
mp.SetAttribute(com.epl.geometry.VertexDescription.Semantics.M, 2, 0, 3);
NUnit.Framework.Assert.IsTrue(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.M, 0, 0) == 1);
NUnit.Framework.Assert.IsTrue(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.M, 1, 0) == 2);
NUnit.Framework.Assert.IsTrue(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.M, 2, 0) == 3);
NUnit.Framework.Assert.IsFalse(mp.HasAttribute(com.epl.geometry.VertexDescription.Semantics.Z));
mp.AddAttribute(com.epl.geometry.VertexDescription.Semantics.Z);
NUnit.Framework.Assert.IsTrue(mp.HasAttribute(com.epl.geometry.VertexDescription.Semantics.Z));
NUnit.Framework.Assert.IsTrue(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.Z, 0, 0) == 0);
NUnit.Framework.Assert.IsTrue(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.Z, 1, 0) == 0);
NUnit.Framework.Assert.IsTrue(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.Z, 2, 0) == 0);
mp.SetAttribute(com.epl.geometry.VertexDescription.Semantics.Z, 0, 0, 11);
mp.SetAttribute(com.epl.geometry.VertexDescription.Semantics.Z, 1, 0, 21);
mp.SetAttribute(com.epl.geometry.VertexDescription.Semantics.Z, 2, 0, 31);
NUnit.Framework.Assert.IsTrue(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.M, 0, 0) == 1);
NUnit.Framework.Assert.IsTrue(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.M, 1, 0) == 2);
NUnit.Framework.Assert.IsTrue(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.M, 2, 0) == 3);
NUnit.Framework.Assert.IsTrue(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.Z, 0, 0) == 11);
NUnit.Framework.Assert.IsTrue(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.Z, 1, 0) == 21);
NUnit.Framework.Assert.IsTrue(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.Z, 2, 0) == 31);
NUnit.Framework.Assert.IsFalse(mp.HasAttribute(com.epl.geometry.VertexDescription.Semantics.ID));
mp.AddAttribute(com.epl.geometry.VertexDescription.Semantics.ID);
NUnit.Framework.Assert.IsTrue(mp.HasAttribute(com.epl.geometry.VertexDescription.Semantics.ID));
NUnit.Framework.Assert.IsTrue(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.ID, 0, 0) == 0);
NUnit.Framework.Assert.IsTrue(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.ID, 1, 0) == 0);
NUnit.Framework.Assert.IsTrue(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.ID, 2, 0) == 0);
mp.SetAttribute(com.epl.geometry.VertexDescription.Semantics.ID, 0, 0, -11);
mp.SetAttribute(com.epl.geometry.VertexDescription.Semantics.ID, 1, 0, -21);
mp.SetAttribute(com.epl.geometry.VertexDescription.Semantics.ID, 2, 0, -31);
NUnit.Framework.Assert.IsTrue(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.M, 0, 0) == 1);
NUnit.Framework.Assert.IsTrue(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.M, 1, 0) == 2);
NUnit.Framework.Assert.IsTrue(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.M, 2, 0) == 3);
NUnit.Framework.Assert.IsTrue(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.Z, 0, 0) == 11);
NUnit.Framework.Assert.IsTrue(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.Z, 1, 0) == 21);
NUnit.Framework.Assert.IsTrue(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.Z, 2, 0) == 31);
NUnit.Framework.Assert.IsTrue(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.ID, 0, 0) == -11);
NUnit.Framework.Assert.IsTrue(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.ID, 1, 0) == -21);
NUnit.Framework.Assert.IsTrue(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.ID, 2, 0) == -31);
mp.DropAttribute(com.epl.geometry.VertexDescription.Semantics.M);
NUnit.Framework.Assert.IsFalse(mp.HasAttribute(com.epl.geometry.VertexDescription.Semantics.M));
NUnit.Framework.Assert.IsTrue(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.Z, 0, 0) == 11);
NUnit.Framework.Assert.IsTrue(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.Z, 1, 0) == 21);
NUnit.Framework.Assert.IsTrue(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.Z, 2, 0) == 31);
NUnit.Framework.Assert.IsTrue(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.ID, 0, 0) == -11);
NUnit.Framework.Assert.IsTrue(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.ID, 1, 0) == -21);
NUnit.Framework.Assert.IsTrue(mp.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.ID, 2, 0) == -31);
com.epl.geometry.MultiPoint mp1 = new com.epl.geometry.MultiPoint();
mp.CopyTo(mp1);
NUnit.Framework.Assert.IsFalse(mp1.HasAttribute(com.epl.geometry.VertexDescription.Semantics.M));
NUnit.Framework.Assert.IsTrue(mp1.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.Z, 0, 0) == 11);
NUnit.Framework.Assert.IsTrue(mp1.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.Z, 1, 0) == 21);
NUnit.Framework.Assert.IsTrue(mp1.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.Z, 2, 0) == 31);
NUnit.Framework.Assert.IsTrue(mp1.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.ID, 0, 0) == -11);
NUnit.Framework.Assert.IsTrue(mp1.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.ID, 1, 0) == -21);
NUnit.Framework.Assert.IsTrue(mp1.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.ID, 2, 0) == -31);
mp1.DropAllAttributes();
mp1.MergeVertexDescription(mp.GetDescription());
NUnit.Framework.Assert.IsTrue(mp1.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.Z, 0, 0) == 0);
NUnit.Framework.Assert.IsTrue(mp1.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.Z, 1, 0) == 0);
NUnit.Framework.Assert.IsTrue(mp1.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.Z, 2, 0) == 0);
NUnit.Framework.Assert.IsTrue(double.IsNaN(mp1.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.M, 0, 0)));
NUnit.Framework.Assert.IsTrue(double.IsNaN(mp1.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.M, 1, 0)));
NUnit.Framework.Assert.IsTrue(double.IsNaN(mp1.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.M, 2, 0)));
NUnit.Framework.Assert.IsTrue(mp1.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.ID, 0, 0) == 0);
NUnit.Framework.Assert.IsTrue(mp1.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.ID, 1, 0) == 0);
NUnit.Framework.Assert.IsTrue(mp1.GetAttributeAsDbl(com.epl.geometry.VertexDescription.Semantics.ID, 2, 0) == 0);
}
public static com.epl.geometry.MultiPoint MakeMultiPoint2()
{
com.epl.geometry.MultiPoint mpoint = new com.epl.geometry.MultiPoint();
com.epl.geometry.Point2D pt1 = new com.epl.geometry.Point2D();
pt1.x = 1.0;
pt1.y = 1.0;
com.epl.geometry.Point2D pt2 = new com.epl.geometry.Point2D();
pt2.x = 1.0;
pt2.y = 1.0;
com.epl.geometry.Point2D pt3 = new com.epl.geometry.Point2D();
pt3.x = 15.0;
pt3.y = 15.0;
com.epl.geometry.Point2D pt4 = new com.epl.geometry.Point2D();
pt4.x = 15.0;
pt4.y = 15.0;
com.epl.geometry.Point2D pt5 = new com.epl.geometry.Point2D();
pt5.x = 1.0;
pt5.y = 1.0;
com.epl.geometry.Point2D pt6 = new com.epl.geometry.Point2D();
pt6.x = 1.0;
pt6.y = 1.0;
com.epl.geometry.Point2D pt7 = new com.epl.geometry.Point2D();
pt7.x = 15.0;
pt7.y = 15.0;
com.epl.geometry.Point2D pt8 = new com.epl.geometry.Point2D();
pt8.x = 15.0;
pt8.y = 15.0;
com.epl.geometry.Point2D pt9 = new com.epl.geometry.Point2D();
pt9.x = 15.0;
pt9.y = 15.0;
com.epl.geometry.Point2D pt10 = new com.epl.geometry.Point2D();
pt10.x = 1.0;
pt10.y = 1.0;
com.epl.geometry.Point2D pt11 = new com.epl.geometry.Point2D();
pt11.x = 15.0;
pt11.y = 15.0;
mpoint.Add(pt1.x, pt1.y);
mpoint.Add(pt2.x, pt2.y);
mpoint.Add(pt3.x, pt3.y);
mpoint.Add(pt4.x, pt4.y);
mpoint.Add(pt5.x, pt5.y);
mpoint.Add(pt6.x, pt6.y);
mpoint.Add(pt7.x, pt7.y);
mpoint.Add(pt8.x, pt8.y);
mpoint.Add(pt9.x, pt9.y);
mpoint.Add(pt10.x, pt10.y);
mpoint.Add(pt11.x, pt11.y);
return(mpoint);
}
