public static void main(string[] args)
{
var seqFact = ExtendedCoordinateSequenceFactory.Instance();
var array1 = new ExtendedCoordinate[] { new ExtendedCoordinate(0, 0, 0, 91),
new ExtendedCoordinate(10, 0, 0, 92), new ExtendedCoordinate(10, 10, 0, 93),
new ExtendedCoordinate(0, 10, 0, 94), new ExtendedCoordinate(0, 0, 0, 91) };
var seq1 = seqFact.Create(array1);
var seq2 = seqFact.Create(new ExtendedCoordinate[] { new ExtendedCoordinate(5, 5, 0, 91),
new ExtendedCoordinate(15, 5, 0, 92), new ExtendedCoordinate(15, 15, 0, 93),
new ExtendedCoordinate(5, 15, 0, 94), new ExtendedCoordinate(5, 5, 0, 91) });
var fact = new GeometryFactory(ExtendedCoordinateSequenceFactory.Instance());
IGeometry g1 = fact.CreatePolygon(fact.CreateLinearRing(seq1), null);
IGeometry g2 = fact.CreatePolygon(fact.CreateLinearRing(seq2), null);
Console.WriteLine("WKT for g1: " + g1);
Console.WriteLine("Internal rep for g1: " + ((IPolygon)g1).ExteriorRing.CoordinateSequence);
Console.WriteLine("WKT for g2: " + g2);
Console.WriteLine("Internal rep for g2: " + ((IPolygon)g2).ExteriorRing.CoordinateSequence);
var gInt = g1.Intersection(g2);
Console.WriteLine("WKT for gInt: " + gInt);
Console.WriteLine("Internal rep for gInt: " + ((IPolygon)gInt).ExteriorRing.CoordinateSequence);
}
public static void PrintSourceData(IList <Envelope> sourceEnvelopes)
{
Console.WriteLine("============ Source Data ============\n");
Console.Write("GEOMETRYCOLLECTION(");
bool first = true;
foreach (var e in sourceEnvelopes)
{
IGeometry g = factory.CreatePolygon(factory.CreateLinearRing(new Coordinate[] {
new Coordinate(e.MinX, e.MinY), new Coordinate(e.MinX, e.MaxY),
new Coordinate(e.MaxX, e.MaxY), new Coordinate(e.MaxX, e.MinY),
new Coordinate(e.MinX, e.MinY)
}), null);
if (first)
{
first = false;
}
else
{
Console.Write(",");
}
Console.Write(g);
}
Console.WriteLine(")\n");
}
public IPolygon CreatePolygon(IList <Coordinate> shell, IList <Coordinate>[] holes = null)
{
ILinearRing[] geomHoles = new ILinearRing[holes == null ? 0 : holes.Length];
for (int i = 0; i < geomHoles.Length; i++)
{
geomHoles[i] = _factory.CreateLinearRing(holes[i]);
}
return(_factory.CreatePolygon(_factory.CreateLinearRing(shell), geomHoles));
}
private void MergeInnerIntoOuterPolygon(ref List <Polygon> outerPolygons, ref List <Polygon> innerPolygons)
{
var newOuterPolygons = new List <Polygon>();
foreach (var outerPolygon in outerPolygons)
{
var currentInnerPolygons = innerPolygons.Where(p => p.Within(outerPolygon)).ToArray();
var holes = currentInnerPolygons.Select(p => _geometryFactory.CreateLinearRing(p.Coordinates)).ToArray();
innerPolygons = innerPolygons.Except(currentInnerPolygons).ToList();
newOuterPolygons.Add(_geometryFactory.CreatePolygon(_geometryFactory.CreateLinearRing(outerPolygon.Coordinates), holes));
}
outerPolygons = newOuterPolygons;
}
public void TestUnclosedLinearRing()
{
try
{
geometryFactory.CreateLinearRing(new Coordinate[] {
new Coordinate(0, 0), new Coordinate(1, 0), new Coordinate(1, 1), new Coordinate(2, 1)
});
Assert.IsTrue(false);
}
catch (Exception e)
{
Assert.IsTrue(e is ArgumentException);
}
}
public void TestWritePolygon()
{
Coordinate[] coordinates =
{
new CoordinateZ(10, 10, 0),
new CoordinateZ(10, 20, 0),
new CoordinateZ(20, 20, 0),
new CoordinateZ(20, 15, 0),
new CoordinateZ(10, 10, 0)
};
var linearRing = _factory.CreateLinearRing(coordinates);
var polygon = _factory.CreatePolygon(linearRing, new LinearRing[] { });
Assert.AreEqual("POLYGON ((10 10, 10 20, 20 20, 20 15, 10 10))", _writer.Write(polygon));
}
static IPolygon ParseFlatbufPolygon(uint[] ends, double[] coords, byte dimensions)
{
if (ends == null)
{
return(ParseFlatbufPolygonSingleRing(coords, dimensions));
}
var sequenceFactory = new PackedCoordinateSequenceFactory();
var factory = new GeometryFactory(sequenceFactory);
var arraySegment = new ArraySegment <double>(coords);
var linearRings = new List <ILinearRing>();
uint offset = 0;
for (var i = 0; i < ends.Length; i++)
{
var end = ends[i] << 1;
var ringCoords = coords.Skip((int)offset).Take((int)end).ToArray();
var linearRing = factory.CreateLinearRing(sequenceFactory.Create(ringCoords, dimensions));
linearRings.Add(linearRing);
offset = end;
}
var shell = linearRings.First();
var holes = linearRings.Skip(1).ToArray();
return(factory.CreatePolygon(shell, holes));
}
private static IPolygon SqlGeometryToGeometryPolygon(SqlGeometry geometry, GeometryFactory factory)
{
ILinearRing exterior = factory.CreateLinearRing(GetPoints(geometry.STExteriorRing()));
ILinearRing[] interior = null;
if (geometry.STNumInteriorRing() > 0)
{
interior = new ILinearRing[geometry.STNumInteriorRing().Value];
for (int i = 1; i <= interior.Length; i++)
{
interior[i - 1] = factory.CreateLinearRing(GetPoints(geometry.STInteriorRingN(i)));
}
}
return(factory.CreatePolygon(exterior, interior));
}
public override Polygon CreateGeometry(
IType type,
object?coordinates,
int?crs)
{
if (type is null)
{
throw new ArgumentNullException(nameof(type));
}
if (coordinates is List <Coordinate> list)
{
coordinates = list.Count == 0
? Array.Empty <Coordinate>()
: list.ToArray();
}
if (coordinates is not Coordinate[] coords)
{
throw Serializer_Parse_CoordinatesIsInvalid(type);
}
if (crs is not null)
{
GeometryFactory factory =
NtsGeometryServices.Instance.CreateGeometryFactory(crs.Value);
LinearRing ringSrid = factory.CreateLinearRing(coords);
return(factory.CreatePolygon(ringSrid));
}
var ring = new LinearRing(coords);
return(new Polygon(ring));
}
private IPolygon CreateSelectionPolygon(ICoordinate worldPosition)
{
if (MultiSelectionMode == MultiSelectionMode.Rectangle)
{
if (0 == Math.Abs(mouseDownLocation.X - worldPosition.X))
{
return(null);
}
if (0 == Math.Abs(mouseDownLocation.Y - worldPosition.Y))
{
return(null);
}
return(CreatePolygon(Math.Min(mouseDownLocation.X, worldPosition.X),
Math.Max(mouseDownLocation.Y, worldPosition.Y),
Math.Max(mouseDownLocation.X, worldPosition.X),
Math.Min(mouseDownLocation.Y, worldPosition.Y)));
}
var vertices = new List <ICoordinate>();
foreach (var point in selectPoints)
{
vertices.Add(Map.ImageToWorld(point));
}
if (vertices.Count == 1)
{
// too few points to create a polygon
return(null);
}
vertices.Add((ICoordinate)worldPosition.Clone());
vertices.Add((ICoordinate)vertices[0].Clone());
ILinearRing newLinearRing = GeometryFactory.CreateLinearRing(vertices.ToArray());
return(GeometryFactory.CreatePolygon(newLinearRing, null));
}
public Geometry GetGeometry(GeometryFactory fact)
{
var ring = fact.CreateLinearRing(GetCoordinates());
var tri = fact.CreatePolygon(ring);
return(tri);
}
/// <summary>
/// Gets the Voronoi cell around a site specified
/// by the origin of a QuadEdge.
/// </summary>
/// <remarks>
/// The userData of the polygon is set to be the <see cref="Coordinate" />
/// of the site. This allows attaching external
/// data associated with the site to this cell polygon.
/// </remarks>
/// <param name="qe">a quadedge originating at the cell site</param>
/// <param name="geomFact">a factory for building the polygon</param>
/// <returns>a polygon indicating the cell extent</returns>
public Polygon GetVoronoiCellPolygon(QuadEdge qe, GeometryFactory geomFact)
{
var cellPts = new List <Coordinate>();
var startQE = qe;
do
{
// Coordinate cc = circumcentre(qe);
// use previously computed circumcentre
var cc = qe.Rot.Orig.Coordinate;
cellPts.Add(cc);
// move to next triangle CW around vertex
qe = qe.OPrev;
} while (qe != startQE);
var coordList = new CoordinateList();
coordList.AddAll(cellPts, false);
coordList.CloseRing();
if (coordList.Count < 4)
{
Debug.WriteLine(coordList);
coordList.Add(coordList[coordList.Count - 1], true);
}
var pts = coordList.ToCoordinateArray();
var cellPoly = geomFact.CreatePolygon(geomFact.CreateLinearRing(pts));
var v = startQE.Orig;
cellPoly.UserData = v.Coordinate;
return(cellPoly);
}
/// <summary>
/// Creates a linar ring from WKB.
/// </summary>
/// <returns></returns>
private LinearRing CreateWKBLinearRing()
{
Coordinates coords = ReadCoordinates();
//Create and return the linearring.
return(_geometryFactory.CreateLinearRing(coords));
}
protected override void OnMouseDoubleClick(MouseEventArgs e)
{
if (map == null)
{
return;
}
foreach (var tool in tools.Where(tool => tool.IsActive))
{
tool.OnMouseDoubleClick(this, e);
}
// todo (TOOLS-1151) move implemention in mapView_MouseDoubleClick to SelectTool::OnMouseDoubleClick?
if (SelectTool.IsActive)
{
base.OnMouseDoubleClick(e);
}
//NS, 2013-12-02, generate polygon coordinate
if (drawPolygonTool.IsActive)
{
if (GeometryDefined != null)
{
var cl = new GisSharpBlog.NetTopologySuite.Geometries.CoordinateList(drawPolygonTool.pointArray, false);
cl.CloseRing();
GeometryDefined(GeometryFactory.CreatePolygon(GeometryFactory.CreateLinearRing(GisSharpBlog.NetTopologySuite.Geometries.CoordinateArrays.AtLeastNCoordinatesOrNothing(4, cl.ToCoordinateArray())), null));
drawPolygonTool.pointArray = null;
}
ActivateTool(panZoomTool);
}
}
/// <summary>
/// Converts this referenced location to a geometry.
/// </summary>
/// <returns></returns>
public FeatureCollection ToFeatures()
{
// create the geometry factory.
var geometryFactory = new GeometryFactory();
// create the feature collection.
var featureCollection = new FeatureCollection();
//// create a point feature at each point in the grid.
//double lonDiff = (this.LowerLeftLongitude - this.UpperRightLongitude) / this.Columns;
//double latDiff = (this.UpperRightLatitude - this.LowerLeftLatitude) / this.Rows;
//for (int column = 0; column < this.Columns; column++)
//{
// double longitude = this.LowerLeftLongitude - (column * lonDiff);
// for (int row = 0; row < this.Rows; row++)
// {
// double latitude = this.UpperRightLatitude - (row * latDiff);
// var point = geometryFactory.CreatePoint(new Coordinate(longitude, latitude));
// var pointAttributes = new AttributesTable();
// featureCollection.Add(new Feature(point, pointAttributes));
// }
//}
// create a lineair ring.
var lineairRingAttributes = new AttributesTable();
featureCollection.Add(new Feature(geometryFactory.CreateLinearRing(new Coordinate[] {
new Coordinate(this.LowerLeftLongitude, this.LowerLeftLatitude),
new Coordinate(this.LowerLeftLongitude, this.UpperRightLatitude),
new Coordinate(this.UpperRightLongitude, this.UpperRightLatitude),
new Coordinate(this.UpperRightLongitude, this.LowerLeftLatitude),
new Coordinate(this.LowerLeftLongitude, this.LowerLeftLatitude)
}), lineairRingAttributes));
return(featureCollection);
}
private Polygon Poly1()
{
_coords1 = new Coordinates();
Coordinate coord = new Coordinate(5, 1);
_coords1.Add(coord);
coord = new Coordinate(6, 2);
_coords1.Add(coord);
coord = new Coordinate(7, 3);
_coords1.Add(coord);
coord = new Coordinate(6, 4);
_coords1.Add(coord);
coord = new Coordinate(5, 5);
_coords1.Add(coord);
coord = new Coordinate(4, 4);
_coords1.Add(coord);
coord = new Coordinate(3, 3);
_coords1.Add(coord);
coord = new Coordinate(4, 2);
_coords1.Add(coord);
coord = new Coordinate(5, 1);
_coords1.Add(coord);
_gf = new GeometryFactory(_precMod, _sRID);
_exterior1 = _gf.CreateLinearRing(_coords1);
Polygon polygon = _gf.CreatePolygon(_exterior1);
return(polygon);
}
public IGeometry GetGeometry(GeometryFactory fact)
{
ILinearRing ring = fact.CreateLinearRing(GetCoordinates());
IPolygon tri = fact.CreatePolygon(ring, null);
return(tri);
}
private Geometry GetGeometryFromNodes(Node[] nodes)
{
var coordinates = nodes.Select(ConvertNode).ToArray();
return(nodes.First().Id == nodes.Last().Id&& nodes.Length >= 4
? _geometryFactory.CreatePolygon(_geometryFactory.CreateLinearRing(coordinates)) as Geometry
: _geometryFactory.CreateLineString(coordinates) as Geometry);
}
/// <summary>
/// Function to read a either a <see cref="Polygon"/> or an <see cref="MultiPolygon"/> from a ShapeFile stream using the specified <paramref name="reader"/>.
/// </summary>
/// <param name="reader">The reader to use</param>
/// <param name="ordinates">The ordinates to read</param>
/// <returns>The read polygonal geometry</returns>
protected Geometry ReadPolygon(BinaryReader reader, Ordinates ordinates)
{
/*var bbox = */ ReadBoundingBox(reader); // jump boundingbox
int numParts = ReadNumParts(reader);
int numPoints = ReadNumPoints(reader);
int[] indexParts = ReadIndexParts(reader, numParts, numPoints);
var buffer = new CoordinateBuffer(numPoints, ShapeFileConstants.NoDataBorder, true);
ReadCoordinates(reader, numPoints, indexParts, ordinates, buffer);
return(numParts == 1
? _factory.CreatePolygon(_factory.CreateLinearRing(buffer.ToSequence()), null)
: CreateSingleOrMultiPolygon(buffer));
}
static IPolygon ParseFlatbufPolygonSingleRing(double[] coords, byte dimensions)
{
var sequenceFactory = new PackedCoordinateSequenceFactory();
var factory = new GeometryFactory(sequenceFactory);
var shell = factory.CreateLinearRing(sequenceFactory.Create(coords, dimensions));
return(factory.CreatePolygon(shell));
}
/// <summary>
/// Transforms a <see cref="LinearRing"/>.
/// <para/>
/// The transformation of a <c>LinearRing</c> may result in a coordinate sequence
/// which does not form a structurally valid ring (i.e. a degenerate ring of 3 or fewer points).
/// In this case a <c>LineString</c> is returned.
/// Subclasses may wish to override this method and check for this situation
/// (e.g.a subclass may choose to eliminate degenerate linear rings)
/// </summary>
/// <param name="geom">The <c>LinearRing</c> to transform</param>
/// <param name="parent">The parent geometry</param>
/// <returns>
/// A <c>LinearRing</c> if the transformation resulted in a structurally valid ring, otherwise,
/// if the transformation caused the LinearRing to collapse to 3 or fewer points, a <c>LineString</c>
/// </returns>
protected virtual Geometry TransformLinearRing(LinearRing geom, Geometry parent)
{
var seq = TransformCoordinates(geom.CoordinateSequence, geom);
if (seq == null)
{
return(Factory.CreateLinearRing((CoordinateSequence)null));
}
int seqSize = seq.Count;
// ensure a valid LinearRing
if (seqSize > 0 && seqSize < 4 && !_preserveType)
{
return(Factory.CreateLineString(seq));
}
return(Factory.CreateLinearRing(seq));
}
private Polygon CreatePolygon(JsonReader reader, List <object> list)
{
var shell = _factory.CreateLinearRing(CreateCoordinateArray(reader, (List <object>)list[0]));
if (list.Count == 1)
{
return(_factory.CreatePolygon(shell));
}
var holes = new LinearRing[list.Count - 1];
for (int i = 0; i < holes.Length; i++)
{
holes[i] = _factory.CreateLinearRing(CreateCoordinateArray(reader, (List <object>)list[i + 1]));
}
return(_factory.CreatePolygon(shell, holes));
}
/// <summary>
/// Compute a LinearRing from the point list previously collected.
/// Test if the ring is a hole (i.e. if it is CCW) and set the hole flag
/// accordingly.
/// </summary>
public void ComputeRing()
{
if (m_objRing != null)
{
return; // don't compute more than once
}
m_objRing = geometryFactory.CreateLinearRing(pts);
m_bIsHole = CGAlgorithms.IsCCW(m_objRing.Coordinates);
}
/// <summary>
/// Transforms a <see cref="LinearRing"/>.
/// </summary>
/// <param name="r">LinearRing to transform</param>
/// <param name="transform">MathTransform</param>
/// <returns>Transformed LinearRing</returns>
public static ILinearRing TransformLinearRing(ILinearRing r, IMathTransform transform)
{
try
{
List <ICoordinate> coords = ExtractCoordinates(r, transform);
return(GeometryFactory.CreateLinearRing(coords.ToArray()));
}
catch { return(null); }
}
/// <summary>
/// Compute a LinearRing from the point list previously collected.
/// Test if the ring is a hole (i.e. if it is CCW) and set the hole flag
/// accordingly.
/// </summary>
public void ComputeRing()
{
if (_ring != null)
{
return; // don't compute more than once
}
// create ring using geometry factory.
_ring = _geometryFactory.CreateLinearRing(_pts);
_isHole = _cga.IsCCW(_ring.GetCoordinates());
} // public void ComputeRing()
// Use ring to restore M values on geoms
private ICollection <NetTopologySuite.Geometries.Geometry> restoreDim4(ICollection <NetTopologySuite.Geometries.Geometry> geoms, Dictionary <Coordinate, Double> map)
{
GeometryFactory factory = new GeometryFactory(
new PackedCoordinateSequenceFactory(PackedCoordinateSequenceFactory.PackedType.Double));
List <NetTopologySuite.Geometries.Geometry> result = new List <NetTopologySuite.Geometries.Geometry>();
foreach (NetTopologySuite.Geometries.Geometry geom in geoms)
{
if (geom is Point)
{
result.Add(factory.CreatePoint(restoreDim4(
((Point)geom).CoordinateSequence, map)));
}
else if (geom is LineString)
{
result.Add(factory.CreateLineString(restoreDim4(
((LineString)geom).CoordinateSequence, map)));
}
else if (geom is Polygon)
{
LinearRing outer = factory.CreateLinearRing(restoreDim4(
((Polygon)geom).ExteriorRing.CoordinateSequence, map));
LinearRing[] inner = new LinearRing[((Polygon)geom).NumInteriorRings];
for (int i = 0; i < ((Polygon)geom).NumInteriorRings; i++)
{
inner[i] = factory.CreateLinearRing(restoreDim4(
((Polygon)geom).GetInteriorRingN(i).CoordinateSequence, map));
}
result.Add(factory.CreatePolygon(outer, inner));
}
else
{
for (int i = 0; i < geom.NumGeometries; i++)
{
result.AddRange(restoreDim4(new List <NetTopologySuite.Geometries.Geometry>()
{
geom.GetGeometryN(i)
}, map));
}
}
}
return(result);
}
/// <summary>
/// Reads a polygon, returning a NTS polygon.
/// </summary>
protected virtual IPolygon Polygon(WktShapeParser.State state)
{
GeometryFactory geometryFactory = m_ctx.GeometryFactory;
IList <Coordinate[]> coordinateSequenceList = CoordinateSequenceList(state);
ILinearRing shell = geometryFactory.CreateLinearRing(coordinateSequenceList[0]);
ILinearRing[] holes = null;
if (coordinateSequenceList.Count > 1)
{
holes = new ILinearRing[coordinateSequenceList.Count - 1];
for (int i = 1; i < coordinateSequenceList.Count; i++)
{
holes[i - 1] = geometryFactory.CreateLinearRing(coordinateSequenceList[i]);
}
}
return(geometryFactory.CreatePolygon(shell, holes));
}
private static LinearRing CreateWKBLinearRing(BinaryReader reader, WkbByteOrder byteOrder, GeometryFactory factory)
{
var points = new List <Coordinate>(ReadCoordinates(reader, byteOrder));
if (!points[0].Equals2D(points[points.Count - 1]))
{
points.Add(new Coordinate(points[0]));
}
return(factory.CreateLinearRing(points.ToArray()));
}
private Geometry CreatePolygonal(CoordinateSequence[] sequences)
{
var polygons = new List <Polygon>();
LinearRing shell = null;
var holes = new List <LinearRing>();
for (int i = 0; i < sequences.Length; i++)
{
var ring = _factory.CreateLinearRing(sequences[i]);
// Shell rings should be CW (https://docs.mapbox.com/vector-tiles/specification/#winding-order)
if (!ring.IsCCW)
{
if (shell != null)
{
polygons.Add(_factory.CreatePolygon(shell, holes.ToArray()));
holes.Clear();
}
shell = ring;
}
// Hole rings should be CCW https://docs.mapbox.com/vector-tiles/specification/#winding-order
else
{
if (shell == null)
{
if (sequences.Length == 1)
{
// WARNING: this is not according to the spec but tiles exists like this in the wild
// that are rendered just fine by other tools, we can ignore them if we want to but
// should not throw an exception. The solution preferred here is to just read them
// but reverse them so the user gets what they expect according to the spec.
shell = ring.Reverse() as LinearRing;
}
else
{
throw new InvalidOperationException("No shell defined.");
}
}
else
{
holes.Add(ring);
}
}
}
polygons.Add(_factory.CreatePolygon(shell, holes.ToArray()));
if (polygons.Count == 1)
{
return(polygons[0]);
}
return(_factory.CreateMultiPolygon(polygons.ToArray()));
}
/// <summary>
/// Transforms a <see cref="NetTopologySuite.Geometries.LinearRing"/>.
/// </summary>
/// <param name="r">LinearRing to transform</param>
/// <param name="transform">MathTransform</param>
/// <param name="targetFactory">The factory to create the target geometry</param>
/// <returns>Transformed LinearRing</returns>
public static LinearRing TransformLinearRing(LinearRing r, MathTransform transform, GeometryFactory targetFactory)
{
try
{
return(targetFactory.CreateLinearRing(TransformCoordinates(r.Coordinates, transform)));
}
catch
{
return(null);
}
}
