internal FeatureRow(DataRowBuilder rb) :
base(rb)
{
tableFeature = ((FeatureDataTable) (Table));
}
/// <summary>
/// reloads the data
/// </summary>
public void Reload()
{
using (System.Data.OleDb.OleDbConnection conn = new OleDbConnection(_ConnectionString))
{
string strSQL = "Select * FROM " + this.Table;
using (System.Data.OleDb.OleDbDataAdapter adapter = new OleDbDataAdapter(strSQL, conn))
{
conn.Open();
System.Data.DataSet ds2 = new System.Data.DataSet();
adapter.Fill(ds2);
conn.Close();
if (ds2.Tables.Count > 0)
{
m_fdt = new FeatureDataTable(ds2.Tables[0]);
foreach (System.Data.DataColumn col in ds2.Tables[0].Columns)
m_fdt.Columns.Add(col.ColumnName, col.DataType, col.Expression);
foreach (System.Data.DataRow dr in ds2.Tables[0].Rows)
{
SharpMap.Data.FeatureDataRow fdr = m_fdt.NewRow();
foreach (System.Data.DataColumn col in ds2.Tables[0].Columns)
fdr[col.ColumnName] = dr[col];
SharpMap.Geometries.Geometry geom = SharpMap.Converters.WellKnownBinary.GeometryFromWKB.Parse((byte[])dr[this.GeometryColumn]);
fdr.Geometry = geom;
m_fdt.AddRow(fdr);
}
}
}
}
}
/// <summary>
/// Protected constructor for the abstract class.
/// </summary>
/// <param name="httpClientUtil">A configured <see cref="HttpClientUtil"/> instance for performing web requests</param>
/// <param name="featureTypeInfo">A <see cref="WfsFeatureTypeInfo"/> instance providing metadata of the featuretype to query</param>
/// <param name="labelInfo">A FeatureDataTable for labels</param>
protected GeometryFactory(HttpClientUtil httpClientUtil, WfsFeatureTypeInfo featureTypeInfo,
FeatureDataTable labelInfo)
{
_FeatureTypeInfo = featureTypeInfo;
_HttpClientUtil = httpClientUtil;
createReader(httpClientUtil);
try
{
if (labelInfo != null)
{
_LabelInfo = labelInfo;
_LabelNode = new PathNode(_FeatureTypeInfo.FeatureTypeNamespace, _LabelInfo.Columns[0].ColumnName,
(NameTable) _XmlReader.NameTable);
}
}
catch (Exception ex)
{
Trace.TraceError("An exception occured while initializing the label path node!");
throw ex;
}
initializePathNodes();
initializeSeparators();
}
public void GetSetAttributesViaIFeature()
{
var featureTable = new FeatureDataTable();
featureTable.Columns.Add("name", typeof (string));
featureTable.Columns.Add("attribute1", typeof(int));
var feature1 = featureTable.NewRow();
feature1.Geometry = new Point(0, 0);
feature1["name"] = "feature1";
feature1["attribute1"] = 1;
featureTable.Rows.Add(feature1);
// now access it using IFeature iterfaces
IFeature f1 = feature1;
f1.Attributes.Count
.Should().Be.EqualTo(2);
f1.Attributes.Keys
.Should().Have.SameSequenceAs(new[] {"name", "attribute1"});
f1.Attributes["name"]
.Should().Be.EqualTo("feature1");
f1.Attributes["attribute1"]
.Should().Be.EqualTo(1);
f1.Attributes[0]
.Should().Be.EqualTo("feature1");
f1.Attributes[1]
.Should().Be.EqualTo(1);
}
public void AddedRowChangesRowState()
{
FeatureDataTable table = new FeatureDataTable();
FeatureDataRow row = table.NewRow();
table.AddRow(row);
Assert.AreEqual(DataRowState.Added, row.RowState);
}
/// <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, Geometry testGeometry)
{
//first we create a new GeometryFactory.
GeometryFactory 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
Geometry 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);
}
}
internal static FeatureDataTable<uint> GetFeatureTableForFields(IEnumerable<DbaseField> _dbaseColumns)
{
FeatureDataTable<uint> table = new FeatureDataTable<uint>(OidColumnName);
foreach (DbaseField dbf in _dbaseColumns)
{
DataColumn col = table.Columns.Add(dbf.ColumnName, dbf.DataType);
if (dbf.DataType == typeof(string))
{
col.MaxLength = dbf.Length;
}
else
{
col.ExtendedProperties[ProviderSchemaHelper.LengthExtendedProperty] = dbf.Length;
}
if (dbf.Decimals > 0)
{
col.ExtendedProperties[ProviderSchemaHelper.NumericPrecisionExtendedProperty] = dbf.Decimals;
}
}
return table;
}
public void ShowMapWithPointLayerBasedOnFeatureDataTable()
{
var table = new FeatureDataTable();
table.Columns.Add("X", typeof(double));
table.Columns.Add("Y", typeof(double));
table.Columns.Add("Category", typeof(string));
DataRow row = table.NewRow();
table.Rows.Add(row);
row.ItemArray = new object[] { 100000, 400000, "testCategory" };
row = table.NewRow();
table.Rows.Add(row);
row.ItemArray = new object[] { 200000, 400000, "TestCategory" };
var dataTablePoint = new DataTablePoint(table, "Category", "X", "Y");
var vectorLayer = new VectorLayer("test", dataTablePoint);
vectorLayer.Theme =ThemeFactory.CreateSingleFeatureTheme(vectorLayer.Style.GeometryType, Color.Blue, 10);
var map = new Map { Name = "testmap" };
map.Layers.Add(vectorLayer);
map.Center = new Coordinate(150000, 400000);
map.Zoom = 200000;
//map.ZoomToExtents();
//map.ZoomToBox(map.Envelope);
MapTestHelper.Show(map);
}
/// <summary>
/// Protected constructor for the abstract class.
/// </summary>
/// <param name="httpClientUtil">A configured <see cref="HttpClientUtil"/> instance for performing web requests</param>
/// <param name="featureTypeInfo">A <see cref="WfsFeatureTypeInfo"/> instance providing metadata of the featuretype to query</param>
/// <param name="labelInfo">A FeatureDataTable for labels</param>
protected GeometryFactory(HttpClientUtil httpClientUtil, WfsFeatureTypeInfo featureTypeInfo,
FeatureDataTable labelInfo)
{
_FeatureTypeInfo = featureTypeInfo;
Factory = featureTypeInfo.Factory;
_httpClientUtil = httpClientUtil;
createReader(httpClientUtil);
try
{
if (labelInfo != null)
{
_LabelInfo = labelInfo;
var pathNodes = new IPathNode[labelInfo.Columns.Count];
for (var i = 0; i < pathNodes.Length; i++)
{
pathNodes[i] = new PathNode(_FeatureTypeInfo.FeatureTypeNamespace, _LabelInfo.Columns[i].ColumnName, (NameTable)_XmlReader.NameTable);
}
_LabelNode = new AlternativePathNodesCollection(pathNodes);
}
}
catch (Exception ex)
{
Trace.TraceError("An exception occured while initializing the label path node!");
throw ex;
}
initializePathNodes();
initializeSeparators();
}
/// <summary>
/// little util wich just adds one vector layer to the map and assigns it a random theme.
/// </summary>
/// <param name="context"></param>
/// <param name="m"></param>
public static void SetupMap(HttpContext context, Map m)
{
var l = new VectorLayer(
"Countries",
new ShapeFile(context.Server.MapPath(ConfigurationManager.AppSettings["shpfilePath"])));
l.Style = RandomStyle.RandomVectorStyleNoSymbols();
l.Theme = new CustomTheme<IVectorStyle>(
delegate { return RandomStyle.RandomVectorStyleNoSymbols(); });
m.Layers.Add(l);
FeatureDataTable labelData = new FeatureDataTable();
labelData.Columns.Add("Name", typeof (string));
FeatureDataRow r = labelData.NewRow();
r["Name"] = "My Lair";
r.Geometry = new Point(5, 5);
labelData.AddRow(r);
LabelLayer labelLayer = new LabelLayer("labelLayer")
{
DataSource = new GeometryFeatureProvider(labelData),
Enabled = true,
LabelColumn = "Name",
Style = new LabelStyle
{
BackColor = new SolidBrush(Color.Black),
ForeColor = Color.White,
Halo = new Pen(Color.Yellow, 0.1F),
CollisionDetection = false,
Font = new Font("Arial", 10, GraphicsUnit.Point)
}
};
m.Layers.Add(labelLayer);
}
public void AcceptChangesAppearAsUnchanged()
{
FeatureDataTable table = new FeatureDataTable();
FeatureDataRow row = table.NewRow();
table.AddRow(row);
table.AcceptChanges();
Assert.AreEqual(DataRowState.Unchanged, row.RowState);
}
public void AddedRowAppearsAsChange()
{
FeatureDataTable table = new FeatureDataTable();
FeatureDataRow row = table.NewRow();
table.AddRow(row);
FeatureDataTable changes = table.GetChanges();
Assert.AreEqual(1, changes.FeatureCount);
}
public void AddedRowIncreasesRowCount()
{
FeatureDataTable table = new FeatureDataTable();
FeatureDataRow row = table.NewRow();
table.AddRow(row);
Assert.AreEqual(1, table.Rows.Count);
Assert.AreEqual(1, table.FeatureCount);
}
protected static FeatureDataTable CreateTable()
{
var res = new FeatureDataTable();
res.Columns.Add(new DataColumn("Oid", typeof(ushort)));
res.Columns.Add(new DataColumn("Value", typeof(double)));
res.Constraints.Add("PK_OID", res.Columns[0], true);
return res;
}
public void NewRowReturnsDetachedFeatureDataRow()
{
FeatureDataTable table = new FeatureDataTable();
FeatureDataRow row = table.NewRow();
Assert.IsNotNull(row);
Assert.AreEqual(0, table.Rows.Count);
Assert.AreEqual(DataRowState.Detached, row.RowState);
Assert.AreSame(table, row.Table);
}
public void AcceptChangesReturnsNullChangesTable()
{
FeatureDataTable table = new FeatureDataTable();
FeatureDataRow row = table.NewRow();
table.AddRow(row);
table.AcceptChanges();
FeatureDataTable changes = table.GetChanges();
Assert.IsNull(changes);
}
/// <summary>
/// Creates an instanc of this class
/// </summary>
/// <param name="content">The geopackage content</param>
public GpkgProvider(GpkgContent content)
:base(content.SRID)
{
_content = content;
ConnectionID = content.ConnectionString;
_reader = new GpkgStandardBinaryReader(GeoAPI.GeometryServiceProvider.Instance);
_extent = content.Extent;
_baseTable = content.GetBaseTable();
_rtreeConstraint = BuildRtreeConstraint(content);
}
private static FeatureDataTable CreateFeatureDataTable(string name)
{
var t1 = new FeatureDataTable { TableName = name };
t1.Columns.Add(new DataColumn("oid", typeof(uint)));
t1.Columns.Add(new DataColumn("P1", typeof(string)));
t1.Columns.Add(new DataColumn("P2", typeof(double)));
t1.Columns.Add(new DataColumn("P3", typeof(DateTime)));
t1.PrimaryKey = new[] { t1.Columns[0] };
return t1;
}
/// <summary>
/// Initializes a new instance of the <see cref="GeometryProvider"/>
/// </summary>
/// <param name="geometries">Set of geometries that this datasource should contain</param>
public GeometryFeatureProvider(Collection<Geometry> geometries)
{
_features = new FeatureDataTable();
foreach (Geometry geom in geometries)
{
FeatureDataRow fdr = _features.NewRow();
fdr.Geometry = geom;
_features.AddRow(fdr);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="GeometryProvider"/>
/// </summary>
/// <param name="geometries">Set of geometries that this datasource should contain</param>
public GeometryFeatureProvider(IEnumerable<IGeometry> geometries)
{
_features = new FeatureDataTable();
foreach (var geom in geometries)
{
var fdr = _features.NewRow();
fdr.Geometry = geom;
_features.AddRow(fdr);
}
_features.TableCleared += HandleFeaturesCleared;
}
public void KeepColumnNamesInSync()
{
var table = new FeatureDataTable();
var row = table.NewRow();
table.Rows.Add(row);
var accessor = new FeatureDataRowAttributeAccessor(row);
// now add column and check if it is available via accessor
table.Columns.Add("Name", typeof (string));
accessor.Count
.Should().Be.EqualTo(1);
}
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);
}
}
}
}
///// <summary>
///// Spacial Reference ID
///// </summary>
//public int SRID
//{
// get
// {
// if (_srid == -2)
// {
// string strSQL = "select SRID from USER_SDO_GEOM_METADATA WHERE TABLE_NAME='" + Table + "'";
// using (OracleConnection conn = new OracleConnection(ConnectionString))
// {
// using (OracleCommand command = new OracleCommand(strSQL, conn))
// {
// try
// {
// conn.Open();
// _srid = (int) (decimal) command.ExecuteScalar();
// conn.Close();
// }
// catch
// {
// _srid = -1;
// }
// }
// }
// }
// return _srid;
// }
// set { throw (new ApplicationException("Spatial Reference ID cannot by set on a Oracle table")); }
//}
/// <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 OracleConnection(ConnectionString))
{
string strSql = "select g.* , g." + GeometryColumn + ").Get_WKB() As sharpmap_tempgeometry from " +
Table + " g WHERE " + ObjectIdColumn + "='" + rowId.ToString(NumberFormatInfo.InvariantInfo) + "'";
using (var adapter = new OracleDataAdapter(strSql, conn))
{
var ds = new DataSet();
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);
}
}
if (ds.Tables[0].Rows.Count > 0)
{
DataRow dr = ds.Tables[0].Rows[0];
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);
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 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 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);
}
}
}
}
//[ExpectedException(typeof (NotImplementedException))]
public void DataViewManagerIsAFeatureDataViewManager()
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
FeatureDataSet dataSet = new FeatureDataSet(_factories.GeoFactory);
dataSet.Tables.Add(table);
FeatureDataView view = dataSet.DefaultViewManager.CreateDataView(table);
Assert.NotNull(view.DataViewManager);
Assert.IsType(typeof(FeatureDataViewManager), view.DataViewManager);
}
private void MapBox1_MapQueried(FeatureDataTable data)
{
this.Cursor = Cursors.WaitCursor;
isQuerying = true;
dgFacts.ClearSelection();
foreach (FeatureDataRow row in data)
{
if (row["DisplayFact"] != null && row["Colour"].ToString() == TearDropLayer.GREY)
{
DisplayFact dispFact = (DisplayFact)row["DisplayFact"];
SelectFact(dispFact);
}
}
isQuerying = false;
this.Cursor = Cursors.Default;
}
public void CloneToCopiesTableStructureAndNoData()
{
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureProvider provider = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(provider.GetExtents());
IFeatureDataReader reader = provider.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
FeatureDataTable clone = new FeatureDataTable(_factories.GeoFactory);
table.CloneTo(clone);
DataTableHelper.AssertTableStructureIdentical(table, clone);
Assert.Equal(0, clone.Rows.Count);
}
/// <summary>
/// Initializes a new instance of the <see cref="GeometryProvider"/>
/// </summary>
/// <param name="geometry">Geometry to be in this datasource</param>
public GeometryFeatureProvider(Geometry geometry)
{
_features = new FeatureDataTable();
var fdr = _features.NewRow();
fdr.Geometry = geometry;
if (geometry != null)
{
SRID = geometry.SRID;
}
_features.AddRow(fdr);
_features.AcceptChanges();
_features.TableCleared += HandleFeaturesCleared;
_features.Constraints.CollectionChanged += HandleConstraintsCollectionChanged;
}
private GeometryFeatureProvider CreateGraticuleDatasource()
{
var fdt = new FeatureDataTable {
TableName = "Graticule"
};
fdt.Columns.Add(new DataColumn("oid", typeof(uint)));
fdt.Columns[0].AutoIncrement = true;
fdt.Columns.Add(new DataColumn("Label", typeof(string)));
fdt.Columns.Add(new DataColumn("Major", typeof(bool)));
fdt.PrimaryKey = new[] { fdt.Columns[0] };
return(new GeometryFeatureProvider(fdt));
}
private static FeatureDataTable CreateMultiPointFeatureDataTable(IGeometryFactory geometryFactory)
{
var fdt = new FeatureDataTable <uint>("OID", geometryFactory);
fdt.Columns.AddRange(new[] { new DataColumn("X", typeof(double)), new DataColumn("Y", typeof(double)), });
for (uint i = 1; i <= 100; i++)
{
var row = fdt.NewRow(i);
var geom = row.Geometry = RandomMultiPoint(geometryFactory);
row["X"] = geom.Centroid[Ordinates.X];
row["Y"] = geom.Centroid[Ordinates.Y];
fdt.Rows.Add(row);
}
Assert.True(fdt.Rows.Count == 100);
return(fdt);
}
private static VectorLayer CreateGeometryFeatureProviderLayer(string name, System.Data.DataColumn[] columns)
{
var fdt = new FeatureDataTable();
fdt.Columns.Add("Oid", typeof(uint));
var con = new System.Data.UniqueConstraint(fdt.Columns[0]);
con.Columns[0].AutoIncrement = true;
con.Columns[0].AutoIncrementSeed = 1000;
fdt.Constraints.Add(con);
fdt.PrimaryKey = new System.Data.DataColumn[] { fdt.Columns[0] };
fdt.Columns.AddRange(columns);
return(new VectorLayer(name, new GeometryFeatureProvider(fdt)));
}
private static FeatureDataTable CreateFeatureDataTable(DataTable table)
{
var res = new FeatureDataTable(table);
foreach (DataColumn c in table.Columns)
{
var resc = new DataColumn(c.ColumnName, c.DataType);
resc.AllowDBNull = c.AllowDBNull;
resc.Caption = c.Caption;
resc.ColumnMapping = c.ColumnMapping;
resc.Expression = c.Expression;
res.Columns.Add(resc);
}
return(res);
}
/// <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 void DefaultViewIsFeatureDataView()
{
FeatureDataTable table = new FeatureDataTable();
DataView view = table.DefaultView;
Assert.IsNotNull(view);
Assert.IsInstanceOfType(typeof(FeatureDataView), view);
Assert.IsNull(view.DataViewManager);
Assert.AreEqual(String.Empty, view.Sort);
Assert.AreEqual(String.Empty, view.RowFilter);
Assert.AreEqual(0, view.Count);
Assert.AreSame(table, view.Table);
FeatureDataView featureView = view as FeatureDataView;
Assert.IsNotNull(featureView);
Assert.IsNull(featureView.GeometryFilter);
Assert.AreEqual(DataViewRowState.CurrentRows, view.RowStateFilter);
}
/// <summary>
///
/// </summary>
/// <param name="geom"></param>
/// <param name="ds"></param>
public void ExecuteIntersectionQuery(Geometry geom, FeatureDataSet ds)
{
GisSharpBlog.NetTopologySuite.Geometries.Geometry 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>
/// Check if the layer can be queried and retrieve data, if there is any.
/// </summary>
protected bool TryGetData(Map map,
float x, float y,
int pixelSensitivity,
WmsServer.InterSectDelegate intersectDelegate,
ICanQueryLayer queryLayer,
string cqlFilter,
out FeatureDataSet fds)
{
if (!queryLayer.IsQueryEnabled)
{
fds = null;
return false;
}
float queryBoxMinX = x - pixelSensitivity;
float queryBoxMinY = y - pixelSensitivity;
float queryBoxMaxX = x + pixelSensitivity;
float queryBoxMaxY = y + pixelSensitivity;
Coordinate minXY = map.ImageToWorld(new PointF(queryBoxMinX, queryBoxMinY));
Coordinate maxXY = map.ImageToWorld(new PointF(queryBoxMaxX, queryBoxMaxY));
Envelope queryBox = new Envelope(minXY, maxXY);
fds = new FeatureDataSet();
queryLayer.ExecuteIntersectionQuery(queryBox, fds);
FeatureTableCollection tables = fds.Tables;
FeatureDataTable table = tables[0];
if (intersectDelegate != null)
tables[0] = intersectDelegate(table, queryBox);
// filter the rows with the CQLFilter if one is provided
if (cqlFilter != null)
{
DataRowCollection rows = table.Rows;
for (int i = rows.Count - 1; i >= 0; i--)
{
FeatureDataRow row = (FeatureDataRow)rows[i];
bool b = CqlFilter(row, cqlFilter);
if (!b)
rows.RemoveAt(i);
}
}
bool res = tables.Count > 0 && table.Rows.Count > 0;
return res;
}
/// <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"));
}
}
/// <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 " + Table + " 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);
}
}
}
/// <summary>
/// Returns all features with the view box
/// </summary>
/// <param name="bbox">view box</param>
/// <param name="d"></param>
/// <param name="ds">FeatureDataSet to fill data into</param>
public IEnumerable <IFeature> GetFeatures(IEnvelope bbox)
{
//List<Geometries.Geometry> features = new List<SharpMap.Geometries.Geometry>();
using (System.Data.OleDb.OleDbConnection conn = new OleDbConnection(_ConnectionString))
{
string strSQL = "Select * FROM " + this.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 += this.XColumn + " BETWEEN " + bbox.MinX.ToString(SharpMap.Map.numberFormat_EnUS) + " AND " + bbox.MaxX.ToString(SharpMap.Map.numberFormat_EnUS) + " AND " + this.YColumn +
" BETWEEN " + bbox.MaxY.ToString(SharpMap.Map.numberFormat_EnUS) + " AND " + bbox.MinY.ToString(SharpMap.Map.numberFormat_EnUS);
using (System.Data.OleDb.OleDbDataAdapter adapter = new OleDbDataAdapter(strSQL, conn))
{
conn.Open();
System.Data.DataSet ds2 = new System.Data.DataSet();
adapter.Fill(ds2);
conn.Close();
if (ds2.Tables.Count > 0)
{
FeatureDataTable fdt = new FeatureDataTable(ds2.Tables[0]);
foreach (System.Data.DataColumn col in ds2.Tables[0].Columns)
{
fdt.Columns.Add(col.ColumnName, col.DataType, col.Expression);
}
foreach (System.Data.DataRow dr in ds2.Tables[0].Rows)
{
SharpMap.Data.FeatureDataRow fdr = fdt.NewRow();
foreach (System.Data.DataColumn col in ds2.Tables[0].Columns)
{
fdr[col.ColumnName] = dr[col];
}
if (dr[this.XColumn] != DBNull.Value && dr[this.YColumn] != DBNull.Value)
{
fdr.Geometry = SharpMap.Converters.Geometries.GeometryFactory.CreatePoint((double)dr[this.XColumn], (double)dr[this.YColumn]);
}
fdt.AddRow(fdr);
}
return(fdt);
}
}
}
return(null);
}
/// <summary>
/// Returns a datarow based on a RowID
/// </summary>
/// <param name="RowID"></param>
/// <returns>datarow</returns>
public SharpMap.Data.FeatureDataRow GetFeature(uint RowID)
{
using (SqlConnection conn = new SqlConnection(_ConnectionString))
{
string strSQL = "SELECT *, " + this.GeometryColumn + " AS sharpmap_tempgeometry FROM " + this.Table + " WHERE " + this.ObjectIdColumn + "='" + RowID.ToString() + "'";
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 (System.Data.DataColumn col in ds.Tables[0].Columns)
{
if (col.ColumnName != this.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)
{
System.Data.DataRow dr = ds.Tables[0].Rows[0];
SharpMap.Data.FeatureDataRow fdr = fdt.NewRow();
foreach (System.Data.DataColumn col in ds.Tables[0].Columns)
{
if (col.ColumnName != this.GeometryColumn && col.ColumnName != "sharpmap_tempgeometry" && !col.ColumnName.StartsWith("Envelope_"))
{
fdr[col.ColumnName] = dr[col];
}
}
fdr.Geometry = SharpMap.Converters.WellKnownText.GeometryFromWKT.Parse(dr["sharpmap_tempgeometry"].ToString());
return(fdr);
}
else
{
return(null);
}
}
else
{
return(null);
}
}
}
}
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>
/// Returns a datarow based on a RowID
/// </summary>
/// <param name="RowID"></param>
/// <returns>datarow</returns>
public SharpMap.Data.FeatureDataRow GetFeature(uint RowID)
{
using (Npgsql.NpgsqlConnection conn = new Npgsql.NpgsqlConnection(_ConnectionString))
{
string strSQL = "select * , AsBinary(" + this.GeometryColumn + ") As sharpmap_tempgeometry from " + this.Table + " WHERE " + this.ObjectIdColumn + "='" + RowID.ToString() + "'";
using (Npgsql.NpgsqlDataAdapter adapter = new Npgsql.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 (System.Data.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)
{
System.Data.DataRow dr = ds.Tables[0].Rows[0];
SharpMap.Data.FeatureDataRow fdr = fdt.NewRow();
foreach (System.Data.DataColumn col in ds.Tables[0].Columns)
{
if (col.ColumnName != this.GeometryColumn && col.ColumnName != "sharpmap_tempgeometry")
{
fdr[col.ColumnName] = dr[col];
}
}
fdr.Geometry = SharpMap.Converters.WellKnownBinary.GeometryFromWKB.Parse((byte[])dr["sharpmap_tempgeometry"]);
return(fdr);
}
else
{
return(null);
}
}
else
{
return(null);
}
}
}
}
private FeatureDataTable CreateTableFromReader(DbDataReader reader, int geomIndex)
{
var res = new FeatureDataTable {
TableName = Table
};
for (var c = 0; c < geomIndex; c++)
{
var fieldType = reader.GetFieldType(c);
if (fieldType == null)
{
throw new Exception("Unable to retrieve field type for column " + c);
}
res.Columns.Add(reader.GetName(c), fieldType);
}
return(res);
}
public VectorLayer CreateGeometryLayer()
{
var gf = new NetTopologySuite.Geometries.GeometryFactory();
var fdt = new FeatureDataTable();
fdt.Columns.Add(new DataColumn("Name", typeof (String)));
fdt.BeginLoadData();
var fdr = (FeatureDataRow)fdt.LoadDataRow(new[] {(object) "Mayence"}, true);
fdr.Geometry = gf.CreatePoint(new Point(8.1, 50.0));
fdt.EndLoadData();
var vLayer = new VectorLayer("GeometryProvider");
vLayer.DataSource = new FeatureProvider(fdt);
vLayer.SRID = 4326;
return vLayer;
}
/// <summary>
/// Throws an NotSupportedException. Attribute data is not supported by this datasource
/// </summary>
/// <param name="box"></param>
/// <param name="ds">FeatureDataSet to fill data into</param>
public void ExecuteIntersectionQuery(SharpMap.Geometries.BoundingBox box, FeatureDataSet ds)
{
FeatureDataTable fdt = new FeatureDataTable();
fdt = _features.Clone();
foreach (FeatureDataRow fdr in _features)
{
if (fdr.Geometry.GetBoundingBox().Intersects(box))
{
fdt.LoadDataRow(fdr.ItemArray, false);
(fdt.Rows[fdt.Rows.Count - 1] as FeatureDataRow).Geometry = fdr.Geometry;
}
}
ds.Tables.Add(fdt);
}
public void render3d(Project project, SceneManager sceneMgr)
{
SharpMap.Map myMap = new SharpMap.Map();
foreach (BuildLayer layer in project.getLayers())
{
Source source = layer.getSource();
BoundingBox envelope = new BoundingBox(-1000.0, -1000.0, 1000.0, 1000.0);//TODO
FeatureDataSet ds = new FeatureDataSet();
source.DataSource.Open();
source.DataSource.ExecuteIntersectionQuery(envelope, ds);
source.DataSource.Close();
FeatureDataTable features = (FeatureDataTable)ds.Tables[0];
//El codigo del PFC
//**********************************************************************************************************
//Show map
//Filters
FilterGraph graph = project.getFilterGraph(source.getName());
if (graph != null)
{
graph.Successors();
FilterEnv env = new FilterEnv(sceneMgr, source.getName());
FeatureList list = Feature.DataTableToList(features);
if (graph.getFilter(1) is FeatureFilter)
{
FeatureFilter filter = (FeatureFilter)graph.getFilter(1);
FeatureList l = filter.process(list, env);
}
else if (graph.getFilter(1) is FragmentFilter)
{
FragmentFilter filter = (FragmentFilter)graph.getFilter(1);
FragmentList l = filter.process(list, env);
}
}
//**********************************************************************************************************
}
}
public FeatureDataRow GetFeature(uint rowId)
{
using (SQLiteConnection conn = SpatiaLiteConnection(_connectionString))
{
string strSQL = "SELECT *, AsBinary(" + GeometryColumn + ") AS sharpmap_tempgeometry FROM " + Table +
" WHERE " + ObjectIdColumn + "='" + rowId + "'";
using (SQLiteDataAdapter adapter = new SQLiteDataAdapter(strSQL, conn))
{
DataSet ds = new DataSet();
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 = GeometryFromWKB.Parse((byte[])dr["sharpmap_tempgeometry"]);
}
return(fdr);
}
return(null);
}
return(null);
}
}
}
/// <summary>
/// Throws an NotSupportedException. Attribute data is not supported by this datasource
/// </summary>
/// <param name="box"></param>
/// <param name="ds">FeatureDataSet to fill data into</param>
public virtual void ExecuteIntersectionQuery(IEnvelope box, FeatureDataSet ds)
{
FeatureDataTable dt = AttributesTable.Clone();
foreach (FeatureDataRow row in AttributesTable)
{
if (!row.Geometry.IsEmpty)
{
if (row.Geometry.EnvelopeInternal.Intersects(box))
{
dt.Rows.Add(row.ItemArray);
((FeatureDataRow)dt.Rows[dt.Count - 1]).Geometry = row.Geometry;
}
}
}
ds.Tables.Add(dt);
}
/// <summary>
/// Reads the field types from the OgrFeatureDefinition -> OgrFieldDefinition
/// </summary>
/// <param name="fdt">FeatureDatatTable</param>
/// <param name="oLayer">OgrLayer</param>
private static void ReadColumnDefinition(FeatureDataTable fdt, OgrLayer oLayer)
{
using (OgrFeatureDefn ogrFeatureDefn = oLayer.GetLayerDefn())
{
int iField;
for (iField = 0; iField < ogrFeatureDefn.GetFieldCount(); iField++)
{
using (OgrFieldDefn ogrFldDef = ogrFeatureDefn.GetFieldDefn(iField))
{
OgrFieldType type = ogrFldDef.GetFieldType();
switch (type)
{
case OgrFieldType.OFTInteger:
fdt.Columns.Add(ogrFldDef.GetName(), typeof(Int32));
break;
case OgrFieldType.OFTReal:
fdt.Columns.Add(ogrFldDef.GetName(), typeof(Double));
break;
case OgrFieldType.OFTString:
fdt.Columns.Add(ogrFldDef.GetName(), typeof(String));
break;
case OgrFieldType.OFTWideString:
fdt.Columns.Add(ogrFldDef.GetName(), typeof(String));
break;
case OgrFieldType.OFTDate:
case OgrFieldType.OFTTime:
case OgrFieldType.OFTDateTime:
fdt.Columns.Add(ogrFldDef.GetName(), typeof(DateTime));
break;
default:
{
//fdt.Columns.Add(_OgrFldDef.GetName(), System.Type.GetType("System.String"));
Debug.WriteLine("Not supported type: " + type + " [" + ogrFldDef.GetName() + "]");
break;
}
}
}
}
}
}
public void LayersWithThemeGroupShareMinMax()
{
var table = new FeatureDataTable();
table.Columns.Add("Id", typeof(int));
table.Columns.Add("X", typeof(double));
table.Columns.Add("Y", typeof(double));
table.Columns.Add("Value", typeof(double));
AddRow(table, new object[] { 0, 5.0, 5.0, 0.0 });
AddRow(table, new object[] { 1, 10.0, 10.0, 10.0 });
var dataSource = new DataTablePoint(table, "Id", "X", "Y");
var table2 = new FeatureDataTable();
table2.Columns.Add("Id", typeof(int));
table2.Columns.Add("X", typeof(double));
table2.Columns.Add("Y", typeof(double));
table2.Columns.Add("Value", typeof(double));
AddRow(table2, new object[] { 0, 5.0, 2.0, 0.0 });
AddRow(table2, new object[] { 1, 10.0, 4.0, 10.0 });
AddRow(table2, new object[] { 2, 7.0, 10.0, 20.0 });
var dataSource2 = new DataTablePoint(table2, "Id", "X", "Y");
var basicTheme = ThemeFactory.CreateGradientTheme("Value", null, ColorBlend.Rainbow7, 0.0, 5.0, 3, 3, false, true, 3);
var layer = new VectorLayer {
AutoUpdateThemeOnDataSourceChanged = true, ThemeGroup = "group1", DataSource = dataSource, Theme = basicTheme
};
var layer2 = new VectorLayer {
AutoUpdateThemeOnDataSourceChanged = true, ThemeGroup = "group1", DataSource = dataSource2, Theme = basicTheme
};
var map = new Map();
map.Layers.Add(layer);
Assert.AreEqual(10.0, ((GradientTheme)layer.Theme).Max); // refresh on add
map.Layers.Add(layer2);
Assert.AreEqual(20.0, ((GradientTheme)layer.Theme).Max); // both to max of the group
Assert.AreEqual(20.0, ((GradientTheme)layer2.Theme).Max);
map.Layers.Remove(layer2);
Assert.AreEqual(10.0, ((GradientTheme)layer.Theme).Max); // refresh on remove
}
/// <summary>
/// Returns a datarow based on a RowID
/// </summary>
/// <param name="rowId"></param>
/// <returns>datarow</returns>
public FeatureDataRow GetFeature(uint rowId)
{
using (OleDbConnection conn = new OleDbConnection(_ConnectionString))
{
string strSQL = "select * from " + Table + " WHERE " + ObjectIdColumn + "=" + rowId.ToString();
using (OleDbDataAdapter adapter = new OleDbDataAdapter(strSQL, conn))
{
conn.Open();
DataSet ds = new DataSet();
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)
{
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)
{
fdr[col.ColumnName] = dr[col];
}
if (dr[XColumn] != DBNull.Value && dr[YColumn] != DBNull.Value)
{
fdr.Geometry = new Point((double)dr[XColumn], (double)dr[YColumn]);
}
return(fdr);
}
else
{
return(null);
}
}
else
{
return(null);
}
}
}
}
public void ExecuteIntersectionQueryReturnsExpectedFeatures()
{
DataTable source = CreateDataTableSource();
DataTablePoint provider = new DataTablePoint(source, "oid", "x", "y");
var query = new Envelope(400, 600, 400, 600);
FeatureDataTable expected = new FeatureDataTable();
expected.TableName = "PointSource";
foreach (DataColumn column in source.Columns)
{
expected.Columns.Add(column.ColumnName, column.DataType);
}
foreach (DataRowView rowView in source.DefaultView)
{
if (query.Contains(new Coordinate((double) rowView["x"], (double) rowView["y"])))
{
expected.ImportRow(rowView.Row);
}
}
FeatureDataSet dataSet = new FeatureDataSet();
provider.ExecuteIntersectionQuery(query, dataSet);
Assert.IsNotNull(dataSet);
Assert.IsNotNull(dataSet.Tables);
Assert.AreEqual(1, dataSet.Tables.Count);
FeatureDataTable actual = dataSet.Tables[0];
Assert.AreEqual(expected.Rows.Count, actual.Rows.Count);
foreach (DataRowView expectedRowView in expected.DefaultView)
{
DataRow[] actualRows = actual.Select("oid = " + expectedRowView["oid"]);
Assert.AreEqual(1, actualRows.Length);
Assert.AreEqual(expectedRowView["oid"], actualRows[0]["oid"]);
Assert.AreEqual(expectedRowView["x"], actualRows[0]["x"]);
Assert.AreEqual(expectedRowView["y"], actualRows[0]["y"]);
}
}
public void CreateNewWithAttributesSchemaTest()
{
FeatureDataTable schema = new FeatureDataTable(_geoFactory);
schema.Columns.AddRange(new DataColumn[]
{
new DataColumn("Name", typeof (String)),
new DataColumn("Date_Created", typeof (DateTime)),
new DataColumn("Visits", typeof (Int32)),
new DataColumn("Weight", typeof (Single))
});
ShapeFileProvider shapeFile = ShapeFileProvider.Create("UnitTestData", "Test1", ShapeType.Point, schema, _geoFactory);
Assert.IsTrue(File.Exists(@"UnitTestData\Test1.shp"));
Assert.IsTrue(File.Exists(@"UnitTestData\Test1.shx"));
Assert.IsTrue(File.Exists(@"UnitTestData\Test1.dbf"));
Assert.IsTrue(shapeFile.HasDbf);
shapeFile.Close();
File.Delete(@"UnitTestData\Test1.shp");
File.Delete(@"UnitTestData\Test1.shx");
File.Delete(@"UnitTestData\Test1.dbf");
}
public VectorLayer CreateGeometryLayer()
{
FeatureDataTable fdt = new FeatureDataTable();
fdt.Columns.Add(new DataColumn("Name", typeof (String)));
FeatureDataRow fdr;
fdr = fdt.NewRow();
fdr["Name"] = "Mayence";
fdr.Geometry = (Geometry) new Point(8.1, 50.0);
fdt.AddRow(fdr);
VectorLayer vLayer = new VectorLayer("GeometryProvider");
vLayer.DataSource = new GeometryFeatureProvider(fdt);
vLayer.SRID = 4326;
return vLayer;
}
internal FeatureMerger(FeatureDataTable target, bool preserveChanges, SchemaMergeAction mergeAction)
{
if ((SchemaMergeAction.ConvertTypes & mergeAction) != SchemaMergeAction.None)
{
throw new NotImplementedException("SchemaMergeAction.ConvertTypes is currently not supported.");
}
if ((SchemaMergeAction.KeyByType & mergeAction) != SchemaMergeAction.None)
{
throw new NotImplementedException("SchemaMergeAction.KeyByType is currently not supported.");
}
if ((SchemaMergeAction.CaseInsensitive & mergeAction) != SchemaMergeAction.None)
{
throw new NotImplementedException("SchemaMergeAction.CaseInsensitive is currently not supported.");
}
_target = target;
_preserveChanges = preserveChanges;
_mergeAction = mergeAction;
_innerMerger = createInnerMerger(target, preserveChanges, mergeAction);
}
internal FeatureDataReader(IGeometryFactory factory,
FeatureDataTable source,
FeatureQueryExpression query,
FeatureQueryExecutionOptions options)
{
if (source == null) throw new ArgumentNullException("source");
if (options != FeatureQueryExecutionOptions.FullFeature)
{
throw new ArgumentException("Only QueryExecutionOptions.All is supported.",
"options");
}
_factory = factory;
_options = options;
_query = query;
_table = source.Clone();
foreach (FeatureDataRow row in source.Select(query.SpatialPredicate))
{
_table.ImportRow(row);
}
}
public void FixtureSetUp()
{
var fdt = new FeatureDataTable();
fdt.Columns.Add(new DataColumn("ID", typeof (int)));
fdt.Columns.Add(new DataColumn("LABEL", typeof (string)));
fdt.Columns.Add(new DataColumn("HALIGN", typeof (int)));
fdt.Columns.Add(new DataColumn("VALIGN", typeof (int)));
var factory = GeoAPI.GeometryServiceProvider.Instance.CreateGeometryFactory(4236);
for (var i = 0; i < 3; i++)
{
for (var j = 0; j < 3; j++)
{
var fdr = fdt.NewRow();
fdr[0] = i*3 + j;
fdr[1] = string.Format("Point({0}, {1})\nID {2}", i, j, i*3 + j);
fdr[2] = j;
fdr[3] = i;
fdr.Geometry = factory.CreatePoint(new Coordinate(j*100, i*100));
fdt.AddRow(fdr);
}
}
_featureDataTable = fdt;
}
private void InitClass()
{
DataSetName = "Map_Info_Tables";
Prefix = "";
Namespace = "";
Locale = new CultureInfo("en-US");
CaseSensitive = false;
EnforceConstraints = true;
tableFeature = new FeatureDataTable();
Tables.Add(tableFeature);
tableStreet = new StreetDataTable();
Tables.Add(tableStreet);
tableCorporation_Link = new Corporation_LinkDataTable();
Tables.Add(tableCorporation_Link);
tablePerson_Link = new Person_LinkDataTable();
Tables.Add(tablePerson_Link);
tableSheet_Link = new Sheet_LinkDataTable();
Tables.Add(tableSheet_Link);
ForeignKeyConstraint fkc;
fkc = new ForeignKeyConstraint("Feature_Corp_Link", new DataColumn[]
{
tableFeature.FeatureIDColumn
}, new DataColumn[]
{
tableCorporation_Link.FeatureIDColumn
});
tableCorporation_Link.Constraints.Add(fkc);
fkc.AcceptRejectRule = AcceptRejectRule.None;
fkc.DeleteRule = Rule.Cascade;
fkc.UpdateRule = Rule.Cascade;
fkc = new ForeignKeyConstraint("Feature_Person_Link", new DataColumn[]
{
tableFeature.FeatureIDColumn
}, new DataColumn[]
{
tablePerson_Link.FeatureIDColumn
});
tablePerson_Link.Constraints.Add(fkc);
fkc.AcceptRejectRule = AcceptRejectRule.None;
fkc.DeleteRule = Rule.Cascade;
fkc.UpdateRule = Rule.Cascade;
fkc = new ForeignKeyConstraint("Feature_Sheet_Link", new DataColumn[]
{
tableFeature.FeatureIDColumn
}, new DataColumn[]
{
tableSheet_Link.FeatureIDColumn
});
tableSheet_Link.Constraints.Add(fkc);
fkc.AcceptRejectRule = AcceptRejectRule.None;
fkc.DeleteRule = Rule.Cascade;
fkc.UpdateRule = Rule.Cascade;
relationFeature_Corp_Link = new DataRelation("Feature_Corp_Link", new DataColumn[]
{
tableFeature.FeatureIDColumn
}, new DataColumn[]
{
tableCorporation_Link.FeatureIDColumn
}, false);
Relations.Add(relationFeature_Corp_Link);
relationFeature_Person_Link = new DataRelation("Feature_Person_Link", new DataColumn[]
{
tableFeature.FeatureIDColumn
}, new DataColumn[]
{
tablePerson_Link.FeatureIDColumn
}, false);
Relations.Add(relationFeature_Person_Link);
relationFeature_Sheet_Link = new DataRelation("Feature_Sheet_Link", new DataColumn[]
{
tableFeature.FeatureIDColumn
}, new DataColumn[]
{
tableSheet_Link.FeatureIDColumn
}, false);
Relations.Add(relationFeature_Sheet_Link);
}
