public static SqlGeometry GridCellsCenterPointsToPolygon(List <WebGridCellSpeciesObservationCount> gridCells)
{
if (gridCells == null || !gridCells.Any())
{
return(null);
}
var gb = new SqlGeometryBuilder();
// Set the Spatial Reference ID
gb.SetSrid(gridCells.First().GridCoordinateSystem.Srid());
// Start the collection
gb.BeginGeometry(OpenGisGeometryType.MultiPoint);
foreach (var gridCell in gridCells)
{
gb.BeginGeometry(OpenGisGeometryType.Point);
gb.BeginFigure(gridCell.OrginalCentreCoordinate.X, gridCell.OrginalCentreCoordinate.Y);
gb.EndFigure();
gb.EndGeometry();
}
// End the multipolygon
gb.EndGeometry();
// Return as a valid SqlGeometry instance
return(gb.ConstructedGeometry.MakeValid());
}
private static void WriteEsriPolygon(SqlGeometryBuilder builder, ISimplePoints points)
{
if (points.NumberOfParts == 1)
{
builder.BeginGeometry(OpenGisGeometryType.Polygon);
WriteLineOrRing(builder, points.Points);
builder.EndGeometry();
}
else if (points.NumberOfParts > 1)
{
builder.BeginGeometry(OpenGisGeometryType.MultiPolygon);
for (int i = 0; i < points.NumberOfParts; i++)
{
builder.BeginGeometry(OpenGisGeometryType.Polygon);
WriteLineOrRing(builder, points.GetPart(i));
builder.EndGeometry();
}
builder.EndGeometry();
}
else
{
throw new NotImplementedException();
}
}
public static SqlGeometry CreateMultiPointGeometry(List <ArtDatabanken.GIS.GeoJSON.Net.Geometry.Point> geoJsonPoints, int srid)
{
if (geoJsonPoints == null)
{
return(null);
}
SqlGeometryBuilder geomBuilder;
geomBuilder = new SqlGeometryBuilder();
geomBuilder.SetSrid(srid);
geomBuilder.BeginGeometry(OpenGisGeometryType.MultiPoint);
foreach (ArtDatabanken.GIS.GeoJSON.Net.Geometry.Point point in geoJsonPoints)
{
// Setting the srid to the same as for the geoJsonPoints
//geomBuilder.SetSrid(srid);
geomBuilder.BeginGeometry(OpenGisGeometryType.Point);
geomBuilder.BeginFigure(point.Coordinates.Longitude, point.Coordinates.Latitude);
geomBuilder.EndFigure();
geomBuilder.EndGeometry();
//pointList.Add(geomBuilder.ConstructedGeometry.MakeValid());
}
geomBuilder.EndGeometry();
SqlGeometry geometry = geomBuilder.ConstructedGeometry.MakeValid();
return(geometry);
}
/// <summary>
/// Constructs a multi point geometry object from a list of points
/// </summary>
/// <param name="points"></param>
/// <returns></returns>
public static SqlGeometry BuildMultiPoint(List <LocationTimeValue> points)
{
// Create a new instance of the SqlGeographyBuilder
SqlGeometryBuilder gb2 = new SqlGeometryBuilder();
// Set the spatial reference identifier
gb2.SetSrid(27700);
try
{
// Declare the type of collection to be created
gb2.BeginGeometry(OpenGisGeometryType.MultiPoint);
for (int i = 0; i < points.Count; i++)
{
// Create the first point in the collection
gb2.BeginGeometry(OpenGisGeometryType.Point);
gb2.BeginFigure(points[i].X, points[i].Y, points[i].Z, points[i].Value[0]);
gb2.EndFigure();
gb2.EndGeometry();
}
}
catch
{
}
finally
{
// End the geometry and retrieve the constructed instance
gb2.EndGeometry();
}
return(gb2.ConstructedGeometry);
}
private static void AddMultiPolygon <T>(SqlGeometryBuilder builder, Geometry <T> geometry) where T : IPoint, new()
{
//return CreatePolygon(points, srid);
//SqlGeometryBuilder builder = new SqlGeometryBuilder();
//builder.SetSrid(geometry.Srid);
builder.BeginGeometry(OpenGisGeometryType.MultiPolygon);
foreach (var item in geometry.Geometries)
{
builder.BeginGeometry(OpenGisGeometryType.Polygon);
foreach (var lines in item.Geometries)
{
if (lines.NumberOfPoints < minimumPolygonPoints)
{
Trace.WriteLine($"CreateMultiPolygon escape!");
continue;
}
AddLineStringOrRing(builder, lines, true);
}
builder.EndGeometry();
}
builder.EndGeometry();
//return builder.ConstructedGeometry.MakeValid();
}
private static void Internal_FillGeometryBuilder(SqlGeometryBuilder gb, MultiLineString multiLineString)
{
gb.BeginGeometry(OpenGisGeometryType.MultiLineString);
foreach (var lineString in multiLineString.Coordinates)
{
gb.BeginGeometry(OpenGisGeometryType.LineString);
bool beginFigureCalled = false;
foreach (var ipos in lineString.Coordinates)
{
Position pos = ipos as Position;
if (!beginFigureCalled)
{
gb.BeginFigure(pos.Longitude, pos.Latitude);
beginFigureCalled = true;
}
else
{
gb.AddLine(pos.Longitude, pos.Latitude);
}
}
gb.EndFigure();
gb.EndGeometry();
}
gb.EndGeometry();
}
public static SqlParameter GetGeometrySqlParameter(string paramName, List <PointD> lines, bool makeValid)
{
SqlParameter sqlParam = new SqlParameter();
sqlParam.ParameterName = paramName;
sqlParam.UdtTypeName = "geometry";
SqlGeometryBuilder geomBuilder = new SqlGeometryBuilder();
// SqlGeometryBuilder.SetSrid Must be called at the beginning of each geometry sequence
geomBuilder.SetSrid(0);
geomBuilder.BeginGeometry(OpenGisGeometryType.GeometryCollection);
if (lines.Count > 0)
{
if (lines.Count == 1) //check if its a point or a line and start a geometry for the point or line
{
geomBuilder.BeginGeometry(OpenGisGeometryType.Point);
}
else
{
geomBuilder.BeginGeometry(OpenGisGeometryType.LineString);
}
int count = 0;
foreach (PointD p in lines) //add all points
{
if (count == 0)
{
geomBuilder.BeginFigure(p.X, p.Y);
}
else
{
geomBuilder.AddLine(p.X, p.Y);
}
count++;
}
geomBuilder.EndFigure();
geomBuilder.EndGeometry();
}
geomBuilder.EndGeometry();
SqlGeometry constructed = geomBuilder.ConstructedGeometry;
if (makeValid)
{
//Note required to convert into a geometry instance with a valid Open Geospatial Consortium (OGC) type.
// this can cause the points to shift - use with caution...
constructed = constructed.MakeValid();
}
sqlParam.Value = constructed;
return(sqlParam);
}
public void EndGeometry()
{
_target.EndGeometry();
// end of multi line
if (_linesCount == 0)
{
_target.EndGeometry();
}
}
private void AddGeometryCollection(IGeometry geometry, OpenGisGeometryType type)
{
builder.BeginGeometry(type);
IGeometryCollection coll = geometry as IGeometryCollection;
Array.ForEach <IGeometry>(coll.Geometries, delegate(IGeometry g)
{
AddGeometry(g);
});
builder.EndGeometry();
}
private static void Internal_FillGeometryBuilder(SqlGeometryBuilder gb, MultiPoint multiPoint)
{
gb.BeginGeometry(OpenGisGeometryType.MultiPoint);
List<Point> coords = multiPoint.Coordinates as List<Point>;
foreach (var coord in coords)
{
GeographicPosition pos = coord.Coordinates as GeographicPosition;
gb.BeginGeometry(OpenGisGeometryType.Point);
gb.BeginFigure(pos.Longitude, pos.Latitude);
gb.EndFigure();
gb.EndGeometry();
}
gb.EndGeometry();
}
private static void Internal_FillGeometryBuilder(SqlGeometryBuilder gb, MultiPoint multiPoint)
{
gb.BeginGeometry(OpenGisGeometryType.MultiPoint);
List <Point> coords = multiPoint.Coordinates.ToList();
foreach (var coord in coords)
{
Position pos = coord.Coordinates as Position;
gb.BeginGeometry(OpenGisGeometryType.Point);
gb.BeginFigure(pos.Longitude, pos.Latitude);
gb.EndFigure();
gb.EndGeometry();
}
gb.EndGeometry();
}
private static void AddMultiLineString(SqlGeometryBuilder builder, GeoJsonMultiLineString geometry, bool isLongitudeFirst)
{
builder.BeginGeometry(OpenGisGeometryType.MultiLineString);
foreach (var item in geometry.Coordinates)
{
builder.BeginGeometry(OpenGisGeometryType.LineString);
AddLineStringOrRing(builder, item, false, isLongitudeFirst);
builder.EndGeometry();
}
builder.EndGeometry();
}
private static void SpatialTraceLine(List <GeoPoint> lineElevationData, string message)
{
const int DEFAULT_HEIGHT = 300;
// Say that 1 sample is one pixel and a graph is usually 300px tall
// So 300px = 300 samples = max height (H)
// So for numSamples, (H * numSamples / 300) = height of 1px
double minH = lineElevationData.Min(p => p.Elevation.GetValueOrDefault(0));
double maxH = lineElevationData.Max(p => p.Elevation.GetValueOrDefault(0));
double H = maxH - minH;
double ratio_11 = lineElevationData.Last().DistanceFromOriginMeters / H;
double ratio = ratio_11 / 4;
double tolerance = H / DEFAULT_HEIGHT;
// Make 4:1 geom
SqlGeometryBuilder gb = new SqlGeometryBuilder();
gb.SetSrid(0); // custom SRID
gb.BeginGeometry(OpenGisGeometryType.LineString);
gb.BeginFigure(lineElevationData[0].DistanceFromOriginMeters / ratio, lineElevationData[0].Elevation.GetValueOrDefault(0));
for (int i = 1; i < lineElevationData.Count; i++)
{
gb.AddLine(lineElevationData[i].DistanceFromOriginMeters / ratio, lineElevationData[i].Elevation.GetValueOrDefault(0));
}
gb.EndFigure();
gb.EndGeometry();
SqlGeometry geom = gb.ConstructedGeometry;
SpatialTrace.Enable();
SpatialTrace.TraceGeometry(geom, message);
SpatialTrace.Disable();
}
/// <summary>
/// Problem here : self intersecting lines are not supported. Not ideal for GPS tracks...
/// </summary>
/// <param name="points"></param>
/// <returns></returns>
public static SqlGeometry ParseGeoPointAsGeometryLine(IEnumerable <GeoPoint> points)
{
SqlGeometryBuilder gb = new SqlGeometryBuilder();
gb.SetSrid(4326);
gb.BeginGeometry(OpenGisGeometryType.LineString);
bool first = true;
foreach (var pt in points)
{
if (first)
{
gb.BeginFigure(pt.Longitude, pt.Latitude);
first = false;
}
else
{
gb.AddLine(pt.Longitude, pt.Latitude);
}
}
gb.EndFigure();
gb.EndGeometry();
SqlGeometry geom = gb.ConstructedGeometry.MakeValidIfInvalid(1);
return(geom);
}
private static void SharpMapMultiPolygonToSqlGeometry(SqlGeometryBuilder geomBuilder, SMMultiPolygon multiPolygon)
{
geomBuilder.BeginGeometry(OpenGisGeometryType.MultiPolygon);
for (int i = 0; i < multiPolygon.NumGeometries; i++)
SharpMapPolygonToSqlGeometry(geomBuilder, multiPolygon.Geometry(i) as SMPolygon);
geomBuilder.EndGeometry();
}
public static SqlGeometry MakeGeometry(List <Point> points, bool isClosed, int srid = 32639)
{
SqlGeometryBuilder builder = new SqlGeometryBuilder();
builder.SetSrid(srid);
builder.BeginGeometry(isClosed ? OpenGisGeometryType.Polygon : OpenGisGeometryType.LineString);
builder.BeginFigure(points[0].X, points[0].Y);
for (int i = 1; i < points.Count; i++)
{
builder.AddLine(points[i].X, points[i].Y);
}
if (isClosed)
{
builder.AddLine(points[0].X, points[0].Y);
}
builder.EndFigure();
builder.EndGeometry();
return(builder.ConstructedGeometry.MakeValid());
}
public static System.Data.Entity.Spatial.DbGeometry Reverse(
this System.Data.Entity.Spatial.DbGeometry linestring)
{
var fromWkb = SqlGeometry.STGeomFromWKB(new SqlBytes(linestring.AsBinary()), 0);
// Create a new Geometry Builder
var gb = new SqlGeometryBuilder();
// Set the Spatial Reference ID equal to the supplied linestring
gb.SetSrid((int)(fromWkb.STSrid));
// Start the linestring
gb.BeginGeometry(OpenGisGeometryType.LineString);
// Add the first point using BeginFigure()
gb.BeginFigure((double)fromWkb.STEndPoint().STX, (double)fromWkb.STEndPoint().STY);
// Loop through remaining points in reverse order
for (var x = (int)fromWkb.STNumPoints() - 1; x > 0; --x)
{
gb.AddLine((double)fromWkb.STPointN(x).STX, (double)fromWkb.STPointN(x).STY);
}
// End the figure
gb.EndFigure();
// End the geometry
gb.EndGeometry();
// Return that as a SqlGeometry instance
return(System.Data.Entity.Spatial.DbGeometry.FromBinary(gb.ConstructedGeometry.STAsBinary().Buffer));
}
private static void BuildPolygonSimplified(SqlGeometryBuilder builder, SqlGeometry shape,
SqlDouble shortestDistance)
{
try
{
builder.BeginGeometry(OpenGisGeometryType.Polygon);
var internalRingsNum = (int)shape.STNumInteriorRing();
var exteriorRing = shape.STExteriorRing();
// Proceed shortening external ring
AddShortenedRingByBuilder(builder, exteriorRing, shortestDistance);
// Proceed interior rings
if (internalRingsNum > 0)
{
for (int i = 1; i <= internalRingsNum; i++)
{
AddShortenedRingByBuilder(builder, shape.STInteriorRingN(i), shortestDistance);
}
}
builder.EndGeometry();
}
catch (Exception ex)
{
throw new Exception(string.Format(" BuildPolygonSimplified: {0}", ex.Message));
}
}
private static void SharpMapPointToSqlGeometry(SqlGeometryBuilder geomBuilder, SMPoint point)
{
geomBuilder.BeginGeometry(OpenGisGeometryType.Point);
geomBuilder.BeginFigure(point.X, point.Y);
geomBuilder.EndFigure();
geomBuilder.EndGeometry();
}
public static System.Data.Entity.Spatial.DbGeometry Reverse(
this System.Data.Entity.Spatial.DbGeometry linestring)
{
var fromWkb = SqlGeometry.STGeomFromWKB(new SqlBytes(linestring.AsBinary()), 0);
// Create a new Geometry Builder
var gb = new SqlGeometryBuilder();
// Set the Spatial Reference ID equal to the supplied linestring
gb.SetSrid((int) (fromWkb.STSrid));
// Start the linestring
gb.BeginGeometry(OpenGisGeometryType.LineString);
// Add the first point using BeginFigure()
gb.BeginFigure((double) fromWkb.STEndPoint().STX, (double) fromWkb.STEndPoint().STY);
// Loop through remaining points in reverse order
for (var x = (int) fromWkb.STNumPoints() - 1; x > 0; --x)
{
gb.AddLine((double) fromWkb.STPointN(x).STX, (double) fromWkb.STPointN(x).STY);
}
// End the figure
gb.EndFigure();
// End the geometry
gb.EndGeometry();
// Return that as a SqlGeometry instance
return System.Data.Entity.Spatial.DbGeometry.FromBinary(gb.ConstructedGeometry.STAsBinary().Buffer);
}
private void AddPolygon(SqlGeometryBuilder builder, IPolygon geometry)
{
builder.BeginGeometry(OpenGisGeometryType.Polygon);
AddCoordinates(builder, geometry.ExteriorRing.CoordinateSequence);
Array.ForEach(geometry.InteriorRings, ring => AddCoordinates(builder, ring.CoordinateSequence));
builder.EndGeometry();
}
public static IEnumerable <SqlGeometry> Segments(this SqlGeometry lineGeom)
{
if (lineGeom == null || lineGeom.IsNull || lineGeom.STIsEmpty())
{
yield return(null);
}
if (lineGeom.STGeometryType().ToString() != OpenGisGeometryType.LineString.ToString())
{
yield return(null);
}
if (lineGeom.STNumPoints().Value < 2)
{
yield return(null);
}
for (int i = 1; i < lineGeom.STNumPoints().Value; i++)
{
SqlGeometry ptStart = lineGeom.STPointN(i);
SqlGeometry ptNext = lineGeom.STPointN(i + 1);
SqlGeometryBuilder gb = new SqlGeometryBuilder();
gb.SetSrid(lineGeom.STSrid.Value);
gb.BeginGeometry(OpenGisGeometryType.LineString);
gb.BeginFigure(ptStart.STX.Value, ptStart.STY.Value);
gb.AddLine(ptNext.STX.Value, ptNext.STY.Value);
gb.EndFigure();
gb.EndGeometry();
yield return(gb.ConstructedGeometry);
}
}
public static SqlGeometry Extend(
SqlGeometry @geom1,
SqlGeometry @geom2,
SqlInt32 @Offset)
{
// Start the LineString
SqlGeometryBuilder gb = new SqlGeometryBuilder();
gb.SetSrid((int)(@geom1.STSrid));
gb.BeginGeometry(OpenGisGeometryType.LineString);
gb.BeginFigure(
(double)@geom1.STStartPoint().STX,
(double)@geom1.STStartPoint().STY
);
// Add the points from the first geometry
for (int x = 2; x <= (int)@geom1.STNumPoints(); x++)
{
gb.AddLine(
(double)@geom1.STPointN(x).STX,
(double)@geom1.STPointN(x).STY
);
}
// Add the points from the second geometry
for (int x = 1 + (int)@Offset; x <= (int)@geom2.STNumPoints(); x++)
{
gb.AddLine(
(double)@geom2.STPointN(x).STX,
(double)@geom2.STPointN(x).STY
);
}
gb.EndFigure();
gb.EndGeometry();
return(gb.ConstructedGeometry);
}
private static void SharpMapMultiLineStringToSqlGeometry(SqlGeometryBuilder geomBuilder, SMMultiLineString multiLineString)
{
geomBuilder.BeginGeometry(OpenGisGeometryType.MultiLineString);
for (int i = 0; i < multiLineString.NumGeometries; i++)
SharpMapLineStringToSqlGeometry(geomBuilder, multiLineString.Geometry(i) as SMLineString);
geomBuilder.EndGeometry();
}
private static void SharpMapGeometryCollectionToSqlGeometry(SqlGeometryBuilder geomBuilder, SMGeometryCollection geometryCollection)
{
geomBuilder.BeginGeometry(OpenGisGeometryType.GeometryCollection);
for (int i = 0; i < geometryCollection.NumGeometries; i++ )
SharpMapGeometryToSqlGeometry(geomBuilder, geometryCollection.Geometry(i));
geomBuilder.EndGeometry();
}
/// <summary>
/// End geometry construction
/// </summary>
public void EndGeometry()
{
if (!_isFirstSegment)
{
_target.EndGeometry();
}
}
private static void AddLineString(SqlGeometryBuilder builder, GeoJsonLineString geometry, bool isLongitudeFirst)
{
builder.BeginGeometry(OpenGisGeometryType.LineString);
AddLineStringOrRing(builder, geometry.Coordinates, false, isLongitudeFirst);
builder.EndGeometry();
}
private static void Internal_FillGeometryBuilder(SqlGeometryBuilder gb, Point point)
{
gb.BeginGeometry(OpenGisGeometryType.Point);
GeographicPosition pos = point.Coordinates as GeographicPosition;
gb.BeginFigure(pos.Longitude, pos.Latitude);
gb.EndFigure();
gb.EndGeometry();
}
public SqlGeometry CreateMultiPoint(params Coordinate[] coords)
{
SqlGeometryBuilder bldr = CreateBuilder();
bldr.BeginGeometry(OpenGisGeometryType.MultiPoint);
foreach (Coordinate coord in coords)
{
bldr.BeginGeometry(OpenGisGeometryType.Point);
AddFigure(bldr, coord);
bldr.EndGeometry();
}
bldr.EndGeometry();
return(bldr.ConstructedGeometry);
}
private static void GeometryToSqlGeometry(ILineString geom, SqlGeometryBuilder bldr)
{
bldr.BeginGeometry(OpenGisGeometryType.LineString);
AddFigure(geom, bldr);
bldr.EndGeometry();
}
private static void GeometryToSqlGeometry(ILineString geom, SqlGeometryBuilder bldr)
{
bldr.BeginGeometry(OpenGisGeometryType.LineString);
AddFigure(geom, bldr);
bldr.EndGeometry();
}
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 void GeometryToSqlGeometry(IPoint geom, SqlGeometryBuilder bldr)
{
bldr.BeginGeometry(OpenGisGeometryType.Point);
bldr.BeginFigure(geom.X, geom.Y);
bldr.EndFigure();
bldr.EndGeometry();
}
private static void SharpMapGeometryCollectionToSqlGeometry(SqlGeometryBuilder geomBuilder, SMGeometryCollection geometryCollection)
{
geomBuilder.BeginGeometry(OpenGisGeometryType.GeometryCollection);
for (int i = 0; i < geometryCollection.NumGeometries; i++)
{
SharpMapGeometryToSqlGeometry(geomBuilder, geometryCollection.Geometry(i));
}
geomBuilder.EndGeometry();
}
private static void SharpMapMultiPolygonToSqlGeometry(SqlGeometryBuilder geomBuilder, SMMultiPolygon multiPolygon)
{
geomBuilder.BeginGeometry(OpenGisGeometryType.MultiPolygon);
for (int i = 0; i < multiPolygon.NumGeometries; i++)
{
SharpMapPolygonToSqlGeometry(geomBuilder, multiPolygon.Geometry(i) as SMPolygon);
}
geomBuilder.EndGeometry();
}
private static void Internal_FillGeometryBuilder(SqlGeometryBuilder gb, Point point)
{
gb.BeginGeometry(OpenGisGeometryType.Point);
Position pos = point.Coordinates as Position;
gb.BeginFigure(pos.Longitude, pos.Latitude);
gb.EndFigure();
gb.EndGeometry();
}
private static void GeometryToSqlGeometry(IPoint geom, SqlGeometryBuilder bldr)
{
bldr.BeginGeometry(OpenGisGeometryType.Point);
bldr.BeginFigure(geom.X, geom.Y);
bldr.EndFigure();
bldr.EndGeometry();
}
private static void SharpMapMultiPointToSqlGeometry(SqlGeometryBuilder geomBuilder, SMMultiPoint multiPoint)
{
geomBuilder.BeginGeometry(OpenGisGeometryType.MultiPoint);
for (int i = 0; i < multiPoint.NumPoints; i++)
{
SharpMapPointToSqlGeometry(geomBuilder, multiPoint[i] as SMPoint);
}
geomBuilder.EndGeometry();
}
private static void Internal_FillGeometryBuilder(SqlGeometryBuilder gb, MultiPolygon multiPolygon)
{
gb.BeginGeometry(OpenGisGeometryType.MultiPolygon);
foreach (var polygon in multiPolygon.Coordinates)
{
Internal_FillGeometryBuilder(gb, polygon);
}
gb.EndGeometry();
}
/// <summary>
/// Builds multipoligon by each polygon inside geometry collection
/// </summary>
public static void BuildMultipolygonSimplified(SqlGeometryBuilder builder, SqlGeometry shape,
SqlDouble shortestDistance)
{
builder.BeginGeometry(OpenGisGeometryType.MultiPolygon);
var polygonCount = shape.STNumGeometries();
for (int i = 1; i <= polygonCount; i++)
{
BuildPolygonSimplified(builder, shape.STGeometryN(i), shortestDistance);
}
// End the geometry
builder.EndGeometry();
}
public static byte[] GeoProcessingNode(Node node)
{
SqlGeometry geo = new SqlGeometry();
SqlGeometryBuilder GeometryBuilder = new SqlGeometryBuilder();
GeometryBuilder.SetSrid(4326);
GeometryBuilder.BeginGeometry(OpenGisGeometryType.Point);
GeometryBuilder.BeginFigure(node.Latitude, node.Longtitude);
GeometryBuilder.EndFigure();
GeometryBuilder.EndGeometry();
geo = GeometryBuilder.ConstructedGeometry;
return geo.STAsBinary().Buffer;
}
public static SqlGeometry ToLineString(this SqlGeometry poly)
{
var geomBuilder = new SqlGeometryBuilder();
geomBuilder.SetSrid((0));
geomBuilder.BeginGeometry(OpenGisGeometryType.LineString);
var startpoint = poly.STStartPoint();
geomBuilder.BeginFigure((double)startpoint.STX, (double)startpoint.STY);
for (int i = 1; i <= poly.STNumPoints(); i++)
{
geomBuilder.AddLine((double)poly.STPointN(i).STX, (double)poly.STPointN(i).STY);
}
geomBuilder.EndFigure();
geomBuilder.EndGeometry();
return geomBuilder.ConstructedGeometry;
}
private static byte[] ConstructLineString(List<Node> nodes, OsmPrimitive osmPrimitive)
{
if (nodes != null)
{
try
{
SqlGeometry line;
SqlGeometryBuilder lineBuilder = new SqlGeometryBuilder();
lineBuilder.SetSrid(4326);
lineBuilder.BeginGeometry(OpenGisGeometryType.LineString);
lineBuilder.BeginFigure(nodes.First().Latitude, nodes.First().Longtitude);
for (int i = 1; i < nodes.Count; i++)
{
lineBuilder.AddLine(nodes[i].Latitude, nodes[i].Longtitude);
}
lineBuilder.EndFigure();
lineBuilder.EndGeometry();
line = lineBuilder.ConstructedGeometry;
if (line.STIsValid())
{
return line.STAsBinary().Buffer;
}
else
{
Log.Log.Write(osmPrimitive.GetType() + " " + osmPrimitive.Id + " not valid");
return null;
}
}
catch (Exception e)
{
Log.Log.Write(osmPrimitive.GetType() + " " + osmPrimitive.Id + " Error constructed Geometry LINE STRING: " + e.Message);
return null;
}
}
else
{
throw new NullReferenceException("Construct polygon failed. Nodes not found.");
}
}
private static void SharpMapPolygonToSqlGeometry(SqlGeometryBuilder geomBuilder, SMPolygon polygon)
{
geomBuilder.BeginGeometry(OpenGisGeometryType.Polygon);
AddRing(geomBuilder, polygon.ExteriorRing);
for (int i = 0; i < polygon.NumInteriorRing; i++)
AddRing(geomBuilder, polygon.InteriorRing(i));
geomBuilder.EndGeometry();
}
private static void SharpMapPointToSqlGeometry(SqlGeometryBuilder geomBuilder, SMPoint point)
{
try
{
geomBuilder.BeginGeometry(OpenGisGeometryType.Point);
geomBuilder.BeginFigure(point.X, point.Y, point.Z, null);
geomBuilder.EndFigure();
geomBuilder.EndGeometry();
}
catch (Exception ex)
{
string exMessage = string.Format("Failed Point X [{0}] Y [{1}] Z[{2}]", point.X, point.Y, point.Z);
Exception wrappingException = new Exception(exMessage, ex);
throw wrappingException;
}
}
private static void SharpMapMultiPointToSqlGeometry(SqlGeometryBuilder geomBuilder, SMMultiPoint multiPoint)
{
// geomBuilder.SetSrid(multiPoint.SRID);
geomBuilder.BeginGeometry(OpenGisGeometryType.MultiPoint);
for (int i = 0; i < multiPoint.NumGeometries; i++)
SharpMapPointToSqlGeometry(geomBuilder, multiPoint.Geometry(i));
geomBuilder.EndGeometry();
}
private static void SharpMapLineStringToSqlGeometry(SqlGeometryBuilder geomBuilder, SMLineString lineString)
{
geomBuilder.BeginGeometry(OpenGisGeometryType.LineString);
SMPoint point = lineString.StartPoint;
geomBuilder.BeginFigure(point.X, point.Y);
for (int i = 1; i < lineString.NumPoints; i++)
{
point = lineString.Point(i);
geomBuilder.AddLine(point.X, point.Y);
}
geomBuilder.EndFigure();
geomBuilder.EndGeometry();
}
private SqlGeometry GetRect(double currentX, double currentY)
{
SqlGeometryBuilder builder = new SqlGeometryBuilder();
builder.SetSrid(this.geometry.STSrid.Value);
builder.BeginGeometry(OpenGisGeometryType.Polygon);
builder.BeginFigure(currentX, currentY);
builder.AddLine(currentX + stepX, currentY);
builder.AddLine(currentX + stepX, currentY + stepY);
builder.AddLine(currentX, currentY + stepY);
builder.AddLine(currentX, currentY);
builder.EndFigure();
builder.EndGeometry();
return builder.ConstructedGeometry;
}
private static void Internal_FillGeometryBuilder(SqlGeometryBuilder gb, MultiPolygon multiPolygon)
{
gb.BeginGeometry(OpenGisGeometryType.MultiPolygon);
foreach (var polygon in multiPolygon.Coordinates)
{
Internal_FillGeometryBuilder(gb, polygon);
}
gb.EndGeometry();
}
private static void Internal_FillGeometryBuilder(SqlGeometryBuilder gb, LineString lineString)
{
gb.BeginGeometry(OpenGisGeometryType.LineString);
bool beginFigureCalled = false;
foreach (var ipos in lineString.Coordinates)
{
GeographicPosition pos = ipos as GeographicPosition;
if (!beginFigureCalled)
{
gb.BeginFigure(pos.Longitude, pos.Latitude);
beginFigureCalled = true;
}
else
{
gb.AddLine(pos.Longitude, pos.Latitude);
}
}
gb.EndFigure();
gb.EndGeometry();
}
private static void RepeatPolygon(SqlGeometryBuilder builder, SqlGeometry shape)
{
try
{
builder.BeginGeometry(OpenGisGeometryType.Polygon);
var internalRingsNum = (int)shape.STNumInteriorRing();
var exteriorRing = shape.STExteriorRing();
// Proceed shortening external ring
AddRingByBuilder(builder, exteriorRing);
// Proceed interior rings
if (internalRingsNum > 0)
for (int i = 1; i <= internalRingsNum; i++)
{
AddRingByBuilder(builder, shape.STInteriorRingN(i));
}
builder.EndGeometry();
}
catch (Exception ex)
{
throw new Exception(string.Format(" RepeatPolygon: {0}", ex.Message));
}
}
/// <summary>
/// Converts a GeoJSON MultiPolygon to an SqlGeometry
/// </summary>
/// <param name="multiPolygon"></param>
/// <param name="srid"></param>
/// <returns></returns>
public static SqlGeometry ToSqlGeometry(this MultiPolygon multiPolygon, int srid = 4326)
{
SqlGeometryBuilder gb = new SqlGeometryBuilder();
gb.SetSrid(srid);
gb.BeginGeometry(OpenGisGeometryType.MultiPolygon);
foreach (var polygon in multiPolygon.Coordinates)
{
Internal_FillGeometryBuilder(gb, polygon);
}
gb.EndGeometry();
return gb.ConstructedGeometry;
}
private SqlGeometry Sample_Polygon(int srid)
{
SqlGeometryBuilder builder = new SqlGeometryBuilder();
builder.SetSrid(srid);
builder.BeginGeometry(OpenGisGeometryType.Polygon);
builder.BeginFigure(10, 110);
builder.AddLine(60, 10);
builder.AddLine(110, 110);
builder.AddLine(10, 110);
builder.EndFigure();
builder.EndGeometry();
return builder.ConstructedGeometry;
}
private void AddMultiLineStringFromPolygon(SqlGeometryBuilder geomBuilder, SqlGeometry poly)
{
int intnum = (int) poly.STNumInteriorRing();
var exteriorRing = poly.STExteriorRing();
if (intnum > 0) geomBuilder.BeginGeometry(OpenGisGeometryType.MultiLineString);
geomBuilder.BeginGeometry(OpenGisGeometryType.LineString);
var startpoint = exteriorRing.STStartPoint();
geomBuilder.BeginFigure((double) startpoint.STX, (double) startpoint.STY);
for (int i = 2; i <= exteriorRing.STNumPoints(); i++)
geomBuilder.AddLine((double) exteriorRing.STPointN(i).STX, (double) exteriorRing.STPointN(i).STY);
geomBuilder.EndFigure();
geomBuilder.EndGeometry();
if (intnum > 0)
{
SqlGeometry intRing;
SqlGeometry point;
for (int i = 1; i <= intnum; i++)
{
intRing = poly.STInteriorRingN(i);
geomBuilder.BeginGeometry(OpenGisGeometryType.LineString);
startpoint = intRing.STStartPoint();
geomBuilder.BeginFigure((double) startpoint.STX, (double) startpoint.STY);
for (int p = 2; p <= intRing.STNumPoints(); p++)
{
point = intRing.STPointN(p);
geomBuilder.AddLine((double) point.STX, (double) point.STY);
}
geomBuilder.EndFigure();
geomBuilder.EndGeometry();
}
geomBuilder.EndFigure();
geomBuilder.EndGeometry();
}
}
private static void SharpMapPointToSqlGeometry(SqlGeometryBuilder geomBuilder, SMPoint point)
{
geomBuilder.BeginGeometry(OpenGisGeometryType.Point);
geomBuilder.BeginFigure(point.X, point.Y);
geomBuilder.EndFigure();
geomBuilder.EndGeometry();
}
private static void SharpMapLineStringToSqlGeometry(SqlGeometryBuilder geomBuilder, SMLineString lineString)
{
geomBuilder.BeginGeometry(OpenGisGeometryType.LineString);
var coords = lineString.Coordinates;
geomBuilder.BeginFigure(coords[0].X, coords[0].Y);
for (int i = 1; i < lineString.NumPoints; i++)
{
var point = coords[i];
geomBuilder.AddLine(point.X, point.Y);
}
geomBuilder.EndFigure();
geomBuilder.EndGeometry();
}
private SqlGeometry Sample_Points(int srid)
{
SqlGeometryBuilder builder = new SqlGeometryBuilder();
builder.SetSrid(srid);
builder.BeginGeometry(OpenGisGeometryType.MultiPoint);
Random rnd = new Random();
for (int i = 0; i < 100; i++)
{
builder.BeginGeometry(OpenGisGeometryType.Point);
builder.BeginFigure(rnd.Next(-50, 200), rnd.Next(-50, 200));
builder.EndFigure();
builder.EndGeometry();
}
builder.EndGeometry();
return builder.ConstructedGeometry;
}
/// <summary>
/// Converts a GeoJSON GeometryCollection to an SqlGeometry
/// </summary>
/// <param name="geometryCollection"></param>
/// <param name="srid"></param>
/// <returns></returns>
public static SqlGeometry ToSqlGeometry(this GeometryCollection geometryCollection, int srid = 4326)
{
SqlGeometryBuilder gb = new SqlGeometryBuilder();
gb.SetSrid(srid);
gb.BeginGeometry(OpenGisGeometryType.GeometryCollection);
foreach (var geom in geometryCollection.Geometries)
{
switch(geom.Type)
{
case GeoJSONObjectType.LineString:
Internal_FillGeometryBuilder(gb, geom as LineString);
break;
case GeoJSONObjectType.MultiLineString:
Internal_FillGeometryBuilder(gb, geom as MultiLineString);
break;
case GeoJSONObjectType.Point:
Internal_FillGeometryBuilder(gb, geom as Point);
break;
case GeoJSONObjectType.MultiPoint:
Internal_FillGeometryBuilder(gb, geom as MultiPoint);
break;
case GeoJSONObjectType.Polygon:
Internal_FillGeometryBuilder(gb, geom as Polygon);
break;
case GeoJSONObjectType.MultiPolygon:
Internal_FillGeometryBuilder(gb, geom as MultiPolygon);
break;
default:
throw new NotSupportedException("Geometry conversion is not supported for " + geom.Type.ToString());
}
}
gb.EndGeometry();
return gb.ConstructedGeometry;
}
private static void SharpMapMultiPointToSqlGeometry(SqlGeometryBuilder geomBuilder, SMMultiPoint multiPoint)
{
geomBuilder.BeginGeometry(OpenGisGeometryType.MultiPoint);
for(int i = 0; i < multiPoint.NumPoints; i++)
SharpMapPointToSqlGeometry(geomBuilder, multiPoint[i] as SMPoint);
geomBuilder.EndGeometry();
}
public static SqlGeometry DrawGeoSpatialSectorVarAngle(SqlDouble longitude, SqlDouble latitude, SqlDouble azimuth,
SqlDouble angle, SqlDouble radius, SqlDouble stepAngle)
{
if (longitude == SqlDouble.Null || latitude == SqlDouble.Null || azimuth == SqlDouble.Null ||
angle == SqlDouble.Null || radius == SqlDouble.Null || radius == 0 || angle == 0)
return SqlGeometry.Parse("GEOMETRYCOLLECTION EMPTY");
SqlGeometryBuilder builder = new SqlGeometryBuilder();
builder.SetSrid(0);
builder.BeginGeometry(OpenGisGeometryType.Polygon);
double firstPointLon;
double firstPointLat;
double sectorStepAngle = (double) stepAngle;
const double earthRadius = 6367.0;
double lat = (double) latitude;
double lon = (double) longitude;
double azim = (double) azimuth;
double ang = (double) angle;
double piRad = (Math.PI/180.0);
double tLat = piRad*lat;
double tLon = piRad*lon;
double distkm = ((double) radius/1000)/earthRadius;
double angleStart = azim - ang/2;
double angleEnd = azim + ang/2;
var _angle = Math.Abs(ang);
if (_angle > 360.0)
{
angle = 360.0;
}
int pointCount = (int) Math.Floor(ang/sectorStepAngle);
double brng;
double latRadians;
double lngRadians;
double ptX;
double ptY;
int i = 0;
if (angle < 360.0)
{
builder.BeginFigure(lon, lat);
firstPointLon = lon;
firstPointLat = lat;
}
else
{
brng = piRad*(angleStart);
latRadians = Math.Asin(Math.Sin(tLat)*Math.Cos(distkm) + Math.Cos(tLat)*Math.Sin(distkm)*Math.Cos(brng));
lngRadians = tLon +
Math.Atan2(Math.Sin(brng)*Math.Sin(distkm)*Math.Cos(tLat),
Math.Cos(distkm) - Math.Sin(tLat)*Math.Sin(latRadians));
ptX = 180.0*lngRadians/Math.PI;
ptY = 180.0*latRadians/Math.PI;
builder.BeginFigure(ptX, ptY);
firstPointLon = ptX;
firstPointLat = ptY;
}
while (i <= pointCount)
{
brng = piRad*(angleStart + i*sectorStepAngle);
latRadians = Math.Asin(Math.Sin(tLat)*Math.Cos(distkm) + Math.Cos(tLat)*Math.Sin(distkm)*Math.Cos(brng));
lngRadians = tLon +
Math.Atan2(Math.Sin(brng)*Math.Sin(distkm)*Math.Cos(tLat),
Math.Cos(distkm) - Math.Sin(tLat)*Math.Sin(latRadians));
ptX = 180.0*lngRadians/Math.PI;
ptY = 180.0*latRadians/Math.PI;
builder.AddLine(ptX, ptY);
i = i + 1;
}
if (((angleStart + pointCount * sectorStepAngle) < angleEnd))
{
brng = piRad * (angleEnd);
latRadians = Math.Asin(Math.Sin(tLat) * Math.Cos(distkm) + Math.Cos(tLat) * Math.Sin(distkm) * Math.Cos(brng));
lngRadians = tLon +
Math.Atan2(Math.Sin(brng) * Math.Sin(distkm) * Math.Cos(tLat),
Math.Cos(distkm) - Math.Sin(tLat) * Math.Sin(latRadians));
ptX = 180.0 * lngRadians / Math.PI;
ptY = 180.0 * latRadians / Math.PI;
builder.AddLine(ptX, ptY);
}
builder.AddLine(firstPointLon, firstPointLat);
builder.EndFigure();
builder.EndGeometry();
return builder.ConstructedGeometry;
}