public override Geometry GetGeometryByID(uint oid)
{
Geometry geom = null;
using (var conn = new SQLiteConnection(ConnectionID))
{
string strSQL = "SELECT " + GeometryColumn + " AS Geom FROM " + Table + " WHERE " + ObjectIdColumn +
"='" + oid.ToString(NumberFormatInfo.InvariantInfo) + "'";
conn.Open();
using (var command = new SQLiteCommand(strSQL, conn))
{
using (var dr = command.ExecuteReader())
{
while (dr.Read())
{
if (dr[0] != DBNull.Value)
{
geom = GeometryFromWKT.Parse((string)dr[0]);
}
}
}
}
conn.Close();
}
return(geom);
}
/// <summary>
/// Returns the geometry corresponding to the Object ID
/// </summary>
/// <param name="oid">Object ID</param>
/// <returns>geometry</returns>
public GeoAPI.Geometries.IGeometry GetGeometryByID(uint oid)
{
GeoAPI.Geometries.IGeometry geom = null;
using (System.Data.OleDb.OleDbConnection conn = new OleDbConnection(_ConnectionString))
{
string strSQL = "Select " + this.XColumn + ", " + this.YColumn + " FROM " + this.Table + " WHERE " + this.ObjectIdColumn + "=" + oid.ToString();
using (System.Data.OleDb.OleDbCommand command = new OleDbCommand(strSQL, conn))
{
conn.Open();
using (System.Data.OleDb.OleDbDataReader dr = command.ExecuteReader())
{
if (dr.Read())
{
//If the read row is OK, create a point geometry from the XColumn and YColumn and return it
if (dr[0] != DBNull.Value && dr[1] != DBNull.Value)
{
geom = SharpMap.Converters.Geometries.GeometryFactory.CreatePoint((double)dr[0], (double)dr[1]);
}
}
}
conn.Close();
}
}
return(geom);
}
private static IEnumerable <GeoJSON> QueryData(BoundingBox bbox, ICanQueryLayer layer)
{
if (layer == null)
{
throw new ArgumentNullException("layer");
}
// Query for data
FeatureDataSet ds = new FeatureDataSet();
layer.ExecuteIntersectionQuery(bbox, ds);
IEnumerable <GeoJSON> data = GeoJSONHelper.GetData(ds);
// Reproject geometries if needed
IMathTransform transform = null;
if (layer is VectorLayer)
{
ICoordinateTransformation transformation = (layer as VectorLayer).CoordinateTransformation;
transform = transformation == null ? null : transformation.MathTransform;
}
if (transform != null)
{
GeometryFactory gf = new GeometryFactory();
data = data.Select(d =>
{
Geometry converted = GeometryTransform.TransformGeometry(d.Geometry, transform, gf);
d.SetGeometry(converted);
return(d);
});
}
return(data);
}
protected override void OnExecuteIntersectionQuery(Geometry geom, FeatureDataSet ds)
{
ExecuteIntersectionQuery(geom.EnvelopeInternal, ds);
//index of last added feature data table
var index = ds.Tables.Count - 1;
if (index <= 0)
{
return;
}
var res = CloneTableStructure(ds.Tables[index]);
res.BeginLoadData();
var fdt = ds.Tables[index];
foreach (FeatureDataRow row in fdt.Rows)
{
if (PreparedGeometry.Intersects(row.Geometry))
{
var fdr = (FeatureDataRow)res.LoadDataRow(row.ItemArray, true);
fdr.Geometry = row.Geometry;
}
}
res.EndLoadData();
ds.Tables.RemoveAt(index);
ds.Tables.Add(res);
}
/// <summary>
/// Returns true if otherGeometry is wholly contained within the source geometry. This is the same as
/// reversing the primary and comparison shapes of the Within operation.
/// </summary>
/// <param name="g1">Source geometry</param>
/// <param name="g2">Other geometry</param>
/// <returns>True if otherGeometry is wholly contained within the source geometry.</returns>
public static bool Contains(Geometry g1, Geometry g2)
{
SqlGeometry sg1 = SqlGeometryConverter.ToSqlGeometry(g1);
SqlGeometry sg2 = SqlGeometryConverter.ToSqlGeometry(g2);
return((bool)(sg1.STContains(sg2)));
}
/// <summary>
/// Returns true if the primary geometry is wholly contained within the comparison geometry.
/// </summary>
/// <param name="g1">Source geometry</param>
/// <param name="g2">Other geometry</param>
/// <returns></returns>
public static bool Within(Geometry g1, Geometry g2)
{
SqlGeometry sg1 = SqlGeometryConverter.ToSqlGeometry(g1);
SqlGeometry sg2 = SqlGeometryConverter.ToSqlGeometry(g2);
return((bool)sg1.STWithin(sg2));
}
/// <summary>
/// Returns true if the given geometries relate according to the provided intersection pattern Matrix
/// </summary>
/// <param name="g1">Source geometry</param>
/// <param name="g2">Other geometry</param>
/// <param name="intersectionPatternMatrix">Intersection pattern Matrix</param>
/// <returns></returns>
public static Boolean Relate(Geometry g1, Geometry g2, string intersectionPatternMatrix)
{
SqlGeometry sg1 = SqlGeometryConverter.ToSqlGeometry(g1);
SqlGeometry sg2 = SqlGeometryConverter.ToSqlGeometry(g2);
return((bool)sg1.STRelate(sg2, intersectionPatternMatrix));
}
/// <summary>
/// Returns the features that intersects with 'geom'
/// </summary>
/// <param name="geom">Geometry</param>
/// <returns>FeatureDataTable</returns>
public FeatureDataTable ExecuteIntersectionQuery(Geometry geom)
{
FeatureDataSet fds = new FeatureDataSet();
ExecuteIntersectionQuery(geom, fds);
return(fds.Tables[0]);
}
/// <summary>
/// Builds from the given provider.
/// </summary>
/// <param name="provider">
/// The base <see cref="SharpMap.Data.Providers.IProvider"/>
/// from witch initialize the <see cref="NtsProvider"/> instance.
/// </param>
private void BuildFromProvider(IProvider provider)
{
// Features list initialization
features = new List <Feature>(provider.GetFeatureCount());
try
{
// Load all features from the given provider
provider.Open();
Collection <uint> ids = provider.GetObjectIDsInView(provider.GetExtents());
foreach (uint id in ids)
{
FeatureDataRow dataRow = provider.GetFeature(id);
GeoAPI.Geometries.IGeometry geometry = GeometryConverter.ToNTSGeometry(dataRow.Geometry, geometryFactory);
AttributesTable attributes = new AttributesTable();
foreach (DataColumn column in dataRow.Table.Columns)
{
if (dataRow[column] == null || dataRow[column].GetType() == typeof(DBNull))
{
throw new ApplicationException("Null values not supported");
}
attributes.AddAttribute(column.ColumnName, dataRow[column]);
}
features.Add(new Feature(geometry, attributes));
}
}
finally
{
if (provider.IsOpen)
{
provider.Close();
}
}
}
public static Geometry Intersection(Geometry g1, Geometry g2)
{
SqlGeometry sg1 = SqlGeometryConverter.ToSqlGeometry(g1);
SqlGeometry sg2 = SqlGeometryConverter.ToSqlGeometry(g2);
SqlGeometry sgIntersection = sg1.STIntersection(sg2);
return SqlGeometryConverter.ToSharpMapGeometry(sgIntersection);
}
/// <summary>
/// Returns the data associated with all the geometries that are intersected by 'geom'
/// </summary>
/// <param name="geom">Geometry to intersect with</param>
/// <param name="ds">FeatureDataSet to fill data into</param>
protected override void OnExecuteIntersectionQuery(Geometry geom, FeatureDataSet ds)
{
OgrGeometry ogrGeometry = OgrGeometry.CreateFromWkb(GeometryToWKB.Write(geom));
_ogrLayer.SetSpatialFilter(ogrGeometry);
ExecuteIntersectionQuery(ds);
}
public bool GenerateFeature(GeoAPI.Geometries.IGeometry geometry, float top, float bottom, GameObject node)
{
var mesh = node.GetOrAddComponent <MeshFilter>().mesh;
mesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;
mesh.Clear(true);
if (!ProcessGeometry(geometry, top, bottom, node))
{
node.SetActive(false);
return(false);
}
var meshRenderer = node.GetOrAddComponent <MeshRenderer>();
meshRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
meshRenderer.receiveShadows = false;
var material = meshRenderer.material;
if (material != null)
{
meshRenderer.material = material;
meshRenderer.material.color = GetColor(GetLocalType());
}
Destroy(node.GetComponent <MeshCollider>());
node.AddComponent <MeshCollider>();
return(true);
}
public void ConvertAndBack(SqlServerSpatialObjectType spatialType)
{
int srid = 4326;
//Prepare data
Geometry gPn = GeometryFromWKT.Parse(Point);
Geometry gMp = GeometryFromWKT.Parse(Multipoint);
Geometry gLi = GeometryFromWKT.Parse(Linestring);
Geometry gML = GeometryFromWKT.Parse(MultiLinestring);
Geometry gPl = GeometryFromWKT.Parse(Polygon);
Geometry gMPol = GeometryFromWKT.Parse(MultiPolygon);
// Geography requires valid SRID
gPn.SRID = srid;
gMp.SRID = srid;
gLi.SRID = srid;
gML.SRID = srid;
gPl.SRID = srid;
gMPol.SRID = srid;
var comparison = new Comparison <Geometry>((u, v) => u.EqualsExact(v) ? 0 : 1);
Assert.That(ToSqlServerAndBack(gPn, spatialType), Is.EqualTo(gPn).Using(comparison));
Assert.That(ToSqlServerAndBack(gMp, spatialType), Is.EqualTo(gMp).Using(comparison));
Assert.That(ToSqlServerAndBack(gLi, spatialType), Is.EqualTo(gLi).Using(comparison));
Assert.That(ToSqlServerAndBack(gML, spatialType), Is.EqualTo(gML).Using(comparison));
Assert.That(ToSqlServerAndBack(gPl, spatialType), Is.EqualTo(gPl).Using(comparison));
Assert.That(ToSqlServerAndBack(gMPol, spatialType), Is.EqualTo(gMPol).Using(comparison));
}
public static Geometry SymDifference(Geometry g1, Geometry g2)
{
SqlGeometry sg1 = SqlGeometryConverter.ToSqlGeometry(g1);
SqlGeometry sg2 = SqlGeometryConverter.ToSqlGeometry(g2);
SqlGeometry sgSymDifference = sg1.STSymDifference(sg2);
return SqlGeometryConverter.ToSharpMapGeometry(sgSymDifference);
}
/// <summary>
/// Returns true if there is any intersection between the two geometries.
/// </summary>
/// <param name="g1">Source geometry</param>
/// <param name="g2">Other geometry</param>
/// <returns></returns>
public static bool Intersects(Geometry g1, Geometry g2)
{
SqlGeometry sg1 = SqlGeometryConverter.ToSqlGeometry(g1);
SqlGeometry sg2 = SqlGeometryConverter.ToSqlGeometry(g2);
return((bool)sg1.STIntersects(sg2));
}
/// <summary>
/// DotSpatial to Ogr at geometry level
/// </summary>
/// <param name="geometry">GeoAPI/DotSpatial IGeometry</param>
/// <param name="featureSet">DotSpatial IFeatureSet</param>
/// <returns>Ogr Geometry</returns>
public static OSGeo.OGR.Geometry DS2OgrGeometry(GeoAPI.Geometries.IGeometry geometry, DotSpatial.Data.IFeatureSet featureSet)
{
string wkbGeometry = geometry.AsText();
OSGeo.OGR.Geometry result = OSGeo.OGR.Ogr.CreateGeometryFromWkt(ref wkbGeometry, DS2OgrProjection(featureSet.Projection));
return(result);
}
/// <summary>
/// Returns the geometry corresponding to the Object ID
/// </summary>
/// <param name="oid">Object ID</param>
/// <returns>geometry</returns>
public override Geometry GetGeometryByID(uint oid)
{
Geometry geom = null;
using (var conn = new SqlConnection(ConnectionString))
{
string strSql = "SELECT g." + GeometryColumn + " FROM " + QualifiedTable + " g WHERE " + ObjectIdColumn + "='" + oid + "'";
conn.Open();
using (var command = new SqlCommand(strSql, conn))
{
using (SqlDataReader dr = command.ExecuteReader())
{
while (dr.Read())
{
if (dr[0] != null && dr[0] != DBNull.Value)
{
geom = SqlGeometryConverter.ToSharpMapGeometry((Microsoft.SqlServer.Types.SqlGeometry)dr[0]);
}
}
}
}
conn.Close();
}
return(geom);
}
/// <summary>
/// 将GeoAPI中的geometry对象转换为arcgis中的geometry对象
/// </summary>
/// <param name="geometry"></param>
/// <returns></returns>
public static IGeometry ConvertGeoApitoEsri(GeoAPI.Geometries.IGeometry geometry)
{
WKBWriter writer = new WKBWriter();
byte[] bytes = writer.Write(geometry);
return(ConvertWkbToGeometry(bytes));
}
public static Geometry ConvexHull(Geometry g)
{
SqlGeometry sg = SqlGeometryConverter.ToSqlGeometry(g);
SqlGeometry sgConvexHull = sg.STConvexHull();
return(SqlGeometryConverter.ToSharpMapGeometry(sgConvexHull));
}
public static Geometry Boundary(Geometry g)
{
SqlGeometry sg = SqlGeometryConverter.ToSqlGeometry(g);
SqlGeometry sgBoundary = sg.STBoundary();
return(SqlGeometryConverter.ToSharpMapGeometry(sgBoundary));
}
/// <summary>
/// Returns the geometry corresponding to the Object ID
/// </summary>
/// <param name="oid">Object ID</param>
/// <returns>geometry</returns>
public override Geometry GetGeometryByID(uint oid)
{
Geometry geom = null;
using (OracleConnection conn = new OracleConnection(ConnectionString))
{
string strSQL = "SELECT g." + GeometryColumn + ".Get_WKB() FROM " + Table + " g WHERE " + ObjectIdColumn +
"='" + oid.ToString() + "'";
conn.Open();
using (OracleCommand command = new OracleCommand(strSQL, conn))
{
using (OracleDataReader dr = command.ExecuteReader())
{
while (dr.Read())
{
if (dr[0] != DBNull.Value)
{
geom = GeometryFromWKB.Parse((byte[])dr[0], Factory);
}
}
}
}
conn.Close();
}
return(geom);
}
public static Geometry Buffer(Geometry g, Double distance)
{
SqlGeometry sg = SqlGeometryConverter.ToSqlGeometry(g);
SqlGeometry sgBuffer = sg.STBuffer(distance);
return(SqlGeometryConverter.ToSharpMapGeometry(sgBuffer));
}
private void txtWkt_TextChanged(object sender, EventArgs e)
{
var txt = txtWkt.Text;
if (string.IsNullOrEmpty(txt))
{
return;
}
GeoAPI.Geometries.IGeometry geometry = null;
try
{
geometry = _wktReader.Read(txt);
if (geometry != _geometry)
{
Geometry = geometry;
}
txtWkt.ForeColor = SystemColors.WindowText;
lblError.Text = "No Errors";
}
catch (Exception ex)
{
txtWkt.ForeColor = Color.Red;
lblError.Text = ex.Message;
}
}
/// <summary>
/// Returns all features with the view box
/// </summary>
/// <param name="bbox">view box</param>
/// <param name="ds">FeatureDataSet to fill data into</param>
public override void ExecuteIntersectionQuery(BoundingBox bbox, FeatureDataSet ds)
{
using (var conn = new SqlConnection(ConnectionString))
{
//Get bounding box string
string strBbox = GetBoxFilterStr(bbox);
string strSql = String.Format(
"SELECT g.* FROM {0} g {1} WHERE ",
Table, BuildTableHints());
if (!String.IsNullOrEmpty(DefinitionQuery))
{
strSql += DefinitionQuery + " AND ";
}
strSql += strBbox;
using (var adapter = new SqlDataAdapter(strSql, conn))
{
conn.Open();
var ds2 = new System.Data.DataSet();
adapter.Fill(ds2);
conn.Close();
if (ds2.Tables.Count > 0)
{
var fdt = new FeatureDataTable(ds2.Tables[0]);
foreach (System.Data.DataColumn col in ds2.Tables[0].Columns)
{
if (col.ColumnName != GeometryColumn)
{
fdt.Columns.Add(col.ColumnName, col.DataType, col.Expression);
}
}
foreach (System.Data.DataRow dr in ds2.Tables[0].Rows)
{
FeatureDataRow fdr = fdt.NewRow();
foreach (System.Data.DataColumn col in ds2.Tables[0].Columns)
{
if (col.ColumnName != GeometryColumn)
{
fdr[col.ColumnName] = dr[col];
}
}
var geom = dr[GeometryColumn];
Geometry sqlGeometry = null;
if (geom != null && geom != DBNull.Value)
{
sqlGeometry = SqlGeometryConverter.ToSharpMapGeometry((Microsoft.SqlServer.Types.SqlGeometry)geom);
}
fdr.Geometry = sqlGeometry;
fdt.AddRow(fdr);
}
ds.Tables.Add(fdt);
}
}
}
}
private void DefaultGeometryDefinedMethod(GeoAPI.Geometries.IGeometry geom)
{
using (var frm = new WktGeometryCreator())
{
frm.Geometry = geom;
if (frm.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
var factory = _geometryProvider.Factory;
if (factory == null)
{
throw new InvalidOperationException("Feature provider does not have a IFeatureFactory");
}
var f = _geometryProvider.Factory.Create(frm.Geometry);
_geometryProvider.Features.Add(f);
if (MapControl != null)
{
var map = MapControl.Map ?? new Map();
if (!map.Layers.Contains(_layer))
{
map.Layers.Add(_layer);
}
MapControl.Refresh();
}
}
}
}
/// <summary>
/// Returns the features that intersects with 'geom'
/// </summary>
/// <param name="geom"></param>
/// <param name="ds">FeatureDataSet to fill data into</param>
protected override void OnExecuteIntersectionQuery(Geometry geom, FeatureDataSet ds)
{
using (var conn = new OracleConnection(ConnectionString))
{
string strGeom = "MDSYS.SDO_GEOMETRY('" + geom.AsText() + "', #SRID#)";
strGeom = strGeom.Replace("#SRID#", SRID > 0 ? SRID.ToString(Map.NumberFormatEnUs) : "NULL");
strGeom = "SDO_RELATE(g." + GeometryColumn + ", " + strGeom +
", 'mask=ANYINTERACT querytype=WINDOW') = 'TRUE'";
string strSql = "SELECT * FROM " +
Table + " g WHERE ";
if (!String.IsNullOrEmpty(_definitionQuery))
{
strSql += DefinitionQuery + " AND ";
}
strSql += strGeom;
using (var adapter = new OracleDataAdapter(strSql, conn))
{
conn.Open();
adapter.Fill(ds);
conn.Close();
if (ds.Tables.Count > 0)
{
var fdt = new FeatureDataTable(ds.Tables[0]);
foreach (DataColumn col in ds.Tables[0].Columns)
{
if (string.Compare(col.ColumnName, GeometryColumn, CultureInfo.InvariantCulture, CompareOptions.OrdinalIgnoreCase) != 0)
{
fdt.Columns.Add(col.ColumnName, col.DataType, col.Expression);
}
}
foreach (DataRow dr in ds.Tables[0].Rows)
{
var fdr = fdt.NewRow();
foreach (DataColumn col in ds.Tables[0].Columns)
{
if (string.Compare(col.ColumnName, GeometryColumn, CultureInfo.InvariantCulture, CompareOptions.OrdinalIgnoreCase) != 0)
{
fdr[col.ColumnName] = dr[col];
}
}
var sdoGeometry = dr[GeometryColumn] as SdoGeometry;
if (sdoGeometry != null)
{
fdr.Geometry = sdoGeometry.AsGeometry();
}
fdt.AddRow(fdr);
}
ds.Tables.Add(fdt);
}
}
}
}
/// <summary>
/// This method takes a pre-populated FeatureDataTable and removes rows that do not truly intersect testGeometry
/// </summary>
/// <param name="featureDataTable">The FeatureDataTable instance to filter</param>
/// <param name="testGeometry">the geometry to compare against</param>
public void PostFilterExistingFeatureDataTable(FeatureDataTable featureDataTable, SMGeometry testGeometry)
{
//first we create a new GeometryFactory.
var geometryFactory = new GeometryFactory();
//then we convert the testGeometry into the equivalent NTS geometry
GeoAPI.Geometries.IGeometry testGeometryAsNtsGeom = GeometryConverter.ToNTSGeometry(testGeometry, geometryFactory);
//now we loop backwards through the FeatureDataTable
for (int i = featureDataTable.Rows.Count - 1; i > -1; i--)
{
//we get each row
FeatureDataRow featureDataRow = featureDataTable.Rows[i] as FeatureDataRow;
//and get the rows' geometry
SMGeometry compareGeometry = featureDataRow.Geometry;
//convert the rows' geometry into the equivalent NTS geometry
GeoAPI.Geometries.IGeometry compareGeometryAsNts = GeometryConverter.ToNTSGeometry(compareGeometry, geometryFactory);
//now test for intesection (note other operations such as Contains, Within, Disjoint etc can all be done the same way)
bool intersects = testGeometryAsNtsGeom.Intersects(compareGeometryAsNts);
//if it doesn't intersect remove the row.
if (!intersects)
{
featureDataTable.Rows.RemoveAt(i);
}
}
}
/// <summary>
/// Returns the geometry corresponding to the Object ID
/// </summary>
/// <param name="oid">Object ID</param>
/// <returns>geometry</returns>
public override Geometry GetGeometryByID(uint oid)
{
Geometry geom = null;
using (var conn = new OracleConnection(ConnectionString))
{
string strSql = "SELECT g." + GeometryColumn + " as Geom FROM " + Table + " g WHERE " + ObjectIdColumn +
"='" + oid.ToString(CultureInfo.InvariantCulture) + "'";
conn.Open();
using (var command = new OracleCommand(strSql, conn))
{
using (OracleDataReader dr = command.ExecuteReader())
{
while (dr.Read())
{
if (dr[0] != DBNull.Value)
{
var sdoGeom = dr[0] as SdoGeometry;
if (sdoGeom != null)
{
geom = sdoGeom.AsGeometry();
}
}
}
}
}
conn.Close();
}
return(geom);
}
/// <summary>
/// Returns the geometry corresponding to the Object ID
/// </summary>
/// <param name="oid">Object ID</param>
/// <returns>geometry</returns>
public override Geometry GetGeometryByOid(object oid)
{
Geometry geom = null;
using (SqlConnection conn = new SqlConnection(ConnectionString))
{
string strSQL = "SELECT g." + GeometryColumn + " FROM " + Table + " g WHERE " + ObjectIdColumn + "='" + oid + "'";
conn.Open();
using (SqlCommand command = new SqlCommand(strSQL, conn))
{
using (SqlDataReader dr = command.ExecuteReader())
{
var spatialReader = CreateReader();
while (dr.Read())
{
if (dr[0] != DBNull.Value)
{
geom = spatialReader.Read(dr[0]);
}
}
}
}
conn.Close();
}
return(geom);
}
public void Operations()
{
//Prepare data
Geometry gPn = GeometryFromWKT.Parse(Point);
gPn.SRID = 0;
Geometry gMp = GeometryFromWKT.Parse(Multipoint);
gMp.SRID = 0;
Geometry gLi = GeometryFromWKT.Parse(Linestring);
gLi.SRID = 0;
Geometry gML = GeometryFromWKT.Parse(MultiLinestring);
gML.SRID = 0;
Geometry gPl = GeometryFromWKT.Parse(Polygon);
gPl.SRID = 0;
Geometry gPnBuffer30 = SpatialOperationsEx.Buffer(gPn, 30);
System.Diagnostics.Trace.WriteLine(gPnBuffer30.ToString());
Geometry gPnBuffer30IntersectiongPl = SpatialOperationsEx.Intersection(gPnBuffer30, gPl);
System.Diagnostics.Trace.WriteLine(gPnBuffer30IntersectiongPl.ToString());
Geometry gUnion = SpatialOperationsEx.Union(gPn, gMp, gML, gLi, gPl);
System.Diagnostics.Trace.WriteLine(gUnion.ToString());
}
/// <summary>
/// Returns the features that intersects with 'geom'
/// </summary>
/// <param name="geom"></param>
/// <param name="fcs">FeatureDataSet to fill data into</param>
/// <param name="cancellationToken">A cancellation token</param>
protected override void OnExecuteIntersectionQuery(Geometry geom, IFeatureCollectionSet fcs, CancellationToken?cancellationToken = null)
{
using (SqlConnection conn = new SqlConnection(ConnectionString))
{
string strGeom = SpatialObjectType + "::STGeomFromText('" + geom.AsText() + "', #SRID#)";
strGeom = strGeom.Replace("#SRID#", SRID > 0 ? SRID.ToString(NumberFormatInfo.InvariantInfo) : "0");
strGeom = GeometryColumn + ".STIntersects(" + strGeom + ") = 1";
string strSQL = "SELECT g.* FROM " + Table + " g " + BuildTableHints() + " WHERE ";
if (!String.IsNullOrEmpty(DefinitionQuery))
{
strSQL += DefinitionQuery + " AND ";
}
strSQL += strGeom;
string extraOptions = GetExtraOptions();
if (!string.IsNullOrEmpty(extraOptions))
{
strSQL += " " + extraOptions;
}
var ds = (System.Data.DataSet) new FeatureDataSet();
using (SqlDataAdapter adapter = new SqlDataAdapter(strSQL, conn))
{
conn.Open();
adapter.Fill(ds);
conn.Close();
if (ds.Tables.Count > 0)
{
FeatureDataTable fdt = new FeatureDataTable(ds.Tables[0]);
foreach (System.Data.DataColumn col in ds.Tables[0].Columns)
{
if (col.ColumnName != GeometryColumn)
{
fdt.Columns.Add(col.ColumnName, col.DataType, col.Expression);
}
}
var geometryReader = CreateReader();
foreach (System.Data.DataRow dr in ds.Tables[0].Rows)
{
FeatureDataRow fdr = fdt.NewRow();
foreach (System.Data.DataColumn col in ds.Tables[0].Columns)
{
if (col.ColumnName != GeometryColumn)
{
fdr[col.ColumnName] = dr[col];
}
}
fdr.Geometry = geometryReader.Read(dr[GeometryColumn]);
fdt.AddRow(fdr);
}
fcs.Add(fdt);
}
}
}
}
public void FailingConversions()
{
//Prepare data
const string invalidMultiPolygon = "MULTIPOLYGON (((20 20, 20 30, 30 30, 30 20, 20 20)), ((21 21, 21 29, 29 29, 29 21, 21 21)))";
Geometry gMP = GeometryFromWKT.Parse(invalidMultiPolygon);
Assert.AreEqual(gMP, ToSqlServerAndBack(gMP));
}
public Photo(System.Drawing.Image i, ScreenManager.SGISEnvelope b)
{
Pic = i;
Bounds = new ScreenManager.SGISEnvelope(b);
OgcCompliantGeometryFactory fact = new OgcCompliantGeometryFactory();
Geometry = fact.ToGeometry(b);
}
public static Geometry Union(Geometry g, params Geometry[] geometries)
{
SqlGeometry sg = SqlGeometryConverter.ToSqlGeometry(g);
foreach (SqlGeometry sgUnion in SqlGeometryConverter.ToSqlGeometries(geometries))
{
sg = sg.STUnion(sgUnion);
}
return SqlGeometryConverter.ToSharpMapGeometry(sg);
}
private void txtWkt_TextChanged(object sender, EventArgs e)
{
var txt = txtWkt.Text;
if (string.IsNullOrEmpty(txt))
return;
GeoAPI.Geometries.IGeometry geometry = null;
try
{
geometry = _wktReader.Read(txt);
if (geometry != _geometry)
Geometry = geometry;
txtWkt.ForeColor = SystemColors.WindowText;
lblError.Text = "No Errors";
}
catch (Exception ex)
{
txtWkt.ForeColor = Color.Red;
lblError.Text = ex.Message;
}
}
/// <summary>
/// Returns true if otherGeometry is wholly contained within the source geometry. This is the same as
/// reversing the primary and comparison shapes of the Within operation.
/// </summary>
/// <param name="g1">Source geometry</param>
/// <param name="g2">Other geometry</param>
/// <returns>True if otherGeometry is wholly contained within the source geometry.</returns>
public static bool Contains(Geometry g1, Geometry g2)
{
SqlGeometry sg1 = SqlGeometryConverter.ToSqlGeometry(g1);
SqlGeometry sg2 = SqlGeometryConverter.ToSqlGeometry(g2);
return (bool)(sg1.STContains(sg2));
}
/// <summary>
/// Returns true if there is any intersection between the two geometries.
/// </summary>
/// <param name="g1">Source geometry</param>
/// <param name="g2">Other geometry</param>
/// <returns></returns>
public static bool Intersects(Geometry g1, Geometry g2)
{
SqlGeometry sg1 = SqlGeometryConverter.ToSqlGeometry(g1);
SqlGeometry sg2 = SqlGeometryConverter.ToSqlGeometry(g2);
return (bool) sg1.STIntersects(sg2);
}
protected override void OnExecuteIntersectionQuery(Geometry geom, FeatureDataSet ds)
{
ExecuteIntersectionQuery(geom.EnvelopeInternal, ds);
//index of last added feature data table
var index = ds.Tables.Count - 1;
if (index <= 0) return;
var res = CloneTableStructure(ds.Tables[index]);
res.BeginLoadData();
var fdt = ds.Tables[index];
foreach (FeatureDataRow row in fdt.Rows)
{
if (PreparedGeometry.Intersects(row.Geometry))
{
var fdr = (FeatureDataRow)res.LoadDataRow(row.ItemArray, true);
fdr.Geometry = row.Geometry;
}
}
res.EndLoadData();
ds.Tables.RemoveAt(index);
ds.Tables.Add(res);
}
public static Geometry ConvexHull(Geometry g)
{
SqlGeometry sg = SqlGeometryConverter.ToSqlGeometry(g);
SqlGeometry sgConvexHull = sg.STConvexHull();
return SqlGeometryConverter.ToSharpMapGeometry(sgConvexHull);
}
public static Geometry Buffer(Geometry g, Double distance)
{
SqlGeometry sg = SqlGeometryConverter.ToSqlGeometry(g);
SqlGeometry sgBuffer = sg.STBuffer(distance);
return SqlGeometryConverter.ToSharpMapGeometry(sgBuffer);
}
public static Geometry Boundary(Geometry g)
{
SqlGeometry sg = SqlGeometryConverter.ToSqlGeometry(g);
SqlGeometry sgBoundary = sg.STBoundary();
return SqlGeometryConverter.ToSharpMapGeometry(sgBoundary);
}
/// <summary>
/// Returns the data associated with all the geometries that are intersected by 'geom'
/// </summary>
/// <param name="geom">Geometry to intersect with</param>
/// <param name="ds">FeatureDataSet to fill data into</param>
protected override void OnExecuteIntersectionQuery(Geometry geom, IFeatureCollectionSet fcs, CancellationToken? ct = null)
{
using (var ogrGeometry = OgrGeometry.CreateFromWkb(GeometryToWKB.Write(geom)))
{
_ogrLayer.SetSpatialFilter(ogrGeometry);
var fds = new FeatureDataSet();
ExecuteIntersectionQuery(fds);
foreach (var fd in fds) fcs.Add(fd);
}
}
/// <summary>
/// Returns the features that intersects with 'geom'
/// </summary>
/// <param name="geom"></param>
/// <param name="ds">FeatureDataSet to fill data into</param>
protected override void OnExecuteIntersectionQuery(Geometry geom, FeatureDataSet ds)
{
using (var conn = new OracleConnection(ConnectionString))
{
string strGeom = "MDSYS.SDO_GEOMETRY('" + geom.AsText() + "', #SRID#)";
strGeom = strGeom.Replace("#SRID#", SRID > 0 ? SRID.ToString(Map.NumberFormatEnUs) : "NULL");
strGeom = "SDO_RELATE(g." + GeometryColumn + ", " + strGeom +
", 'mask=ANYINTERACT querytype=WINDOW') = 'TRUE'";
string strSql = "SELECT * FROM " +
Table + " g WHERE ";
if (!String.IsNullOrEmpty(_definitionQuery))
strSql += DefinitionQuery + " AND ";
strSql += strGeom;
using (var adapter = new OracleDataAdapter(strSql, conn))
{
conn.Open();
adapter.Fill(ds);
conn.Close();
if (ds.Tables.Count > 0)
{
var fdt = new FeatureDataTable(ds.Tables[0]);
foreach (DataColumn col in ds.Tables[0].Columns)
if (string.Compare(col.ColumnName, GeometryColumn, CultureInfo.InvariantCulture, CompareOptions.OrdinalIgnoreCase) != 0)
fdt.Columns.Add(col.ColumnName, col.DataType, col.Expression);
foreach (DataRow dr in ds.Tables[0].Rows)
{
var fdr = fdt.NewRow();
foreach (DataColumn col in ds.Tables[0].Columns)
if (string.Compare(col.ColumnName, GeometryColumn, CultureInfo.InvariantCulture, CompareOptions.OrdinalIgnoreCase) != 0)
fdr[col.ColumnName] = dr[col];
var sdoGeometry = dr[GeometryColumn] as SdoGeometry;
if (sdoGeometry != null)
{
fdr.Geometry = sdoGeometry.AsGeometry();
}
fdt.AddRow(fdr);
}
ds.Tables.Add(fdt);
}
}
}
}
/// <summary>
/// Returns true if otherGeometry is disjoint from the source geometry.
/// </summary>
/// <param name="g1">Source geometry</param>
/// <param name="g2">Other geometry</param>
/// <returns></returns>
public static bool Disjoint(Geometry g1, Geometry g2)
{
return !g2.Intersects(g1);
}
/// <summary>
/// Returns the features that intersects with 'geom'
/// </summary>
/// <param name="geom"></param>
/// <param name="ds">FeatureDataSet to fill data into</param>
protected override void OnExecuteIntersectionQuery(Geometry geom, FeatureDataSet ds)
{
using (var conn = new OracleConnection(ConnectionString))
{
string strGeom = "MDSYS.SDO_GEOMETRY('" + geom.AsText() + "', #SRID#)";
if (SRID > 0)
{
strGeom = strGeom.Replace("#SRID#", SRID.ToString(Map.NumberFormatEnUs));
}
else
{
strGeom = strGeom.Replace("#SRID#", "NULL");
}
strGeom = "SDO_RELATE(g." + GeometryColumn + ", " + strGeom +
", 'mask=ANYINTERACT querytype=WINDOW') = 'TRUE'";
string strSQL = "SELECT g.* , g." + GeometryColumn + ").Get_WKB() As sharpmap_tempgeometry FROM " +
Table + " g WHERE ";
if (!String.IsNullOrEmpty(_definitionQuery))
strSQL += DefinitionQuery + " AND ";
strSQL += strGeom;
using (var adapter = new OracleDataAdapter(strSQL, conn))
{
conn.Open();
adapter.Fill(ds);
conn.Close();
if (ds.Tables.Count > 0)
{
var fdt = new FeatureDataTable(ds.Tables[0]);
foreach (DataColumn col in ds.Tables[0].Columns)
if (col.ColumnName != GeometryColumn && col.ColumnName != "sharpmap_tempgeometry")
fdt.Columns.Add(col.ColumnName, col.DataType, col.Expression);
foreach (DataRow dr in ds.Tables[0].Rows)
{
var fdr = fdt.NewRow();
foreach (DataColumn col in ds.Tables[0].Columns)
if (col.ColumnName != GeometryColumn && col.ColumnName != "sharpmap_tempgeometry")
fdr[col.ColumnName] = dr[col];
fdr.Geometry = GeometryFromWKB.Parse((byte[]) dr["sharpmap_tempgeometry"], Factory);
fdt.AddRow(fdr);
}
ds.Tables.Add(fdt);
}
}
}
}
private static GeoAPIGeometryCollection FromGeometryCollection(IGeometryCollection geometry, GeoAPIGeometryFactory factory, bool copyUserData)
{
var dsGeometries = new GeoAPI.Geometries.IGeometry[geometry.NumGeometries];
for (var i = 0; i < dsGeometries.Length; i++)
dsGeometries[i] = FromGeometry(geometry.GetGeometryN(i), factory, copyUserData);
var result = factory.CreateGeometryCollection(dsGeometries);
if (copyUserData)
result.UserData = geometry.UserData;
return result;
}
/// <summary>
/// Returns the features that intersects with 'geom'
/// </summary>
/// <param name="geom"></param>
/// <param name="ds">FeatureDataSet to fill data into</param>
protected override void OnExecuteIntersectionQuery(Geometry geom, FeatureDataSet ds)
{
using (var conn = new SqlConnection(ConnectionString))
{
string strGeom = SpatialObject + "::STGeomFromText('" + geom.AsText() + "', #SRID#)";
strGeom = strGeom.Replace("#SRID#", SRID > 0 ? SRID.ToString(CultureInfo.InvariantCulture) : "0");
strGeom = GeometryColumn + ".STIntersects(" + strGeom + ") = 1";
string strSql = "SELECT g.* FROM " + Table + " g " + BuildTableHints() + " WHERE ";
if (!String.IsNullOrEmpty(DefinitionQuery))
strSql += DefinitionQuery + " AND ";
strSql += strGeom;
using (var adapter = new SqlDataAdapter(strSql, conn))
{
conn.Open();
adapter.Fill(ds);
conn.Close();
if (ds.Tables.Count > 0)
{
var fdt = new FeatureDataTable(ds.Tables[0]);
foreach (System.Data.DataColumn col in ds.Tables[0].Columns)
if (col.ColumnName != GeometryColumn)
fdt.Columns.Add(col.ColumnName, col.DataType, col.Expression);
foreach (System.Data.DataRow dr in ds.Tables[0].Rows)
{
FeatureDataRow fdr = fdt.NewRow();
foreach (System.Data.DataColumn col in ds.Tables[0].Columns)
if (col.ColumnName != GeometryColumn)
fdr[col.ColumnName] = dr[col];
var ogeom = dr[GeometryColumn];
Geometry sqlGeometry = null;
if (ogeom != null && ogeom != DBNull.Value)
sqlGeometry = SqlGeometryConverter.ToSharpMapGeometry((Microsoft.SqlServer.Types.SqlGeometry)ogeom);
fdr.Geometry = sqlGeometry;
fdt.AddRow(fdr);
}
ds.Tables.Add(fdt);
}
}
}
}
/// <summary>
/// Returns the features that intersects with 'geom'
/// </summary>
/// <param name="geom">Geometry</param>
/// <returns>FeatureDataTable</returns>
public FeatureDataTable ExecuteIntersectionQuery(Geometry geom)
{
var fds = new FeatureDataSet();
ExecuteIntersectionQuery(geom, fds);
return fds.Tables[0];
}
public FeatureDataTable QueryFeatures(Geometry geom, double distance)
{
throw new NotSupportedException();
}
/// <summary>
/// Returns the data associated with all the geometries that are intersected by 'geom'
/// </summary>
/// <param name="geom">Geometry to intersect with</param>
/// <param name="ds">FeatureDataSet to fill data into</param>
protected override void OnExecuteIntersectionQuery(Geometry geom, FeatureDataSet ds)
{
using (var ogrGeometry = OgrGeometry.CreateFromWkb(GeometryToWKB.Write(geom)))
{
_ogrLayer.SetSpatialFilter(ogrGeometry);
ExecuteIntersectionQuery(ds);
}
}
/// <summary>
/// Returns true if the given geometries relate according to the provided intersection pattern Matrix
/// </summary>
/// <param name="g1">Source geometry</param>
/// <param name="g2">Other geometry</param>
/// <param name="intersectionPatternMatrix">Intersection pattern Matrix</param>
/// <returns></returns>
public static Boolean Relate(Geometry g1, Geometry g2, string intersectionPatternMatrix)
{
SqlGeometry sg1 = SqlGeometryConverter.ToSqlGeometry(g1);
SqlGeometry sg2 = SqlGeometryConverter.ToSqlGeometry(g2);
return (bool)sg1.STRelate(sg2, intersectionPatternMatrix);
}
/// <summary>
/// Returns true if the intersection of the two geometries results in a geometry whose dimension is less than
/// the maximum dimension of the two geometries and the intersection geometry is not equal to either.
/// geometry.
/// </summary>
/// <param name="g1">Source geometry</param>
/// <param name="g2">Other geometry</param>
/// <returns></returns>
public static bool Crosses(Geometry g1, Geometry g2)
{
SqlGeometry sg1 = SqlGeometryConverter.ToSqlGeometry(g1);
SqlGeometry sg2 = SqlGeometryConverter.ToSqlGeometry(g2);
return (bool)sg1.STCrosses(sg2);
}
private Geometry ToSqlServerAndBack(Geometry gIn)
{
Assert.That(gIn, Is.Not.Null);
Assert.That(gIn.SRID, Is.EqualTo(-1));
gIn.SRID = 0;
SqlGeometry sqlGeometry = SqlGeometryConverter.ToSqlGeometry(gIn);
Geometry gOut = SqlGeometryConverter.ToSharpMapGeometry(sqlGeometry, new NetTopologySuite.Geometries.GeometryFactory());
return gOut;
}
/// <summary>
/// Returns true if the primary geometry is wholly contained within the comparison geometry.
/// </summary>
/// <param name="g1">Source geometry</param>
/// <param name="g2">Other geometry</param>
/// <returns></returns>
public static bool Within(Geometry g1, Geometry g2)
{
SqlGeometry sg1 = SqlGeometryConverter.ToSqlGeometry(g1);
SqlGeometry sg2 = SqlGeometryConverter.ToSqlGeometry(g2);
return (bool)sg1.STWithin(sg2);
}
