public void MovingRowTriggersViewListChangedItemMovedNotification()
{
// TODO: implement MovingRowTriggersViewListChangedItemMovedNotification
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
IExtents halfBounds = data.GetExtents();
halfBounds.Scale(0.5);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
FeatureDataView view = new FeatureDataView(table);
Boolean addNotificationOccured = false;
view.ListChanged += delegate(Object sender, ListChangedEventArgs e)
{
if (e.ListChangedType == ListChangedType.ItemMoved)
{
addNotificationOccured = true;
}
};
Assert.True(addNotificationOccured);
}
public void Flush()
{
var lineString = newArrowLineGeometry;
if (null == lineString)
{
return;
}
FeatureProvider.Add(lineString);
StopDrawing();
IFeature feature = FeatureProvider.GetFeature(FeatureProvider.GetFeatureCount() - 1);
// hack? sourceLayer doesn't have to be part of a network; thus we are
// required to force repaint. DataSource has no knowledge of layer.
Layer.RenderRequired = true;
if (null != feature)
{
MapControl.SelectTool.Select(Layer, feature, 0);
}
newArrowLineGeometry = null;
}
public override void OnMouseUp(ICoordinate worldPosition, MouseEventArgs e)
{
if (!isBusy)
{
return;
}
if (null == snapResult)
{
MapControl.SelectTool.Clear();
}
else
{
GeometryHelper.SetCoordinate(newNode, 0, snapResult.Location);
FeatureProvider.Add(newNode);
IFeature feature = FeatureProvider.GetFeature(FeatureProvider.GetFeatureCount() - 1);
IFeatureEditor featureEditor = MapControl.SelectTool.GetFeatureEditor(Layer, feature);
//if (null != featureEditor)
//{only when move
// featureEditor.Start();
// featureEditor.Stop(snapResult);
//}
Layer.RenderRequired = true;
MapControl.SelectTool.Select(Layer, feature, 0);
}
isBusy = false;
StopDrawing();
MapControl.Refresh();
}
private void Form2_Load(object sender, EventArgs e)
{
//TileAsyncLayer osmLayer= new TileAsyncLayer(new OsmTileSource(), "TileLayer - OSM");
TileAsyncLayer bingLayer = new TileAsyncLayer(new BingTileSource(BingRequest.UrlBing, "", BingMapType.Roads), "TileLayer - Bing");
this.mapBox1.Map.BackgroundLayer.Add(bingLayer);
GeometryFactory gf = new GeometryFactory(new PrecisionModel(), 3857);
#if DotSpatialProjections
var mathTransform = LayerTools.Wgs84toGoogleMercator;
var geom = GeometryTransform.TransformBox(
new Envelope(-9.205626, -9.123736, 38.690993, 38.740837),
mathTransform.Source, mathTransform.Target);
#else
IMathTransform mathTransform = LayerTools.Wgs84toGoogleMercator.MathTransform;
Envelope geom = GeometryTransform.TransformBox(
new Envelope(-9.205626, -9.123736, 38.690993, 38.740837),
mathTransform);
#endif
//Adds a pushpin layer
VectorLayer pushPinLayer = new VectorLayer("PushPins");
List<IGeometry> geos = new List<IGeometry>();
geos.Add(gf.CreatePoint(geom.Centre));
var geoProvider = new FeatureProvider(geos);
pushPinLayer.DataSource = geoProvider;
//this.mapBox1.Map.Layers.Add(pushPinLayer);
this.mapBox1.Map.ZoomToBox(geom);
this.mapBox1.Map.Zoom = 8500;
this.mapBox1.Refresh();
}
public void ChangeViewSpatialFilterTriggersNotification()
{
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);
FeatureDataView view = new FeatureDataView(table);
Boolean resetNotificationOccured = false;
view.ListChanged += delegate(Object sender, ListChangedEventArgs e)
{
if (e.ListChangedType == ListChangedType.Reset)
{
resetNotificationOccured = true;
}
};
Assert.False(resetNotificationOccured);
IExtents queryExtents = _factories.GeoFactory.CreateExtents2D(0, 0, 10, 10);
SpatialBinaryExpression expression = SpatialBinaryExpression.Intersects(queryExtents);
view.SpatialFilter = expression;
Assert.True(resetNotificationOccured);
}
public void AddingRowToTableTriggersViewListChangedItemAddedNotification()
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
IExtents halfBounds = data.GetExtents();
halfBounds.Scale(0.5);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(halfBounds);
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
FeatureDataView view = new FeatureDataView(table);
Boolean addNotificationOccured = false;
view.ListChanged += delegate(Object sender, ListChangedEventArgs e)
{
if (e.ListChangedType == ListChangedType.ItemAdded)
{
addNotificationOccured = true;
}
};
FeatureDataRow row = table.NewRow();
row["Oid"] = Guid.NewGuid();
row["FeatureName"] = "New row";
row.Geometry = _factories.GeoFactory.CreatePoint2D(44, 44);
table.AddRow(row);
Assert.True(addNotificationOccured);
}
public virtual IEnumerable <FeatureProvider> CreateFeatureProviders(Type featureProviderType, Predicate <Type> match)
{
if (featureProviderType == null)
{
throw new ArgumentNullException("featureProviderType");
}
if (match == null)
{
throw new ArgumentNullException("match");
}
if (!typeof(FeatureProvider).IsAssignableFrom(featureProviderType))
{
throw new ArgumentException(string.Format((IFormatProvider)CultureInfo.CurrentCulture, Resources.Error_IncorrectTypePassed, new object[1]
{
(object)typeof(FeatureProvider).Name
}));
}
if (this._knownFeatureProviders != null)
{
foreach (Type type in this._knownFeatureProviders)
{
if (featureProviderType.IsAssignableFrom(type) && match(type))
{
FeatureProvider featureProvider = FeatureManager.CreateFeatureProvider(type);
if (featureProvider != null)
{
yield return(featureProvider);
}
}
}
}
}
public void ChangeViewSpatialFilterReturnsOnlyFilteredRows()
{
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);
IGeometry queryExtents = _factories.GeoFactory.CreateExtents2D(0, 0, 10, 10).ToGeometry();
List <FeatureDataRow> expectedRows = new List <FeatureDataRow>();
foreach (FeatureDataRow row in table)
{
IGeometry g = row.Geometry;
if (queryExtents.Intersects(g))
{
expectedRows.Add(row);
}
}
FeatureDataView view = new FeatureDataView(table);
SpatialBinaryExpression expression = SpatialBinaryExpression.Intersects(queryExtents);
view.SpatialFilter = expression;
Assert.Equal(expectedRows.Count, view.Count);
}
public override void OnMouseUp(ICoordinate worldPosition, MouseEventArgs e)
{
if (!isBusy)
{
return;
}
if (null == snapResult)
{
MapControl.SelectTool.Clear();
}
else
{
GeometryHelper.SetCoordinate(newNode, 0, snapResult.Location);
var feature = FeatureProvider.Add(newNode);
if (feature == null)
{
isBusy = false;
return;
}
Layer.RenderRequired = true;
MapControl.SelectTool.Select(Layer, feature, 0);
}
isBusy = false;
StopDrawing();
MapControl.Refresh();
}
public void ChangeViewAttributeFilterTriggersNotification()
{
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);
FeatureDataView view = new FeatureDataView(table);
Boolean resetNotificationOccured = false;
view.ListChanged += delegate(Object sender, ListChangedEventArgs e)
{
if (e.ListChangedType == ListChangedType.Reset)
{
resetNotificationOccured = true;
}
};
Assert.False(resetNotificationOccured);
Assert.Throws <NotSupportedException>(delegate { view.RowFilter = "FeatureName LIKE 'A m*'"; });
Assert.True(resetNotificationOccured);
}
private void Form2_Load(object sender, EventArgs e)
{
//TileAsyncLayer osmLayer= new TileAsyncLayer(new OsmTileSource(), "TileLayer - OSM");
TileAsyncLayer bingLayer = new TileAsyncLayer(new BingTileSource(BingRequest.UrlBing, "", BingMapType.Roads), "TileLayer - Bing");
this.mapBox1.Map.BackgroundLayer.Add(bingLayer);
GeometryFactory gf = new GeometryFactory(new PrecisionModel(), 3857);
#if DotSpatialProjections
var mathTransform = LayerTools.Wgs84toGoogleMercator;
var geom = GeometryTransform.TransformBox(
new Envelope(-9.205626, -9.123736, 38.690993, 38.740837),
mathTransform.Source, mathTransform.Target);
#else
IMathTransform mathTransform = LayerTools.Wgs84toGoogleMercator.MathTransform;
Envelope geom = GeometryTransform.TransformBox(
new Envelope(-9.205626, -9.123736, 38.690993, 38.740837),
mathTransform);
#endif
//Adds a pushpin layer
VectorLayer pushPinLayer = new VectorLayer("PushPins");
List <IGeometry> geos = new List <IGeometry>();
geos.Add(gf.CreatePoint(geom.Centre));
var geoProvider = new FeatureProvider(geos);
pushPinLayer.DataSource = geoProvider;
//this.mapBox1.Map.Layers.Add(pushPinLayer);
this.mapBox1.Map.ZoomToBox(geom);
this.mapBox1.Map.Zoom = 8500;
this.mapBox1.Refresh();
}
public void Flush()
{
ILineString lineString = (ILineString)newLineGeometry[0];
if (null == lineString)
{
return;
}
// MouseDoubleClick has added 2 points at the end of the line; remove the last point.
lineString = RemoveDuplicatePoints(lineString);
if (null != lineString)
{
FeatureProvider.Add(lineString);
}
StopDrawing();
IFeature feature = FeatureProvider.GetFeature(FeatureProvider.GetFeatureCount() - 1);
// hack? sourceLayer doesn't have to be part of a network; thus we are
// required to force repaint. DataSource has no knowledge of layer.
Layer.RenderRequired = true;
if (null != feature)
{
MapControl.SelectTool.Select(Layer, feature, 0);
}
newLineGeometry.Clear();
}
public void SettingOidFilterAllowsOnlyFeaturesContainingFilteredOidsInView()
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable <Guid> table = new FeatureDataTable <Guid>("Oid", _factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
Guid[] ids = new Guid[3];
ids[0] = (table.Rows[1] as FeatureDataRow <Guid>).Id;
ids[1] = (table.Rows[4] as FeatureDataRow <Guid>).Id;
ids[2] = (table.Rows[6] as FeatureDataRow <Guid>).Id;
FeatureDataView view = new FeatureDataView(table);
view.OidFilter = new OidCollectionExpression(ids);
Assert.Equal(3, view.Count);
Assert.True(view.Find(ids[0]) > -1);
Assert.True(view.Find(ids[1]) > -1);
Assert.True(view.Find(ids[2]) > -1);
Assert.Equal(-1, view.Find((table.Rows[0] as FeatureDataRow <Guid>).Id));
Assert.Equal(-1, view.Find((table.Rows[2] as FeatureDataRow <Guid>).Id));
Assert.Equal(-1, view.Find((table.Rows[3] as FeatureDataRow <Guid>).Id));
Assert.Equal(-1, view.Find((table.Rows[5] as FeatureDataRow <Guid>).Id));
}
public void LoadingTableFromReader()
{
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureProvider provider = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(provider.GetExtents());
table.Load(provider.ExecuteFeatureQuery(query));
}
private IFeatureProvider generateFeatureDataSource()
{
List <DataColumn> featureAttributes = new List <DataColumn>(generateAttributeSchema());
FeatureProvider provider = new FeatureProvider(_geometryFactory, featureAttributes.ToArray());
generateFeatures(provider);
return(provider);
}
public static void Main()
{
Console.WriteLine("What feature is active?");
IFlagResolver flagResolver = new FlagResolver();
IFeatureProvider featureProvider = new FeatureProvider(flagResolver, "app3");
var feature = featureProvider.GetFeature();
feature.Execute();
}
protected override bool IsValidProvider(FeatureProvider featureProvider)
{
TaskProvider taskProvider = featureProvider as TaskProvider;
if (taskProvider != null)
{
return(taskProvider.IsToolSupported(this.CurrentTool));
}
return(false);
}
protected override bool IsValidProvider(FeatureProvider featureProvider)
{
AdornerProvider adornerProvider = featureProvider as AdornerProvider;
if (adornerProvider != null && this.CurrentTool != null)
{
return(adornerProvider.IsToolSupported(this.CurrentTool));
}
return(false);
}
public void TestMapDecorationTest()
{
Map m = new Map(new Size(780, 540))
{
BackColor = Color.White, SRID = 0
};
GeoPoint[] pts = new [] { new GeoPoint(0, 0), new GeoPoint(779, 539) };
FeatureProvider p = new FeatureProvider(m.Factory.CreateLineString(pts));
m.Layers.Add(new VectorLayer("t", p));
m.ZoomToExtents();
m.Decorations.Add(new TestDecoration
{
Anchor = MapDecorationAnchor.LeftTop,
BorderColor = Color.Green,
BackgroundColor = Color.LightGreen,
BorderWidth = 2,
Location = new Point(10, 10),
BorderMargin = new Size(5, 5),
RoundedEdges = true,
Opacity = 0.6f
});
m.Decorations.Add(new TestDecoration
{
Anchor = MapDecorationAnchor.RightTop,
BorderColor = Color.Red,
BackgroundColor = Color.LightCoral,
BorderWidth = 2,
Location = new Point(10, 10),
BorderMargin = new Size(5, 5),
RoundedEdges = true,
Opacity = 0.2f
});
m.Decorations.Add(new ScaleBar
{
Anchor = MapDecorationAnchor.Default,
BorderColor = Color.Blue,
BackgroundColor = Color.CornflowerBlue,
BorderWidth = 2,
Location = new Point(10, 10),
BorderMargin = new Size(5, 5),
RoundedEdges = true,
BarWidth = 4,
ScaleText = ScaleBarLabelText.RepresentativeFraction,
NumTicks = 2,
Opacity = 1f
});
Image bmp = m.GetMap();
bmp.Save("TestMapDecorationTest.bmp");
}
public void NullSpatialFilterReturnsAllRows()
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
table.Load(data.ExecuteFeatureQuery(query));
FeatureDataView view = new FeatureDataView(table);
Assert.Equal(table.Rows.Count, view.Count);
}
public void DefaultViewReturnsAllRows()
{
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);
Assert.Equal(table.Rows.Count, table.DefaultView.Count);
}
public void AddNewRowThrowsNotSupported()
{
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);
FeatureDataView view = new FeatureDataView(table);
Assert.Throws <NotSupportedException>(delegate { view.AddNew(); });
}
public void AddFeatureServices_ValidatesArguments()
{
// Arrange
var services = new ServiceCollection();
var featureProvider = new FeatureProvider(new[] { new TestFeature() });
// Act
// Assert
Assert.Throws <ArgumentNullException>(() => ServiceCollectionExtensions.AddFeatureServices(null /* services */, null /* featureProvider */, null /* featureStateProvider */));
Assert.Throws <ArgumentNullException>(() => ServiceCollectionExtensions.AddFeatureServices(services, null /* featureProvider */, null /* featureStateProvider */));
Assert.Throws <ArgumentNullException>(() => ServiceCollectionExtensions.AddFeatureServices(services, featureProvider, null /* featureStateProvider */));
}
public void CreatingDataViewReturnsValidDataView()
{
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);
FeatureDataView view = new FeatureDataView(table);
Assert.IsType(typeof(FeatureDataTable), view.Table);
Assert.Same(table, view.Table);
}
public void SpatialQueryTypeIsWhatIsSpecifiedAtCreateTime()
{
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);
IGeometry filter = _factories.GeoFactory.CreateExtents2D(0, 0, 10, 10).ToGeometry();
FeatureDataView view = new FeatureDataView(table, filter, "", DataViewRowState.CurrentRows);
Assert.Equal(SpatialOperation.Intersects, view.SpatialFilter.Op);
}
protected virtual IEnumerable <Member> LookupDependencies()
{
var metadata = FeatureProvider.GetMetadata(DeclaringType.UnderlyingType);
if (metadata != null)
{
var namesOfPropsWeDependOn = metadata.GetMemberDependencies(this.Name);
return(namesOfPropsWeDependOn.Select(s => DeclaringType.GetMember(s)));
}
else
{
return(new List <Member>());
}
}
private void createDataViewOnNewTable(out FeatureDataView view,
out FeatureDataTable <Guid> table,
Boolean includeGeometryCollections)
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory,
includeGeometryCollections);
table = new FeatureDataTable <Guid>("Oid", _factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
view = new FeatureDataView(table);
}
public void CreatingDataViewWithEqualsSpatialExpressionSucceeds()
{
// This test is here so that when it is supported, the test breaks and is rewritten
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);
Point <BufferedCoordinate> empty = _factories.GeoFactory.CreatePoint() as Point <BufferedCoordinate>;
new FeatureDataView(table, empty, SpatialOperation.Equals, "", DataViewRowState.CurrentRows);
}
public void TestMapDecorationTest()
{
var m = new Map(new Size(780, 540)) {BackColor = Color.White, SRID = 0};
var pts = new [] {new GeoPoint(0, 0), new GeoPoint(779, 539)};
var p = new FeatureProvider(m.Factory.CreateLineString(pts));
m.Layers.Add(new VectorLayer("t",p));
m.ZoomToExtents();
m.Decorations.Add(new TestDecoration
{
Anchor = MapDecorationAnchor.LeftTop,
BorderColor = Color.Green,
BackgroundColor = Color.LightGreen,
BorderWidth = 2,
Location = new Point(10, 10),
BorderMargin = new Size(5, 5),
RoundedEdges = true,
Opacity = 0.6f
});
m.Decorations.Add(new TestDecoration
{
Anchor = MapDecorationAnchor.RightTop,
BorderColor = Color.Red,
BackgroundColor = Color.LightCoral,
BorderWidth = 2,
Location = new Point(10, 10),
BorderMargin = new Size(5, 5),
RoundedEdges = true,
Opacity = 0.2f
});
m.Decorations.Add(new ScaleBar
{
Anchor = MapDecorationAnchor.Default,
BorderColor = Color.Blue,
BackgroundColor = Color.CornflowerBlue,
BorderWidth = 2,
Location = new Point(10, 10),
BorderMargin = new Size(5, 5),
RoundedEdges = true,
BarWidth = 4,
ScaleText =ScaleBarLabelText.RepresentativeFraction,
NumTicks = 2,
Opacity = 1f
});
var bmp = m.GetMap();
bmp.Save("TestMapDecorationTest.bmp");
}
public void MergeSchemaToSchemalessTargetShouldCreateIdenticalTable()
{
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 target = new FeatureDataTable(_factories.GeoFactory);
table.MergeSchemaTo(target);
DataTableHelper.AssertTableStructureIdentical(table, target);
}
public void MergeSchemaToKeyedTableWithDifferentKeyNameButSameTypeShouldKeepKeyButAddOtherColumns()
{
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 <Guid> target = new FeatureDataTable <Guid>("GID", _factories.GeoFactory);
table.MergeSchemaTo(target);
DataTableHelper.AssertTableStructureIdentical(table, target);
}
private void StartNewPolygon(ICoordinate worldPos)
{
List <ICoordinate> vertices = new List <ICoordinate>();
vertices.Add(GeometryFactory.CreateCoordinate(worldPos.X, worldPos.Y));
vertices.Add(GeometryFactory.CreateCoordinate(worldPos.X, worldPos.Y));
vertices.Add(GeometryFactory.CreateCoordinate(worldPos.X, worldPos.Y));
vertices.Add(GeometryFactory.CreateCoordinate(worldPos.X, worldPos.Y)); // ILinearRing must have > 3 points
ILinearRing linearRing = GeometryFactory.CreateLinearRing(vertices.ToArray());
IPolygon polygon = GeometryFactory.CreatePolygon(linearRing, null);
FeatureProvider.Add(polygon);
newObjectIndex = FeatureProvider.GetFeatureCount() - 1;
// do not remove see newline MapControl.SelectTool.Select((VectorLayer)Layer, polygon, 1);
}
public void MultiLineCenterAlignedTest()
{
using (var m = new SharpMap.Map(new Size(600, 400)))
{
m.BackColor = Color.SeaShell;
//_featureDataTable.Clear();
var gfp = new FeatureProvider(_featureDataTable);
var vl = new VectorLayer("VL", gfp);
var ll = new LabelLayer("MultiLineCenterAligned") {DataSource = gfp};
ll.Theme = CreateTheme();
ll.LabelColumn = "LABEL";
m.Layers.Add(vl);
m.Layers.Add(ll);
m.ZoomToExtents();
using (var mapImage = m.GetMap())
mapImage.Save("MultiLineCenterAligned.png", ImageFormat.Png);
}
}
internal static FeatureProvider CreateFeatureDatasource(IGeometryFactory geoFactory,
Boolean includeGeometryCollections)
{
DataColumn nameColumn = new DataColumn("FeatureName", typeof(String));
FeatureProvider provider = new FeatureProvider(geoFactory, nameColumn);
FeatureDataTable<Guid> features = new FeatureDataTable<Guid>("Oid", geoFactory);
features.Columns.Add("FeatureName", typeof(String));
FeatureDataRow<Guid> row;
row = features.NewRow(Guid.NewGuid());
row["FeatureName"] = "An empty point";
row.Geometry = geoFactory.WktReader.Read(EmptyPoint);
features.AddRow(row);
if (includeGeometryCollections)
{
row = features.NewRow(Guid.NewGuid());
row["FeatureName"] = "A geometry collection";
row.Geometry = geoFactory.WktReader.Read(GeometryCollection);
features.AddRow(row);
}
row = features.NewRow(Guid.NewGuid());
row["FeatureName"] = "A multipolygon";
row.Geometry = geoFactory.WktReader.Read(MultiPolygon);
features.AddRow(row);
row = features.NewRow(Guid.NewGuid());
row["FeatureName"] = "A linestring";
row.Geometry = geoFactory.WktReader.Read(LineString);
features.AddRow(row);
row = features.NewRow(Guid.NewGuid());
row["FeatureName"] = "A multilinestring";
row.Geometry = geoFactory.WktReader.Read(MultiLineString);
features.AddRow(row);
row = features.NewRow(Guid.NewGuid());
row["FeatureName"] = "A polygon";
row.Geometry = geoFactory.WktReader.Read(Polygon);
features.AddRow(row);
row = features.NewRow(Guid.NewGuid());
row["FeatureName"] = "A point";
row.Geometry = geoFactory.WktReader.Read(Point);
features.AddRow(row);
row = features.NewRow(Guid.NewGuid());
row["FeatureName"] = "A multipoint";
row.Geometry = geoFactory.WktReader.Read(MultiPoint);
features.AddRow(row);
row = features.NewRow(Guid.NewGuid());
row["FeatureName"] = "An empty multipolygon";
row.Geometry = geoFactory.WktReader.Read(EmptyMultiPolygon);
features.AddRow(row);
row = features.NewRow(Guid.NewGuid());
row["FeatureName"] = "An empty multilinestring";
row.Geometry = geoFactory.WktReader.Read(EmptyMultiLineString);
features.AddRow(row);
row = features.NewRow(Guid.NewGuid());
row["FeatureName"] = "An empty multipoint";
row.Geometry = geoFactory.WktReader.Read(EmptyMultiPoint);
features.AddRow(row);
row = features.NewRow(Guid.NewGuid());
row["FeatureName"] = "An empty linestring";
row.Geometry = geoFactory.WktReader.Read(EmptyLineString);
features.AddRow(row);
provider.Insert((IEnumerable<FeatureDataRow<Guid>>) features);
return provider;
}
private IFeatureProvider generateFeatureDataSource()
{
List<DataColumn> featureAttributes = new List<DataColumn>(generateAttributeSchema());
FeatureProvider provider = new FeatureProvider(_geometryFactory, featureAttributes.ToArray());
generateFeatures(provider);
return provider;
}
private void generateFeatures(FeatureProvider provider)
{
Collection<IGeometry> geometry = new Collection<IGeometry>();
switch (_rnd.Next(3))
{
case 0:
generatePoints(_geometryFactory, geometry, _rnd);
break;
case 1:
generateLines(_geometryFactory, geometry, _rnd);
break;
case 2:
generatePolygons(_geometryFactory, geometry, _rnd);
break;
default:
throw new NotSupportedException();
}
}
internal static FeatureProvider CreateFeatureDatasource()
{
DataColumn nameColumn = new DataColumn("FeatureName", typeof (string));
FeatureProvider provider = new FeatureProvider(nameColumn);
FeatureDataTable<Guid> features = new FeatureDataTable<Guid>("oid");
features.Columns.Add("FeatureName", typeof (string));
FeatureDataRow<Guid> row;
row = features.NewRow(Guid.NewGuid());
row["FeatureName"] = "An empty point";
row.Geometry = Geometry.FromText("POINT EMPTY");
features.AddRow(row);
row = features.NewRow(Guid.NewGuid());
row["FeatureName"] = "A geometry collection";
row.Geometry = Geometry.FromText("GEOMETRYCOLLECTION (POINT (10 10), POINT (30 30), LINESTRING (15 15, 20 20))");
features.AddRow(row);
row = features.NewRow(Guid.NewGuid());
row["FeatureName"] = "A multipolygon";
row.Geometry = Geometry.FromText("MULTIPOLYGON (((0 0, 10 0, 10 10, 0 10, 0 0)), ((5 5, 7 5, 7 7, 5 7, 5 5)))");
features.AddRow(row);
row = features.NewRow(Guid.NewGuid());
row["FeatureName"] = "A linestring";
row.Geometry = Geometry.FromText("LINESTRING (20 20, 20 30, 30 30, 30 20, 40 20)");
features.AddRow(row);
row = features.NewRow(Guid.NewGuid());
row["FeatureName"] = "A multilinestring";
row.Geometry = Geometry.FromText("MULTILINESTRING ((10 10, 40 50), (20 20, 30 20), (20 20, 50 20, 50 60, 20 20))");
features.AddRow(row);
row = features.NewRow(Guid.NewGuid());
row["FeatureName"] = "A polygon";
row.Geometry = Geometry.FromText(
"POLYGON ((20 20, 20 30, 30 30, 30 20, 20 20), (21 21, 29 21, 29 " +
"29, 21 29, 21 21), (23 23, 23 27, 27 27, 27 23, 23 23))");
features.AddRow(row);
row = features.NewRow(Guid.NewGuid());
row["FeatureName"] = "A point";
row.Geometry = Geometry.FromText("POINT (58.813841159 84.7561198972)");
features.AddRow(row);
row = features.NewRow(Guid.NewGuid());
row["FeatureName"] = "A multipoint";
row.Geometry = Geometry.FromText("MULTIPOINT (20 100, 45 32, 100 54)");
features.AddRow(row);
row = features.NewRow(Guid.NewGuid());
row["FeatureName"] = "An empty multipolygon";
row.Geometry = Geometry.FromText("MULTIPOLYGON EMPTY");
features.AddRow(row);
row = features.NewRow(Guid.NewGuid());
row["FeatureName"] = "An empty multilinestring";
row.Geometry = Geometry.FromText("MULTILINESTRING EMPTY");
features.AddRow(row);
row = features.NewRow(Guid.NewGuid());
row["FeatureName"] = "An empty multipoint";
row.Geometry = Geometry.FromText("MULTIPOINT EMPTY");
features.AddRow(row);
row = features.NewRow(Guid.NewGuid());
row["FeatureName"] = "An empty linestring";
row.Geometry = Geometry.FromText("LINESTRING EMPTY");
features.AddRow(row);
provider.Insert(features);
return provider;
}
private void addNewRandomGeometryLayer()
{
Random rndGen = new Random();
Collection<IGeometry> geometry = new Collection<IGeometry>();
VectorLayer layer = new VectorLayer(String.Empty);
var gf = new GeometryFactory();
switch (rndGen.Next(3))
{
case 0:
{
GeneratePoints(gf, geometry, rndGen);
KeyValuePair<string, Bitmap> symbolEntry = getSymbolEntry(rndGen.Next(_symbolTable.Count));
layer.Style.Symbol = symbolEntry.Value;
layer.LayerName = symbolEntry.Key;
}
break;
case 1:
{
GenerateLines(gf, geometry, rndGen);
KeyValuePair<string, Color> colorEntry = getColorEntry(rndGen.Next(_colorTable.Count));
layer.Style.Line = new Pen(colorEntry.Value);
layer.LayerName = String.Format("{0} lines", colorEntry.Key);
}
break;
case 2:
{
GeneratePolygons(gf, geometry, rndGen);
KeyValuePair<string, Color> colorEntry = getColorEntry(rndGen.Next(_colorTable.Count));
layer.Style.Fill = new SolidBrush(colorEntry.Value);
layer.LayerName = String.Format("{0} squares", colorEntry.Key);
}
break;
default:
throw new NotSupportedException();
}
var provider = new FeatureProvider(geometry);
layer.DataSource = provider;
addLayer(layer);
}
