private static IGeometryCollection ClipGeometryCollection(IGeometryCollection geom, Envelope clipEnv)
{
var clipPoly = geom.Factory.ToGeometry(clipEnv);
var clipped = new List<IGeometry>();
for (var i = 0; i < geom.NumGeometries; i++)
{
var g = geom.GetGeometryN(i);
IGeometry result = null;
// don't clip unless necessary
if (clipEnv.Contains(g.EnvelopeInternal))
result = g;
else if (clipEnv.Intersects(g.EnvelopeInternal))
{
result = clipPoly.Intersection(g);
// keep vertex key info
result.UserData = g.UserData;
}
if (result != null && !result.IsEmpty)
{
clipped.Add(result);
}
}
return geom.Factory.CreateGeometryCollection(GeometryFactory.ToGeometryArray(clipped));
}
/// <summary>
/// Adds a <see cref="IGeometry"/> to the centroid total.
/// </summary>
/// <param name="geom">>The <see cref="IGeometry"/> to add.</param>
private void Add(IGeometry geom)
{
if (geom.IsEmpty)
{
return;
}
if (geom is IPoint)
{
AddPoint(geom.Coordinate);
}
else if (geom is ILineString)
{
AddLineSegments(geom.Coordinates);
}
else if (geom is IPolygon)
{
IPolygon poly = (IPolygon)geom;
Add(poly);
}
else if (geom is IGeometryCollection)
{
IGeometryCollection gc = (IGeometryCollection)geom;
for (int i = 0; i < gc.NumGeometries; i++)
{
Add(gc.GetGeometryN(i));
}
}
}
protected internal override int CompareToSameClass(object o, IComparer <ICoordinateSequence> comp)
{
IGeometryCollection gc = (IGeometryCollection)o;
int n1 = NumGeometries;
int n2 = gc.NumGeometries;
int i = 0;
while (i < n1 && i < n2)
{
IGeometry thisGeom = GetGeometryN(i);
Assert.IsTrue(thisGeom is Geometry);
IGeometry otherGeom = gc.GetGeometryN(i);
int holeComp = ((Geometry)thisGeom).CompareToSameClass(otherGeom, comp);
if (holeComp != 0)
{
return(holeComp);
}
i++;
}
if (i < n1)
{
return(1);
}
if (i < n2)
{
return(-1);
}
return(0);
}
private static IGeometryCollection ClipGeometryCollection(IGeometryCollection geom, Envelope clipEnv)
{
IGeometry clipPoly = geom.Factory.ToGeometry(clipEnv);
List <IGeometry> clipped = new List <IGeometry>();
for (int i = 0; i < geom.NumGeometries; i++)
{
IGeometry g = geom.GetGeometryN(i);
IGeometry result = null;
// don't clip unless necessary
if (clipEnv.Contains(g.EnvelopeInternal))
{
result = g;
}
else if (clipEnv.Intersects(g.EnvelopeInternal))
{
result = clipPoly.Intersection(g);
// keep vertex key info
result.UserData = g.UserData;
}
if (result != null && !result.IsEmpty)
{
clipped.Add(result);
}
}
return(geom.Factory.CreateGeometryCollection(GeometryFactory.ToGeometryArray(clipped)));
}
/// <summary>
///
/// </summary>
/// <param name="collection"></param>
/// <param name="operation"></param>
/// <returns></returns>
private IGeometryCollection EditGeometryCollection(IGeometryCollection collection, GeometryEditorOperation operation)
{
IGeometryCollection newCollection = (IGeometryCollection)operation.Edit(collection, factory);
ArrayList geometries = new ArrayList();
for (int i = 0; i < newCollection.NumGeometries; i++)
{
IGeometry geometry = Edit(newCollection.GetGeometryN(i), operation);
if (geometry.IsEmpty)
{
continue;
}
geometries.Add(geometry);
}
if (newCollection is IMultiPoint)
{
return(factory.CreateMultiPoint((IPoint[])geometries.ToArray(typeof(IPoint))));
}
if (newCollection is IMultiLineString)
{
return(factory.CreateMultiLineString((ILineString[])geometries.ToArray(typeof(ILineString))));
}
if (newCollection is IMultiPolygon)
{
return(factory.CreateMultiPolygon((IPolygon[])geometries.ToArray(typeof(IPolygon))));
}
return(factory.CreateGeometryCollection((IGeometry[])geometries.ToArray(typeof(IGeometry))));
}
private static void DoTest(Type expectedType)
{
string name = expectedType.Name;
string file = String.Format("{0}s", name.ToLowerInvariant().Substring(1));
string resname = String.Format("NetTopologySuite.Tests.NUnit.TestData.{0}.xml", file);
string path = EmbeddedResourceManager.SaveEmbeddedResourceToTempFile(resname);
var doc =
#if !PCL
new XmlDocument();
doc.Load(path);
#else
XDocument.Load(path);
#endif
GMLReader gr = new GMLReader();
IGeometryCollection gc = (IGeometryCollection)gr.Read(doc);
Assert.IsTrue(gc.NumGeometries == 25);
for (int i = 0; i < 25; i++)
{
IGeometry g = gc.GetGeometryN(i);
Assert.IsNotNull(g);
Assert.IsInstanceOf(expectedType, g);
}
}
public void LoadSourceGeometries(IGeometryCollection geomColl)
{
for (int i = 0; i < geomColl.NumGeometries; i++)
{
IGeometry geom = geomColl.GetGeometryN(i);
LoadVertices(geom.Coordinates, geom.UserData);
}
}
/// <summary>
///
/// </summary>
/// <param name="gc"></param>
private void AddCollection(IGeometryCollection gc)
{
for (int i = 0; i < gc.NumGeometries; i++)
{
IGeometry g = gc.GetGeometryN(i);
Add(g);
}
}
public void LoadSourceGeometries(IGeometryCollection geomColl)
{
for (int i = 0; i < geomColl.NumGeometries; i++)
{
IGeometry geom = geomColl.GetGeometryN(i);
LoadVertices(geom.Coordinates, geom.UserData);
}
}
private void AddCollection(IGeometryCollection gc)
{
for (int i = 0; i < gc.GetNumGeometries(); i++)
{
Geometry g = (Geometry)gc.GetGeometryN(i);
Add(g);
}
} // private void AddCollection(OGC.Geometries.IGeometryCollection gc)
/// <summary>
///
/// </summary>
/// <param name="gc"></param>
/// <returns></returns>
private IGeometry WidestGeometry(IGeometryCollection gc)
{
if (gc.IsEmpty)
{
return(gc);
}
IGeometry widestGeometry = gc.GetGeometryN(0);
for (int i = 1; i < gc.NumGeometries; i++) //Start at 1
{
if (gc.GetGeometryN(i).EnvelopeInternal.Width > widestGeometry.EnvelopeInternal.Width)
{
widestGeometry = gc.GetGeometryN(i);
}
}
return(widestGeometry);
}
private void WriteGeometryCollection(IGeometryCollection gc, int level,
StringBuilder sb)
{
StartLine("<MultiGeometry>\n", level, sb);
for (int t = 0; t < gc.NumGeometries; t++)
{
WriteGeometry(gc.GetGeometryN(t), level + 1, sb);
}
StartLine("</MultiGeometry>\n", level, sb);
}
private static IGeometry WidestGeometry(IGeometryCollection gc)
{
if (gc.IsEmpty)
{
return(gc);
}
var widestGeometry = gc.GetGeometryN(0);
// scan remaining geom components to see if any are wider
for (int i = 1; i < gc.NumGeometries; i++) //Start at 1
{
if (gc.GetGeometryN(i).EnvelopeInternal.Width > widestGeometry.EnvelopeInternal.Width)
{
widestGeometry = gc.GetGeometryN(i);
}
}
return(widestGeometry);
}
/// <summary>
/// Transforms a <see cref="GeoAPI.Geometries.IGeometryCollection"/>.
/// </summary>
/// <param name="geoms">GeometryCollection to transform</param>
/// <param name="from">Source Projection</param>
/// <param name="to">Target Projection</param>
/// <param name="toFactory">The factory to create geometries for <paramref name="to"/></param>
/// <returns>Transformed GeometryCollection</returns>
public static IGeometryCollection TransformGeometryCollection(IGeometryCollection geoms, ProjectionInfo from, ProjectionInfo to, IGeometryFactory toFactory)
{
var gOut = new IGeometry[geoms.Count];
for (var i = 0; i < geoms.Count; i++)
{
gOut[i] = TransformGeometry(geoms.GetGeometryN(i), from, to, toFactory);
}
return(toFactory.CreateGeometryCollection(gOut));
}
/// <summary>
///
/// </summary>
/// <param name="gc"></param>
/// <returns></returns>
public IGeometryCollection Map(IGeometryCollection gc)
{
IList<IGeometry> mapped = new List<IGeometry>();
for (var i = 0; i < gc.NumGeometries; i++)
{
var g = _mapOp(gc.GetGeometryN(i));
if (!g.IsEmpty)
mapped.Add(g);
}
return gc.Factory.CreateGeometryCollection(
GeometryFactory.ToGeometryArray(mapped));
}
/// <summary>
///
/// </summary>
/// <param name="gc"></param>
/// <returns></returns>
private bool HasRepeatedPoint(IGeometryCollection gc)
{
for (int i = 0; i < gc.NumGeometries; i++)
{
IGeometry g = gc.GetGeometryN(i);
if (HasRepeatedPoint(g))
{
return(true);
}
}
return(false);
}
private GraphicsPath ToShape(IGeometryCollection gc)
{
var shape = new GeometryCollectionGraphicsPath();
// add components to GC shape
for (int i = 0; i < gc.NumGeometries; i++)
{
var g = gc.GetGeometryN(i);
shape.Add(ToShape(g));
}
return(shape.Path);
}
private static void WriteCollection(IGeometryCollection geometry, PostGis2GeometryHeader pgh, BinaryWriter writer)
{
writer.Write((uint)geometry.OgcGeometryType.ToPostGis2());
if (geometry.IsEmpty)
{
writer.Write(0);
return;
}
for (var i = 0; i < geometry.NumGeometries; i++)
{
Write(geometry.GetGeometryN(i), writer, pgh.Ordinates, pgh.IsGeodetic);
}
}
private SdoGeometry Write(IGeometryCollection geometryCollection)
{
var elemInfoList = new List <decimal>();
var ordinateList = new List <decimal>();
int pos = 1;
int cnt = geometryCollection.NumGeometries;
for (int i = 0; i < cnt; i++)
{
var geom = geometryCollection.GetGeometryN(i);
switch (geom.OgcGeometryType)
{
case OgcGeometryType.Point:
pos = ProcessPoint((IPoint)geom, elemInfoList, ordinateList, pos);
break;
case OgcGeometryType.LineString:
pos = ProcessLinear((ILineString)geom, elemInfoList, ordinateList, pos);
break;
case OgcGeometryType.Polygon:
pos = ProcessPolygon((IPolygon)geom, elemInfoList, ordinateList, pos);
break;
case OgcGeometryType.MultiPoint:
pos = ProcessMultiPoint((IMultiPoint)geom, elemInfoList, ordinateList, pos);
break;
case OgcGeometryType.MultiLineString:
pos = ProcessMultiLineString((IMultiLineString)geom, elemInfoList, ordinateList, pos);
break;
case OgcGeometryType.MultiPolygon:
pos = ProcessMultiPolygon((IMultiPolygon)geom, elemInfoList, ordinateList, pos);
break;
default:
throw new ArgumentException("Geometry not supported in GeometryCollection: " + geom);
}
}
return(new SdoGeometry
{
SdoGtype = GType(geometryCollection),
Sdo_Srid = geometryCollection.SRID,
ElemArray = elemInfoList.ToArray(),
OrdinatesArray = ordinateList.ToArray(),
});
}
/// <summary>
///
/// </summary>
/// <param name="collection"></param>
/// <returns></returns>
private static ICoordinateSequence BuildSequence(IGeometryCollection collection)
{
var seq = collection.Factory.CoordinateSequenceFactory.Create(collection.NumPoints,
DetectOrdinates(collection));
var count = 0;
for (var i = 0; i < collection.Count; i++)
{
var tmp = collection.GetGeometryN(i);
ICoordinateSequence tmpSeq = null;
switch (tmp.OgcGeometryType)
{
case OgcGeometryType.Point:
tmpSeq = ((IPoint)tmp).CoordinateSequence;
break;
case OgcGeometryType.LineString:
tmpSeq = ((ILineString)tmp).CoordinateSequence;
break;
case OgcGeometryType.Polygon:
var poly = (IPolygon)tmp;
tmpSeq = poly.ExteriorRing.CoordinateSequence;
if (poly.NumInteriorRings > 0)
{
CoordinateSequences.Copy(tmpSeq, 0, seq, count, tmpSeq.Count);
int j;
for (j = 0; j < poly.NumInteriorRings - 1; j++)
{
tmpSeq = poly.GetInteriorRingN(j).CoordinateSequence;
CoordinateSequences.Copy(tmpSeq, 0, seq, count, tmpSeq.Count);
count += tmpSeq.Count;
}
tmpSeq = poly.GetInteriorRingN(j).CoordinateSequence;
}
break;
default:
throw new ArgumentException("Invalid geometry type");
}
if (tmpSeq != null)
{
CoordinateSequences.Copy(tmpSeq, 0, seq, count, tmpSeq.Count);
count += tmpSeq.Count;
}
}
return(seq);
}
/// <summary>
///
/// </summary>
/// <param name="gc"></param>
/// <returns></returns>
public IGeometryCollection Map(IGeometryCollection gc)
{
IList <IGeometry> mapped = new List <IGeometry>();
for (var i = 0; i < gc.NumGeometries; i++)
{
var g = _mapOp(gc.GetGeometryN(i));
if (!g.IsEmpty)
{
mapped.Add(g);
}
}
return(gc.Factory.CreateGeometryCollection(
GeometryFactory.ToGeometryArray(mapped)));
}
private static GeoAPIGeometryCollection FromGeometryCollection(IGeometryCollection geometry, GeoAPIGeometryFactory factory, bool copyUserData)
{
var dsGeometries = new GeoAPI.Geometries.IGeometry[geometry.NumGeometries];
for (var i = 0; i < dsGeometries.Length; i++)
{
dsGeometries[i] = FromGeometry(geometry.GetGeometryN(i), factory, copyUserData);
}
var result = factory.CreateGeometryCollection(dsGeometries);
if (copyUserData)
{
result.UserData = geometry.UserData;
}
return(result);
}
private static DSGeometryCollection FromGeometryCollection(IGeometryCollection geometry, DSGeometryFactory factory, bool setUserData)
{
var dsGeometries = new DotSpatial.Topology.IGeometry[geometry.NumGeometries];
for (var i = 0; i < dsGeometries.Length; i++)
{
dsGeometries[i] = FromGeometry(geometry.GetGeometryN(i), factory, setUserData);
}
var result = factory.CreateGeometryCollection(dsGeometries);
if (setUserData)
{
result.UserData = geometry.UserData;
}
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="geom"></param>
/// <param name="parent"></param>
/// <returns></returns>
protected virtual IGeometry TransformGeometryCollection(IGeometryCollection geom, IGeometry parent)
{
ArrayList transGeomList = new ArrayList();
for (int i = 0; i < geom.NumGeometries; i++)
{
IGeometry transformGeom = Transform(geom.GetGeometryN(i));
if (transformGeom == null)
{
continue;
}
if (PRUNE_EMPTY_GEOMETRY && transformGeom.IsEmpty)
{
continue;
}
transGeomList.Add(transformGeom);
}
return(_factory.CreateGeometryCollection(GeometryFactory.ToGeometryArray(transGeomList)));
}
/// <summary>
/// Converts a <c>GeometryCollection</c> to GeometryCollectionText
/// format, then appends it to the writer.
/// </summary>
/// <param name="geometryCollection">The <c>GeometryCollection</c> to process.</param>
/// <param name="level"></param>
/// <param name="writer">The output writer to append to.</param>
private void AppendGeometryCollectionText(IGeometryCollection geometryCollection, int level, TextWriter writer)
{
if (geometryCollection.IsEmpty)
{
writer.Write(" EMPTY");
}
else
{
var level2 = level;
writer.Write("(");
for (var i = 0; i < geometryCollection.NumGeometries; i++)
{
if (i > 0)
{
writer.Write(",");
level2 = level + 1;
}
AppendGeometryTaggedText(geometryCollection.GetGeometryN(i), level2, writer);
}
writer.Write(")");
}
}
/// <summary>
/// Writes a geometrycollection.
/// </summary>
/// <param name="gc">The geometrycollection to be written.</param>
/// <param name="bWriter">Stream to write to.</param>
/// <param name="byteorder">Byte order</param>
private static void WriteGeometryCollection(IGeometryCollection gc, BinaryWriter bWriter, WkbByteOrder byteorder)
{
//Get the number of geometries in this geometrycollection.
var num = gc.NumGeometries;
//Write the number of geometries.
WriteUInt32((uint)num, bWriter, byteorder);
//Loop on the number of geometries.
//NOTE: by contract, the first item returned
// from GetEnumerator (i.e. using foreach) is the IGeometryCollection itself!
for (var i = 0; i < num; i++)
{
IGeometry geom = gc.GetGeometryN(i);
//Write the byte-order format of the following geometry.
bWriter.Write((byte)byteorder);
//Write the type of each geometry.
WriteType(geom, bWriter, byteorder);
//Write each geometry.
WriteGeometry(geom, bWriter, byteorder);
}
}
/// <summary>
///
/// </summary>
/// <param name="geom"></param>
/// <param name="parent"></param>
/// <returns></returns>
protected virtual IGeometry TransformGeometryCollection(IGeometryCollection geom, IGeometry parent)
{
ArrayList transGeomList = new ArrayList();
for (int i = 0; i < geom.NumGeometries; i++)
{
IGeometry transformGeom = Transform(geom.GetGeometryN(i));
if (transformGeom == null)
{
continue;
}
if (pruneEmptyGeometry && transformGeom.IsEmpty)
{
continue;
}
transGeomList.Add(transformGeom);
}
if (preserveGeometryCollectionType)
{
return(factory.CreateGeometryCollection(GeometryFactory.ToGeometryArray(transGeomList)));
}
return(factory.BuildGeometry(transGeomList));
}
/// <summary>
///
/// </summary>
/// <param name="gc"></param>
/// <returns></returns>
private static IGeometry WidestGeometry(IGeometryCollection gc)
{
if (gc.IsEmpty)
return gc;
IGeometry widestGeometry = gc.GetGeometryN(0);
for (int i = 1; i < gc.NumGeometries; i++) //Start at 1
if (gc.GetGeometryN(i).EnvelopeInternal.Width > widestGeometry.EnvelopeInternal.Width)
widestGeometry = gc.GetGeometryN(i);
return widestGeometry;
}
/// <summary>
///
/// </summary>
/// <param name="geom"></param>
/// <param name="parent"></param>
/// <returns></returns>
protected virtual IGeometry TransformGeometryCollection(IGeometryCollection geom, IGeometry parent)
{
ArrayList transGeomList = new ArrayList();
for (int i = 0; i < geom.NumGeometries; i++)
{
IGeometry transformGeom = Transform(geom.GetGeometryN(i));
if (transformGeom == null) continue;
if (PRUNE_EMPTY_GEOMETRY && transformGeom.IsEmpty) continue;
transGeomList.Add(transformGeom);
}
return _factory.CreateGeometryCollection(GeometryFactory.ToGeometryArray(transGeomList));
}
/*
// Obsolete (slower code)
private Shape OLDtoShape(Polygon p)
{
ArrayList holeVertexCollection = new ArrayList();
for (int j = 0; j < p.getNumInteriorRing(); j++) {
holeVertexCollection.add(
toViewCoordinates(p.getInteriorRingN(j).getCoordinates()));
}
return new PolygonShape(
toViewCoordinates(p.getExteriorRing().getCoordinates()),
holeVertexCollection);
}
private Coordinate[] toViewCoordinates(Coordinate[] modelCoordinates)
{
Coordinate[] viewCoordinates = new Coordinate[modelCoordinates.length];
for (int i = 0; i < modelCoordinates.length; i++) {
Point2D point2D = toPoint(modelCoordinates[i]);
viewCoordinates[i] = new Coordinate(point2D.getX(), point2D.getY());
}
return viewCoordinates;
}
*/
private GraphicsPath ToShape(IGeometryCollection gc)
{
var shape = new GeometryCollectionGraphicsPath();
// add components to GC shape
for (int i = 0; i < gc.NumGeometries; i++)
{
var g = gc.GetGeometryN(i);
shape.Add(ToShape(g));
}
return shape.Path;
}
/// <summary>
/// Transforms a <see cref="GeoAPI.Geometries.IGeometryCollection"/>.
/// </summary>
/// <param name="geoms">GeometryCollection to transform</param>
/// <param name="from">Source Projection</param>
/// <param name="to">Target Projection</param>
/// <param name="toFactory">The factory to create geometries for <paramref name="to"/></param>
/// <returns>Transformed GeometryCollection</returns>
public static IGeometryCollection TransformGeometryCollection(IGeometryCollection geoms, ProjectionInfo from, ProjectionInfo to, IGeometryFactory toFactory)
{
var gOut = new IGeometry[geoms.Count];
for (var i = 0; i < geoms.Count; i++)
gOut[i] = TransformGeometry(geoms.GetGeometryN(i), from, to, toFactory);
return toFactory.CreateGeometryCollection(gOut);
}
/// <summary>
///
/// </summary>
/// <param name="gc"></param>
private void AddCollection(IGeometryCollection gc)
{
for (int i = 0; i < gc.NumGeometries; i++)
{
IGeometry g = gc.GetGeometryN(i);
Add(g);
}
}
/// <summary>
///
/// </summary>
/// <param name="gc"></param>
/// <returns></returns>
private bool HasRepeatedPoint(IGeometryCollection gc)
{
for (int i = 0; i < gc.NumGeometries; i++)
{
IGeometry g = gc.GetGeometryN(i);
if (HasRepeatedPoint(g))
return true;
}
return false;
}
/// <summary>
/// Writes a geometrycollection.
/// </summary>
/// <param name="gc">The geometrycollection to be written.</param>
/// <param name="bWriter">Stream to write to.</param>
/// <param name="byteorder">Byte order</param>
private static void WriteGeometryCollection(IGeometryCollection gc, BinaryWriter bWriter, WkbByteOrder byteorder)
{
//Get the number of geometries in this geometrycollection.
var num = gc.NumGeometries;
//Write the number of geometries.
WriteUInt32((uint) num, bWriter, byteorder);
//Loop on the number of geometries.
//NOTE: by contract, the first item returned
// from GetEnumerator (i.e. using foreach) is the IGeometryCollection itself!
for (var i = 0; i < num; i++)
{
IGeometry geom = gc.GetGeometryN(i);
//Write the byte-order format of the following geometry.
bWriter.Write((byte) byteorder);
//Write the type of each geometry.
WriteType(geom, bWriter, byteorder);
//Write each geometry.
WriteGeometry(geom, bWriter, byteorder);
}
}
private static GeoAPIGeometryCollection FromGeometryCollection(IGeometryCollection geometry, GeoAPIGeometryFactory factory, bool copyUserData)
{
var dsGeometries = new GeoAPI.Geometries.IGeometry[geometry.NumGeometries];
for (var i = 0; i < dsGeometries.Length; i++)
dsGeometries[i] = FromGeometry(geometry.GetGeometryN(i), factory, copyUserData);
var result = factory.CreateGeometryCollection(dsGeometries);
if (copyUserData)
result.UserData = geometry.UserData;
return result;
}
private static void WriteCollection(IGeometryCollection geometry, PostGis2GeometryHeader pgh, BinaryWriter writer)
{
writer.Write((uint)geometry.OgcGeometryType.ToPostGis2());
if (geometry.IsEmpty)
{
writer.Write(0);
return;
}
for (var i = 0; i < geometry.NumGeometries; i++)
Write(geometry.GetGeometryN(i), writer, pgh.Ordinates, pgh.IsGeodetic);
}
private void WriteGeometryCollection(IGeometryCollection gc, int level,
StringBuilder sb)
{
StartLine("<MultiGeometry>\n", level, sb);
for (int t = 0; t < gc.NumGeometries; t++)
WriteGeometry(gc.GetGeometryN(t), level + 1, sb);
StartLine("</MultiGeometry>\n", level, sb);
}
/// <summary>
///
/// </summary>
/// <param name="collection"></param>
/// <returns></returns>
private static ICoordinateSequence BuildSequence(IGeometryCollection collection)
{
var seq = collection.Factory.CoordinateSequenceFactory.Create(collection.NumPoints,
DetectOrdinates(collection));
var count = 0;
for (var i = 0; i < collection.Count; i++)
{
var tmp = collection.GetGeometryN(i);
ICoordinateSequence tmpSeq = null;
switch (tmp.OgcGeometryType)
{
case OgcGeometryType.Point:
tmpSeq = ((IPoint) tmp).CoordinateSequence;
break;
case OgcGeometryType.LineString:
tmpSeq = ((ILineString)tmp).CoordinateSequence;
break;
case OgcGeometryType.Polygon:
var poly = (IPolygon) tmp;
tmpSeq = poly.ExteriorRing.CoordinateSequence;
if (poly.NumInteriorRings > 0)
{
CoordinateSequences.Copy(tmpSeq, 0, seq, count, tmpSeq.Count);
int j;
for (j = 0; j < poly.NumInteriorRings - 1; j++)
{
tmpSeq = poly.GetInteriorRingN(j).CoordinateSequence;
CoordinateSequences.Copy(tmpSeq, 0, seq, count, tmpSeq.Count);
count += tmpSeq.Count;
}
tmpSeq = poly.GetInteriorRingN(j).CoordinateSequence;
}
break;
default:
throw new ArgumentException("Invalid geometry type");
}
if (tmpSeq != null)
{
CoordinateSequences.Copy(tmpSeq, 0, seq, count, tmpSeq.Count);
count += tmpSeq.Count;
}
}
return seq;
}
/// <summary>
/// Converts a <c>GeometryCollection</c> to GeometryCollectionText
/// format, then appends it to the writer.
/// </summary>
/// <param name="geometryCollection">The <c>GeometryCollection</c> to process.</param>
/// <param name="level"></param>
/// <param name="writer">The output writer to append to.</param>
private void AppendGeometryCollectionText(IGeometryCollection geometryCollection, int level, TextWriter writer)
{
if (geometryCollection.IsEmpty)
writer.Write(" EMPTY");
else
{
int level2 = level;
writer.Write("(");
for (int i = 0; i < geometryCollection.NumGeometries; i++)
{
if (i > 0)
{
writer.Write(",");
level2 = level + 1;
}
AppendGeometryTaggedText(geometryCollection.GetGeometryN(i), level2, writer);
}
writer.Write(")");
}
}
private static void DoTest(IGeometryCollection geomsWrite, Ordinates ordinates, bool testGetOrdinate = true)
{
string fileName = string.Empty;
try
{
fileName = Path.GetTempFileName();
fileName = Path.ChangeExtension(fileName, "shp");
ShapefileWriter.WriteGeometryCollection(fileName, geomsWrite);
var reader = new ShapefileReader(fileName, ShapeFileShapeFactory.FactoryRead);
var geomsRead = reader.ReadAll();
// This tests x- and y- values
if (!geomsWrite.EqualsExact(geomsRead))
{
Assert.AreEqual(geomsWrite.NumGeometries, geomsRead.NumGeometries);
//
// This akward test is necessary since EqualsTopologically throws currently exceptions
var equal = true;
for (var i = 0; i < geomsRead.NumGeometries; i++)
{
var gw = geomsWrite.GetGeometryN(i);
var gr = geomsRead.GetGeometryN(i);
if (gw.IsEmpty && gr.IsEmpty)
{
if ((gw is ILineal && gr is ILineal) ||
(gw is IPolygonal && gr is IPolygonal))
{
// suppose these are equal
}
else
{
Console.WriteLine(string.Format("Geometries don't match at index {0}", i));
Console.WriteLine(string.Format(" written: {0}", gw.AsText()));
Console.WriteLine(string.Format(" read : {0}", gr.AsText()));
equal = false;
Assert.IsTrue(equal, "Differenced found in geometries written and read!");
}
}
else if (!gw.EqualsExact(gr))
{
var hsm = new HausdorffSimilarityMeasure().Measure(gw, gr);
var asm = new AreaSimilarityMeasure().Measure(gw, gr);
var smc = SimilarityMeasureCombiner.Combine(hsm, asm);
if (!gw.EqualsNormalized(gr) || (1d - smc) > 1e-7)
{
Console.WriteLine(string.Format("Geometries don't match at index {0}", i));
Console.WriteLine(string.Format(" written: {0}", gw.AsText()));
Console.WriteLine(string.Format(" read : {0}", gr.AsText()));
equal = false;
Assert.IsTrue(equal, "Differenced found in geometries written and read!");
}
}
}
//For polygons this has a tendency to fail, since the polygonhandler might rearrange the whole thing
if (testGetOrdinate)
{
if ((ordinates & Ordinates.Z) == Ordinates.Z)
{
var writeZ = geomsWrite.GetOrdinates(Ordinate.Z);
var readZ = geomsRead.GetOrdinates(Ordinate.Z);
Assert.IsTrue(ArraysEqual(writeZ, readZ));
}
if ((ordinates & Ordinates.M) == Ordinates.M)
{
var writeM = geomsWrite.GetOrdinates(Ordinate.M);
var readM = geomsRead.GetOrdinates(Ordinate.M);
Assert.IsTrue(ArraysEqual(writeM, readM));
}
}
}
// delete sample files
File.Delete(fileName);
File.Delete(Path.ChangeExtension(fileName, "shx"));
File.Delete(Path.ChangeExtension(fileName, "dbf"));
}
catch (AssertionException ex)
{
Console.WriteLine("Failed test with {0}", ordinates);
Console.WriteLine(ex.Message);
Console.WriteLine(" Testfile '{0}' not deleted!", fileName);
throw;
}
}
private static DSGeometryCollection FromGeometryCollection(IGeometryCollection geometry, DSGeometryFactory factory, bool setUserData)
{
var dsGeometries = new DotSpatial.Topology.IGeometry[geometry.NumGeometries];
for (var i = 0; i < dsGeometries.Length; i++)
dsGeometries[i] = FromGeometry(geometry.GetGeometryN(i), factory, setUserData);
var result = factory.CreateGeometryCollection(dsGeometries);
if (setUserData)
result.UserData = geometry.UserData;
return result;
}
private static void DoTest(IGeometryCollection geomsWrite, Ordinates ordinates, bool testGetOrdinate = true)
{
string fileName = string.Empty;
try
{
fileName = Path.GetTempFileName();
fileName = Path.ChangeExtension(fileName, "shp");
ShapefileWriter.WriteGeometryCollection(fileName, geomsWrite);
var reader = new ShapefileReader(fileName, ShapeFileShapeFactory.FactoryRead);
var geomsRead = reader.ReadAll();
// This tests x- and y- values
if (!geomsWrite.EqualsExact(geomsRead))
{
Assert.AreEqual(geomsWrite.NumGeometries, geomsRead.NumGeometries);
//
// This akward test is necessary since EqualsTopologically throws currently exceptions
bool equal = true;
for (int i = 0; i < geomsRead.NumGeometries; i++)
{
var gw = geomsWrite.GetGeometryN(i);
var gr = geomsRead.GetGeometryN(i);
if (gw.IsEmpty && gr.IsEmpty)
{
if ((gw is ILineal && gr is ILineal) ||
(gw is IPolygonal && gr is IPolygonal))
{
// suppose these are equal
}
else
{
Console.WriteLine(string.Format("Geometries don't match at index {0}", i));
Console.WriteLine(string.Format(" written: {0}", gw.AsText()));
Console.WriteLine(string.Format(" read : {0}", gr.AsText()));
equal = false;
Assert.IsTrue(equal, "Differenced found in geometries written and read!");
}
}
else if (!gw.EqualsExact(gr))
{
double hsm = new HausdorffSimilarityMeasure().Measure(gw, gr);
double asm = new AreaSimilarityMeasure().Measure(gw, gr);
double smc = SimilarityMeasureCombiner.Combine(hsm, asm);
if (!gw.EqualsNormalized(gr) || (1d - smc) > 1e-7)
{
Console.WriteLine(string.Format("Geometries don't match at index {0}", i));
Console.WriteLine(string.Format(" written: {0}", gw.AsText()));
Console.WriteLine(string.Format(" read : {0}", gr.AsText()));
equal = false;
Assert.IsTrue(equal, "Differenced found in geometries written and read!");
}
}
}
//For polygons this has a tendency to fail, since the polygonhandler might rearrange the whole thing
if (testGetOrdinate)
{
if ((ordinates & Ordinates.Z) == Ordinates.Z)
{
double[] writeZ = geomsWrite.GetOrdinates(Ordinate.Z);
double[] readZ = geomsRead.GetOrdinates(Ordinate.Z);
Assert.IsTrue(ArraysEqual(writeZ, readZ));
}
if ((ordinates & Ordinates.M) == Ordinates.M)
{
double[] writeM = geomsWrite.GetOrdinates(Ordinate.M);
double[] readM = geomsRead.GetOrdinates(Ordinate.M);
Assert.IsTrue(ArraysEqual(writeM, readM));
}
}
}
// delete sample files
File.Delete(fileName);
File.Delete(Path.ChangeExtension(fileName, "shx"));
File.Delete(Path.ChangeExtension(fileName, "dbf"));
}
catch (AssertionException ex)
{
Console.WriteLine("Failed test with {0}", ordinates);
Console.WriteLine(ex.Message);
Console.WriteLine(" Testfile '{0}' not deleted!", fileName);
throw;
}
}
/// <summary>
///
/// </summary>
/// <param name="geom"></param>
/// <param name="parent"></param>
/// <returns></returns>
protected virtual IGeometry TransformGeometryCollection(IGeometryCollection geom, IGeometry parent)
{
ArrayList transGeomList = new ArrayList();
for (int i = 0; i < geom.NumGeometries; i++)
{
IGeometry transformGeom = Transform(geom.GetGeometryN(i));
if (transformGeom == null) continue;
if (pruneEmptyGeometry && transformGeom.IsEmpty) continue;
transGeomList.Add(transformGeom);
}
if (preserveGeometryCollectionType)
return factory.CreateGeometryCollection(GeometryFactory.ToGeometryArray(transGeomList));
return factory.BuildGeometry(transGeomList);
}
private static IGeometry WidestGeometry(IGeometryCollection gc)
{
if (gc.IsEmpty)
return gc;
var widestGeometry = gc.GetGeometryN(0);
// scan remaining geom components to see if any are wider
for (int i = 1; i < gc.NumGeometries; i++) //Start at 1
if (gc.GetGeometryN(i).EnvelopeInternal.Width > widestGeometry.EnvelopeInternal.Width)
widestGeometry = gc.GetGeometryN(i);
return widestGeometry;
}
private void AddCollection(IGeometryCollection gc)
{
for( int i = 0; i < gc.GetNumGeometries(); i++ )
{
Geometry g = (Geometry)gc.GetGeometryN( i );
Add( g );
}
}
