/// <summary> /// Returns the geometry corresponding to the Object ID /// </summary> /// <param name="oid">Object ID</param> /// <returns>geometry</returns> public IGeometry GetGeometryByID(int 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); }
/// <summary> /// Returns the data associated with all the geometries that are intersected by 'geom' /// </summary> /// <param name="geometry">Geometry to intersect with</param> /// <param name="ds">FeatureDataSet to fill data into</param> public void ExecuteIntersectionQuery(IGeometry geometry, FeatureDataSet ds) { if (CoordinateTransformation != null) { #if !DotSpatialProjections if (ReverseCoordinateTransformation != null) { geometry = GeometryTransform.TransformGeometry(geometry, ReverseCoordinateTransformation.MathTransform, GeometryServiceProvider.Instance.CreateGeometryFactory((int)ReverseCoordinateTransformation.TargetCS.AuthorityCode)); } else { CoordinateTransformation.MathTransform.Invert(); geometry = GeometryTransform.TransformGeometry(geometry, CoordinateTransformation.MathTransform, GeometryServiceProvider.Instance.CreateGeometryFactory((int)CoordinateTransformation.SourceCS.AuthorityCode)); CoordinateTransformation.MathTransform.Invert(); } #else geometry = GeometryTransform.TransformGeometry(geometry, CoordinateTransformation.Target, CoordinateTransformation.Source, CoordinateTransformation.SourceFactory); #endif } lock (_dataSource) { _dataSource.Open(); _dataSource.ExecuteIntersectionQuery(geometry, ds); _dataSource.Close(); } }
/// <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] is 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(); } } }
/// <summary> /// Method to insert a new feature to the tree /// </summary> /// <param name="fid">The feature's id</param> /// <param name="geometry">The feature's geometry</param> public void Insert(uint fid, GeoAPI.Geometries.IGeometry geometry) { Interval x, y, z, m; GeometryMetricExtensions.GetMetric(geometry, out x, out y, out z, out m); Insert(fid, geometry.EnvelopeInternal, z, m); }
public static SqlGeometry ToSqlGeometry(SMGeometry smGeometry) { SqlGeometryBuilder builder = new SqlGeometryBuilder(); builder.SetSrid(smGeometry.SRID); SharpMapGeometryToSqlGeometry(builder, smGeometry); SqlGeometry g = builder.ConstructedGeometry; if (!g.STIsValid()) { try { g = g.Reduce(ReduceTolerance); g = g.MakeValid(); } catch (Exception ex) { throw new SqlGeometryConverterException(ex, smGeometry); } } if (!g.STIsValid()) { throw new SqlGeometryConverterException(smGeometry); } return(g); }
/// <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 + ".Get_WKB() 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) { geom = GeometryFromWKB.Parse((byte[])dr[0], Factory); } } } } 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 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 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]); }
/// <summary> /// /// </summary> /// <param name="other"></param> /// <param name="tolerance"></param> /// <returns></returns> public override bool EqualsExact(GeoAPI.Geometries.IGeometry other, double tolerance) { if (!IsEquivalentClass(other)) { return(false); } return(base.EqualsExact(other, tolerance)); }
/// <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); } }
void mapBox1_GeometryDefined(GeoAPI.Geometries.IGeometry geometry) { MessageBox.Show("Geometry defined!\r\n" + geometry); geoProvider.Geometries.Add(geometry); this.mapBox1.ActiveTool = SharpMap.Forms.MapBox.Tools.Pan; this.mapBox1.Refresh(); }
/// <summary> /// Returns the data associated with all the geometries that are intersected by 'geom' /// </summary> /// <param name="geometry">Geometry to intersect with</param> /// <param name="ds">FeatureDataSet to fill data into</param> public void ExecuteIntersectionQuery(IGeometry geometry, FeatureDataSet ds) { geometry = ToSource(geometry); lock (_dataSource) { _dataSource.Open(); _dataSource.ExecuteIntersectionQuery(geometry, ds); _dataSource.Close(); } }
/* * private static OpenGisGeometryType ParseGeometryType(string stGeometryType) * { * switch (stGeometryType.ToUpper()) * { * case "POINT": * return OpenGisGeometryType.Point; * case "LINESTRING": * return OpenGisGeometryType.LineString; * case "POLYGON": * return OpenGisGeometryType.Polygon; * case "MULTIPOINT": * return OpenGisGeometryType.MultiPoint; * case "MULTILINESTRING": * return OpenGisGeometryType.MultiLineString; * case "MULTIPOLYGON": * return OpenGisGeometryType.MultiPolygon; * case "GEOMETRYCOLLECTION": * return OpenGisGeometryType.GeometryCollection; * } * throw new ArgumentException(String.Format("Invalid geometrytype '{0}'!", stGeometryType), "stGeometryType"); * } */ private static SMGeometryCollection SqlGeometryToSharpMapGeometryCollection(SqlGeometry geometry, Factory factory) { var fact = factory ?? Services.CreateGeometryFactory((int)geometry.STSrid); var geoms = new SMGeometry[(int)geometry.STNumGeometries()]; for (var i = 1; i <= geometry.STNumGeometries(); i++) { geoms[i - 1] = ToSharpMapGeometry(geometry.STGeometryN(i), fact); } return(fact.CreateGeometryCollection(geoms)); }
/// <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 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); } } } }
/// <summary> /// Converts any <see cref="SharpMap.Geometries.Geometry"/> array to the correspondant /// <see cref="GisSharpBlog.NetTopologySuite.Geometries.Geometry" /> array. /// </summary> public static NTSGeometry[] ToNTSGeometry(Geometries.Geometry[] geometries, IGeometryFactory factory) { NTSGeometry[] converted = new NTSGeometry[geometries.Length]; int index = 0; foreach (Geometries.Geometry geometry in geometries) converted[index++] = ToNTSGeometry(geometry, factory); if ((geometries.Length != converted.Length)) throw new ApplicationException("Conversion error"); return converted; }
internal static NTSGeometryCollection ToNTSGeometryCollection(Geometries.GeometryCollection geom, IGeometryFactory factory) { NTSGeometry[] geometries = new NTSGeometry[geom.Collection.Count]; int index = 0; foreach (Geometries.Geometry geometry in geom.Collection) { geometries[index++] = ToNTSGeometry(geometry, factory); } return(factory.CreateGeometryCollection(geometries) as NTSGeometryCollection); }
/// <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))) { OgrDataSource ogrDataSource; using (var ogrLayer = GetLayer(_layerIndex, out ogrDataSource)) { ogrLayer.SetSpatialFilter(ogrGeometry); ExecuteIntersectionQuery(ds, ogrLayer); ogrDataSource.Dispose(); } } }
/// <summary> /// /// </summary> /// <param name="geom"></param> /// <param name="ds"></param> public void ExecuteIntersectionQuery(Geometry geom, FeatureDataSet ds) { GeoAPI.Geometries.IGeometry geometry = GeometryConverter.ToNTSGeometry(geom, _geometryFactory); FeatureDataTable dataTable = CreateFeatureDataTable(); foreach (Feature feature in _features) { if (feature.Geometry.Intersects(geometry)) { CreateNewRow(dataTable, feature); } } ds.Tables.Add(dataTable); }
/// <summary> /// Converts any <see cref="SharpMap.Geometries.Geometry"/> array to the correspondant /// <see cref="GisSharpBlog.NetTopologySuite.Geometries.Geometry" /> array. /// </summary> public static NTSGeometry[] ToNTSGeometry(Geometries.Geometry[] geometries, IGeometryFactory factory) { NTSGeometry[] converted = new NTSGeometry[geometries.Length]; int index = 0; foreach (Geometries.Geometry geometry in geometries) { converted[index++] = ToNTSGeometry(geometry, factory); } if ((geometries.Length != converted.Length)) { throw new ApplicationException("Conversion error"); } return(converted); }
/// <summary> /// /// </summary> /// <param name="geom"></param> /// <param name="ds"></param> protected override void OnExecuteIntersectionQuery(Geometry geom, FeatureDataSet ds) { FeatureDataTable dataTable = CreateFeatureDataTable(); dataTable.BeginLoadData(); foreach (Feature feature in _features) { if (PreparedGeometry.Intersects(feature.Geometry)) { CreateNewRow(dataTable, feature); } } dataTable.EndLoadData(); ds.Tables.Add(dataTable); }
private void transform_Click(object sender, EventArgs e) { if (vlay == null) { return; } if (vlay.DataSource == null) { MessageBox.Show("请先载入shp文件"); } else { if (!vlay.DataSource.IsOpen) { vlay.DataSource.Open(); } SharpMap.Data.Providers.ShapeFile shapefile = (SharpMap.Data.Providers.ShapeFile)vlay.DataSource; int geoCount = shapefile.GetFeatureCount(); string writefile = null; saveFileDialog1.Filter = "(*.txt*)|*.txt"; if (saveFileDialog1.ShowDialog() == DialogResult.OK) { writefile = saveFileDialog1.FileName; } if (writefile == null) { MessageBox.Show("输出文件不能为空,请正确选择"); return; } FileStream fs = new FileStream(writefile, FileMode.Append); StreamWriter sw = new StreamWriter(fs, Encoding.Default); for (int i = 0; i < geoCount; i++) { GeoAPI.Geometries.IGeometry geo = shapefile.GetGeometryByID(Convert.ToUInt32(i)); sw.Write(geo + "\n"); } // Console.WriteLine(geo); vlay.DataSource.Close(); sw.Close(); fs.Close(); MessageBox.Show("文件已转换完毕!"); } }
/// <summary> /// Throws NotSupportedException. /// </summary> /// <param name="geom"></param> public IEnumerable <IFeature> GetFeatures(GeoAPI.Geometries.IGeometry geom) { throw new NotSupportedException("GetFeatures(Geometry) is not supported by the OleDbPointProvider."); //When relation model has been implemented the following will complete the query /* * GetFeatures(geom.GetBoundingBox(), ds); * if (ds.Tables.Count > 0) * { * for(int i=ds.Tables[0].Count-1;i>=0;i--) * { * if (!geom.Intersects(ds.Tables[0][i].Geometry)) * ds.Tables.RemoveAt(i); * } * } */ }
/// <summary> /// Converts any <see cref="SharpMap.Geometries.Geometry"/> to the correspondant /// <see cref="GisSharpBlog.NetTopologySuite.Geometries.Geometry"/>. /// </summary> public static Geometries.Geometry ToSharpMapGeometry(NTSGeometry geometry) { if (geometry == null) { throw new NullReferenceException("geometry"); } if (TypeOf(geometry, typeof(NTSPoint))) { return(ToSharpMapPoint(geometry as NTSPoint)); } if (TypeOf(geometry, typeof(NTSLineString))) { return(ToSharpMapLineString(geometry as NTSLineString)); } if (TypeOf(geometry, typeof(NTSPolygon))) { return(ToSharpMapPolygon(geometry as NTSPolygon)); } if (TypeOf(geometry, typeof(NTSMultiPoint))) { return(ToSharpMapMultiPoint(geometry as NTSMultiPoint)); } if (TypeOf(geometry, typeof(NTSMultiLineString))) { return(ToSharpMapMultiLineString(geometry as NTSMultiLineString)); } if (TypeOf(geometry, typeof(NTSMultiPolygon))) { return(ToSharpMapMultiPolygon(geometry as NTSMultiPolygon)); } if (TypeOf(geometry, typeof(NTSGeometryCollection))) { return(ToSharpMapGeometryCollection(geometry as NTSGeometryCollection)); } var message = String.Format("Type {0} not supported", geometry.GetType().FullName); throw new NotSupportedException(message); }
/// <summary> /// Returns geometries within the specified bounding box /// </summary> /// <param name="bbox"></param> /// <returns></returns> public override Collection <Geometry> GetGeometriesInView(Envelope bbox) { var features = new Collection <Geometry>(); using (var conn = new OracleConnection(ConnectionString)) { //Get bounding box string string strBbox = GetBoxFilterStr(bbox); //string strSQL = "SELECT AsBinary(" + this.GeometryColumn + ") AS Geom "; string strSql = "SELECT g." + GeometryColumn + ".Get_WKB() "; strSql += " FROM " + Table + " g WHERE "; if (!String.IsNullOrEmpty(_definitionQuery)) { strSql += DefinitionQuery + " AND "; } strSql += strBbox; using (var command = new OracleCommand(strSql, conn)) { conn.Open(); using (OracleDataReader dr = command.ExecuteReader()) { while (dr.Read()) { if (dr[0] != DBNull.Value) { Geometry geom = GeometryFromWKB.Parse((byte[])dr[0], Factory); if (geom != null) { features.Add(geom); } } } } conn.Close(); } } return(features); }
/// <summary> /// Returns geometries within the specified bounding box /// </summary> /// <param name="bbox"></param> /// <returns></returns> public ICollection <IGeometry> GetGeometriesInView(IEnvelope bbox, double minGeometrySize) { Collection <IGeometry> features = new Collection <IGeometry>(); using (SqlConnection conn = new SqlConnection(_ConnectionString)) { string strSQL = "SELECT ST.AsBinary(" + this.BuildGeometryExpression() + ") "; strSQL += "FROM ST.FilterQuery" + this.BuildSpatialQuerySuffix() + "(" + this.BuildEnvelope(bbox) + ")"; if (!String.IsNullOrEmpty(this.DefinitionQuery)) { strSQL += " WHERE " + this.DefinitionQuery; } if (!String.IsNullOrEmpty(this.OrderQuery)) { strSQL += " ORDER BY " + this.OrderQuery; } using (SqlCommand command = new SqlCommand(strSQL, conn)) { conn.Open(); using (SqlDataReader dr = command.ExecuteReader()) { while (dr.Read()) { if (dr[0] != DBNull.Value) { GeoAPI.Geometries.IGeometry geom = SharpMap.Converters.WellKnownBinary.GeometryFromWKB.Parse((byte[])dr[0]); if (geom != null) { features.Add(geom); } } } } conn.Close(); } } return(features); }
/// <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) { DataRow[] rows; Geometry geom = null; if (Table.Rows.Count == 0) { return(null); } string selectStatement = ObjectIdColumn + " = " + oid; rows = Table.Select(selectStatement); foreach (DataRow dr in rows) { geom = Factory.CreatePoint(new Coordinate((double)dr[XColumn], (double)dr[YColumn])); } return(geom); }
private static bool TypeOf(NTSGeometry geometry, Type type) { if (geometry == null) { throw new ArgumentNullException("geometry"); } if (type == null) { throw new ArgumentNullException("type"); } var interfaces = geometry.GetType().GetInterfaces(); foreach (Type item in interfaces) { if (item == type) { return(true); } } return(false); }
/// <summary> /// Returns geometries within the specified bounding box /// </summary> /// <param name="bbox"></param> /// <returns></returns> public ICollection <IGeometry> GetGeometriesInView(IEnvelope bbox, double minGeometrySize) { Collection <GeoAPI.Geometries.IGeometry> features = new Collection <GeoAPI.Geometries.IGeometry>(); using (SqlConnection conn = new SqlConnection(_ConnectionString)) { string BoxIntersect = GetBoxClause(bbox); string strSQL = "SELECT " + this.GeometryColumn + " AS Geom "; strSQL += "FROM " + this.Table + " WHERE "; strSQL += BoxIntersect; if (!String.IsNullOrEmpty(_defintionQuery)) { strSQL += " AND " + this.DefinitionQuery; } using (SqlCommand command = new SqlCommand(strSQL, conn)) { conn.Open(); using (SqlDataReader dr = command.ExecuteReader()) { while (dr.Read()) { if (dr[0] != DBNull.Value) { GeoAPI.Geometries.IGeometry geom = SharpMap.Converters.WellKnownBinary.GeometryFromWKB.Parse((byte[])dr[0]); if (geom != null) { features.Add(geom); } } } } conn.Close(); } } return(features); }
public static SqlGeometry ToSqlGeometry(SMGeometry smGeometry) { SqlGeometryBuilder builder = new SqlGeometryBuilder(); //#if !DotSpatialProjections // if (smGeometry.SpatialReference != null) // builder.SetSrid((int) smGeometry.SpatialReference.AuthorityCode); //#else // if (smGeometry.SpatialReference != null) // builder.SetSrid((int) smGeometry.SpatialReference.EpsgCode); //#endif // else builder.SetSrid(smGeometry.SRID); SharpMapGeometryToSqlGeometry(builder, smGeometry); SqlGeometry g = builder.ConstructedGeometry; if (!g.STIsValid()) { try { g.Reduce(ReduceTolerance); g.MakeValid(); } catch (Exception ex) { throw new SqlGeometryConverterException(ex, smGeometry); } } if (!g.STIsValid()) { throw new SqlGeometryConverterException(smGeometry); } return(g); }
private List <LineString> GetAllLine(GeoAPI.Geometries.IGeometry polyline) { List <LineString> resultLineList = new List <LineString>(); if (polyline.GeometryType != "LineString") { return(resultLineList); } int count = polyline.Coordinates.Count(); for (int i = 0; i < count; i++) { if (i + 1 < count) { List <Coordinate> temp = new List <Coordinate>() { polyline.Coordinates[i], polyline.Coordinates[i + 1] }; LineString line = new LineString(temp.ToArray()); resultLineList.Add(line); } } return(resultLineList); }
/// <summary> /// Returns the geometry corresponding to the Object ID /// </summary> /// <param name="oid">Object ID</param> /// <returns>geometry</returns> public IGeometry GetGeometryByID(int oid) { GeoAPI.Geometries.IGeometry geom = null; using (SqlConnection conn = new SqlConnection(this.ConnectionString)) { string strSQL = "SELECT ST.AsBinary(" + this.BuildGeometryExpression() + ") AS Geom FROM " + this.Table + " WHERE " + this.ObjectIdColumn + "='" + oid.ToString() + "'"; conn.Open(); using (SqlCommand command = new SqlCommand(strSQL, conn)) { using (SqlDataReader dr = command.ExecuteReader()) { while (dr.Read()) { if (dr[0] != DBNull.Value) { geom = SharpMap.Converters.WellKnownBinary.GeometryFromWKB.Parse((byte[])dr[0]); } } } } conn.Close(); } return(geom); }
public SqlGeometryConverterException(Exception inner, SMGeometry geometry) : this("Failed to convert SharpMapGeometry", inner, geometry) { }
private static void SharpMapGeometryToSqlGeometry(SqlGeometryBuilder geomBuilder, SMGeometry smGeometry) { switch (smGeometry.OgcGeometryType) { case SMGeometryType.Point: SharpMapPointToSqlGeometry(geomBuilder, smGeometry as SMPoint); break; case SMGeometryType.LineString: SharpMapLineStringToSqlGeometry(geomBuilder, smGeometry as SMLineString); break; case SMGeometryType.Polygon: SharpMapPolygonToSqlGeometry(geomBuilder, smGeometry as SMPolygon); break; case SMGeometryType.MultiPoint: SharpMapMultiPointToSqlGeometry(geomBuilder, smGeometry as SMMultiPoint); break; case SMGeometryType.MultiLineString: SharpMapMultiLineStringToSqlGeometry(geomBuilder, smGeometry as SMMultiLineString); break; case SMGeometryType.MultiPolygon: SharpMapMultiPolygonToSqlGeometry(geomBuilder, smGeometry as SMMultiPolygon); break; case SMGeometryType.GeometryCollection: SharpMapGeometryCollectionToSqlGeometry(geomBuilder, smGeometry as SMGeometryCollection); break; default: throw new ArgumentException( String.Format("Cannot convert '{0}' geometry type", smGeometry.GeometryType), "smGeometry"); } }
/// <summary> /// Returns the data associated with all the geometries that are intersected by 'geom' /// </summary> /// <param name="geometry">Geometry to intersect with</param> /// <param name="ds">FeatureDataSet to fill data into</param> public void ExecuteIntersectionQuery(Geometry geometry, FeatureDataSet ds) { ExecuteIntersectionQuery(geometry.EnvelopeInternal, ds); }
/// <summary> /// Converts any <see cref="GisSharpBlog.NetTopologySuite.Geometries.Geometry"/> array to the correspondant /// <see cref="SharpMap.Geometries.Geometry"/> array. /// </summary> public static Geometries.Geometry[] ToSharpMapGeometry(NTSGeometry[] geometries) { Geometries.Geometry[] converted = new Geometries.Geometry[geometries.Length]; int index = 0; foreach (NTSGeometry geometry in geometries) converted[index++] = ToSharpMapGeometry(geometry); if ((geometries.Length != converted.Length)) throw new ApplicationException("Conversion error"); return converted; }
public static SqlGeometry ToSqlGeometry(SMGeometry smGeometry) { SqlGeometryBuilder builder = new SqlGeometryBuilder(); //#if !DotSpatialProjections // if (smGeometry.SpatialReference != null) // builder.SetSrid((int) smGeometry.SpatialReference.AuthorityCode); //#else // if (smGeometry.SpatialReference != null) // builder.SetSrid((int) smGeometry.SpatialReference.EpsgCode); //#endif // else builder.SetSrid(smGeometry.SRID); SharpMapGeometryToSqlGeometry(builder, smGeometry); SqlGeometry g = builder.ConstructedGeometry; if (!g.STIsValid()) { try { g.Reduce(ReduceTolerance); g.MakeValid(); } catch (Exception ex) { throw new SqlGeometryConverterException(ex, smGeometry); } } if (!g.STIsValid()) throw new SqlGeometryConverterException(smGeometry); return g; }
private static bool TypeOf(NTSGeometry geometry, Type type) { if (geometry == null) throw new ArgumentNullException("geometry"); if (type == null) throw new ArgumentNullException("type"); var interfaces = geometry.GetType().GetInterfaces(); foreach (Type item in interfaces) if (item == type) return true; return false; }
/// <summary> /// Converts any <see cref="SharpMap.Geometries.Geometry"/> to the correspondant /// <see cref="GisSharpBlog.NetTopologySuite.Geometries.Geometry"/>. /// </summary> public static Geometries.Geometry ToSharpMapGeometry(NTSGeometry geometry) { if (geometry == null) throw new NullReferenceException("geometry"); if (TypeOf(geometry, typeof(NTSPoint))) return ToSharpMapPoint(geometry as NTSPoint); if (TypeOf(geometry, typeof (NTSLineString))) return ToSharpMapLineString(geometry as NTSLineString); if (TypeOf(geometry, typeof (NTSPolygon))) return ToSharpMapPolygon(geometry as NTSPolygon); if (TypeOf(geometry, typeof (NTSMultiPoint))) return ToSharpMapMultiPoint(geometry as NTSMultiPoint); if (TypeOf(geometry, typeof (NTSMultiLineString))) return ToSharpMapMultiLineString(geometry as NTSMultiLineString); if (TypeOf(geometry, typeof (NTSMultiPolygon))) return ToSharpMapMultiPolygon(geometry as NTSMultiPolygon); if (TypeOf(geometry, typeof (NTSGeometryCollection))) return ToSharpMapGeometryCollection(geometry as NTSGeometryCollection); var message = String.Format("Type {0} not supported", geometry.GetType().FullName); throw new NotSupportedException(message); }
internal static NTSGeometryCollection ToNTSGeometryCollection(Geometries.GeometryCollection geom, IGeometryFactory factory) { NTSGeometry[] geometries = new NTSGeometry[geom.Collection.Count]; int index = 0; foreach (Geometries.Geometry geometry in geom.Collection) geometries[index++] = ToNTSGeometry(geometry, factory); return factory.CreateGeometryCollection(geometries) as NTSGeometryCollection; }
/// <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 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); } } } }
public SqlGeometryConverterException(SMGeometry geometry) : this("Failed to convert SharpMapGeometry", geometry) { Geometry = geometry; }
/// <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)) { using (var sourceDataSet = new DataSet()) { conn.Open(); adapter.Fill(sourceDataSet); conn.Close(); if (sourceDataSet.Tables.Count > 0) { var fdt = new FeatureDataTable(sourceDataSet.Tables[0]); foreach (DataColumn col in sourceDataSet.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 sourceDataSet.Tables[0].Rows) { var fdr = fdt.NewRow(); foreach (DataColumn col in sourceDataSet.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); } } } } }
public FeatureDataTable QueryFeatures(Geometry geom, double distance) { throw new NotSupportedException(); }
/// <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]; }
/// <summary> /// /// </summary> /// <param name="geom"></param> /// <param name="ds"></param> protected override void OnExecuteIntersectionQuery(Geometry geom, FeatureDataSet ds) { FeatureDataTable dataTable = CreateFeatureDataTable(); dataTable.BeginLoadData(); foreach (Feature feature in _features) if (PreparedGeometry.Intersects(feature.Geometry)) CreateNewRow(dataTable, feature); dataTable.EndLoadData(); ds.Tables.Add(dataTable); }
public SqlGeometryConverterException(string message, Exception inner, SMGeometry geometry) : base(message, inner) { Geometry = geometry; }
/* private static OpenGisGeometryType ParseGeometryType(string stGeometryType) { switch (stGeometryType.ToUpper()) { case "POINT": return OpenGisGeometryType.Point; case "LINESTRING": return OpenGisGeometryType.LineString; case "POLYGON": return OpenGisGeometryType.Polygon; case "MULTIPOINT": return OpenGisGeometryType.MultiPoint; case "MULTILINESTRING": return OpenGisGeometryType.MultiLineString; case "MULTIPOLYGON": return OpenGisGeometryType.MultiPolygon; case "GEOMETRYCOLLECTION": return OpenGisGeometryType.GeometryCollection; } throw new ArgumentException(String.Format("Invalid geometrytype '{0}'!", stGeometryType), "stGeometryType"); } */ private static SMGeometryCollection SqlGeometryToSharpMapGeometryCollection(SqlGeometry geometry, Factory factory) { var fact = factory ?? Services.CreateGeometryFactory((int)geometry.STSrid); var geoms = new SMGeometry[(int)geometry.STNumGeometries()]; for (var i = 1; i <= geometry.STNumGeometries(); i++) geoms[i-1] = ToSharpMapGeometry(geometry.STGeometryN(i), fact); return fact.CreateGeometryCollection(geoms); }