/// <summary>
/// Renders a <see cref="SharpMap.Geometries.MultiPoint"/> to the map.
/// </summary>
/// <param name="g">Graphics reference</param>
/// <param name="points">MultiPoint to render</param>
/// <param name="symbol">Symbol to place over point</param>
/// <param name="symbolscale">The amount that the symbol should be scaled. A scale of '1' equals to no scaling</param>
/// <param name="offset">Symbol offset af scale=1</param>
/// <param name="rotation">Symbol rotation in degrees</param>
/// <param name="map">Map reference</param>
public static void DrawMultiPoint(Graphics g, IMultiPoint points, Bitmap symbol, float symbolscale, PointF offset, float rotation, Map map)
{
for (int i = 0; i < points.Geometries.Length; i++)
{
DrawPoint(g, (IPoint)points.Geometries[i], symbol, symbolscale, offset, rotation, map);
}
}
public static void Write(IMultiPoint points, JsonTextWriter jwriter)
{
if (points == null)
{
return;
}
if (jwriter == null)
{
throw new ArgumentNullException("jwriter", "A valid JSON writer object is required.");
}
jwriter.WriteStartObject();
jwriter.WriteMember("type");
jwriter.WriteString("MultiPoint");
jwriter.WriteMember("coordinates");
jwriter.WriteStartArray();
foreach (ICoordinate entry in points.Coordinates)
{
Write(entry, jwriter);
}
jwriter.WriteEndArray();
jwriter.WriteEndObject();
}
public static IEnumerable <IEnumerable <IPoint> > GetCoordinates(this IGeometry geometry)
{
List <IPoint[]> points = new List <IPoint[]>();
if (geometry is IPolygon)
{
IPolygon polygon = (IPolygon)geometry;
points.AddRange(polygon.Rings.Select(a => a.Select(b => b).Cast <IPoint>().ToArray()));
}
else if (geometry is IPoint)
{
IPoint point = (IPoint)geometry;
points.Add(new IPoint[] { point });
}
else if (geometry is IMultiPoint)
{
IMultiPoint multipoint = (IMultiPoint)geometry;
points.AddRange(multipoint.Points.Select(a => new IPoint[] { a }));
}
else if (geometry is IMultiLine)
{
IMultiLine polyline = (IMultiLine)geometry;
points.AddRange(polyline.Paths.Select(a => a.Select(b => b).Cast <IPoint>().ToArray()));
}
else if (geometry is LineString)
{
LineString line = (LineString)geometry;
points.Add(line.Coordinates.ToArray());
}
else
{
throw new NotSupportedException();
}
return(points.AsEnumerable());
}
/// <summary>
/// Writes <paramref name="multiPoint"/> to a stream using <paramref name="writer"/>
/// </summary>
/// <param name="multiPoint">The multi point to write</param>
/// <param name="writer">The writer to use</param>
public void Write(IMultiPoint multiPoint, BinaryWriter writer)
{
writer.Write((int)ShapeGeometryType.MultiPoint);
// Write BoundingBox
WriteBoundingBox(multiPoint.EnvelopeInternal, writer);
// Write NumPoints
writer.Write((int)multiPoint.NumPoints);
// Merge sequences of points into one
var seq = multiPoint.Factory.CoordinateSequenceFactory.Create(
multiPoint.NumGeometries, ((IPoint)multiPoint.GetGeometryN(0)).CoordinateSequence.Ordinates);
for (var i = 0; i < seq.Count; i++)
{
var pt = (IPoint)multiPoint.GetGeometryN(i);
seq.SetOrdinate(i, Ordinate.X, pt.CoordinateSequence.GetOrdinate(i, Ordinate.X));
seq.SetOrdinate(i, Ordinate.Y, pt.CoordinateSequence.GetOrdinate(i, Ordinate.Y));
if ((seq.Ordinates & Ordinates.Z) == Ordinates.Z)
{
seq.SetOrdinate(i, Ordinate.Z, pt.CoordinateSequence.GetOrdinate(i, Ordinate.Z));
}
if ((seq.Ordinates & Ordinates.M) == Ordinates.M)
{
seq.SetOrdinate(i, Ordinate.M, pt.CoordinateSequence.GetOrdinate(i, Ordinate.M));
}
}
// Write Coordinates
WriteCoordinates(seq, writer, seq.Ordinates);
}
/// <summary>
/// Method to write a multipoint geometry to the <paramref name="writer"/>
/// </summary>
/// <param name="points">The multipoint geometry</param>
/// <param name="writer">The JSON writer</param>
public static void Write(IMultiPoint points, JsonTextWriter writer)
{
if (points == null)
{
return;
}
if (writer == null)
{
throw new ArgumentNullException("writer", "A valid JSON writer object is required");
}
writer.WriteStartObject();
writer.WritePropertyName("type");
writer.WriteValue("MultiPoint");
writer.WritePropertyName("coordinates");
/*
* writer.WriteStartArray();
* foreach (var entry in points.Coordinates)
* WriteCoord(entry, writer);
* writer.WriteEndArray();
*/
WriteCoord(points.Coordinates, writer);
writer.WriteEndObject();
}
public static MultipointN FromCommon(IMultiPoint commonMultiPoint)
{
MultipointN agsMultiPoint = new MultipointN();
agsMultiPoint.PointArray = commonMultiPoint.Select(o => PointN.FromCommon(o)).Cast <Point>().ToArray();
return(agsMultiPoint);
}
/// <summary>
/// Writes a Geometry to the given binary wirter.
/// </summary>
/// <param name="geometry">The geometry to write.</param>
/// <param name="file">The file stream to write to.</param>
/// <param name="geometryFactory">The geometry factory to use.</param>
public override void Write(IGeometry geometry, BinaryWriter file, IGeometryFactory geometryFactory)
{
if (!(geometry is IMultiPoint))
{
throw new ArgumentException("Geometry Type error: MultiPoint expected, but the type retrieved is " + geometry.GetType().Name);
}
// Slow and maybe not useful...
// if (!geometry.IsValid)
// Trace.WriteLine("Invalid multipoint being written.");
IMultiPoint mpoint = geometry as IMultiPoint;
file.Write(int.Parse(EnumUtility.Format(typeof(ShapeGeometryType), ShapeType, "d")));
Envelope box = geometry.EnvelopeInternal as Envelope;
Envelope bounds = GetEnvelopeExternal(geometryFactory.PrecisionModel, box);
file.Write(bounds.MinX);
file.Write(bounds.MinY);
file.Write(bounds.MaxX);
file.Write(bounds.MaxY);
int numPoints = mpoint.NumPoints;
file.Write(numPoints);
// write the points
for (int i = 0; i < numPoints; i++)
{
IPoint point = (IPoint)mpoint.Geometries[i];
file.Write(point.X);
file.Write(point.Y);
}
}
public void TopoJsonWriterWrittenContentTest()
{
GeometryFactory factory = new GeometryFactory();
IMultiPolygon mp = factory.CreateMultiPolygon
(
new List <IPolygon>
{
factory.CreatePolygon(factory.CreatePoint(10, 10),
factory.CreatePoint(20, 10),
factory.CreatePoint(25, 17),
factory.CreatePoint(10, 10)),
factory.CreatePolygon(factory.CreatePoint(50, 30),
factory.CreatePoint(40, 20),
factory.CreatePoint(20, 10),
factory.CreatePoint(25, 17),
factory.CreatePoint(30, 30),
factory.CreatePoint(50, 30))
}
);
Assert.AreEqual(2, mp.Count);
IMultiPoint p = factory.CreateMultiPoint(
new IPoint[2]
{
factory.CreatePoint(10, 10),
factory.CreatePoint(23, 23)
});
ILineString lstr = factory.CreateLineString(
factory.CreatePoint(50, 60),
factory.CreatePoint(55, 60),
factory.CreatePoint(71, 71)
);
List <IGeometry> geo = new List <IGeometry>()
{
p, lstr
};
string outFileName = _outputPath + ".topojson";
TopoJsonWriter writer = new TopoJsonWriter(outFileName);
writer.Write(mp as IGeometry);
writer.Write(geo);
writer.Close();
TopoJsonReader reader = new TopoJsonReader(outFileName);
IList <IGeometry> geometries = reader.ReadToEnd();
reader.Close();
GeometryComparer comp = new GeometryComparer();
Assert.AreEqual(0, comp.Compare(geometries[0], mp));
Assert.AreEqual(0, comp.Compare(geometries[1], p));
Assert.AreEqual(0, comp.Compare(geometries[2], lstr));
}
/// <summary>
/// Renders a <see cref="SharpMap.Geometries.MultiPoint"/> to the map.
/// </summary>
/// <param name="g">Graphics reference</param>
/// <param name="points">MultiPoint to render</param>
/// <param name="symbol">Symbol to place over point</param>
/// <param name="symbolscale">The amount that the symbol should be scaled. A scale of '1' equals to no scaling</param>
/// <param name="offset">Symbol offset af scale=1</param>
/// <param name="rotation">Symbol rotation in degrees</param>
/// <param name="map">Map reference</param>
public static void DrawMultiPoint(System.Drawing.Graphics g, IMultiPoint points, System.Drawing.Bitmap symbol, float symbolscale, System.Drawing.PointF offset, float rotation, SharpMap.Map map)
{
for (int i = 0; i < points.Geometries.Length; i++)
{
DrawPoint(g, (IPoint)points.Geometries[i], symbol, symbolscale, offset, rotation, map);
}
}
public static void WriteTo(ArcXmlWriter writer, IMultiPoint multiPoint)
{
try
{
writer.WriteStartElement("MULTIPOINT");
foreach (IPoint point in multiPoint.Geometries.Cast <IPoint>())
{
WriteTo(writer, point);
}
writer.WriteEndElement();
}
catch (Exception ex)
{
if (ex is ArcXmlException)
{
throw ex;
}
else
{
throw new ArcXmlException("Could not write MultiPoint object.", ex);
}
}
}
private bool LabelPointCollection(IDisplay disp, IPolygon polygon, IMultiPoint pColl, double[] values, double valSum, double valMin, double valMax)
{
if (pColl == null)
{
return(false);
}
for (int i = 0; i < pColl.PointCount; i++)
{
if (disp.LabelEngine.TryAppend(disp,
ChartAnnotationPolygon(disp, pColl[i], values, valSum, valMin, valMax),
pColl[i], _labelPriority != SimpleLabelRenderer.labelPriority.always) == LabelAppendResult.Succeeded)
{
DrawChart(disp, pColl[i], values, valSum, valMin, valMax);
return(true);
}
}
for (int i = 0; i < pColl.PointCount; i++)
{
ISmartLabelPoint slp = pColl[i] as ISmartLabelPoint;
if (slp != null)
{
LabelPointCollection(disp, polygon, slp.AlernativeLabelPoints(disp), values, valSum, valMin, valMax);
}
}
return(false);
}
private bool LabelPolygon(IDisplay disp, IPolygon polygon, double[] values, double valSum, double valMin, double valMax)
{
IEnvelope env = new Envelope(_clipEnvelope);
if (polygon is ITopologicalOperation)
{
IGeometry g;
((ITopologicalOperation)polygon).Clip(env, out g);
if (g == null)
{
return(false);
}
if (g is IPolygon)
{
polygon = (IPolygon)g;
}
}
if (polygon == null)
{
return(false);
}
IMultiPoint pColl = gView.Framework.SpatialAlgorithms.Algorithm.PolygonLabelPoints(polygon);
return(LabelPointCollection(disp, polygon, pColl, values, valSum, valMin, valMax));
}
private static IGeometry ClipEnvelope(Envelope envelope, IGeometry clippee)
{
if (envelope == null || clippee == null)
{
return(null);
}
if (double.IsInfinity(envelope.Width) ||
double.IsInfinity(envelope.Height))
{
return(clippee);
}
IEnvelope geomEnv = clippee.Envelope;
if (!envelope.Intersects(geomEnv))
{
return(null);
}
if (geomEnv.minx >= envelope.minx && geomEnv.maxx <= envelope.maxx &&
geomEnv.miny >= envelope.miny && geomEnv.maxy <= envelope.maxy)
{
// Full included...
return(clippee);
}
if (clippee is IMultiPoint)
{
// Point ist schon durch den oberen Test enthalten...
IMultiPoint multipoint = (IMultiPoint)clippee;
MultiPoint newMultiPoint = new MultiPoint();
for (int i = 0; i < multipoint.PointCount; i++)
{
IPoint point = ClipPoint2Envelope(envelope, multipoint[i]);
if (point != null)
{
newMultiPoint.AddPoint(point);
}
}
return(newMultiPoint);
}
if (clippee is IPolyline)
{
return(ClipPolyline2Envelope(envelope, (IPolyline)clippee));
}
if (clippee is IPolygon)
{
//GeomPolygon clipperGeom = new GeomPolygon(envelope);
//GeomPolygon clippeeGeom = new GeomPolygon((IPolygon)clippee);
//GeomPolygon result = clippeeGeom.Clip(ClipOperation.Intersection, clipperGeom);
//int x = result.NofContours;
//return result.ToPolygon();
return(((IPolygon)clippee).Clip(envelope));
}
return(null);
}
/// <summary>
/// Renders a <see cref="GeoAPI.Geometries.IMultiPoint"/> to the map.
/// </summary>
/// <param name="g">Graphics reference</param>
/// <param name="points">MultiPoint to render</param>
/// <param name="symbol">Symbol to place over point</param>
/// <param name="symbolscale">The amount that the symbol should be scaled. A scale of '1' equals to no scaling</param>
/// <param name="offset">Symbol offset af scale=1</param>
/// <param name="rotation">Symbol rotation in degrees</param>
/// <param name="map">Map reference</param>
//[MethodImpl(MethodImplOptions.Synchronized)]
public static void DrawMultiPoint(Graphics g, IMultiPoint points, Image symbol, float symbolscale, PointF offset, float rotation, IMapViewPort map)
{
for (var i = 0; i < points.NumGeometries; i++)
{
var point = (IPoint)points[i];
DrawPoint(g, point, symbol, symbolscale, offset, rotation, map);
}
}
public static void DrawMultiPoint(Graphics g, IMultiPoint points, Brush brush, float size, PointF offset, MapViewport map)
{
for (var i = 0; i < points.NumGeometries; i++)
{
var point = (IPoint)points[i];
DrawPoint(g, point, brush, size, offset, map);
}
}
/// <summary>
/// Writes a 'MultiPoint' to the stream.
/// </summary>
/// <param name="multiPoint">The polygon to write.</param>
/// <param name="ordinates">The ordinates to write. <see cref="Ordinates.XY"/> are always written.</param>
/// <param name="byteOrder">The byte order.</param>
/// <param name="writer">The writer to use.</param>
private void Write(IMultiPoint multiPoint, Ordinates ordinates, ByteOrder byteOrder, BinaryWriter writer)
{
WriteHeader(PostGisGeometryType.MultiPoint,
HandleSRID ? multiPoint.SRID : -1,
ordinates, byteOrder, writer);
writer.Write(multiPoint.NumGeometries);
Write(multiPoint.Geometries, ordinates, byteOrder, writer);
}
/// <summary>
/// Gets the coordinates for a <see cref="IMultiPoint"/>
/// </summary>
/// <param name="multiPoint">the MultiPoint</param>
/// <returns>A collection of coordinates</returns>
public static IEnumerable <IEnumerable <double> > GetCoordinates(this IMultiPoint multiPoint)
{
return(multiPoint == null
? Enumerable.Empty <IEnumerable <double> >()
: multiPoint.Geometries
.Cast <IPoint>()
.Select(p => p.GetCoordinates()));
}
public static void DrawMultiPointWithCircle(Graphics g, IMultiPoint points, Bitmap symbol, float symbolscale, PointF offset,
float rotation, Map map, bool circleradius, int radius, Pen circleline)
{
for (int i = 0; i < points.Geometries.Length; i++)
{
DrawPointWithCircle(g, (IPoint)points.Geometries[i], symbol, symbolscale, offset, rotation, map, circleradius, radius, circleline);
}
}
/// <summary>
/// Creates a multi point.
/// </summary>
/// <param name="other">The other multi point.</param>
/// <returns>A multi point that matches <paramref name="other" />.</returns>
/// <exception cref="System.ArgumentNullException">The other multi point is null.</exception>
public virtual IMultiPoint CreateMultiPoint(IMultiPoint other)
{
if (other == null)
{
throw new ArgumentNullException(nameof(other));
}
return(new MultiPoint(this.PrecisionModel, this.ReferenceSystem, other));
}
/// <summary>
/// Writes MultiPoint to the output using specified writer.
/// </summary>
/// <param name="multipoint">The MultiPoint to write.</param>
/// <param name="writer">The BinaryWriter used to write geometry to the output.</param>
private static void WriteMultiPoint(IMultiPoint multipoint, BinaryWriter writer)
{
writer.Write((uint)WkbWriter.AdjustGeometryType(multipoint, WkbGeometryType.MultiPoint));
writer.Write((uint)multipoint.Geometries.Count());
foreach (var point in multipoint.Geometries)
{
WkbWriter.WriteCoordinate(point.Position, writer);
}
}
private IMultiPoint ReadMultiPoint(int dim, int lrsDim, SdoGeometry sdoGeom)
{
Double[] ordinates = sdoGeom.OrdinatesArray.Select(d => Convert.ToDouble(d)).ToArray();
ICoordinateSequence cs = ConvertOrdinateArray(ordinates, sdoGeom);
IMultiPoint multipoint = factory.CreateMultiPoint(cs);
multipoint.SRID = (int)sdoGeom.Sdo_Srid;
return(multipoint);
}
public static void DrawMultiPoint(D2D1.RenderTarget renderTarget, D2D1.Factory factory,
IMultiPoint points, D2D1.Brush brush, float size, Vector2 offset, Map map)
{
for (var i = 0; i < points.NumGeometries; i++)
{
var point = (IPoint)points[i];
DrawPoint(renderTarget, factory, point, brush, size, offset, map);
}
}
private static void GeometryToSqlGeometry(IMultiPoint geom, SqlGeometryBuilder bldr)
{
bldr.BeginGeometry(OpenGisGeometryType.MultiPoint);
for (int i = 0, c = geom.NumGeometries; i < c; i++)
GeometryToSqlGeometry(geom.Geometries[i] as IPoint, bldr);
bldr.EndGeometry();
}
private static GeoAPIMultiPoint FromMultiPoint(IMultiPoint geometry, GeoAPIGeometryFactory factory, bool copyUserData)
{
var result = factory.CreateMultiPoint(FromCoordinates(geometry.Coordinates));
if (copyUserData)
{
result.UserData = geometry.UserData;
}
return(result);
}
private static DSMultiPoint FromMultiPoint(IMultiPoint geometry, DSGeometryFactory factory, bool setUserData)
{
var result = factory.CreateMultiPoint(FromCoordinates(geometry.Coordinates));
if (setUserData)
{
result.UserData = geometry.UserData;
}
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="multiPoint"></param>
/// <param name="writer"></param>
protected void Write(IMultiPoint multiPoint, BinaryWriter writer)
{
WriteByteOrder(writer); // LittleIndian
writer.Write((int)(HasValidCoordinateZ(multiPoint)? WKBGeometryTypes.WKBMultiPointZ : WKBGeometryTypes.WKBMultiPoint));
writer.Write((int)multiPoint.NumGeometries);
for (int i = 0; i < multiPoint.NumGeometries; i++)
{
Write(multiPoint.Geometries[i] as IPoint, writer);
}
}
private static IMultiPoint FlattenMultiPoint(IMultiPoint mpoint, FgfGeometryFactory factory)
{
PointCollection points = new PointCollection();
for (int i = 0; i < mpoint.Count; i++)
{
points.Add(FlattenPoint(mpoint[i], factory));
}
return(factory.CreateMultiPoint(points));
}
public static IEnumerable <IPoint> Execute(IMultiPoint points, IGeometry line)
{
foreach (IPoint point in points.Points)
{
if (ExecuteBoolean(point, line))
{
yield return(point);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="multiPoint"></param>
/// <param name="writer"></param>
protected virtual void Write(IMultiPoint multiPoint, BinaryWriter writer)
{
WriteByteOrder(writer); // LittleIndian
writer.Write((int)WKBGeometryTypes.WKBMultiPoint);
writer.Write((int)multiPoint.NumGeometries);
for (int i = 0; i < multiPoint.NumGeometries; i++)
{
Write(multiPoint.Geometries[i] as Point, writer);
}
}
/// <summary>
///
/// </summary>
/// <param name="multiPoint"></param>
/// <param name="writer"></param>
protected virtual void Write(IMultiPoint multiPoint, BinaryWriter writer)
{
WriteByteOrder(writer);
writer.Write((int)WkbGeometryType.MultiPoint);
writer.Write(multiPoint.NumGeometries);
for (int i = 0; i < multiPoint.NumGeometries; i++)
{
Write(multiPoint.Geometries[i] as Point, writer);
}
}
/// <summary>
///
/// </summary>
/// <param name="multiPoint"></param>
/// <returns></returns>
protected int SetByteStreamLength(IMultiPoint multiPoint)
{
int count = InitValue;
foreach (IPoint p in multiPoint.Geometries)
{
count += SetByteStreamLength(p);
}
return(count);
}
/// <summary>
///
/// </summary>
public MultiPointSamples() : base()
{
ICoordinate[] coordinates = new ICoordinate[]
{
new Coordinate(100,100),
new Coordinate(200,200),
new Coordinate(300,300),
new Coordinate(400,400),
new Coordinate(500,500),
};
multiPoint = Factory.CreateMultiPoint(coordinates);
}
static BasicTestForms()
{
var gf = GeometryFactory.Default;
_multiPoint = gf.CreateMultiPoint(
new []
{
new Coordinate(100*_random.NextDouble(), 100*_random.NextDouble()),
new Coordinate(100*_random.NextDouble(), 100*_random.NextDouble()),
new Coordinate(100*_random.NextDouble(), 100*_random.NextDouble()),
new Coordinate(100*_random.NextDouble(), 100*_random.NextDouble()),
new Coordinate(100*_random.NextDouble(), 100*_random.NextDouble())
});
}
/// <summary>
/// A MultiPoint is simple if it has no repeated points.
/// </summary>
public bool IsSimple(IMultiPoint mp)
{
if (mp.IsEmpty)
return true;
ISet points = new ListSet();
for (int i = 0; i < mp.NumGeometries; i++)
{
IPoint pt = (IPoint) mp.GetGeometryN(i);
ICoordinate p = pt.Coordinate;
if (points.Contains(p))
return false;
points.Add(p);
}
return true;
}
/// <summary>
///
/// </summary>
public GMLTesting()
{
point = Factory.CreatePoint(new Coordinate(100, 100));
ICoordinate[] coordinates = new ICoordinate[]
{
new Coordinate(10,10),
new Coordinate(20,20),
new Coordinate(20,10),
};
line = Factory.CreateLineString(coordinates);
coordinates = new ICoordinate[]
{
new Coordinate(100,100),
new Coordinate(200,100),
new Coordinate(200,200),
new Coordinate(100,200),
new Coordinate(100,100),
};
ICoordinate[] interior1 = new ICoordinate[]
{
new Coordinate(120,120),
new Coordinate(180,120),
new Coordinate(180,180),
new Coordinate(120,180),
new Coordinate(120,120),
};
ILinearRing linearRing = Factory.CreateLinearRing(coordinates);
ILinearRing[] holes = new ILinearRing[] { Factory.CreateLinearRing(interior1), };
polygon = Factory.CreatePolygon(linearRing, holes);
coordinates = new ICoordinate[]
{
new Coordinate(100,100),
new Coordinate(200,200),
new Coordinate(300,300),
new Coordinate(400,400),
new Coordinate(500,500),
};
multiPoint = Factory.CreateMultiPoint(coordinates);
writer = new GMLWriter();
reader = new GMLReader();
}
public SerializationSamples() : base()
{
filepath = Path.GetTempPath() + "\\testserialization.bin";
serializer = new BinaryFormatter();
point = Factory.CreatePoint(new Coordinate(100, 100));
coordinates = new Coordinate[]
{
new Coordinate(10,10),
new Coordinate(20,20),
new Coordinate(20,10),
};
line = Factory.CreateLineString(coordinates);
coordinates = new Coordinate[]
{
new Coordinate(100,100),
new Coordinate(200,100),
new Coordinate(200,200),
new Coordinate(100,200),
new Coordinate(100,100),
};
ILinearRing linearRing = Factory.CreateLinearRing(coordinates);
polygon = Factory.CreatePolygon(linearRing, null);
coordinates = new Coordinate[]
{
new Coordinate(100,100),
new Coordinate(200,200),
new Coordinate(300,300),
new Coordinate(400,400),
new Coordinate(500,500),
};
multiPoint = Factory.CreateMultiPoint(coordinates);
}
/// <summary>
/// Checks validity of a MultiPoint.
/// </summary>
/// <param name="g"></param>
private void CheckValid(IMultiPoint g)
{
CheckInvalidCoordinates(g.Coordinates);
}
private static DSMultiPoint FromMultiPoint(IMultiPoint geometry, DSGeometryFactory factory, bool setUserData)
{
var result = factory.CreateMultiPoint(FromCoordinates(geometry.Coordinates));
if (setUserData)
result.UserData = geometry.UserData;
return result;
}
/// <summary>
///
/// </summary>
/// <param name="geom"></param>
/// <param name="parent"></param>
/// <returns></returns>
protected virtual IGeometry TransformMultiPoint(IMultiPoint geom, IGeometry parent)
{
ArrayList transGeomList = new ArrayList();
for (int i = 0; i < geom.NumGeometries; i++)
{
IGeometry transformGeom = TransformPoint((IPoint) geom.GetGeometryN(i), geom);
if (transformGeom == null) continue;
if (transformGeom.IsEmpty) continue;
transGeomList.Add(transformGeom);
}
return factory.BuildGeometry(transGeomList);
}
/// <summary>
///
/// </summary>
/// <param name="multiPoint"></param>
/// <returns></returns>
protected int SetByteStreamLength(IMultiPoint multiPoint)
{
int numPoints = multiPoint.NumPoints;
return CalculateLength(numPoints);
}
/// <summary>
///
/// </summary>
/// <param name="multiPoint"></param>
/// <param name="writer"></param>
protected void Write(IMultiPoint multiPoint, BinaryWriter writer)
{
WriteByteOrder(writer); // LittleIndian
writer.Write((int) WKBGeometryTypes.WKBMultiPoint);
writer.Write((int) multiPoint.NumGeometries);
for (int i = 0; i < multiPoint.NumGeometries; i++)
Write(multiPoint.Geometries[i] as IPoint, writer);
}
/// <summary>
///
/// </summary>
/// <param name="multiPoint"></param>
/// <returns></returns>
protected int SetByteStreamLength(IMultiPoint multiPoint)
{
int count = InitValue;
foreach (IPoint p in multiPoint.Geometries)
count += SetByteStreamLength(p);
return count;
}
/// <summary>
/// Converts a <c>MultiPoint</c> to <MultiPoint Tagged Text
/// format, then appends it to the writer.
/// </summary>
/// <param name="multipoint">The <c>MultiPoint</c> to process.</param>
/// <param name="level"></param>
/// <param name="writer">The output writer to append to.</param>
private void AppendMultiPointTaggedText(IMultiPoint multipoint, int level, TextWriter writer)
{
writer.Write("MULTIPOINT");
AppendMultiPointText(multipoint, level, writer);
}
/// <summary>
/// Converts a <c>MultiPoint</c> to <MultiPoint Text format, then
/// appends it to the writer.
/// </summary>
/// <param name="multiPoint">The <c>MultiPoint</c> to process.</param>
/// <param name="level"></param>
/// <param name="writer">The output writer to append to.</param>
private void AppendMultiPointText(IMultiPoint multiPoint, int level, TextWriter writer)
{
if (multiPoint.IsEmpty)
writer.Write(" EMPTY");
else
{
writer.Write("(");
for (int i = 0; i < multiPoint.NumGeometries; i++)
{
if (i > 0) writer.Write(",");
AppendCoordinate(((IPoint) multiPoint.GetGeometryN(i)).Coordinate, writer, multiPoint.PrecisionModel);
}
writer.Write(")");
}
}
/// <summary>
/// Method to write a multipoint geometry to the <paramref name="writer"/>
/// </summary>
/// <param name="points">The multipoint geometry</param>
/// <param name="writer">The JSON writer</param>
public static void Write(IMultiPoint points, TextWriter writer)
{
if (points == null)
return;
if (writer == null)
throw new ArgumentNullException("writer", "A valid text writer object is required");
JsonTextWriter jwriter = CreateWriter(writer);
Write(points, jwriter);
}
private static GeoAPIMultiPoint FromMultiPoint(IMultiPoint geometry, GeoAPIGeometryFactory factory, bool copyUserData)
{
var result = factory.CreateMultiPoint(FromCoordinates(geometry.Coordinates));
if (copyUserData)
result.UserData = geometry.UserData;
return result;
}
/// <summary>
/// Method to write a multipoint geometry to the <paramref name="writer"/>
/// </summary>
/// <param name="points">The multipoint geometry</param>
/// <param name="writer">The JSON writer</param>
public static void Write(IMultiPoint points, JsonTextWriter writer)
{
if (points == null)
return;
if (writer == null)
throw new ArgumentNullException("writer", "A valid JSON writer object is required");
writer.WriteStartObject();
writer.WritePropertyName("type");
writer.WriteValue("MultiPoint");
writer.WritePropertyName("coordinates");
/*
writer.WriteStartArray();
foreach (var entry in points.Coordinates)
WriteCoord(entry, writer);
writer.WriteEndArray();
*/
WriteCoord(points.Coordinates, writer);
writer.WriteEndObject();
}
/// <summary>
/// Writes a multipoint.
/// </summary>
/// <param name="mp">The multipoint to be written.</param>
/// <param name="bWriter">Stream to write to.</param>
/// <param name="byteorder">Byte order</param>
private static void WriteMultiPoint(IMultiPoint mp, BinaryWriter bWriter, WkbByteOrder byteorder)
{
var vertices = mp.Coordinates;
//Write the number of points.
WriteUInt32((uint) vertices.Length, bWriter, byteorder);
//Loop on the number of points.
foreach (var p in vertices)
{
//Write Points Header
bWriter.Write((byte) byteorder);
WriteUInt32((uint) WKBGeometryType.wkbPoint, bWriter, byteorder);
//Write each point.
WritePoint(p, bWriter, byteorder);
}
}
/// <summary>
/// Transforms a <see cref="GeoAPI.Geometries.IMultiPoint"/>.
/// </summary>
/// <param name="points">MultiPoint 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 MultiPoint</returns>
public static IMultiPoint TransformMultiPoint(IMultiPoint points, ProjectionInfo from, ProjectionInfo to, IGeometryFactory toFactory)
{
try
{
var seq = toFactory.CoordinateSequenceFactory.Create(points.Coordinates);
var toSeq = TransformSequence(seq, from, to, toFactory.CoordinateSequenceFactory);
return toFactory.CreateMultiPoint(toSeq);
}
catch
{
return null;
}
}
/// <summary>
///
/// </summary>
/// <param name="multiPoint"></param>
/// <param name="writer"></param>
protected virtual void Write(IMultiPoint multiPoint, BinaryWriter writer)
{
WriteByteOrder(writer);
writer.Write((int)WkbGeometryType.MultiPoint);
writer.Write(multiPoint.NumGeometries);
for (int i = 0; i < multiPoint.NumGeometries; i++)
Write(multiPoint.Geometries[i] as Point, writer);
}
/// <summary>
///
/// </summary>
/// <param name="multiPoint"></param>
/// <param name="writer"></param>
protected void Write(IMultiPoint multiPoint, XmlTextWriter writer)
{
writer.WriteStartElement("MultiPoint", GMLElements.gmlNS);
for (int i = 0; i < multiPoint.NumGeometries; i++)
{
writer.WriteStartElement("pointMember", GMLElements.gmlNS);
Write(multiPoint.Geometries[i] as IPoint, writer);
writer.WriteEndElement();
}
writer.WriteEndElement();
}
/// <summary>
///
/// </summary>
/// <param name="geometry"></param>
/// <returns></returns>
protected virtual int SetByteStream(IMultiPoint geometry)
{
int count = INIT_COUNT;
count += 4; // NumPoints
foreach (Point geom in geometry.Geometries)
count += SetByteStream(geom);
return count;
}
/// <summary>
///
/// </summary>
/// <param name="multiPoint"></param>
/// <param name="writer"></param>
public void Write(IMultiPoint multiPoint, BinaryWriter writer)
{
writer.Write((int) ShapeGeometryTypes.MultiPoint);
// Write BoundingBox
WriteBoundingBox(multiPoint, writer);
// Write NumPoints
writer.Write((int) multiPoint.NumPoints);
// Write Coordinates
for (int i = 0; i < multiPoint.NumPoints; i++)
Write(multiPoint.Coordinates[i], writer);
}
public bool IsSimple(IMultiPoint mp)
{
return IsSimpleMultiPoint(mp);
}
/// <summary>
///
/// </summary>
/// <param name="geometry"></param>
/// <returns></returns>
protected int SetByteStream(IMultiPoint geometry)
{
int count = InitCount;
count += 4; // NumPoints
foreach (IPoint geom in geometry.Geometries)
count += SetByteStream(geom);
return count;
}
private bool IsSimpleMultiPoint(IMultiPoint mp)
{
if (mp.IsEmpty)
return true;
HashSet<Coordinate> points = new HashSet<Coordinate>();
for (int i = 0; i < mp.NumGeometries; i++)
{
IPoint pt = (IPoint)mp.GetGeometryN(i);
Coordinate p = pt.Coordinate;
if (points.Contains(p))
{
_nonSimpleLocation = p;
return false;
}
points.Add(p);
}
return true;
}
/// <summary>
///
/// </summary>
/// <param name="multiPoint"></param>
/// <param name="writer"></param>
protected void Write(IMultiPoint multiPoint, BinaryWriter writer)
{
WriteHeader(multiPoint, PostGisGeometryType.MultiPoint, writer);
writer.Write((int)multiPoint.NumGeometries);
Write(multiPoint.Geometries, writer);
}
/// <summary>
///
/// </summary>
/// <param name="geometry"></param>
/// <returns></returns>
protected int SetByteStream(IMultiPoint geometry)
{
// int size
int result = 4;
if (geometry.NumPoints > 0)
{
// We can shortcut here, as all subgeoms have the same fixed size
result += geometry.NumPoints * SetByteStream(geometry.Geometries[0] as IGeometry);
}
return result;
}
/// <summary>
/// Transforms a <see cref="MultiPoint" /> object.
/// </summary>
/// <param name="points"></param>
/// <param name="transform"></param>
/// <returns></returns>
public static IMultiPoint TransformMultiPoint(IMultiPoint points, IMathTransform transform)
{
List<double[]> pointList = new List<double[]>(points.Geometries.Length);
foreach (IPoint p in points.Geometries)
pointList.Add(ToArray(p.X, p.Y));
pointList = transform.TransformList(pointList);
IPoint[] array = new IPoint[pointList.Count];
for (int i = 0; i < pointList.Count; i++)
array[i] = ToNTS(pointList[i][0], pointList[i][1]);
return new MultiPoint(array);
}
/// <summary>
/// Converts the <c>ICollection</c> to an array.
/// </summary>
/// <param name="multiPoints">The <c>ICollection</c> of MultiPoints to convert.</param>
/// <returns>The <c>ICollection</c> in array format.</returns>
public static IMultiPoint[] ToMultiPointArray(ICollection multiPoints)
{
IMultiPoint[] list = new IMultiPoint[multiPoints.Count];
int i = 0;
foreach (IMultiPoint mp in multiPoints)
list[i++] = mp;
return list;
}
