private void AddMultiPolygon(IMultiPolygon geometry, GraphicsPath graphicsPath)
{
if (geometry == null)
throw new ArgumentNullException("geometry");
foreach (var geom in geometry.Geometries)
this.AddPolygon((IPolygon)geom, graphicsPath);
}
/// <summary>
///
/// </summary>
/// <param name="geom"></param>
/// <param name="parent"></param>
/// <returns></returns>
protected override IGeometry TransformMultiPolygon(IMultiPolygon geom, IGeometry parent)
{
IGeometry roughGeom = base.TransformMultiPolygon(geom, parent);
return CreateValidArea(roughGeom);
}
/// <summary>
///
/// </summary>
/// <param name="multiPolygon"></param>
/// <param name="writer"></param>
protected virtual void Write(IMultiPolygon multiPolygon, BinaryWriter writer)
{
WriteByteOrder(writer);
writer.Write((int)WkbGeometryType.MultiPolygon);
writer.Write(multiPolygon.NumGeometries);
for (int i = 0; i < multiPolygon.NumGeometries; i++)
Write(multiPolygon.Geometries[i] as Polygon, writer);
}
/// <summary>
/// Writes a multipolygon.
/// </summary>
/// <param name="mp">The mulitpolygon to be written.</param>
/// <param name="bWriter">Stream to write to.</param>
/// <param name="byteorder">Byte order</param>
private static void WriteMultiPolygon(IMultiPolygon mp, BinaryWriter bWriter, WkbByteOrder byteorder)
{
//Write the number of polygons.
int num = mp.NumGeometries;
WriteUInt32((uint) num, bWriter, byteorder);
//Loop on the number of polygons.
//NOTE: by contract, the first item returned
// from GetEnumerator (i.e. using foreach) is the IMultiPolygon itself!
for (int i = 0; i < num; i++)
{
IPolygon poly = (IPolygon) mp.GetGeometryN(i);
//Write polygon header
bWriter.Write((byte) byteorder);
WriteUInt32((uint) WKBGeometryType.wkbPolygon, bWriter, byteorder);
//Write each polygon.
WritePolygon(poly, bWriter, byteorder);
}
}
/// <summary>
/// Converts a <c>MultiPolygon</c> to MultiPolygon Tagged Text
/// format, then appends it to the writer.
/// </summary>
/// <param name="multiPolygon">The <c>MultiPolygon</c> to process.</param>
/// <param name="level"></param>
/// <param name="writer">The output writer to append to.</param>
private void AppendMultiPolygonTaggedText(IMultiPolygon multiPolygon, int level, TextWriter writer)
{
writer.Write("MULTIPOLYGON");
AppendMultiPolygonText(multiPolygon, level, writer);
}
/// <summary>
/// Converts the <c>ICollection</c> to an array.
/// </summary>
/// <param name="multiPolygons">The <c>ICollection</c> of MultiPolygons to convert.</param>
/// <returns>The <c>ICollection</c> in array format.</returns>
public static IMultiPolygon[] ToMultiPolygonArray(ICollection multiPolygons)
{
IMultiPolygon[] list = new IMultiPolygon[multiPolygons.Count];
int i = 0;
foreach (IMultiPolygon mp in multiPolygons)
list[i++] = mp;
return list;
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
IGeometry geom = value as IGeometry;
if (geom == null)
{
return;
}
writer.WriteStartObject();
GeoJsonObjectType geomType = ToGeoJsonObject(geom);
writer.WritePropertyName("type");
writer.WriteValue(Enum.GetName(typeof(GeoJsonObjectType), geomType));
switch (geomType)
{
case GeoJsonObjectType.Point:
{
serializer.Serialize(writer, geom.Coordinate);
break;
}
case GeoJsonObjectType.LineString:
case GeoJsonObjectType.MultiPoint:
{
serializer.Serialize(writer, geom.Coordinates);
break;
}
case GeoJsonObjectType.Polygon:
{
IPolygon poly = (IPolygon)geom;
List <Coordinate[]> coords = PolygonCoords(poly);
serializer.Serialize(writer, coords);
break;
}
case GeoJsonObjectType.MultiPolygon:
{
IMultiPolygon mpoly = (IMultiPolygon)geom;
List <List <Coordinate[]> > list = new List <List <Coordinate[]> >();
foreach (IPolygon poly in mpoly.Geometries)
{
List <Coordinate[]> coords = PolygonCoords(poly);
list.Add(coords);
}
serializer.Serialize(writer, list);
break;
}
case GeoJsonObjectType.GeometryCollection:
{
IGeometryCollection coll = (IGeometryCollection)geom;
serializer.Serialize(writer, coll.Geometries);
break;
}
default:
{
List <Coordinate[]> list = new List <Coordinate[]>();
IGeometryCollection coll = (IGeometryCollection)geom;
foreach (IGeometry geometry in coll.Geometries)
{
Coordinate[] coords = geometry.Coordinates;
list.Add(coords);
}
serializer.Serialize(writer, list);
break;
}
}
writer.WriteEndObject();
}
/// <summary>
///
/// </summary>
/// <param name="multiPolygon"></param>
/// <param name="writer"></param>
protected void Write(IMultiPolygon multiPolygon, BinaryWriter writer)
{
WriteByteOrder(writer); // LittleIndian
writer.Write((int) WKBGeometryTypes.WKBMultiPolygon);
writer.Write((int) multiPolygon.NumGeometries);
for (int i = 0; i < multiPolygon.NumGeometries; i++)
Write(multiPolygon.Geometries[i] as IPolygon, writer);
}
public void SearchModelPoint(IPolygon tarPolygon)
{
this.axRenderControl1.FeatureManager.UnhighlightAll();
IRowBuffer row = null;
foreach (IFeatureClass fc in fcMap.Keys)
{
if (!fc.Name.Equals("Building"))
{
continue;
}
IFdeCursor cursor = null;
try
{
ISpatialFilter filter = new SpatialFilter();
filter.Geometry = tarPolygon;
filter.SpatialRel = gviSpatialRel.gviSpatialRelEnvelope; //用不相离查不出来
filter.GeometryField = "Geometry";
cursor = fc.Search(filter, false);
while ((row = cursor.NextRow()) != null)
{
int oid = (int)row.GetValue(0);
this.axRenderControl1.FeatureManager.SetFeatureVisibleMask(fc, oid, gviViewportMask.gviViewNone);
int geoPos = row.FieldIndex("Geometry");
IModelPoint mp = row.GetValue(geoPos) as IModelPoint;
if (geoConvertor == null)
{
geoConvertor = new GeometryConvertor();
}
if (mPolygon == null)
{
mPolygon = (new GeometryFactory()).CreateGeometry(gviGeometryType.gviGeometryMultiPolygon, gviVertexAttribute.gviVertexAttributeZ) as IMultiPolygon;
}
mPolygon.Clear();
mPolygon.AddGeometry(tarPolygon);
GetZToolStripTextBox();
IResourceManager rm = fc.FeatureDataSet as IResourceManager;
IModel model = rm.GetModel(mp.ModelName);
IModel modelInterior = null;
IModelPoint mpInterior = null;
IModel modelExterior = null;
IModelPoint mpExterior = null;
if (minz == maxz)
{
geoConvertor.SplitModelPointByPolygon2D(mPolygon, model, mp, out modelInterior, out mpInterior, out modelExterior, out mpExterior);
}
else
{
geoConvertor.SplitModelPointByPolygon2DWithZ(mPolygon, model, mp, minz, maxz, out modelInterior, out mpInterior, out modelExterior, out mpExterior);
}
if (modelExterior != null)
{
this.axRenderControl1.ObjectManager.AddModel(fc.Name + oid + "Exterior", modelExterior);
mpExterior.ModelName = fc.Name + oid + "Exterior";
string[] imagenames = modelExterior.GetImageNames();
for (int j = 0; j < imagenames.Length; j++)
{
IImage image = rm.GetImage(imagenames[j]);
this.axRenderControl1.ObjectManager.AddImage(imagenames[j], image);
}
IRenderModelPoint rrrr = this.axRenderControl1.ObjectManager.CreateRenderModelPoint(mpExterior, null, rootId);
lll.Add(rrrr);
}
}
}
catch (COMException ex)
{
System.Diagnostics.Trace.WriteLine(ex.Message);
}
finally
{
if (cursor != null)
{
//Marshal.ReleaseComObject(cursor);
cursor = null;
}
}
} // end of foreach (IFeatureClass fc in fcMap.Keys)
}
/// <summary>
/// Sets the coordinates using the MultiPolygon
/// </summary>
/// <param name="descriptor">the descriptor</param>
/// <param name="multiPolygon">the MultiPolygon</param>
/// <returns>the <see cref="GeoShapeMultiPolygonFilterDescriptor"/></returns>
public static GeoShapeMultiPolygonFilterDescriptor Coordinates(
this GeoShapeMultiPolygonFilterDescriptor descriptor,
IMultiPolygon multiPolygon) => descriptor.Coordinates(multiPolygon.GetCoordinates());
/// <summary>
/// Converts a <c>MultiPolygon</c> to MultiPolygon Tagged Text
/// format, then appends it to the writer.
/// </summary>
/// <param name="multiPolygon">The <c>MultiPolygon</c> to process.</param>
/// <param name="level"></param>
/// <param name="writer">The output writer to append to.</param>
private void AppendMultiPolygonTaggedText(IMultiPolygon multiPolygon, int level, TextWriter writer)
{
writer.Write("MULTIPOLYGON ");
AppendMultiPolygonText(multiPolygon, level, writer);
}
/// <summary>
/// Converts a <see cref="IMultiLineString"/> to a <see cref="GeoAPIMultiLineString"/>
/// </summary>
/// <param name="self">The <see cref="IMultiLineString"/> to convert</param>
/// <param name="factory">The factory to create the <see cref="GeoAPIMultiLineString"/></param>
/// <param name="setUserData">Sets the <see cref="GeoAPIGeometry.UserData"/> to <paramref name="self"/>.UserData</param>
/// <returns>The converted geometry</returns>
public static GeoAPIMultiPolygon ToGeoAPI(this IMultiPolygon self, GeoAPIGeometryFactory factory = null, bool setUserData = false)
{
var useFactory = factory ?? self.Factory.ToGeoAPI();
return(FromMultiPolygon(self, useFactory, setUserData));
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
IGeometry geom = value as IGeometry;
if (geom == null)
{
return;
}
writer.WriteStartObject();
GeoJSONObjectType geomType = ToGeoJsonObject(geom);
writer.WritePropertyName("type");
writer.WriteValue(Enum.GetName(typeof(GeoJSONObjectType), geomType));
switch (geomType)
{
case GeoJSONObjectType.Point:
serializer.Serialize(writer, geom.Coordinate);
break;
case GeoJSONObjectType.LineString:
case GeoJSONObjectType.MultiPoint:
serializer.Serialize(writer, geom.Coordinates);
break;
case GeoJSONObjectType.Polygon:
IPolygon poly = geom as IPolygon;
Debug.Assert(poly != null);
serializer.Serialize(writer, PolygonCoordiantes(poly));
break;
case GeoJSONObjectType.MultiPolygon:
IMultiPolygon mpoly = geom as IMultiPolygon;
Debug.Assert(mpoly != null);
List <List <Coordinate[]> > list = new List <List <Coordinate[]> >();
foreach (IPolygon mempoly in mpoly.Geometries)
{
list.Add(PolygonCoordiantes(mempoly));
}
serializer.Serialize(writer, list);
break;
case GeoJSONObjectType.GeometryCollection:
IGeometryCollection gc = geom as IGeometryCollection;
Debug.Assert(gc != null);
serializer.Serialize(writer, gc.Geometries);
break;
default:
List <Coordinate[]> coordinates = new List <Coordinate[]>();
foreach (IGeometry geometry in ((IGeometryCollection)geom).Geometries)
{
coordinates.Add(geometry.Coordinates);
}
serializer.Serialize(writer, coordinates);
break;
}
writer.WriteEndObject();
}
/// <summary>
/// Computes the transformation of the source geometry.
/// </summary>
/// <param name="source">The source geometry.</param>
/// <returns>The geometry in the specified reference system.</returns>
private IMultiPolygon Compute(IMultiPolygon source)
{
return(_factory.CreateMultiPolygon(source.Select(item => Compute(item)),
_metadataPreservation ? source.Metadata : null));
}
/// <summary>
/// Simplifies a <see cref="IMultiPolygon"/>, fixing it if required.
/// </summary>
/// <param name="geom"></param>
/// <param name="parent"></param>
/// <returns></returns>
protected override IGeometry TransformMultiPolygon(IMultiPolygon geom, IGeometry parent)
{
IGeometry rawGeom = base.TransformMultiPolygon(geom, parent);
return(CreateValidArea(rawGeom));
}
/// <summary>
///
/// </summary>
/// <param name="multiPolygon"></param>
/// <returns></returns>
protected int SetByteStreamLength(IMultiPolygon multiPolygon)
{
int count = InitValue;
foreach (IPolygon p in multiPolygon.Geometries)
count += SetByteStreamLength(p);
return count;
}
/// <summary>
///
/// </summary>
/// <param name="multiPolygon"></param>
/// <returns></returns>
protected int SetByteStreamLength(IMultiPolygon multiPolygon)
{
int numParts = multiPolygon.NumGeometries; // Exterior rings count
foreach (IPolygon polygon in multiPolygon.Geometries) // Adding interior rings count
numParts += polygon.NumInteriorRings;
int numPoints = multiPolygon.NumPoints;
return CalculateLength(numParts, numPoints);
}
public static void DrawMultiPolygon(Graphics g, IMultiPolygon multiPolygon, Brush brush, Pen pen, bool clip, MapViewport map)
{
DrawMultiPolygonEx(g, multiPolygon, brush, pen, clip, map);
}
/// <summary>
///
/// </summary>
/// <param name="geometry"></param>
/// <returns></returns>
protected int SetByteStream(IMultiPolygon geometry)
{
// 4-byte count + subgeometries
return 4 + SetByteStream(geometry.Geometries);
}
/// <summary>
///
/// </summary>
/// <param name="multiPolygon"></param>
/// <param name="writer"></param>
protected void Write(IMultiPolygon multiPolygon, BinaryWriter writer)
{
WriteByteOrder(writer); // LittleIndian
if (Double.IsNaN(multiPolygon.Coordinate.Z))
writer.Write((int)WKBGeometryTypes.WKBMultiPolygon);
else writer.Write((int)WKBGeometryTypes.WKBMultiPolygonZ);
writer.Write((int) multiPolygon.NumGeometries);
for (int i = 0; i < multiPolygon.NumGeometries; i++)
Write(multiPolygon.Geometries[i] as IPolygon, writer);
}
/// <summary>
/// Determines whether specific Coordinate is in the given multipolygon.
/// </summary>
/// <param name="c">The coordinate to check.</param>
/// <param name="multipolygon">The multipolygon to check coordinate against.</param>
/// <param name="includeBoundaries">bool values that specifies whether points on boundaries of the polygon should be considered as inside.</param>
/// <returns>true if coordinate lies inside any polygon of the given multipolygon, otherwise false.</returns>
public bool IsInside(Coordinate c, IMultiPolygon multipolygon, bool includeBoundaries)
{
foreach (var polygon in multipolygon.Geometries) {
if (this.IsInside(c, polygon, includeBoundaries)) {
return true;
}
}
return false;
}
public static void DrawMultiPolygon(D2D1.RenderTarget renderTarget, D2D1.Factory factory, IMultiPolygon pols, D2D1.Brush brush, D2D1.Brush pen, float penWidth, D2D1.StrokeStyle penStrokeStyle, bool clip, Map map)
{
for (var i = 0; i < pols.NumGeometries; i++)
{
var p = (IPolygon)pols[i];
DrawPolygon(renderTarget, factory, p, brush, pen, penWidth, penStrokeStyle, clip, map);
}
}
/// <summary>
///
/// </summary>
/// <param name="geom"></param>
/// <param name="parent"></param>
/// <returns></returns>
protected virtual IGeometry TransformMultiPolygon(IMultiPolygon geom, IGeometry parent)
{
ArrayList transGeomList = new ArrayList();
for (int i = 0; i < geom.NumGeometries; i++)
{
IGeometry transformGeom = TransformPolygon((IPolygon) geom.GetGeometryN(i), geom);
if (transformGeom == null) continue;
if (transformGeom.IsEmpty) continue;
transGeomList.Add(transformGeom);
}
return factory.BuildGeometry(transGeomList);
}
/// <summary>
/// Method to write a multi polygon geometry to the <paramref name="writer"/>
/// </summary>
/// <param name="areas">The multi polygon geometry</param>
/// <param name="writer">The JSON writer</param>
public static void Write(IMultiPolygon areas, JsonTextWriter writer)
{
if (areas == null)
return;
if (writer == null)
throw new ArgumentNullException("writer", "A valid JSON writer object is required");
writer.WriteStartObject();
writer.WritePropertyName("type");
writer.WriteValue("MultiPolygon");
writer.WritePropertyName("coordinates");
writer.WriteStartArray();
for ( var i = 0; i < areas.NumGeometries; i++)
{
var area = (IPolygon) areas[i];
writer.WriteStartArray();
WriteCoord(area.ExteriorRing.Coordinates, writer);
foreach (ILinearRing hole in area.InteriorRings)
WriteCoord(hole.Coordinates, writer);
writer.WriteEndArray();
}
writer.WriteEndArray();
writer.WriteEndObject();
}
/// <summary>
/// Converts a <c>MultiPolygon</c> to <MultiPolygon Text format,
/// then appends it to the writer.
/// </summary>
/// <param name="multiPolygon">The <c>MultiPolygon</c> to process.</param>
/// <param name="level"></param>
/// <param name="writer">The output writer to append to.</param>
private void AppendMultiPolygonText(IMultiPolygon multiPolygon, int level, TextWriter writer)
{
if (multiPolygon.IsEmpty)
writer.Write(" EMPTY");
else
{
int level2 = level;
bool doIndent = false;
writer.Write("(");
for (int i = 0; i < multiPolygon.NumGeometries; i++)
{
if (i > 0)
{
writer.Write(",");
level2 = level + 1;
doIndent = true;
}
AppendPolygonText((IPolygon) multiPolygon.GetGeometryN(i), level2, doIndent, writer);
}
writer.Write(")");
}
}
/// <summary>
/// Method to write a multi polygon geometry to the <paramref name="writer"/>
/// </summary>
/// <param name="areas">The multi polygon geometry</param>
/// <param name="writer">The JSON writer</param>
public static void Write(IMultiPolygon areas, TextWriter writer)
{
if (areas == null)
return;
if (writer == null)
throw new ArgumentNullException("writer", "A valid text writer object is required");
Write(areas, CreateWriter(writer));
}
/// <summary>
/// Transforms a <see cref="GeoAPI.Geometries.IMultiPolygon"/>.
/// </summary>
/// <param name="polys">MultiPolygon 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 MultiPolygon</returns>
public static IMultiPolygon TransformMultiPolygon(IMultiPolygon polys, ProjectionInfo from, ProjectionInfo to, IGeometryFactory toFactory)
{
var pOut = new IPolygon[polys.Count];
for (var i = 0; i < polys.Count; i++)
pOut[i] = TransformPolygon((IPolygon)polys.GetGeometryN(i), from, to, toFactory);
return toFactory.CreateMultiPolygon(pOut);
}
/// <summary>
///
/// </summary>
/// <param name="g"></param>
private void CheckValid(IMultiPolygon g)
{
foreach(IPolygon p in g.Geometries)
{
CheckInvalidCoordinates(p);
if (validErr != null) return;
CheckClosedRings(p);
if (validErr != null) return;
}
GeometryGraph graph = new GeometryGraph(0, g);
CheckTooFewPoints(graph);
if (validErr != null) return;
CheckConsistentArea(graph);
if (validErr != null) return;
if (!IsSelfTouchingRingFormingHoleValid)
{
CheckNoSelfIntersectingRings(graph);
if (validErr != null) return;
}
foreach(IPolygon p in g.Geometries)
{
CheckHolesInShell(p, graph);
if (validErr != null) return;
}
foreach (IPolygon p in g.Geometries)
{
CheckHolesNotNested(p, graph);
if (validErr != null) return;
}
CheckShellsNotNested(g, graph);
if (validErr != null) return;
CheckConnectedInteriors(graph);
}
/// <summary>
///
/// </summary>
/// <param name="geometry"></param>
/// <returns></returns>
protected virtual int SetByteStream(IMultiPolygon geometry)
{
int count = INIT_COUNT;
count += 4;
foreach (Polygon geom in geometry.Geometries)
count += SetByteStream(geom);
return count;
}
/// <summary>
/// Tests that no element polygon is wholly in the interior of another element polygon.
/// Preconditions:
/// Shells do not partially overlap.
/// Shells do not touch along an edge.
/// No duplicate rings exists.
/// This routine relies on the fact that while polygon shells may touch at one or
/// more vertices, they cannot touch at ALL vertices.
/// </summary>
private void CheckShellsNotNested(IMultiPolygon mp, GeometryGraph graph)
{
for (int i = 0; i < mp.NumGeometries; i++)
{
IPolygon p = (IPolygon) mp.GetGeometryN(i);
ILinearRing shell = p.Shell;
for (int j = 0; j < mp.NumGeometries; j++)
{
if (i == j)
continue;
IPolygon p2 = (IPolygon) mp.GetGeometryN(j);
CheckShellNotNested(shell, p2, graph);
if (validErr != null) return;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="multiPolygon"></param>
/// <param name="writer"></param>
protected void Write(IMultiPolygon multiPolygon, XmlTextWriter writer)
{
writer.WriteStartElement("MultiPolygon", GMLElements.gmlNS);
for (int i = 0; i < multiPolygon.NumGeometries; i++)
{
writer.WriteStartElement("polygonMember", GMLElements.gmlNS);
Write(multiPolygon.Geometries[i] as IPolygon, writer);
writer.WriteEndElement();
}
writer.WriteEndElement();
}
private static GeoAPIMultiPolygon FromMultiPolygon(IMultiPolygon geometry, GeoAPIGeometryFactory factory, bool copyUserData)
{
var dsPolygons = new GeoAPI.Geometries.IPolygon[geometry.NumGeometries];
for (var i = 0; i < dsPolygons.Length; i++)
dsPolygons[i] = FromPolygon((IPolygon)geometry.GetGeometryN(i), factory, copyUserData);
var result = factory.CreateMultiPolygon(dsPolygons);
if (copyUserData)
result.UserData = geometry.UserData;
return result;
}
/// <summary>
///
/// </summary>
/// <param name="multiPolygon"></param>
/// <param name="writer"></param>
public void Write(IMultiPolygon multiPolygon, BinaryWriter writer)
{
writer.Write((int) ShapeGeometryTypes.Polygon);
// Write BoundingBox
WriteBoundingBox(multiPolygon, writer);
// Write NumParts and NumPoints
int numParts = multiPolygon.NumGeometries; // Exterior rings count
for (int i = 0; i < multiPolygon.NumGeometries; i++) // Adding interior rings count
numParts += ((IPolygon) multiPolygon.GetGeometryN(i)).NumInteriorRings;
writer.Write((int) numParts);
writer.Write((int) multiPolygon.NumPoints);
// Write IndexParts
int count = 0;
writer.Write((int) count);
for (int i = 0; i < multiPolygon.NumGeometries; i++)
{
IPolygon polygon = (IPolygon) multiPolygon.GetGeometryN(i);
ILineString shell = polygon.ExteriorRing;
count += shell.NumPoints;
if (count == multiPolygon.NumPoints)
break;
writer.Write((int) count);
for (int j = 0; j < polygon.NumInteriorRings; j++)
{
ILineString hole = (ILineString) polygon.GetInteriorRingN(j);
count += hole.NumPoints;
if (count == multiPolygon.NumPoints)
break;
writer.Write((int) count);
}
}
// Write Coordinates
for (int i = 0; i < multiPolygon.NumPoints; i++)
Write(multiPolygon.Coordinates[i], writer);
}
private static DSMultiPolygon FromMultiPolygon(IMultiPolygon geometry, DSGeometryFactory factory, bool setUserData)
{
var dsPolygons = new DotSpatial.Topology.IPolygon[geometry.NumGeometries];
for (var i = 0; i < dsPolygons.Length; i++)
dsPolygons[i] = FromPolygon((IPolygon)geometry.GetGeometryN(i), factory, setUserData);
var result = factory.CreateMultiPolygon(dsPolygons);
if (setUserData)
result.UserData = geometry.UserData;
return result;
}
/// <summary>
///
/// </summary>
/// <param name="geometry"></param>
/// <returns></returns>
protected int SetByteStream(IMultiPolygon geometry)
{
int count = InitCount;
count += 4;
foreach (IPolygon geom in geometry.Geometries)
count += SetByteStream(geom);
return count;
}
private void Write(IMultiPolygon multiPoly)
{
EnsureGeometryFactory(multiPoly);
int contentLength = ContentLength(multiPoly);
_writerIndex.WriteBE(_filePos);
_writerIndex.WriteBE(contentLength);
_writerShape.WriteBE(_recordNumber++);
_writerShape.WriteBE(contentLength);
_writerShape.Write((int)ShapefileGeometryType.Polygon);
Write(multiPoly.EnvelopeInternal);
int numParts = multiPoly.Geometries.Cast<IPolygon>().Sum(g => g.Holes.Length + 1);
int numPoints = multiPoly.NumPoints;
_writerShape.Write(numParts);
_writerShape.Write(numPoints);
// write the offsets to the points
int offset = 0;
foreach (IPolygon poly in multiPoly.Geometries)
{
// offset to the shell points
_writerShape.Write(offset);
offset = offset + poly.Shell.NumPoints;
// offstes to the holes
foreach (ILinearRing ring in poly.Holes)
{
_writerShape.Write(offset);
offset = offset + ring.NumPoints;
}
}
// write the points
foreach (IPolygon poly in multiPoly.Geometries)
{
Write(poly.Shell.Coordinates);
foreach (ILinearRing ring in poly.Holes)
Write(ring.Coordinates);
}
_filePos += 4 + contentLength;
}
/// <summary>
///
/// </summary>
/// <param name="multiPolygon"></param>
/// <param name="writer"></param>
protected void Write(IMultiPolygon multiPolygon, BinaryWriter writer)
{
WriteHeader(multiPolygon, PostGisGeometryType.MultiPolygon, writer);
writer.Write((int) multiPolygon.NumGeometries);
Write(multiPolygon.Geometries, writer);
}
public int ContentLength(IMultiPolygon poly)
{
int numParts = poly.Geometries.Cast<IPolygon>().Sum(g => g.Holes.Length + 1);
return (22 + (2 * numParts) + (poly.NumPoints * 8)); // 22 => shapetype(2) + bbox(4*4) + numparts(2) + numpoints(2)
}
/// <summary>
/// Transforms a <see cref="MultiPolygon" /> object.
/// </summary>
/// <param name="polys"></param>
/// <param name="transform"></param>
/// <returns></returns>
public static IMultiPolygon TransformMultiPolygon(IMultiPolygon polys, IMathTransform transform)
{
List<IPolygon> polygons = new List<IPolygon>(polys.Geometries.Length);
foreach (IPolygon p in polys.Geometries)
polygons.Add(TransformPolygon(p, transform));
return new MultiPolygon(polygons.ToArray());
}
int INpgsqlTypeHandler <IMultiPolygon> .ValidateAndGetLength(IMultiPolygon value, ref NpgsqlLengthCache lengthCache, NpgsqlParameter parameter) => ValidateAndGetLength(value, ref lengthCache, parameter);
