public static IGeometry SqlGeometryToGeometry(SqlGeometry geom, GeometryFactory factory)
{
if (geom.STIsEmpty())
return factory.CreateGeometryCollection(null);
OpenGisGeometryType geometryType = (OpenGisGeometryType)Enum.Parse(typeof(OpenGisGeometryType), geom.STGeometryType().Value);
switch (geometryType)
{
case OpenGisGeometryType.Point:
return SqlGeometryToGeometryPoint(geom, factory);
case OpenGisGeometryType.LineString:
return SqlGeometryToGeometryLineString(geom, factory);
case OpenGisGeometryType.Polygon:
return SqlGeometryToGeometryPolygon(geom, factory);
case OpenGisGeometryType.MultiPoint:
return SqlGeometryToGeometryMultiPoint(geom, factory);
case OpenGisGeometryType.MultiLineString:
return SqlGeometryToGeometryMultiLineString(geom, factory);
case OpenGisGeometryType.MultiPolygon:
return SqlGeometryToGeometryMultiPolygon(geom, factory);
case OpenGisGeometryType.GeometryCollection:
return SqlGeometryToGeometryGeometryCollection(geom, factory);
}
throw new ArgumentException(string.Format("Cannot convert SqlServer '{0}' to Geometry", geom.STGeometryType()), "geom");
}
/// <summary>
/// Cuts already pixeled geometry by the frame of a tile
/// </summary>
/// <param name="poly"></param>
/// <param name="X"></param>
/// <param name="Y"></param>
/// <returns></returns>
private List<SqlGeometry> CutZoomedPixelPolygonByZeroTile(SqlGeometry poly)
{
List<SqlGeometry> result = new List<SqlGeometry>();
SqlGeometry stroke = null;
SqlGeometry contour;
SqlGeometry tileLineString;
SqlGeometry tobecut;
SqlGeometry tile = _conv.GetTilePixelBound(0, 0, 1);
var tiled = poly.STIntersection(tile);
result.Add(tiled);
switch (GetOpenGisGeometryType(tiled))
{
case OpenGisGeometryType.Polygon:
// Получаем контур полигона и внутренние кольца в виде MULTILINESTRING
contour = PolygonToMultiLineString(tiled);
// удаляем линии среза геометрии по границе тайла
tileLineString = tile.ToLineString();
tobecut = contour.STIntersection(tileLineString);
stroke = contour.STDifference(tobecut);
break;
case OpenGisGeometryType.MultiPolygon:
// Получаем контур полигона и внутренние кольца в виде MULTILINESTRING
contour = MultiPolygonToMultiLineString(tiled);
// удаляем линии среза геометрии по границе тайла
tileLineString = tile.ToLineString();
tobecut = contour.STIntersection(tileLineString);
stroke = contour.STDifference(tobecut);
break;
}
result.Add(stroke);
return result;
}
public static SqlGeometry Envelope(SqlGeometry geometry)
{
if (geometry.IsNull)
return SqlGeometry.Null;
return geometry.Envelope;
}
public async Task<ResponseContainer<IntersectResponse>> QueryIntersectionsAsync(SqlGeometry geometry, string category)
{
category = category.ToLower();
// include stream miles because it's aquatic
if (category == "aquatic/riparian treatment area")
{
_criteria["15"] = new[] { "fcode_text" }; // nhd
}
// send geometry to soe for calculations
var url = string.Format(
"http://{0}/Reference/MapServer/exts/wri_soe/ExtractIntersections",
Settings.Default.gisServerBaseUrl);
var uri = new Uri(url);
var base64Geometry = Convert.ToBase64String(geometry.STAsBinary().Value);
var formContent = new[]
{
new KeyValuePair<string, string>("geometry", base64Geometry),
new KeyValuePair<string, string>("criteria",
JsonConvert.SerializeObject(_criteria)),
new KeyValuePair<string, string>("f", "json")
}.AsFormContent();
var request = await _httpClient.PostAsync(uri, formContent);
return await request.Content.ReadAsAsync<ResponseContainer<IntersectResponse>>(
new[]
{
new TextPlainResponseFormatter()
});
}
private static IGeometry SqlGeometryToGeometryMultiPoint(SqlGeometry geometry, GeometryFactory factory)
{
IPoint[] points = new IPoint[geometry.STNumGeometries().Value];
for (int i = 1; i <= points.Length; i++)
points[i - 1] = SqlGeometryToGeometryPoint(geometry.STGeometryN(i), factory);
return factory.CreateMultiPoint(points);
}
public SqlGeometry Assign(int wishedArea, int srid, List<Adopter> adopters)
{
foreach (var adopter in adopters)
{
var g = SqlGeometry.STGeomFromText(new SqlChars(adopter.geom), Constants.SRID_INT);
assignedUnion = assignedUnion == null ? g : assignedUnion.STUnion(g);
}
SqlGeometry newStartingPoint = GenerateStartingPoint(wishedArea);
if (newStartingPoint != null)
{
double x = Math.Floor(newStartingPoint.STX.Value);
double y = Math.Floor(newStartingPoint.STY.Value);
SqlGeometry assigned = generate(x, y, wishedArea, srid);
// Defensive check
if (Math.Abs(assigned.STArea().Value - wishedArea) > epsilon)
{
//throw new Exception("Incorrect area");
return null;
}
return assigned;
}
return null;
}
public AssignPlotOfLand()
{
assignedUnion = null;
startingPoint = null;
outerBoundary = null;
assigned = new List<SqlGeometry>();
}
public static SqlNumber Area(SqlGeometry geometry)
{
if (geometry == null || geometry.IsNull)
return SqlNumber.Null;
return geometry.Area;
}
public static SMGeometry ToSharpMapGeometry(SqlGeometry geometry, Factory factory)
{
if (geometry == null) return null;
var fact = factory ?? Services.CreateGeometryFactory((int) geometry.STSrid);
if (geometry.STIsEmpty())
return fact.CreateGeometryCollection(null);
if (!geometry.STIsValid())
geometry.MakeValid();
OpenGisGeometryType geometryType = (OpenGisGeometryType)Enum.Parse(typeof(OpenGisGeometryType), (string)geometry.STGeometryType());
switch (geometryType)
{
case OpenGisGeometryType.Point:
return SqlGeometryToSharpMapPoint(geometry, fact);
case OpenGisGeometryType.LineString:
return SqlGeometryToSharpMapLineString(geometry, fact);
case OpenGisGeometryType.Polygon:
return SqlGeometryToSharpMapPolygon(geometry, fact);
case OpenGisGeometryType.MultiPoint:
return SqlGeometryToSharpMapMultiPoint(geometry, fact);
case OpenGisGeometryType.MultiLineString:
return SqlGeometryToSharpMapMultiLineString(geometry, fact);
case OpenGisGeometryType.MultiPolygon:
return SqlGeometryToSharpMapMultiPolygon(geometry, fact);
case OpenGisGeometryType.GeometryCollection:
return SqlGeometryToSharpMapGeometryCollection(geometry, fact);
}
throw new ArgumentException(string.Format("Cannot convert SqlServer '{0}' to Sharpmap.Geometry", geometry.STGeometryType()), "geometry");
}
private void AppendGeometryToSQLSource(SqlGeometry geom, string label)
{
if (_ACTIVATE_CLIPBOARD == false) return;
if (_geomSqlSrcBuilder == null)
{
ResetSQLSource();
_geomSqlSrcBuilder = new StringBuilder();
_geomSqlSrcBuilderSELECT = new StringBuilder();
}
else
{
_geomSqlSrcBuilder.AppendLine();
_geomSqlSrcBuilderSELECT.AppendLine();
_geomSqlSrcBuilderSELECT.Append("UNION ALL ");
}
_geomSqlSrcBuilder.AppendFormat("DECLARE @g{0} geometry = geometry::STGeomFromText('{1}',{2})", ++_geomSqlSourceCount, geom.ToString(), geom.STSrid.Value);
// TODO: Prevent SQL injection with the label param
//SqlCommand com = new SqlCommand(string.Format("SELECT @g{0} AS geom, @Label AS Label", _geomSqlSourceCount));
//label = label ?? "Geom 'cool' " + _geomSqlSourceCount.ToString();
//com.Parameters.AddWithValue("@Label", label);
label = label ?? "Geometry " + _geomSqlSourceCount.ToString();
_geomSqlSrcBuilderSELECT.AppendFormat("SELECT @g{0} AS geom, '{1}' AS Label", _geomSqlSourceCount, label.Replace("'", "''"));
}
public static SqlBoolean Contains(SqlGeometry geometry, SqlGeometry other)
{
if (geometry == null || geometry.IsNull)
return SqlBoolean.Null;
return geometry.Contains(other);
}
private void getSectorCoverage()
{
dc_tmap.ExecuteCommand(HandleTable.createCellTracing);
Console.WriteLine(dc_oss.SITE.Count());
foreach (var site in dc_oss.SITE)
{
if (site.latitude == null) continue;
CellCoverage cc = new CellCoverage();
#region 这里的算法复杂度高，仿真的过程比较复杂
cc.pre_rxlev = -94;
#endregion
sgeog = cc.MergePoint(site);
sgeom = SqlGeometry.STGeomFromWKB(sgeog.STAsBinary(), 4326).STConvexHull();
pencolor = HandleTable.getRandomPenColor(false, false, false);
CellTracing ct = new CellTracing();
ct.cell = site.cell;
ct.MI_STYLE = "Pen (1, 60," + pencolor.ToString() + ")";
ct.SP_GEOMETRY = sgeom;
sql = @" INSERT INTO [CELLTRACING]([cell],[MI_STYLE],[SP_GEOMETRY]) VALUES ('"
+ ct.cell + "','" + ct.MI_STYLE + "','" + ct.SP_GEOMETRY + "')";
dc_tmap.ExecuteCommand(sql);
}
}
private SqlGeometry CutZoomedPixelMultiLineStringByTile(SqlGeometry poly, int X, int Y)
{
SqlGeometry result;
SqlGeometry tile = _conv.GetTilePixelBound(X, Y, 1);
result = poly.STIntersection(tile);
return result;
}
public static SqlNumber Distance(SqlGeometry geometry, SqlGeometry other)
{
if (geometry == null || geometry.IsNull)
return SqlNumber.Null;
return geometry.Distance(other);
}
private static IMultiLineString SqlGeometryToGeometryMultiLineString(SqlGeometry geometry, GeometryFactory factory)
{
ILineString[] lineStrings = new ILineString[geometry.STNumGeometries().Value];
for (int i = 1; i <= lineStrings.Length; i++)
lineStrings[i - 1] = SqlGeometryToGeometryLineString(geometry.STGeometryN(i), factory);
return factory.CreateMultiLineString(lineStrings);
}
private static IGeometryCollection SqlGeometryToGeometryGeometryCollection(SqlGeometry geometry, GeometryFactory factory)
{
IGeometry[] geoms = new IGeometry[geometry.STNumGeometries().Value];
for (int i = 1; i <= geoms.Length; i++)
geoms[i - 1] = SqlGeometryToGeometry(geometry.STGeometryN(i), factory);
return factory.CreateGeometryCollection(geoms);
}
private static void ExpandEnv(Envelope env, SqlGeometry geom)
{
for (int i = 0, c = geom.STNumPoints().Value; i < c; i++)
{
SqlGeometry geomPoint = geom.STPointN(i + 1);
env.ExpandToInclude(geomPoint.STX.Value, geomPoint.STY.Value);
}
}
private static IList<SMPoint> GetPoints(SqlGeometry geometry)
{
SMPoint[] pts = new SMPoint[(int)geometry.STNumPoints()];
for (int i = 0; i < (int)geometry.STNumPoints(); i++)
{
SqlGeometry ptGeometry = geometry.STPointN(i);
pts[i] = new SMPoint((double)ptGeometry.STX, (double)ptGeometry.STY);
}
return pts;
}
private static Coordinate[] GetPoints(SqlGeometry geometry)
{
Coordinate[] pts = new Coordinate[geometry.STNumPoints().Value];
for (int i = 1; i <= pts.Length; i++)
{
SqlGeometry ptGeometry = geometry.STPointN(i);
pts[i - 1] = new Coordinate(ptGeometry.STX.Value, ptGeometry.STY.Value);
}
return pts;
}
private static Point[] GetPointsFromSqlGeometry(SqlGeometry sqlGeometry)
{
Point[] points = new Point[(Int32)(sqlGeometry.STNumPoints())];
for (int i = 0; i < sqlGeometry.STNumPoints(); i++)
{
SqlGeometry pointGeometry = sqlGeometry.STPointN(i + 1);
points[i] = new Point((float)pointGeometry.STX.Value, (float)pointGeometry.STY.Value);
}
return points;
}
// Converts a geometry (ring or linestring) to list of points
public static List<Point> ToPointList(SqlGeometry sqlGeometry)
{
List<Point> points = new List<Point>();
for (int i = 1; i <= sqlGeometry.STNumPoints(); i++)
{
SqlGeometry p = sqlGeometry.STPointN(i);
points.Add(new Point(p.STX.Value, p.STY.Value));
}
return points;
}
public static SqlGeometry ReprojectGeometryToMercator(SqlGeometry geom, int zoomLevel)
{
//SqlGeometry testDotSpatial = geom.ReprojectTo(DotSpatial.Projections.KnownCoordinateSystems.Projected.World.Mercatorworld);
return SqlGeometryProjectionSink.ReprojectGeometry(geom, geom.STSrid.Value, new Func<double, double, double[]>((x, y) => {
double projX = 0;
double projY = 0;
BingMapsTileSystem.LatLongToDoubleXY(y, x, out projX, out projY);
//System.Diagnostics.Trace.TraceInformation("X: {0} / Y: {1}", projX, projY);
return new double[] { projX, projY };
}));
}
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 IGeometry Read(byte[] bytes)
{
using (MemoryStream stream = new MemoryStream(bytes))
{
using (BinaryReader reader = new BinaryReader(stream))
{
SqlGeometry sqlGeometry = new SqlGeometry();
sqlGeometry.Read(reader);
return Read(sqlGeometry);
}
}
}
public FourthHandler()
{
Size = new Size(800, 800);
BorderStyle = BorderStyle.Fixed3D;
a = SqlGeometry.Parse("POLYGON ((0 0, 2 0, 2 2, 0 2, 0 0))");
b = SqlGeometry.Parse("POLYGON ((1 1, 3 1, 3 3, 1 3, 1 1))");
UpdateValues(a, b);
Invalidate();
}
public static SqlGeometry ReprojectGeometry(SqlGeometry geom, int srid, Func<double, double, double[]> coordTransform)
{
if (geom != null)
{
SqlGeometryBuilder builder = new SqlGeometryBuilder();
SqlGeometryProjectionSink sink = new SqlGeometryProjectionSink(builder, srid, coordTransform);
geom.Populate(sink);
return builder.ConstructedGeometry;
}
return null;
}
/// <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 bool TryToGeometry(this SqlGeography geog, out SqlGeometry outputGeometry)
{
try
{
outputGeometry = SqlGeometry.STGeomFromText(new SqlChars(new SqlString(geog.ToString())), 4326);
outputGeometry = outputGeometry.MakeValidIfInvalid();
return true;
}
catch
{
outputGeometry = null;
return false;
}
}
public lineLocating()
{
#region //这里用的是通用方法
ExcuteSqlScript es = new ExcuteSqlScript();
//es.insertSqltableIntoMapinfo(tableName);
es.createLocatingTable(tableName);
#endregion
eventsLookup = dc.EventLocating.ToLookup(e => e.events);
eventsKey = eventsLookup.Select(e => e.Key);
foreach (var p in eventsKey)
{
foreach (var q in eventsLookup[p])
{
// Console.WriteLine(".....{0}...{1}....{2}", q.events, 3 * Math.Pow(10, -8), q.SP_GEOMETRY.STArea());
//这里剔除天线高度为0的小区，避免定位干扰？
if (q.SP_GEOMETRY.STArea() >3 * Math.Pow(10, -8))
{
//Console.WriteLine("面接多少.....{0}....", q.SP_GEOMETRY.STArea());
mrPointsgeom = mrPointsgeom.STUnion(q.SP_GEOMETRY);
events = q.events;
}
}
redindex++;
if (redindex > 255) redindex = 0;
pencolor = redindex * 65535 + greenindex * 256 + blueindex;
pen = "Pen (1, 2," + pencolor.ToString() + ")";
mrPointsgeom = mrPointsgeom.STConvexHull().STCentroid().STPointN(1);
if (!mrPointsgeom.STIsValid()) continue;
tsgeog = SqlGeography.STGeomFromWKB(mrPointsgeom.STAsBinary(), 4326);
if (tsgeog.IsNull) continue;
tsgeog = SqlGeography.Point((double)tsgeog.Lat, (double)tsgeog.Long, 4326);
tsgeog = tsgeog.STBuffer(1);
mrLinesgeom = SqlGeometry.STGeomFromWKB(tsgeog.STAsBinary(), 4326);
Console.WriteLine(mrLinesgeom.STArea());
insertLocating2Sql(events, pen, mrLinesgeom);
}
}
/// <summary>
/// Вовращает полигон и контур для указанного тайла для полигона без внутренних колец
/// </summary>
/// <param name="poly"></param>
/// <param name="X"></param>
/// <param name="Y"></param>
/// <returns></returns>
private List<SqlGeometry> CutZoomedPixelPolygonByTile(SqlGeometry poly, int X, int Y)
{
List<SqlGeometry> result = new List<SqlGeometry>();
SqlGeometry tile = _conv.GetTilePixelBound(X, Y, 1);
var tiled = poly.STIntersection(tile);
// Получаем контур полигона и внутренние кольца в виде MULTILINESTRING
var contour = PolygonToMultiLineString(tiled);
result.Add(tiled);
// удаляем линии среза геометрии по границе тайла
var tileLineString = tile.ToLineString();
var tobecut = contour.STIntersection(tileLineString);
var stroke = contour.STDifference(tobecut);
result.Add(stroke);
return result;
}
public override SqlFeatureSet GetSqlFeatures(SqlGeometry geometry)
{
throw new NotImplementedException();
}
public override object FromStringValue(string xml)
{
return(SqlGeometry.STGeomFromText(new SqlChars(xml), 0));
}
/// <summary>
/// Get a SqlGeometry instance with same
/// information as provided WebPolygon.
/// </summary>
/// <param name="polygon">This polygon.</param>
/// <returns>
/// A SqlGeometry instance with same
/// information as provided WebPolygon.
/// </returns>
public static SqlGeometry GetGeometry(this WebPolygon polygon)
{
return(SqlGeometry.Parse(new SqlString(polygon.GetWkt())));
}
private OpenGisGeometryType GetOpenGisGeometryType(SqlGeometry geom)
{
return((OpenGisGeometryType)Enum.Parse(typeof(OpenGisGeometryType), (string)geom.STGeometryType()));
}
/// <summary>
/// Executes a database query given a GeoJSON input and returns a GeoJSON output.
/// </summary>
/// <param name="json"></param>
/// <param name="connection"></param>
/// <param name="provider"></param>
/// <param name="sql"></param>
/// <returns></returns>
public static string DatabaseRequest(string json, string connection, string provider, string sql)
{
string result = null;
SqlGeometry sqlGeom = GeospatialServices.GeoJSON.GeoJSON.JSONToGeometry(json);
Dictionary <string, object> parameters = GeospatialServices.GeoJSON.GeoJSON.JSONToProperties(json);
System.Data.DataSet ds = new DataSet();
try
{
DbProviderFactory f = DbProviderFactories.GetFactory(provider);
DbConnection dbConnection = f.CreateConnection();
dbConnection.ConnectionString = connection;
DbCommand command = f.CreateCommand();
command.CommandText = sql;
command.Connection = dbConnection;
if (command.CommandText.Contains("@wkt"))
{
DbParameter dbSqlGeometryParameter = command.CreateParameter();
dbSqlGeometryParameter.ParameterName = "@wkt";
dbSqlGeometryParameter.Value = sqlGeom.ToString();
command.Parameters.Add(dbSqlGeometryParameter);
}
if (command.CommandText.Contains("@srid"))
{
DbParameter dbSridParameter = command.CreateParameter();
dbSridParameter.ParameterName = "@srid";
dbSridParameter.Value = sqlGeom.STSrid;
command.Parameters.Add(dbSridParameter);
}
foreach (KeyValuePair <string, object> item in parameters)
{
// sanitise the key value pairs
if (!Regex.IsMatch(item.Key, @"^[a-zA-Z_'.\s]{1,50}$"))
{
throw new ArgumentException("Invalid Key value provided in GeoJSON");
}
if (item.Value is string)
{
if (!Regex.IsMatch((string)item.Value, @"^[a-zA-Z_'.\s]{1,80}$"))
{
throw new ArgumentException("Invalid Value value provided in GeoJSON");
}
}
if (command.CommandText.Contains("@" + item.Key))
{
DbParameter dbParameter = command.CreateParameter();
dbParameter.ParameterName = "@" + item.Key;
dbParameter.Value = item.Value;
command.Parameters.Add(dbParameter);
}
}
DbDataAdapter da = f.CreateDataAdapter();
da.SelectCommand = command;
da.Fill(ds);
dbConnection.Close();
}
catch (Exception)
{
throw;
}
result = GeospatialServices.GeoJSON.GeoJSON.DataSetToJSON(ds);
return(result);
}
public override List <SqlGeometry> GetGeometries(SqlGeometry geometry)
{
return(GetGeometries().Where(i => i.STIntersects(geometry).IsTrue).ToList());
}
public override DataTable GetEntireFeatures(SqlGeometry geometry)
{
string wkt = new string(geometry.STAsText().Value);
return(GetEntireFeaturesWhereIntersects(wkt));
}
public override DataTable GetEntireFeaturesWhereIntersects(SqlGeometry geometry)
{
throw new NotImplementedException();
}
public abstract DataTable GetEntireFeaturesWhereIntersects(SqlGeometry geometry);
static void Main(string[] args)
{
// EXAMPLE 1 : POINT
// Create a new instance of the SqlGeographyBuilder
SqlGeometryBuilder gb = new SqlGeometryBuilder();
// Set the spatial reference identifier
gb.SetSrid(27700);
// Declare the type of geometry to be created
gb.BeginGeometry(OpenGisGeometryType.Point);
// Add the coordinates of the first (and only) point
gb.BeginFigure(300500, 600200);
// End the figure
gb.EndFigure();
// End the geometry
gb.EndGeometry();
// Retrieve the constructed geometry
SqlGeometry Point = gb.ConstructedGeometry;
// Print WKT of the geometry to the console window
Console.WriteLine(Point.ToString());
// EXAMPLE 2 : MULTIPOINT
// Create a new instance of the SqlGeographyBuilder
SqlGeographyBuilder gb2 = new SqlGeographyBuilder();
// Set the spatial reference identifier
gb2.SetSrid(4269);
// Declare the type of collection to be created
gb2.BeginGeography(OpenGisGeographyType.MultiPoint);
// Create the first point in the collection
gb2.BeginGeography(OpenGisGeographyType.Point);
gb2.BeginFigure(40, -120);
gb2.EndFigure();
gb2.EndGeography();
// Create the second point in the collection
gb2.BeginGeography(OpenGisGeographyType.Point);
gb2.BeginFigure(45, -100);
gb2.EndFigure();
gb2.EndGeography();
// Create the second point in the collection
gb2.BeginGeography(OpenGisGeographyType.Point);
gb2.BeginFigure(42, -110);
gb2.EndFigure();
gb2.EndGeography();
// End the geometry and retrieve the constructed instance
gb2.EndGeography();
SqlGeography MultiPoint = gb2.ConstructedGeography;
Console.WriteLine(MultiPoint.ToString());
// EXAMPLE 3: POLYGON WITH INTERIOR RING
// Create a new instance of the SqlGeometryBuilder
SqlGeometryBuilder gb3 = new SqlGeometryBuilder();
// Set the spatial reference identifier
gb3.SetSrid(0);
// Declare the type of geometry to be created
gb3.BeginGeometry(OpenGisGeometryType.Polygon);
// Exterior ring
gb3.BeginFigure(0, 0);
gb3.AddLine(10, 0);
gb3.AddLine(10, 20);
gb3.AddLine(0, 20);
gb3.AddLine(0, 0);
gb3.EndFigure();
// Interior ring
gb3.BeginFigure(3, 3);
gb3.AddLine(7, 3);
gb3.AddLine(5, 17);
gb3.AddLine(3, 3);
gb3.EndFigure();
// End the geometry and retrieve the constructed instance
gb3.EndGeometry();
SqlGeometry Polygon = gb3.ConstructedGeometry;
// EXAMPLE 4: CURVED GEOMETRIES
// Create a new instance of the SqlGeographyBuilder
SqlGeometryBuilder gb4 = new SqlGeometryBuilder();
// Set the spatial reference identifier
gb4.SetSrid(0);
// Declare the type of geometry to be created
gb4.BeginGeometry(OpenGisGeometryType.CompoundCurve);
// Begin the figure at a point
gb4.BeginFigure(50, 0);
// Draw a straight line edge
gb4.AddLine(50, 10);
// Draw a circular curved edge
gb4.AddCircularArc(55, 5, 60, 0);
// End the figure
gb4.EndFigure();
// End the geometry
gb4.EndGeometry();
SqlGeometry CompoundCurve = gb4.ConstructedGeometry;
Console.WriteLine(CompoundCurve.ToString());
// EXAMPLE 5: 3- AND 4- DIMENSIONAL COORDINATES
// Create a new instance of the SqlGeographyBuilder
SqlGeographyBuilder gb5 = new SqlGeographyBuilder();
// Set the spatial reference identifier
gb5.SetSrid(4326);
// Declare the type of collection to be created
gb5.BeginGeography(OpenGisGeographyType.Point);
gb5.BeginFigure(52, 0.15, 140, null);
gb5.EndFigure();
gb5.EndGeography();
SqlGeography PointZ = gb5.ConstructedGeography;
Console.WriteLine(PointZ.ToString());
Console.ReadLine();
}
// Convert an input WKT to a valid geography instance.
// This function requires that the WKT coordinate values are longitude/latitude values,
// in that order and that a valid geography SRID value is supplied.
//
public static SqlGeography MakeValidGeographyFromText(string inputWKT, int srid)
{
return(MakeValidGeographyFromGeometry(SqlGeometry.STGeomFromText(new SqlChars(inputWKT), srid)));
}
public static SqlGeometry MakePointCollection(IEnumerable <IPoint> points)
{
var wkt = $"MULTIPOINT({string.Join(",", points.Select(i => $"({i.X} {i.Y})"))})";
return(SqlGeometry.Parse(new System.Data.SqlTypes.SqlString(wkt)));
}
/// <summary>
/// Sets the geometry column to null
/// </summary>
public void SetFeatureGeometryNull()
{
this.Geometry = null;
}
public List <GeoPoint> GetLineGeometryElevation(SqlGeometry lineStringGeometry, DEMDataSet dataSet, InterpolationMode interpolationMode = InterpolationMode.Bilinear)
{
if (lineStringGeometry == null || lineStringGeometry.IsNull)
{
return(null);
}
if (lineStringGeometry.STGeometryType().Value != "LineString")
{
throw new Exception("Geometry must be a linestring");
}
if (lineStringGeometry.STSrid.Value != 4326)
{
throw new Exception("Geometry SRID must be set to 4326 (WGS 84)");
}
BoundingBox bbox = lineStringGeometry.GetBoundingBox();
List <FileMetadata> tiles = this.GetCoveringFiles(bbox, dataSet);
// Init interpolator
IInterpolator interpolator = GetInterpolator(interpolationMode);
int numPointsSql = lineStringGeometry.STNumPoints().Value;
var sqlStart = lineStringGeometry.STPointN(1);
var sqlEnd = lineStringGeometry.STPointN(numPointsSql);
GeoPoint start = new GeoPoint(sqlStart.STY.Value, sqlStart.STX.Value);
GeoPoint end = new GeoPoint(sqlEnd.STY.Value, sqlEnd.STX.Value);
double lengthMeters = start.DistanceTo(end);
int demResolution = dataSet.ResolutionMeters;
int totalCapacity = 2 * (int)(lengthMeters / demResolution);
List <GeoPoint> geoPoints = new List <GeoPoint>(totalCapacity);
using (GeoTiffDictionary adjacentGeoTiffs = new GeoTiffDictionary())
{
bool isFirstSegment = true; // used to return first point only for first segments, for all other segments last point will be returned
foreach (SqlGeometry segment in lineStringGeometry.Segments())
{
List <FileMetadata> segTiles = this.GetCoveringFiles(segment.GetBoundingBox(), dataSet, tiles);
// Find all intersection with segment and DEM grid
List <GeoPoint> intersections = this.FindSegmentIntersections(segment.STStartPoint().STX.Value
, segment.STStartPoint().STY.Value
, segment.STEndPoint().STX.Value
, segment.STEndPoint().STY.Value
, segTiles
, isFirstSegment
, true);
// Get elevation for each point
this.GetElevationData(ref intersections, adjacentGeoTiffs, segTiles, interpolator);
// Add to output list
geoPoints.AddRange(intersections);
isFirstSegment = false;
}
//Debug.WriteLine(adjacentGeoTiffs.Count);
} // Ensures all geotifs are properly closed
return(geoPoints);
}
public override List <SqlFeature> GetFeatures(SqlGeometry geometry)
{
throw new NotImplementedException();
}
/// <summary>
/// Validates the specified value, to see if it is valid for this column.
/// </summary>
/// <param name="value">The value.</param>
/// <param name="sqlValue">The SQL value.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentOutOfRangeException"></exception>
/// <remarks></remarks>
public bool Validate(object value, out object sqlValue)
{
if (value.IsNull())
{
sqlValue = NullValue;
return(IsIsNullable);
}
if (!ClassType.IsInstanceOfType(value))
{
sqlValue = DBNull.Value;
return(false);
}
Debug.Assert(value != null);
switch (SqlDbType)
{
case SqlDbType.BigInt:
sqlValue = (Int64)value;
return(true);
case SqlDbType.Binary:
case SqlDbType.Image:
case SqlDbType.Timestamp:
case SqlDbType.VarBinary:
byte[] bytes = (byte[])value;
sqlValue = bytes;
return(FixedLength < 0 ||
(bytes.Length <= FixedLength));
case SqlDbType.Bit:
sqlValue = (bool)value;
return(true);
case SqlDbType.Text:
case SqlDbType.Char:
case SqlDbType.VarChar:
string s = (string)value;
sqlValue = s;
return(FixedLength < 0 ||
(s.Length <= FixedLength));
case SqlDbType.DateTime:
case SqlDbType.DateTime2:
sqlValue = (DateTime)value;
return(true);
case SqlDbType.Decimal:
case SqlDbType.Money:
case SqlDbType.SmallMoney:
sqlValue = (decimal)value;
return(true);
case SqlDbType.Float:
sqlValue = (double)value;
return(true);
case SqlDbType.Int:
sqlValue = (int)value;
return(true);
case SqlDbType.NChar:
case SqlDbType.NText:
case SqlDbType.NVarChar:
case SqlDbType.Xml:
string ns = (string)value;
sqlValue = ns;
return(FixedLength < 0 || (ns.Length <= (FixedLength / 2)));
case SqlDbType.Real:
sqlValue = (float)value;
return(true);
case SqlDbType.UniqueIdentifier:
sqlValue = (Guid)value;
return(true);
case SqlDbType.SmallDateTime:
DateTime dt = (DateTime)value;
sqlValue = dt;
return(dt >= Tester.MinSmallDateTime && dt <= Tester.MaxSmallDateTime);
case SqlDbType.SmallInt:
sqlValue = (Int16)value;
return(true);
case SqlDbType.TinyInt:
sqlValue = (byte)value;
return(true);
case SqlDbType.Variant:
sqlValue = value;
return(true);
case SqlDbType.Udt:
sqlValue = value;
SqlGeography sqlGeography = value as SqlGeography;
if (sqlGeography != null)
{
return(true);
}
SqlGeometry sqlGeometry = value as SqlGeometry;
if (sqlGeometry != null)
{
return(true);
}
return(value is SqlHierarchyId);
case SqlDbType.Date:
sqlValue = ((DateTime)value).Date;
return(true);
case SqlDbType.Time:
sqlValue = (TimeSpan)value;
return(true);
case SqlDbType.DateTimeOffset:
sqlValue = (DateTimeOffset)value;
return(true);
default:
// ReSharper disable once NotResolvedInText
throw new ArgumentOutOfRangeException(
"SqlDbType",
SqlDbType,
string.Format("Unsupported SqlDbType for column '{0}'", this));
}
}
public override List <NamedSqlGeometry> GetGeometryLabelPairs(SqlGeometry geometry)
{
throw new NotImplementedException();
}
public String ImportFromShapefile(String shapeFilePath, String connectionString)
{
String shapeFileName = Path.GetFileNameWithoutExtension(shapeFilePath);
//Define destination table
DataTable bulkSqlTable = new DataTable();
var newNames = _textBoxPanel.Children.OfType <TextBox>().ToList();
int rowNo = 0;
foreach (DataColumn col in _table.Columns)
{
bulkSqlTable.Columns.Add(newNames[rowNo++].Text, col.DataType);
}
bulkSqlTable.Columns.Add("Geom", typeof(SqlGeometry));
//Populate destination table
foreach (FeatureDataRow row in _table)
{
rowNo = 0;
DataRow newTableRow = bulkSqlTable.NewRow();
foreach (DataColumn col in _table.Columns)
{
newTableRow[newNames[rowNo++].Text] = row[col.ColumnName];
}
newTableRow["Geom"] = SqlGeometry.STGeomFromWKB(new SqlBytes(row.Geometry.AsBinary()), row.Geometry.SRID);
bulkSqlTable.Rows.Add(newTableRow);
}
try
{
bulkSqlTable.PrimaryKey = new DataColumn[] { bulkSqlTable.Columns[_primaryKey.Text] };
if (bulkSqlTable.Columns[_primaryKey.Text].DataType == typeof(String))
{
bulkSqlTable.Columns[_primaryKey.Text].MaxLength = 400;
}
}
catch
{
_status.Text = "Wrong primary key, bad column choice";
return(String.Empty);
}
//Save destination table
using (SqlConnection connection = new SqlConnection(connectionString))
{
SqlTransaction transaction = null;
connection.Open();
try
{
transaction = connection.BeginTransaction();
SqlTableCreator tableCreator = new SqlTableCreator(connection, transaction);
tableCreator.DestinationTableName = _tableName.Text;
tableCreator.CreateFromDataTable(bulkSqlTable);
using (var sqlBulkCopy = new SqlBulkCopy(connection, SqlBulkCopyOptions.TableLock, transaction))
{
sqlBulkCopy.DestinationTableName = _tableName.Text;
sqlBulkCopy.BatchSize = 10000;
sqlBulkCopy.WriteToServer(bulkSqlTable);
}
transaction.Commit();
}
catch (Exception e)
{
if (transaction != null)
{
transaction.Rollback();
}
_status.Text = "Bad table name. Probabbly already exists. Check the primary key too.";
return(String.Empty);
}
finally
{
connection.Close();
SqlConnection.ClearPool(connection);
}
}
return(shapeFileName);
}
public override List <SqlGeometry> GetGeometries(BoundingBox boundingBox)
{
SqlGeometry boundary = boundingBox.AsSqlGeometry(GetSrid());
return(GetGeometries(boundary));
}
public SqlFeature(SqlGeometry geometry, Dictionary <string, object> attributes)
{
this.TheSqlGeometry = geometry;
this.Attributes = attributes;
}
private List <SqlGeometry> CutPolygonByZoomedPixelTile(SqlGeometry poly, int X, int Y, int Z)
{
return(CutZoomedPixelPolygonByTile(_parser.ConvertToZoomedPixelGeometry(poly, Z), X, Y));
}
public NamedSqlGeometry(SqlGeometry geometry, string label)
{
this.TheSqlGeometry = geometry;
this.Label = label;
}
/// <summary>
/// Выполняет рендеринг части геометрии пересекающейся с тайлом на образе тайла
/// </summary>
/// <param name="shape">полная геометрия объекта в угловых координатах (широта, долгота)</param>
/// <param name="X">номер тайла X</param>
/// <param name="Y">номер тайла Y</param>
/// <param name="Zoom">номер масштаба</param>
/// <param name="argbFill">цвет в ARGB</param>
/// <param name="argbStroke"></param>
/// <param name="strokeWidth">ширина контура</param>
public void DrawPartObjectShapeOnTile(SqlGeometry shape, int X, int Y, int Zoom, string argbFill,
string argbStroke, int strokeWidth)
{
PasteShapeOnTile(CreateColor(argbFill), CreateColor(argbStroke), strokeWidth,
CutPolygonByZoomedPixelZeroTile(shape, X, Y, Zoom));
}
public static void GeometryVoronoi(SqlGeometry MultiPoint)
{
// Retrieve the SRID
int srid = (int)MultiPoint.STSrid;
// Check valid input
if (!(MultiPoint.STGeometryType() == "MULTIPOINT" && MultiPoint.STNumPoints() > 3))
{
throw new ArgumentException("Input must be a MultiPoint containing at least three points");
}
// Initialise a list of vertices
List <SimplePoint> Vertices = new List <SimplePoint>();
// Add all the original supplied points
for (int i = 1; i <= MultiPoint.STNumPoints(); i++)
{
SimplePoint Point = new SimplePoint((double)MultiPoint.STPointN(i).STX, (double)MultiPoint.STPointN(i).STY);
// MultiPoints can contain the same point twice, but this messes up Delauney
if (!Vertices.Contains(Point))
{
Vertices.Add(Point);
}
}
// Important - count the number of points in the array, NOT using STNumPoints of the supplied geometry, as some duplicate points
// may have been removed
int numPoints = Vertices.Count;
// Important! Sort the list so that points sweep from left - right
Vertices.Sort();
// Calculate the "supertriangle" that encompasses the pointset
SqlGeometry Envelope = MultiPoint.STEnvelope();
// Width
double dx = (double)(Envelope.STPointN(2).STX - Envelope.STPointN(1).STX);
// Height
double dy = (double)(Envelope.STPointN(4).STY - Envelope.STPointN(1).STY);
// Maximum dimension
double dmax = (dx > dy) ? dx : dy;
// Centre
double avgx = (double)Envelope.STCentroid().STX;
double avgy = (double)Envelope.STCentroid().STY;
// Create the points at corners of the supertriangle
SimplePoint a = new SimplePoint(avgx - 2 * dmax, avgy - dmax);
SimplePoint b = new SimplePoint(avgx + 2 * dmax, avgy - dmax);
SimplePoint c = new SimplePoint(avgx, avgy + 2 * dmax);
// Add the supertriangle vertices to the end of the vertex array
Vertices.Add(a);
Vertices.Add(b);
Vertices.Add(c);
double radius;
SimplePoint circumcentre;
CalculateCircumcircle(a, b, c, out circumcentre, out radius);
// Create a triangle from the vertices
SimpleTriangle SuperTriangle = new SimpleTriangle(numPoints, numPoints + 1, numPoints + 2, circumcentre, radius);
// Add the supertriangle to the list of triangles
List <SimpleTriangle> Triangles = new List <SimpleTriangle>();
Triangles.Add(SuperTriangle);
List <SimpleTriangle> CompletedTriangles = new List <SimpleTriangle>();
// Loop through each point
for (int i = 0; i < numPoints; i++)
{
// Initialise the edge buffer
List <int[]> Edges = new List <int[]>();
// Loop through each triangle
for (int j = Triangles.Count - 1; j >= 0; j--)
{
// If the point lies within the circumcircle of this triangle
if (Distance(Triangles[j].circumcentre, Vertices[i]) < Triangles[j].radius)
{
// Add the triangle edges to the edge buffer
Edges.Add(new int[] { Triangles[j].a, Triangles[j].b });
Edges.Add(new int[] { Triangles[j].b, Triangles[j].c });
Edges.Add(new int[] { Triangles[j].c, Triangles[j].a });
// Remove this triangle from the list
Triangles.RemoveAt(j);
}
// If this triangle is complete
else if (Vertices[i].x > Triangles[j].circumcentre.x + Triangles[j].radius)
{
{
CompletedTriangles.Add(Triangles[j]);
}
Triangles.RemoveAt(j);
}
}
// Remove duplicate edges
for (int j = Edges.Count - 1; j > 0; j--)
{
for (int k = j - 1; k >= 0; k--)
{
// Compare if this edge match in either direction
if (Edges[j][0].Equals(Edges[k][1]) && Edges[j][1].Equals(Edges[k][0]))
{
// Remove both duplicates
Edges.RemoveAt(j);
Edges.RemoveAt(k);
// We've removed an item from lower down the list than where j is now, so update j
j--;
break;
}
}
}
// Create new triangles for the current point
for (int j = 0; j < Edges.Count; j++)
{
CalculateCircumcircle(Vertices[Edges[j][0]], Vertices[Edges[j][1]], Vertices[i], out circumcentre, out radius);
SimpleTriangle T = new SimpleTriangle(Edges[j][0], Edges[j][1], i, circumcentre, radius);
Triangles.Add(T);
}
}
// We've finished triangulation. Move any remaining triangles onto the completed list
CompletedTriangles.AddRange(Triangles);
// Define the metadata of the result columns
SqlMetaData metadata = new SqlMetaData("VoronoiCell", SqlDbType.Udt, typeof(SqlGeometry));
// Create a record based on this metadata
SqlDataRecord record = new SqlDataRecord(metadata);
// Send the results back to the client
SqlContext.Pipe.SendResultsStart(record);
for (var i = 0; i < Vertices.Count; i++)
{
// Initiliase a new geometry to hold the voronoi polygon
SqlGeometry vp = SqlGeometry.STGeomFromText(new SqlChars("POINT EMPTY"), srid);
// Look through each triangle
foreach (SimpleTriangle Tri in CompletedTriangles)
{
// If the triangle intersects this point
if (Tri.a == i || Tri.b == i || Tri.c == i)
{
SqlGeometry p = SqlGeometry.Point(Tri.circumcentre.x, Tri.circumcentre.y, srid);
// Add the circumcentre of this triangle to the list
vp = vp.STUnion(p);
}
}
// Create the voronoi polygon from the convex hull of the circumcentres of intersecting triangles
vp = vp.STConvexHull();
record.SetValues(vp);
SqlContext.Pipe.SendResultsRow(record);
}
}
/// This method fetches geojson data for groups.
/// /// </summary>
/// <param name="deliveryGroups"List of delivery groups.</param>
/// <returns>Geojson string for groups.</returns>
private static string GetDeliveryGroupsJsonData(List <DeliveryPointGroupDataDTO> deliveryGroups)
{
var geoJson = new GeoJson
{
features = new List <Feature>()
};
if (deliveryGroups != null && deliveryGroups.Count > 0)
{
foreach (var group in deliveryGroups)
{
Geometry groupGeometry = new Geometry();
groupGeometry.type = group.GroupBoundary.Shape.SpatialTypeName;
SqlGeometry groupSqlGeometry = null;
if (groupGeometry.type == Convert.ToString(OpenGisGeometryType.Polygon.ToString()))
{
groupSqlGeometry = SqlGeometry.STPolyFromWKB(new SqlBytes(group.GroupBoundary.Shape.AsBinary()), 27700).MakeValid();
List <List <double[]> > listCords = new List <List <double[]> >();
List <double[]> cords = new List <double[]>();
for (int pt = 1; pt <= groupSqlGeometry.STNumPoints().Value; pt++)
{
double[] coordinates = new double[] { groupSqlGeometry.STPointN(pt).STX.Value, groupSqlGeometry.STPointN(pt).STY.Value };
cords.Add(coordinates);
}
listCords.Add(cords);
groupGeometry.coordinates = listCords;
}
Feature groupFeature = new Feature();
groupFeature.geometry = groupGeometry;
groupFeature.type = DeliveryPointGroupConstants.FeatureType;
groupFeature.id = group.DeliveryGroup.ID.ToString();
groupFeature.properties = new Dictionary <string, Newtonsoft.Json.Linq.JToken>
{
{ DeliveryPointGroupConstants.LayerType, Convert.ToString(OtherLayersType.Group.GetDescription()) },
{ "groupType", group.DeliveryGroup.GroupTypeGUID },
{ "groupName", group.DeliveryGroup.GroupName }
};
geoJson.features.Add(groupFeature);
foreach (var addedDeliveryPoint in group.AddedDeliveryPoints)
{
Geometry groupDPGeometry = new Geometry();
groupDPGeometry.type = addedDeliveryPoint.Shape.SpatialTypeName;
SqlGeometry groupDPSqlGeometry = null;
if (groupDPGeometry.type == Convert.ToString(OpenGisGeometryType.Point.ToString()))
{
groupDPSqlGeometry = SqlGeometry.STGeomFromWKB(new SqlBytes(addedDeliveryPoint.Shape.AsBinary()), DeliveryPointGroupConstants.BNGCOORDINATESYSTEM).MakeValid();
groupDPGeometry.coordinates = new double[] { groupDPSqlGeometry.STX.Value, groupDPSqlGeometry.STY.Value };
}
Feature groupDPFeature = new Feature();
groupDPFeature.geometry = groupDPGeometry;
groupDPFeature.type = DeliveryPointGroupConstants.FeatureType;
groupDPFeature.id = addedDeliveryPoint.ID.ToString();
groupDPFeature.properties = new Dictionary <string, Newtonsoft.Json.Linq.JToken>
{
{ DeliveryPointGroupConstants.LayerType, Convert.ToString(OtherLayersType.DeliveryPoint.GetDescription()) }
};
geoJson.features.Add(groupDPFeature);
}
}
}
return(JsonConvert.SerializeObject(geoJson));
}
public SqlFeature(SqlGeometry geometry) : this(geometry, new Dictionary <string, object>())
{
}
private static StoredProcedure InsertRecord_SqlServer(Int32 primaryKeyColumnValue)
{
var sp = new AllDataTypeTableInsert();
sp.PrimaryKeyColumn = primaryKeyColumnValue;
sp.TimestampColumn = new Byte[] { 1, 2, 3, };
sp.BigIntColumn = 1;
sp.BinaryColumn = null;
sp.BitColumn = true;
sp.CharColumn = "Char";
sp.DateColumn = DateTime.Now;
sp.DateTime2Column = DateTime.Now;
sp.DateTimeColumn = DateTime.Now;
sp.DateTimeOffsetColumn = DateTime.Now;
sp.DecimalColumn = 0;
sp.FloatColumn = 3;
sp.ImageColumn = new Byte[0];
sp.IntColumn = 14;
sp.MoneyColumn = 122;
sp.NCharColumn = "NChar";
sp.NTextColumn = "NText";
sp.NVarCharColumn = "NVarChar";
sp.RealColumn = 100;
sp.SmallDateTimeColumn = new DateTime(2013, 2, 2);
sp.SmallIntColumn = 2;
sp.SmallMoneyColumn = 200;
switch (primaryKeyColumnValue % 4)
{
case 0: sp.SqlVariantColumn = 1; break;
case 1: sp.SqlVariantColumn = "Variant1"; break;
case 2: sp.SqlVariantColumn = DateTime.Now; break;
case 3: sp.SqlVariantColumn = true; break;
}
sp.TextColumn = "Text";
sp.TimeColumn = new TimeSpan(9, 0, 0);
sp.TinyIntColumn = 3;
sp.UniqueIdentifierColumn = Guid.NewGuid();
sp.VarBinaryColumn = new Byte[] { 1, 2, 3, 4 };
sp.VarCharColumn = "VarChar";
sp.XmlColumn = "<xml></xml>";
sp.GeometryColumn = SqlGeometry.Point(137, 42, 4320);
sp.GeographyColumn = SqlGeography.Point(42, 135, 4326);
sp.HierarchyIDColumn = SqlHierarchyId.Parse("/1/2/" + primaryKeyColumnValue + "/");
sp.EnumColumn = HigLabo.DbSharpSample.SqlServer.MyEnum.Value1;
sp.NotNullBigIntColumn = 1;
sp.NotNullBinaryColumn = new Byte[] { 3, 2, 7 };
sp.NotNullBitColumn = true;
sp.NotNullCharColumn = "Char";
sp.NotNullDateColumn = DateTime.Now;
sp.NotNullDateTime2Column = DateTime.Now;
sp.NotNullDateTimeColumn = DateTime.Now;
sp.NotNullDateTimeOffsetColumn = DateTime.Now;
sp.NotNullDecimalColumn = 0;
sp.NotNullFloatColumn = 3;
sp.NotNullImageColumn = new Byte[0];
sp.NotNullIntColumn = 14;
sp.NotNullMoneyColumn = 122;
sp.NotNullNCharColumn = "NChar";
sp.NotNullNTextColumn = "NText";
sp.NotNullNVarCharColumn = "NVarChar";
sp.NotNullRealColumn = 100;
sp.NotNullSmallDateTimeColumn = new DateTime(2013, 2, 2);
sp.NotNullSmallIntColumn = 2;
sp.NotNullSmallMoneyColumn = 200;
switch (primaryKeyColumnValue % 4)
{
case 0: sp.NotNullSqlVariantColumn = 1; break;
case 1: sp.NotNullSqlVariantColumn = "Variant1"; break;
case 2: sp.NotNullSqlVariantColumn = DateTime.Now; break;
case 3: sp.NotNullSqlVariantColumn = true; break;
}
sp.NotNullTextColumn = "Text";
sp.NotNullTimeColumn = new TimeSpan(9, 0, 0);
sp.NotNullTinyIntColumn = 3;
sp.NotNullUniqueIdentifierColumn = Guid.NewGuid();
sp.NotNullVarBinaryColumn = new Byte[] { 1, 2, 3, 4 };
sp.NotNullVarCharColumn = "VarChar";
sp.NotNullXmlColumn = "<xml></xml>";
sp.NotNullGeometryColumn = SqlGeometry.Point(137, 42, 4320);
sp.NotNullGeographyColumn = SqlGeography.Point(42, 135, 4326);
sp.NotNullHierarchyIDColumn = SqlHierarchyId.Parse("/1/2/" + primaryKeyColumnValue + "/");
sp.NotNullEnumColumn = HigLabo.DbSharpSample.SqlServer.MyEnum.Value1;
return(sp);
}
public SqlFeature(SqlGeometry geometry, string label) : this(geometry, new Dictionary <string, object>() { { _defaultLabelAttributeName, label } })
{
}
public DataDeliveryContentValidator()
{
norwayExtents = SqlGeometry.STGeomFromText(
new SqlChars("POLYGON((-500000 6000000, -500000 8500000, 1500000 8500000, 1500000 6000000, -500000 6000000))"), 32633);
}
public override List <NamedSqlGeometry> GetGeometryLabelPairs(SqlGeometry geometry)
{
return(GetGeometries().Select(g => new NamedSqlGeometry(g, string.Empty)).ToList());
}
