private static IStyle StyleBasedOnAlignment(FeatureDataRow dr)
{
var style = new LabelStyle
{
HorizontalAlignment = (LabelStyle.HorizontalAlignmentEnum)(int) dr[2],
VerticalAlignment = (LabelStyle.VerticalAlignmentEnum)(int) dr[3],
Rotation = -20,
BackColor = Brushes.Pink,
Halo = new Pen(Brushes.LightBlue, 2)
};
return(style);
}
private FeatureDataRow AddFeatureDataRow(DisplayFact dispfact, MapLocation loc, string colour)
{
GeoResponse.CResult.CGeometry.CViewPort vp = loc.Location.ViewPort;
FeatureDataRow r = TearDropLocations.NewRow();
r["DisplayFact"] = dispfact;
r["MapLocation"] = loc;
r["ViewPort"] = new Envelope(vp.NorthEast.Long, vp.SouthWest.Long, vp.NorthEast.Lat, vp.SouthWest.Lat);
r["Colour"] = colour;
r.Geometry = loc.Geometry;
TearDropLocations.AddRow(r);
return(r);
}
/// <summary>
/// Creates a new row in the given <see cref="SharpMap.Data.FeatureDataTable"/> <paramref name="dataTable"/>
/// using data in <see cref="GisSharpBlog.NetTopologySuite.Features.Feature"/> <paramref name="feature"/>.
/// </summary>
/// <param name="dataTable">The <see cref="SharpMap.Data.FeatureDataTable"/> to fill.</param>
/// <param name="feature">Data to insert in the <see cref="SharpMap.Data.FeatureDataTable"/>.</param>
private void CreateNewRow(FeatureDataTable dataTable, Feature feature)
{
FeatureDataRow dataRow = dataTable.NewRow();
dataRow.Geometry =
GeometryConverter.ToSharpMapGeometry(
feature.Geometry as GisSharpBlog.NetTopologySuite.Geometries.Geometry);
foreach (string columnName in feature.Attributes.GetNames())
{
dataRow[columnName] = feature.Attributes[columnName];
}
dataTable.AddRow(dataRow);
}
/// <summary>
/// Returns the <see cref="IStyle">style</see>
/// based on a value in the feature, as computed by the
/// <see cref="StyleDelegate"/> method.
/// </summary>
/// <param name="row">Feature to compute style for.</param>
/// <returns>Feature value dependent style.</returns>
public IStyle GetStyle(FeatureDataRow row)
{
IStyle style = _getStyleDelegate(row);
if (style != null)
{
return(style);
}
else
{
return(_defaultStyle);
}
}
public void ExecuteIntersectionQuery(BoundingBox box, FeatureDataSet ds)
{
using (SQLiteConnection conn = SpatiaLiteConnection(_connectionString))
{
string strSql = "SELECT *, AsBinary(" + GeometryColumn + ") AS sharpmap_tempgeometry ";
strSql += "FROM " + Table + " WHERE ";
strSql += GetBoxClause(box);
if (!String.IsNullOrEmpty(_defintionQuery))
{
strSql += " AND " + DefinitionQuery;
}
using (SQLiteDataAdapter adapter = new SQLiteDataAdapter(strSql, conn))
{
DataSet ds2 = new DataSet();
adapter.Fill(ds2);
conn.Close();
if (ds2.Tables.Count > 0)
{
FeatureDataTable fdt = new FeatureDataTable(ds2.Tables[0]);
foreach (DataColumn col in ds2.Tables[0].Columns)
{
if (col.ColumnName != GeometryColumn && col.ColumnName != "sharpmap_tempgeometry" &&
!col.ColumnName.StartsWith("Envelope_"))
{
fdt.Columns.Add(col.ColumnName, col.DataType, col.Expression);
}
}
foreach (DataRow dr in ds2.Tables[0].Rows)
{
FeatureDataRow fdr = fdt.NewRow();
foreach (DataColumn col in ds2.Tables[0].Columns)
{
if (col.ColumnName != GeometryColumn && col.ColumnName != "sharpmap_tempgeometry" &&
!col.ColumnName.StartsWith("Envelope_"))
{
fdr[col.ColumnName] = dr[col];
}
}
if (dr["sharpmap_tempgeometry"] != DBNull.Value)
{
fdr.Geometry = GeometryFromWKB.Parse((byte[])dr["sharpmap_tempgeometry"]);
}
fdt.AddRow(fdr);
}
ds.Tables.Add(fdt);
}
}
}
}
/// <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 void ExecuteIntersectionQuery(BoundingBox bbox, FeatureDataSet ds)
{
using (PgConnection conn = new PgConnection(_ConnectionString))
{
string strBbox = GetBoundingBoxSql(bbox, SRID);
string strSQL = String.Format("SELECT *, AsBinary({0}) AS sharpmap_tempgeometry FROM {1} WHERE ",
GeometryColumn,
Table);
if (!String.IsNullOrEmpty(_defintionQuery))
{
strSQL += DefinitionQuery + " AND ";
}
strSQL += GeometryColumn + " && " + strBbox;
using (PgDataAdapter adapter = new PgDataAdapter(strSQL, conn))
{
conn.Open();
DataSet ds2 = new DataSet();
adapter.Fill(ds2);
conn.Close();
if (ds2.Tables.Count > 0)
{
FeatureDataTable fdt = new FeatureDataTable(ds2.Tables[0]);
foreach (DataColumn col in ds2.Tables[0].Columns)
{
if (col.ColumnName != GeometryColumn && col.ColumnName != "sharpmap_tempgeometry")
{
fdt.Columns.Add(col.ColumnName, col.DataType, col.Expression);
}
}
foreach (DataRow dr in ds2.Tables[0].Rows)
{
FeatureDataRow fdr = fdt.NewRow();
foreach (DataColumn col in ds2.Tables[0].Columns)
{
if (col.ColumnName != GeometryColumn && col.ColumnName != "sharpmap_tempgeometry")
{
fdr[col.ColumnName] = dr[col];
}
}
fdr.Geometry = GeometryFromWKB.Parse((byte[])dr["sharpmap_tempgeometry"]);
fdt.AddRow(fdr);
}
ds.Tables.Add(fdt);
}
}
}
}
/// <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 OracleConnection(ConnectionString))
{
//Get bounding box string
var strBbox = GetBoxFilterStr(bbox);
var strSQL = "SELECT g.*, g." + GeometryColumn + ".Get_WKB() AS sharpmap_tempgeometry ";
strSQL += "FROM " + Table + " g WHERE ";
if (!String.IsNullOrEmpty(_definitionQuery))
{
strSQL += DefinitionQuery + " AND ";
}
strSQL += strBbox;
using (var adapter = new OracleDataAdapter(strSQL, conn))
{
conn.Open();
var ds2 = new DataSet();
adapter.Fill(ds2);
conn.Close();
if (ds2.Tables.Count > 0)
{
var fdt = new FeatureDataTable(ds2.Tables[0]);
foreach (DataColumn col in ds2.Tables[0].Columns)
{
if (col.ColumnName != GeometryColumn && col.ColumnName != "sharpmap_tempgeometry")
{
fdt.Columns.Add(col.ColumnName, col.DataType, col.Expression);
}
}
foreach (DataRow dr in ds2.Tables[0].Rows)
{
FeatureDataRow fdr = fdt.NewRow();
foreach (DataColumn col in ds2.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>
/// Returns the features that intersects with 'geom'
/// </summary>
/// <param name="geom"></param>
/// <param name="ds">FeatureDataSet to fill data into</param>
public override void ExecuteIntersectionQuery(Geometry geom, FeatureDataSet ds)
{
using (SqlConnection conn = new SqlConnection(ConnectionString))
{
string strGeom = _spatialObject + "::STGeomFromText('" + geom.AsText() + "', #SRID#)";
strGeom = strGeom.Replace("#SRID#", SRID > 0 ? SRID.ToString() : "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 (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);
}
}
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 = SqlGeometryConverter.ToSharpMapGeometry((Microsoft.SqlServer.Types.SqlGeometry)dr[GeometryColumn]);
fdt.AddRow(fdr);
}
ds.Tables.Add(fdt);
}
}
}
}
public FeatureDataSet ExecuteQuery(string query, Geometry filter)
{
try
{
FeatureDataSet ds = new FeatureDataSet();
FeatureDataTable myDt = new FeatureDataTable();
Layer results = _OgrDataSource.ExecuteSQL(query, filter, "");
//reads the column definition of the layer/feature
ReadColumnDefinition(myDt, results);
OSGeo.OGR.Feature _OgrFeature;
results.ResetReading();
while ((_OgrFeature = results.GetNextFeature()) != null)
{
FeatureDataRow _dr = myDt.NewRow();
for (int iField = 0; iField < _OgrFeature.GetFieldCount(); iField++)
{
if (myDt.Columns[iField].DataType == System.Type.GetType("System.String"))
{
_dr[iField] = _OgrFeature.GetFieldAsString(iField);
}
else if (myDt.Columns[iField].GetType() == System.Type.GetType("System.Int32"))
{
_dr[iField] = _OgrFeature.GetFieldAsInteger(iField);
}
else if (myDt.Columns[iField].GetType() == System.Type.GetType("System.Double"))
{
_dr[iField] = _OgrFeature.GetFieldAsDouble(iField);
}
else
{
_dr[iField] = _OgrFeature.GetFieldAsString(iField);
}
}
_dr.Geometry = this.ParseOgrGeometry(_OgrFeature.GetGeometryRef());
myDt.AddRow(_dr);
}
ds.Tables.Add(myDt);
_OgrDataSource.ReleaseResultSet(results);
return(ds);
}
catch (Exception exc)
{
System.Diagnostics.Debug.WriteLine(exc.ToString());
return(new FeatureDataSet());
}
}
private void CreateFeatureElements(List <ImageMapFeatureElement> targetList, ILayer lyr, Map map)
{
if (map.Center == null)
{
throw (new ApplicationException("Cannot render map. View center not specified"));
}
IDataLayer dataLayer = lyr as IDataLayer;
if (dataLayer == null)
{
return;
}
IProvider dataSource = dataLayer.DataSource;
if (this.ImageMapStyle != null || this._themeProvider != null)
{
FeatureDataSet ds = new FeatureDataSet();
dataSource.Open();
dataSource.ExecuteIntersectionQuery(map.Envelope, ds);
dataSource.Close();
if (ds.Tables.Count > 0)
{
FeatureDataTable features = ds.Tables[0];
for (int k = 0; k < features.Count; k++)
{
FeatureDataRow fdr = features[k];
ImageMapStyle useStyle =
this._themeProvider != null?this._themeProvider(lyr, fdr) : this.ImageMapStyle;
if (useStyle == null ||
!useStyle.Enabled ||
map.Zoom < useStyle.MinVisible ||
map.Zoom > useStyle.MaxVisible)
{
continue;
}
AddFeatureElement(targetList, map, lyr, fdr.Geometry, fdr, useStyle);
}
}
}
}
/// <summary>
/// Returns a FeatureDataRow based on a RowID
/// </summary>
/// <param name="index"></param>
/// <returns>FeatureDataRow</returns>
public virtual IFeature GetFeature(int index)
{
var fid = ((Collection <int>)GetObjectIDsInView(GetExtents()))[index];
FeatureDataTable featureDataTable = CreateFeatureDataTableStructure();
using (var ogrFeature = ogrLayer.GetFeature(fid))
{
FeatureDataRow feature = featureDataTable.NewRow();
feature.Id = fid;
SetFeatureValuesInRow(featureDataTable, ogrFeature, feature);
feature.Geometry = ParseOgrGeometry(ogrFeature.GetGeometryRef());
return(feature);
}
}
/// <summary>
/// Returns a datarow based on a RowID
/// </summary>
/// <param name="rowId"></param>
/// <returns>datarow</returns>
public FeatureDataRow GetFeature(uint rowId)
{
using (PgConnection conn = new PgConnection(_ConnectionString))
{
string strSQL =
String.Format("select * , AsBinary({0}) As sharpmap_tempgeometry from {1} WHERE {2} = '{3}'",
GeometryColumn, Table, ObjectIdColumn, rowId);
using (PgDataAdapter adapter = new PgDataAdapter(strSQL, conn))
{
FeatureDataSet ds = new FeatureDataSet();
conn.Open();
adapter.Fill(ds);
conn.Close();
if (ds.Tables.Count > 0)
{
FeatureDataTable 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);
}
}
if (ds.Tables[0].Rows.Count > 0)
{
DataRow dr = ds.Tables[0].Rows[0];
FeatureDataRow 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"]);
return(fdr);
}
else
{
return(null);
}
}
else
{
return(null);
}
}
}
}
public void KmlFileURL2Test()
{
GeoAPI.GeometryServiceProvider.Instance = NetTopologySuite.NtsGeometryServices.Instance;
HttpWebRequest req = (HttpWebRequest)WebRequest.Create(new Uri("http://112.74.67.213:6080/huayu/TestData/raw/master/online/Polygontwo_LayerToKML.kml"));
HttpWebResponse resp = (HttpWebResponse)req.GetResponse();
var kml = KmlProvider.FromKml(resp.GetResponseStream());
Assert.IsNotNull(kml);
var fullExtent = kml.GetExtents();
Assert.IsNotNull(fullExtent);
List <string> ids = kml.GetObjectIDsInViewForSList(fullExtent);
Assert.AreEqual(ids[1], "ID_00001");
FeatureDataRow dr = kml.GetFeature(ids[1]);
Assert.IsNotNull(dr);
Assert.IsNotNull(dr.ItemArray);
Assert.AreEqual(dr.ItemArray[0], "ID_00001");
Assert.AreEqual(dr.ItemArray[1], "PolyStyle00");
SharpKml.Dom.Placemark placemark = (SharpKml.Dom.Placemark)dr.ItemArray[2];
Assert.IsNotNull(placemark);
Assert.AreEqual(placemark.Id, "ID_00001");
Assert.AreEqual(placemark.Name, "b");
Assert.AreEqual(placemark.Description.Text.Trim().Length, 1095);
Assert.AreEqual(placemark.StyleUrl.ToString(), "#PolyStyle00");
Assert.IsNull(placemark.Visibility);
Assert.IsNull(placemark.Open);
Assert.IsNull(placemark.Address);
Assert.IsNotNull(placemark.Snippet);
Assert.IsNotNull(dr.Geometry);
Assert.IsInstanceOf(typeof(GeometryCollection), dr.Geometry);
GeometryCollection gc = (GeometryCollection)dr.Geometry;
Assert.AreEqual(gc.NumGeometries, 6);
for (int i = 0; i < gc.NumGeometries; i++)
{
IGeometry geo = gc.GetGeometryN(i);
Console.WriteLine($"{i}:{geo.GeometryType},{gwl(geo.Coordinates.ToList())}");
}
Assert.IsNotNull(dr.Table);
Assert.AreEqual(dr.IsFeatureGeometryNull(), false);
Assert.AreEqual(kml.GetFeatureCount(), 2);
Console.WriteLine(string.Format("kml.GetFeatureCount():{0}", kml.GetFeatureCount()));
Console.WriteLine(string.Format("kml.GetExtents():{0}", kml.GetExtents()));
}
/// <summary>
/// Gets the feature at the specified Object ID
/// </summary>
/// <param name="oid">Row index. Zero-based.</param>
/// <param name="table">The feature table containing the schema used to
/// read the row.</param>
/// <returns>The feature row for the given row index</returns>
/// <exception cref="InvalidDbaseFileOperationException">
/// Thrown if this reader is closed (check <see cref="IsOpen"/> before calling),
/// or if the column is an unsupported type.
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="oid"/>
/// < 0 or <paramref name="oid"/> >= <see cref="RecordCount"/></exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="table"/> is
/// null</exception>
/// <exception cref="ObjectDisposedException">Thrown when the method is called and
/// Object has been disposed</exception>
internal IFeatureDataRecord GetAttributes(UInt32 oid, FeatureDataTable <UInt32> table)
{
checkState();
if (!_isOpen)
{
throw new InvalidDbaseFileOperationException("An attempt was made to read " +
"from a closed dBase file");
}
if (oid <= 0 || oid > RecordCount)
{
throw new ArgumentOutOfRangeException("Invalid DataRow requested " +
"at index " + oid);
}
if (_reader.IsRowDeleted(oid)) // is record marked deleted?
{
return(null);
}
if (table != null)
{
FeatureDataRow <UInt32> dr = table.NewRow(oid);
foreach (DbaseField field in Header.Columns)
{
try
{
dr[field.ColumnName] = _reader.GetValue(oid, field);
}
catch (NotSupportedException)
{
String message = String.Format("Column type {0} is not supported.",
field.DataType);
throw new InvalidDbaseFileOperationException(message);
}
}
return(dr);
}
else
{
ShapeFileFeatureDataRecord dr = new ShapeFileFeatureDataRecord(Header.Columns);
dr.SetColumnValue(0, oid);
dr.SetColumnValues(1, 1 + Header.Columns.Count, _reader.GetValues(oid));//jd: added 1 to Header.Columns.Count because we are offsetting the start index by one (OID is stored at zero)
return(dr);
}
}
/// <summary>
/// Returns the style based on a feature
/// </summary>
/// <param name="attribute">Attribute to calculate color from</param>
/// <returns>Color</returns>
public SharpMap.Styles.IStyle GetStyle(FeatureDataRow attribute)
{
VectorStyle vs = new VectorStyle();
if (!_brushes.ContainsKey(attribute.Geometry))
{
_brushes[attribute.Geometry] = new SolidBrush(Color.FromArgb(rand.Next(255), rand.Next(255), rand.Next(255)));
}
vs.Fill = _brushes[attribute.Geometry];
vs.Outline = new Pen(Color.Black);
vs.EnableOutline = true;
return(vs);
}
/// <summary>
/// Returns a datarow based on a RowID
/// </summary>
/// <param name="rowId"></param>
/// <returns>datarow</returns>
public override FeatureDataRow GetFeature(uint rowId)
{
using (var conn = new SqlConnection(ConnectionString))
{
string strSql = "select g.* , g." + GeometryColumn + ".STAsBinary() As sharpmap_tempgeometry from " +
QualifiedTable + " g WHERE " + ObjectIdColumn + "=" + rowId + "";
using (var adapter = new SqlDataAdapter(strSql, conn))
{
var ds = new System.Data.DataSet();
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 && col.ColumnName != "sharpmap_tempgeometry")
{
fdt.Columns.Add(col.ColumnName, col.DataType, col.Expression);
}
}
if (ds.Tables[0].Rows.Count > 0)
{
System.Data.DataRow dr = ds.Tables[0].Rows[0];
FeatureDataRow fdr = fdt.NewRow();
foreach (System.Data.DataColumn col in ds.Tables[0].Columns)
{
if (col.ColumnName != GeometryColumn && col.ColumnName != "sharpmap_tempgeometry")
{
fdr[col.ColumnName] = dr[col];
}
}
var tmpGeom =
Converters.WellKnownBinary.GeometryFromWKB.Parse((byte[])dr["sharpmap_tempgeometry"],
Factory);
if (tmpGeom != null && _spatialObjectType == SqlServerSpatialObjectType.Geography)
{
FlipXY(tmpGeom);
tmpGeom.GeometryChanged();
}
fdr.Geometry = tmpGeom;
return(fdr);
}
return(null);
}
return(null);
}
}
}
private void RenderVectorFeature(StringBuilder sb, ILayer layer, FeatureDataRow fdr)
{
sb.Append("{");
Geometry g = fdr.Geometry;
sb.Append(FormatJsonAttribute("type", "Feature"));
sb.Append(",");
sb.Append("\"properties\":");
RenderFeatureProperties(sb, layer, fdr);
sb.Append(",");
sb.Append("\"geometry\":");
RenderGeometry(sb, g);
sb.Append("}");
}
public ExportContext(KmlFileFeaturesExporter exporter, IList<string> additionalFiles, FeatureDataRow feature)
{
if (exporter == null)
throw new ArgumentNullException("exporter");
if (additionalFiles == null)
throw new ArgumentNullException("additionalFiles");
if (feature == null)
throw new ArgumentNullException("feature");
Exporter = exporter;
AdditionalFiles = additionalFiles;
Feature = feature;
}
private void RenderFeatureProperties(StringBuilder sb, ILayer layer, FeatureDataRow fdr)
{
sb.Append("{");
if (this.AttributeProviders.Count > 0)
{
foreach (KeyValuePair <string, Func <ILayer, FeatureDataRow, string> > v in this.AttributeProviders)
{
sb.Append(FormatJsonAttribute(v.Key, v.Value(layer, fdr)));
sb.Append(",");
}
sb.Remove(sb.Length - 1, 1);
}
sb.Append("}");
}
void BuildClusteredFeatureTable()
{
clusteredDataTable.Clear();
foreach (MapCluster cluster in this.clusters)
{
FeatureDataRow row = clusteredDataTable.NewRow();
row.Geometry = cluster.Geometry;
row["Features"] = cluster.Features;
row["Count"] = cluster.Features.Count;
row["Label"] = cluster.Features.Count >= minClusterSize?cluster.Features.Count.ToString() : string.Empty;
row["Cluster"] = cluster.ClusterType;
clusteredDataTable.AddRow(row);
}
}
public FeatureDataSet ExecuteQuery(string query, OgrGeometry filter)
{
try
{
FeatureDataSet ds = new FeatureDataSet();
FeatureDataTable myDt = new FeatureDataTable();
OgrLayer results = _ogrDataSource.ExecuteSQL(query, filter, "");
//reads the column definition of the layer/feature
ReadColumnDefinition(myDt, results);
OgrFeature ogrFeature;
results.ResetReading();
while ((ogrFeature = results.GetNextFeature()) != null)
{
FeatureDataRow dr = OgrFeatureToFeatureDataRow(myDt, ogrFeature, Factory);
myDt.AddRow(dr);
/*
* myDt.NewRow();
* for (int iField = 0; iField < ogrFeature.GetFieldCount(); iField++)
* {
* if (myDt.Columns[iField].DataType == Type.GetType("System.String"))
* dr[iField] = ogrFeature.GetFieldAsString(iField);
* else if (myDt.Columns[iField].GetType() == Type.GetType("System.Int32"))
* dr[iField] = ogrFeature.GetFieldAsInteger(iField);
* else if (myDt.Columns[iField].GetType() == Type.GetType("System.Double"))
* dr[iField] = ogrFeature.GetFieldAsDouble(iField);
* else
* dr[iField] = ogrFeature.GetFieldAsString(iField);
* }
*
* dr.Geometry = ParseOgrGeometry(ogrFeature.GetGeometryRef());
* myDt.AddRow(dr);
*/
}
ds.Tables.Add(myDt);
_ogrDataSource.ReleaseResultSet(results);
return(ds);
}
catch (Exception exc)
{
Debug.WriteLine(exc.ToString());
return(new FeatureDataSet());
}
}
/// <summary>
/// Returns a datarow based on a RowID
/// </summary>
/// <param name="RowID"></param>
/// <returns>datarow</returns>
public FeatureDataRow GetFeature(uint RowID)
{
using (NpgsqlConnection conn = new NpgsqlConnection(_ConnectionString))
{
string strSQL = "select * , AsBinary(\"" + GeometryColumn + "\") As sharpmap_tempgeometry from " +
QualifiedTable + " WHERE \"" + ObjectIdColumn + "\"='" + RowID + "'";
using (NpgsqlDataAdapter adapter = new NpgsqlDataAdapter(strSQL, conn))
{
FeatureDataSet ds = new FeatureDataSet();
conn.Open();
adapter.Fill(ds);
conn.Close();
if (ds.Tables.Count > 0)
{
FeatureDataTable 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);
}
}
if (ds.Tables[0].Rows.Count > 0)
{
DataRow dr = ds.Tables[0].Rows[0];
FeatureDataRow 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"]);
return(fdr);
}
else
{
return(null);
}
}
else
{
return(null);
}
}
}
}
//public IFeature GetFeature(int index)
//{
// return GetFeature(index, null);
//}
public IFeature GetFeature(int index)
{
using (SqlConnection conn = new SqlConnection(this._connectionString))
{
int rowId = index + 1; // index looks zero-based
string strSQL = String.Format(
"select g.* , g.{0}.STAsBinary() As sharpmap_tempgeometry from {1} g WHERE {2}={3}",
//"select g.* , g.{0}.STAsText() As sharpmap_tempgeometry from {1} g WHERE {2}={3}",
this.GeometryColumn, this.Table, this.ObjectIdColumn, rowId);
using (SqlDataAdapter adapter = new SqlDataAdapter(strSQL, conn))
{
DataSet ds = new DataSet();
conn.Open();
adapter.Fill(ds);
conn.Close();
if (ds.Tables.Count > 0)
{
FeatureDataTable fdt = new FeatureDataTable(ds.Tables[0]);
foreach (DataColumn col in ds.Tables[0].Columns)
{
if (col.ColumnName != this.GeometryColumn && col.ColumnName != "sharpmap_tempgeometry")
{
fdt.Columns.Add(col.ColumnName, col.DataType, col.Expression);
}
}
if (ds.Tables[0].Rows.Count > 0)
{
DataRow dr = ds.Tables[0].Rows[0];
FeatureDataRow fdr = fdt.NewRow();
foreach (DataColumn col in ds.Tables[0].Columns)
{
if (col.ColumnName != this.GeometryColumn && col.ColumnName != "sharpmap_tempgeometry")
{
fdr[col.ColumnName] = dr[col];
}
}
fdr.Geometry = GeometryFromWKB.Parse((byte[])dr["sharpmap_tempgeometry"]);
//fdr.Geometry = SharpMap.Converters.WellKnownText.GeometryFromWKT.Parse(dr["sharpmap_tempgeometry"].ToString());
return(fdr);
}
return(null);
}
return(null);
}
}
}
public override IFeature GetFeatureByOid(object oid)
{
using (var conn = new SQLiteConnection(ConnectionString))
{
string strSQL = "SELECT *, " + GeometryColumn + " AS sharpmap_tempgeometry FROM " + Table + " WHERE " +
ObjectIdColumn + "=@POid";
using (var adapter = new SQLiteDataAdapter(strSQL, conn))
{
adapter.SelectCommand.Parameters.Add(new SQLiteParameter("POid", oid));
var ds = new DataSet();
conn.Open();
adapter.Fill(ds);
conn.Close();
if (ds.Tables.Count > 0)
{
FeatureDataTable fdt = new FeatureDataTable(ds.Tables[0]);
foreach (DataColumn col in ds.Tables[0].Columns)
{
if (col.ColumnName != GeometryColumn && col.ColumnName != "sharpmap_tempgeometry" &&
!col.ColumnName.StartsWith("Envelope_"))
{
fdt.Columns.Add(col.ColumnName, col.DataType, col.Expression);
}
}
if (ds.Tables[0].Rows.Count > 0)
{
DataRow dr = ds.Tables[0].Rows[0];
FeatureDataRow fdr = fdt.NewRow();
foreach (DataColumn col in ds.Tables[0].Columns)
{
if (col.ColumnName != GeometryColumn && col.ColumnName != "sharpmap_tempgeometry" &&
!col.ColumnName.StartsWith("Envelope_"))
{
fdr[col.ColumnName] = dr[col];
}
}
if (dr["sharpmap_tempgeometry"] != DBNull.Value)
{
fdr.Geometry = GeometryFromWKT.Parse((string)dr["sharpmap_tempgeometry"]);
}
return(fdr);
}
return(null);
}
return(null);
}
}
}
/// <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 void ExecuteIntersectionQuery(BoundingBox bbox, FeatureDataSet ds)
{
//List<Geometries.Geometry> features = new List<SharpMap.Geometries.Geometry>();
using (OleDbConnection conn = new OleDbConnection(_ConnectionString))
{
string strSQL = "Select * FROM " + Table + " WHERE ";
if (!String.IsNullOrEmpty(_defintionQuery))
{
//If a definition query has been specified, add this as a filter on the query
strSQL += _defintionQuery + " AND ";
}
//Limit to the points within the boundingbox
strSQL += XColumn + " BETWEEN " + bbox.Left.ToString(Map.NumberFormatEnUs) + " AND " +
bbox.Right.ToString(Map.NumberFormatEnUs) + " AND " + YColumn +
" BETWEEN " + bbox.Bottom.ToString(Map.NumberFormatEnUs) + " AND " +
bbox.Top.ToString(Map.NumberFormatEnUs);
using (OleDbDataAdapter adapter = new OleDbDataAdapter(strSQL, conn))
{
conn.Open();
DataSet ds2 = new DataSet();
adapter.Fill(ds2);
conn.Close();
if (ds2.Tables.Count > 0)
{
FeatureDataTable fdt = new FeatureDataTable(ds2.Tables[0]);
foreach (DataColumn col in ds2.Tables[0].Columns)
{
fdt.Columns.Add(col.ColumnName, col.DataType, col.Expression);
}
foreach (DataRow dr in ds2.Tables[0].Rows)
{
FeatureDataRow fdr = fdt.NewRow();
foreach (DataColumn col in ds2.Tables[0].Columns)
{
fdr[col.ColumnName] = dr[col];
}
if (dr[XColumn] != DBNull.Value && dr[YColumn] != DBNull.Value)
{
fdr.Geometry = new Point((double)dr[XColumn], (double)dr[YColumn]);
}
fdt.AddRow(fdr);
}
ds.Tables.Add(fdt);
}
}
}
}
/// <summary>
/// Returns a datarow based on a RowID
/// </summary>
/// <param name="rowId"></param>
/// <returns>datarow</returns>
public FeatureDataRow GetFeature(uint rowId)
{
using (OracleConnection conn = new OracleConnection(_ConnectionString))
{
string strSQL = "select g.* , g." + GeometryColumn + ").Get_WKB() As sharpmap_tempgeometry from " +
Table + " g WHERE " + ObjectIdColumn + "='" + rowId.ToString() + "'";
using (OracleDataAdapter adapter = new OracleDataAdapter(strSQL, conn))
{
FeatureDataSet ds = new FeatureDataSet();
conn.Open();
adapter.Fill(ds);
conn.Close();
if (ds.Tables.Count > 0)
{
FeatureDataTable 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);
}
}
if (ds.Tables[0].Rows.Count > 0)
{
DataRow dr = ds.Tables[0].Rows[0];
FeatureDataRow 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"]);
return(fdr);
}
else
{
return(null);
}
}
else
{
return(null);
}
}
}
}
/// <summary>
/// Returns a datarow based on a RowID
/// </summary>
/// <param name="rowId"></param>
/// <returns>datarow</returns>
public override FeatureDataRow GetFeature(uint rowId)
{
using (var conn = new SqlConnection(ConnectionString))
{
string strSql = "select g.* from " + QualifiedTable + " g WHERE " + ObjectIdColumn + "=" + rowId + "";
using (var adapter = new SqlDataAdapter(strSql, conn))
{
var ds = new System.Data.DataSet();
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);
}
}
if (ds.Tables[0].Rows.Count > 0)
{
System.Data.DataRow dr = ds.Tables[0].Rows[0];
FeatureDataRow fdr = fdt.NewRow();
foreach (System.Data.DataColumn col in ds.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;
return(fdr);
}
return(null);
}
return(null);
}
}
}
/// <summary>
/// Converts DataRowCollection to IEnumerable of FeatureDataRow
/// </summary>
/// <param name="features"></param>
/// <returns>IEnumerable</returns>
private static IEnumerable <FeatureDataRow> IEnumerableOfDataRowCollection(DataRowCollection features)
{
if (features == null)
{
throw new ArgumentNullException("features");
}
foreach (FeatureDataRow fdr in features)
{
FeatureDataRow <TOid> fdrTOid = fdr as FeatureDataRow <TOid>;
if (fdrTOid != null)
{
yield return(fdrTOid);
}
}
}
private float GetHeatValueFromColumn(FeatureDataRow row)
{
if (row == null)
{
return(0);
}
if (row[HeatValueColumn] == DBNull.Value)
{
return(0);
}
var res = HeatValueScale * Convert.ToSingle(row[HeatValueColumn]);
return(res <0f ? 0f : res> 1f ? 1f : res);
}
public override FeatureDataRow GetFeature(uint rowId)
{
using (var conn = new SQLiteConnection(ConnectionString))
{
string strSQL = "SELECT *, " + GeometryColumn + " AS sharpmap_tempgeometry FROM " + Table + " WHERE " +
ObjectIdColumn + "='" + rowId.ToString(NumberFormatInfo.InvariantInfo) + "'";
using (var adapter = new SQLiteDataAdapter(strSQL, conn))
{
DataSet ds = new DataSet();
conn.Open();
adapter.Fill(ds);
conn.Close();
if (ds.Tables.Count > 0)
{
FeatureDataTable fdt = new FeatureDataTable(ds.Tables[0]);
foreach (DataColumn col in ds.Tables[0].Columns)
{
if (col.ColumnName != GeometryColumn && col.ColumnName != "sharpmap_tempgeometry" &&
!col.ColumnName.StartsWith("Envelope_"))
{
fdt.Columns.Add(col.ColumnName, col.DataType, col.Expression);
}
}
if (ds.Tables[0].Rows.Count > 0)
{
DataRow dr = ds.Tables[0].Rows[0];
FeatureDataRow fdr = fdt.NewRow();
foreach (DataColumn col in ds.Tables[0].Columns)
{
if (col.ColumnName != GeometryColumn && col.ColumnName != "sharpmap_tempgeometry" &&
!col.ColumnName.StartsWith("Envelope_"))
{
fdr[col.ColumnName] = dr[col];
}
}
if (dr["sharpmap_tempgeometry"] != DBNull.Value)
{
fdr.Geometry = GeometryFromWKT.Parse((string)dr["sharpmap_tempgeometry"]);
}
return(fdr);
}
return(null);
}
return(null);
}
}
}
/// <summary>
/// Gets a datarow from the datasource at the specified index belonging to the specified datatable
/// </summary>
/// <param name="RowID"></param>
/// <param name="dt">Datatable to feature should belong to.</param>
/// <returns></returns>
public FeatureDataRow GetFeature(uint RowID, FeatureDataTable dt)
{
Debug.Assert(dt != null);
if (dbaseFile != null)
{
//MemoryCache
if (_UseMemoryCache == true)
{
FeatureDataRow dr2 = null;
cacheDataTable.TryGetValue(RowID, out dr2);
if (dr2 == null)
{
dr2 = dbaseFile.GetFeature(RowID, dt);
dr2.Geometry = ReadGeometry(RowID);
cacheDataTable.Add(RowID, dr2);
}
//Make a copy to return
FeatureDataRow drNew = dt.NewRow();
for (int i = 0; i < dr2.Table.Columns.Count; i++)
{
drNew[i] = dr2[i];
}
drNew.Geometry = dr2.Geometry;
return(drNew);
}
else
{
//FeatureDataRow dr = (FeatureDataRow)dbaseFile.GetFeature(RowID, (dt == null) ? dbaseFile.NewTable : dt);
FeatureDataRow dr = dbaseFile.GetFeature(RowID, dt);
dr.Geometry = ReadGeometry(RowID);
if (FilterDelegate == null || FilterDelegate(dr))
{
return(dr);
}
else
{
return(null);
}
}
}
else
{
throw (new ApplicationException(
"An attempt was made to read DBase data from a shapefile without a valid .DBF file"));
}
}
private static string Get(FeatureDataRow feature, string columnName)
{
var value = feature[columnName];
return value == null ? null : value.ToString();
}
private Placemark WrapPlacemark(Geometry kmlGeometry, StyleSelector style, FeatureDataRow feature)
{
var placemark = new Placemark();
if (!string.IsNullOrEmpty(NameColumn))
placemark.Name = Get(feature, NameColumn);
placemark.Description = new Description { Text = CreateDescription(feature) };
placemark.Geometry = kmlGeometry;
if (GetFeatureSnippet != null)
{
placemark.Snippet = new Snippet { Text = GetFeatureSnippet(new ExportContext(this, _additionalFiles, feature)) };
}
if (style != null)
{
placemark.StyleUrl = new Uri("#" + style.Id, UriKind.Relative);
}
return placemark;
}
/// <summary>
/// Initializes a new instance of the <see cref="GeometryProvider"/>
/// </summary>
/// <param name="feature">Feature to be in this datasource</param>
public GeometryProvider(FeatureDataRow feature)
{
Geometries = new List<IGeometry> {feature.Geometry};
}
protected virtual Feature CreateKmlFeature(FeatureDataRow feature, StyleSelector style)
{
var geometry = feature.Geometry;
geometry = ToTarget(geometry);
switch (geometry.OgcGeometryType)
{
case OgcGeometryType.Point:
{
var location = geometry.Coordinate;
var p = new Point { Coordinate = new Vector(location.Y, location.X) };
return WrapPlacemark(p, style, feature);
}
case OgcGeometryType.MultiPoint:
{
var multiGeometry = new MultipleGeometry();
foreach (var coordinate in geometry.Coordinates)
{
var p = new Point { Coordinate = new Vector(coordinate.Y, coordinate.X) };
multiGeometry.AddGeometry(p);
}
return WrapPlacemark(multiGeometry, style, feature);
}
case OgcGeometryType.LineString:
{
var lineString = CreateLineString(geometry);
return WrapPlacemark(lineString, style, feature);
}
case OgcGeometryType.Polygon:
{
var polygon = (IPolygon)geometry;
var kmlPolygon = CreateKmlPolygon(polygon);
return WrapPlacemark(kmlPolygon, style, feature);
}
case OgcGeometryType.MultiLineString:
{
var multiGeometry = new MultipleGeometry();
var multiLineString = (IMultiLineString)geometry;
foreach (var innerGeometry in multiLineString.Geometries)
{
var lineString = CreateLineString(innerGeometry);
multiGeometry.AddGeometry(lineString);
}
return WrapPlacemark(multiGeometry, style, feature);
}
case OgcGeometryType.MultiPolygon:
{
var multiGeometry = new MultipleGeometry();
var multiPoly = (IMultiPolygon)geometry;
foreach (var innerGeometry in multiPoly.Geometries.Cast<IPolygon>())
{
var polygon = CreateKmlPolygon(innerGeometry);
multiGeometry.AddGeometry(polygon);
}
return WrapPlacemark(multiGeometry, style, feature);
}
default:
throw new InvalidOperationException("Geometry not supported");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="GeometryProvider"/>
/// </summary>
/// <param name="feature">Feature to be in this datasource</param>
public GeometryProvider(FeatureDataRow feature)
{
_Geometries = new Collection<Geometry>();
_Geometries.Add(feature.Geometry);
}
protected virtual string CreateDescription(FeatureDataRow feature)
{
var values = feature.Table.Columns
.Cast<DataColumn>()
.Where(dc => dc.ColumnName != NameColumn)
.ToDictionary(dc => dc.ColumnName, dc => feature[dc]);
var s = values.Select(kvp => kvp.Key + " = " + kvp.Value);
return string.Join("\r\n", s);
}
public VectorStyle GetKmlStyle(FeatureDataRow row)
{
//get styleID from row
var styleId = (string)row["StyleUrl"];
if (_kmlStyles.ContainsKey(styleId))
{
return _kmlStyles[styleId];
}
//look in style maps
foreach (var stl in _styleMaps)
{
if (stl.Id == styleId)
{
return _kmlStyles[stl.NormalStyleUrl];
}
}
if (row.Geometry.OgcGeometryType == OgcGeometryType.Point ||
row.Geometry.OgcGeometryType == OgcGeometryType.MultiPoint)
{
return DefaultPointStyle();
}
return DefaultVectorStyle();
}
