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 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 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 SharpMapMultiPointToSqlGeometry(SqlGeometryBuilder geomBuilder, SMMultiPoint multiPoint)
{
geomBuilder.BeginGeometry(OpenGisGeometryType.MultiPoint);
for(int i = 0; i <= multiPoint.NumGeometries; i++)
SharpMapPointToSqlGeometry(geomBuilder, multiPoint.Geometry(i));
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 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();
}
private static void GeometryToSqlGeometry(ILineString geom, SqlGeometryBuilder bldr)
{
bldr.BeginGeometry(OpenGisGeometryType.LineString);
AddFigure(geom, 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 GeometryToSqlGeometry(IMultiLineString geom, SqlGeometryBuilder bldr)
{
bldr.BeginGeometry(OpenGisGeometryType.MultiLineString);
for (int i = 0, c = geom.NumGeometries; i < c; i++)
GeometryToSqlGeometry(geom.Geometries[i] as ILineString, bldr);
bldr.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 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 SharpMapPointToSqlGeometry(SqlGeometryBuilder geomBuilder, SMPoint point)
{
geomBuilder.BeginGeometry(OpenGisGeometryType.Point);
geomBuilder.BeginFigure(point.X, point.Y);
geomBuilder.EndFigure();
geomBuilder.EndGeometry();
}
private static SqlGeometry CreateMultiPolygonFromGeometryCollectionWithExcludingLineString( SqlGeometry geometry)
{
SqlGeometryBuilder builder = new SqlGeometryBuilder();
builder.SetSrid(0);
if (GetOpenGisGeometryType(geometry) != OpenGisGeometryType.GeometryCollection) return geometry;
builder.BeginGeometry(OpenGisGeometryType.MultiPolygon);
var polygonCount = geometry.STNumGeometries();
for (int i = 1; i <= polygonCount; i++)
{
var shape = geometry.STGeometryN(i);
if (GetOpenGisGeometryType(shape) == OpenGisGeometryType.Polygon)
{
RepeatPolygon(builder, shape);
}
}
// End the geometry
builder.EndGeometry();
return builder.ConstructedGeometry;
}
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 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 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;
}
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 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 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();
}
}
/// <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 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 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 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();
}
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;
}
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();
}
public void BeginGeography(OpenGisGeographyType type)
{
_builder.BeginGeometry((OpenGisGeometryType)type);
}