private void NewFeatureLayer(DotSpatial.Controls.IMap map, string directory)
{
string filename = Path.Combine(directory, this.Name + ".shp");
if (!File.Exists(filename))
{
CreateFeature(map.Projection, directory);
}
this.Feature = FeatureSet.Open(filename);
if (this.Feature.FeatureType == FeatureType.Polygon)
{
var layer = new MapPolygonLayer(this.Feature);
map.Layers.Add(layer);
this.FeatureLayer = layer;
}
else if (this.Feature.FeatureType == FeatureType.Line)
{
var layer = new MapLineLayer(this.Feature);
map.Layers.Add(layer);
this.FeatureLayer = layer;
}
else if (this.Feature.FeatureType == FeatureType.Point)
{
var layer = new MapPointLayer(this.Feature);
map.Layers.Add(layer);
this.FeatureLayer = layer;
}
}
internal IMapFeatureLayer CreateLayer(string type, string layerName)
{
IMapFeatureLayer layer = null;
switch (type)
{
case "Polygon":
layer = new MapPolygonLayer();
break;
case "Line":
layer = new MapLineLayer();
break;
case "Point":
layer = new MapPointLayer();
break;
case "MultiPolygon":
layer = new MapPolygonLayer();
break;
default:
throw new Exception("Wrong Layer Class:" + type);
}
layer.DataSet.Name = layerName;
layer.LegendText = layerName;
return(layer);
}
public override void CreateGridFeature()
{
this.GridFeatureFilePath = "GeoSpatial\\Grid.shp";
this.CentroidFeatureFilePath = "GeoSpatial\\Centroid.shp";
var full_gridfea_file = Path.Combine(this.AbsolutePathToProjectFile, GridFeatureFilePath);
var full_centroid_file = Path.Combine(this.AbsolutePathToProjectFile, CentroidFeatureFilePath);
this.Model.Grid.Build(full_gridfea_file);
var fs_grid = FeatureSet.Open(full_gridfea_file);
_GridLayer = new MapPolygonLayer(fs_grid);
this.Model.Grid.FeatureSet = fs_grid;
this.Model.Grid.FeatureLayer = _GridLayer;
this.Map.Layers.Add(_GridLayer);
this.Model.Grid.BuildCentroid(full_centroid_file);
var fs_centroid = FeatureSet.Open(full_centroid_file);
_CentroidLayer = new MapPointLayer(fs_centroid);
this.Model.Grid.CentroidFeature = fs_centroid;
this.Model.Grid.CentroidFeatureLayer = _CentroidLayer;
this.Map.Layers.Add(_CentroidLayer);
this.Map.Invalidate();
}
/// <summary>
/// This method is used to get the area of the selected region on the combobox
/// </summary>
/// <param name="uniqueColumnName">Field name</param>
/// <param name="uniqueValue">Unique value from the selected region combobox</param>
/// <param name="mapInput">map layer</param>
/// <returns>area of the selected field</returns>
/// <remarks></remarks>
private double _getArea(string uniqueColumnName, string uniqueValue, DotSpatial.Controls.Map mapInput)
{
double stateArea = 0;
if ((mapInput.Layers.Count > 0))
{
MapPolygonLayer stateLayer = default(MapPolygonLayer);
stateLayer = (MapPolygonLayer)mapInput.Layers[0];
if ((stateLayer == null))
{
MessageBox.Show("The layer is not a polygon layer.");
}
else
{
stateLayer.SelectByAttribute("[" + uniqueColumnName + "] =" + "'" + uniqueValue + "'");
foreach (IFeature stateFeature in stateLayer.DataSet.Features)
{
if (uniqueValue.CompareTo(stateFeature.DataRow[uniqueColumnName]) == 0)
{
stateArea = stateFeature.Area();
break; // TODO: might not be correct. Was : Exit For
}
}
}
}
return(stateArea);
}
private void btnFilterByStateName_Click(object sender, EventArgs e)
{
if (map1.Layers.Count > 0)
{
//Declare a MapPolygonLayer
MapPolygonLayer stateLayer = default(MapPolygonLayer);
//TypeCast the first layer from MapControl to MapPolygonLayer.
//Layers are 0 based, therefore 0 is going to grab the first layer from the MapControl
stateLayer = (MapPolygonLayer)map1.Layers[0];
//Check whether stateLayer is polygon layer or not
if (stateLayer == null)
{
MessageBox.Show("The layer is not a polygon layer.");
}
else
{
//SelectByAttribute method is used to implement the filter operations.
//In this example, STATE_NAME is used implement the filter operation
//We can see the IdhoSate on the map
stateLayer.SelectByAttribute("[STATE_NAME] = 'Idaho'");
}
}
else
{
MessageBox.Show("Please add a layer to the map.");
}
}
/// <summary>
/// 将属性表导出成Excel
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void exportAttributeTableToExcelToolStripMenuItem_Click(object sender, EventArgs e)
{
//Declare a datatable
System.Data.DataTable dt = null;
if (map1.Layers.Count > 0)
{
MapPolygonLayer stateLayer = default(MapPolygonLayer);
stateLayer = (MapPolygonLayer)map1.Layers[0];
if (stateLayer == null)
{
MessageBox.Show("The layer is not a polygon layer.");
}
else
{
//Get the shapefile's attribute table to our datatable dt
dt = stateLayer.DataSet.DataTable;
//Call the sub ExportToExcel
//This sub procedure expects a datatable as an input
ExportToExcel(dt);
}
}
else
{
MessageBox.Show("Please add a layer to the map.");
}
}
public void ConvertLayerProperties_MapPolygonDataWithStyle_ConvertsStyleToMapPolygonLayer(
[Values(KnownColor.AliceBlue, KnownColor.Azure)]
KnownColor fillColor,
[Values(KnownColor.AppWorkspace, KnownColor.BlueViolet)]
KnownColor outlineFillColor,
[Values(1, 5)] int width)
{
// Setup
var converter = new MapPolygonDataConverter();
var mapPolygonLayer = new MapPolygonLayer();
Color expectedFillColor = Color.FromKnownColor(fillColor);
Color expectedOutlineFillColor = Color.FromKnownColor(outlineFillColor);
var mapPolygonData = new MapPolygonData("test", new PolygonStyle
{
FillColor = expectedFillColor,
StrokeColor = expectedOutlineFillColor,
StrokeThickness = width
});
// Call
converter.ConvertLayerProperties(mapPolygonData, mapPolygonLayer);
// Assert
AssertAreEqual(new PolygonSymbolizer(expectedFillColor, expectedOutlineFillColor, width), mapPolygonLayer.Symbolizer);
}
protected IMapPolygonLayer GetPolygonLayer()
{
IMapPolygonLayer polygonLayer = null;
foreach (ILayer item in _map.MapFrame.DrawingLayers)
{
if (item.LegendText == "Polygon")
{
polygonLayer = item as IMapPolygonLayer;
break;
}
}
if (polygonLayer == null)
{
polygonLayer = new MapPolygonLayer();
polygonLayer.LegendText = "Polygon";
polygonLayer.Symbolizer = GIS.FrameWork.ROIConfigure.polygonSymbolizer;
if (_map.MapFrame.DrawingLayers.Count > 0 && _map.MapFrame.DrawingLayers[0].LegendText == "ROI")
{
_map.MapFrame.DrawingLayers.Insert(1, polygonLayer);
}
else
{
_map.MapFrame.DrawingLayers.Insert(0, polygonLayer);
}
}
return(polygonLayer);
}
/// <summary>
/// Default loading: We add the U.S states layer to our map
/// </summary>
private void frmMain_Load(object sender, EventArgs e)
{
//set superscript in grpVolume
grpResults.Text = "Results";
string executablePath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
string dataFolder = Path.Combine(executablePath, "Snow_Data");
//get path of the shapefile in the Snow_Data subfolder
string statesShapefile = Path.Combine(dataFolder, "us_states.shp");
if (File.Exists(statesShapefile))
{
//set map symbol to transparent color and black outline
IFeatureSet statesF = FeatureSet.Open(statesShapefile);
MapPolygonLayer statesLayer = new MapPolygonLayer(statesF);
statesLayer.Symbolizer.SetOutline(Color.Black, 1.0);
statesLayer.Symbolizer.SetFillColor(Color.Transparent);
mapMain.Layers.Add(statesLayer);
}
//get path of the shapefile in the Snow_Data subfolder
string lakesShapefile = Path.Combine(dataFolder, "us_lakes.shp");
if (File.Exists(lakesShapefile))
{
//set map symbol to blue color and blue outline
IFeatureSet lakesF = FeatureSet.Open(lakesShapefile);
MapPolygonLayer lakesLayer = new MapPolygonLayer(lakesF);
lakesLayer.Symbolizer.SetOutline(Color.Blue, 1.0);
lakesLayer.Symbolizer.SetFillColor(Color.LightBlue);
mapMain.Layers.Add(lakesLayer);
}
}
/// <summary>
/// 创建面文件
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void createPloygonShapefileToolStripMenuItem_Click(object sender, EventArgs e)
{
//initialize polyline feature set
map1.Cursor = Cursors.Cross;
//set shape type
shapeType = "polygon";
//set projection
polygonF.Projection = map1.Projection;
//initialize the featureSet attribute table
DataColumn column = new DataColumn("PolygonID");
if (!polygonF.DataTable.Columns.Contains("PolygonID"))
{
polygonF.DataTable.Columns.Add(column);
}
//add the featureSet as map layer
MapPolygonLayer polygonLayer = (MapPolygonLayer)map1.Layers.Add(polygonF);
PolygonSymbolizer symbol = new PolygonSymbolizer(Color.Green);
polygonLayer.Symbolizer = symbol;
polygonLayer.LegendText = "polygon";
firstClick = true;
polygonmouseClick = true;
}
/// <summary>
/// Adds the hidden "Search Rectangle" layer to the map
/// </summary>
private void AddRectangleLayer()
{
//check for the rectangle layer
if (_rectangleLayer == null)
{
_rectangleLayer = _mainMap.GetAllLayers().OfType <MapPolygonLayer>()
.Where(lay => lay.LegendText == "Search Rectangle")
.FirstOrDefault();
}
if (_rectangleLayer == null)
{
var rectangleFs = new FeatureSet(FeatureType.Polygon);
rectangleFs.DataTable.Columns.Add(new DataColumn("ID"));
rectangleFs.Projection = _mainMap.Projection;
_rectangleLayer = new MapPolygonLayer(rectangleFs)
{
LegendText = "Search Rectangle"
};
var redColor = Color.Red.ToTransparent(0.5f);
_rectangleLayer.Symbolizer = new PolygonSymbolizer(redColor, Color.Red);
_rectangleLayer.SelectionSymbolizer = _rectangleLayer.Symbolizer;
_mainMap.Layers.Add(_rectangleLayer);
}
}
private void deleteColumnToolStripMenuItem_Click(object sender, EventArgs e)
{
//Declare a datatable
System.Data.DataTable dt = null;
if (map1.Layers.Count > 0)
{
MapPolygonLayer stateLayer = default(MapPolygonLayer);
stateLayer = map1.Layers[0] as MapPolygonLayer;
if (stateLayer == null)
{
MessageBox.Show("The layer is not a polygon layer.");
}
else
{
//Get the shapefile's attribute table to our datatable dt
dt = stateLayer.DataSet.DataTable;
//Remove a column
dt.Columns.Remove("PercentMales");
//Set the datagridview datasource from datatable dt
dgvAttributeTable.DataSource = dt;
}
}
else
{
MessageBox.Show("Please add a layer to the map.");
}
}
public void ConvertLayerFeatures_MapPolygonDataWithSingleGeometryFeature_ConvertsFeatureToMapPolygonLayerAsPolygonData()
{
// Setup
var converter = new MapPolygonDataConverter();
var mapPolygonLayer = new MapPolygonLayer();
var mapPolygonData = new MapPolygonData("test data")
{
Features = new[]
{
new MapFeature(new[]
{
new MapGeometry(new[]
{
CreateRectangularRing(0.0, 10.0)
})
})
}
};
// Call
converter.ConvertLayerFeatures(mapPolygonData, mapPolygonLayer);
// Assert
IFeature feature = mapPolygonLayer.DataSet.Features[0];
Assert.AreEqual(mapPolygonData.Features.Count(), mapPolygonLayer.DataSet.Features.Count);
Assert.IsInstanceOf <Polygon>(feature.Geometry);
IEnumerable <Coordinate> expectedCoordinates = mapPolygonData.Features.First().MapGeometries.First().PointCollections.First().Select(p => new Coordinate(p.X, p.Y));
CollectionAssert.AreEqual(expectedCoordinates, mapPolygonLayer.DataSet.Features[0].Geometry.Coordinates);
}
private static Layer GetPolygonLayer(dynamic layer)
{
MapPolygonLayer polyLayer = new MapPolygonLayer(FeatureSet.OpenFile(layer["Path"]));
LegacyDeserializer.DeserializeLayer(layer, polyLayer);
return(polyLayer);
}
public Form1()
{
InitializeComponent();
map1.FunctionMode = FunctionMode.Pan;
string gridfile = "NLDAS_Grid_Reference.shp";
string polyfile = "..\\..\\..\\tests\\Lake_St._Clair_Shoreline.shp";//"..\\..\\..\\tests\\Catchment.shp";
map1.AddLayer(polyfile);
map1.AddLayer(gridfile);
MapPolygonLayer polylayer = (MapPolygonLayer)map1.Layers[0];
polylayer.Symbolizer = new PolygonSymbolizer(Color.LightBlue, Color.Black);
MapPolygonLayer gridlayer = (MapPolygonLayer)map1.Layers[1];
gridlayer.Symbolizer = new PolygonSymbolizer(Color.FromArgb(0, Color.White), Color.Black);
//Read geometries from both shapefiles and store in array lists
//As well as calculate shapefile areas ahead of time
ShapefileDataReader reader = new ShapefileDataReader(polyfile, NetTopologySuite.Geometries.GeometryFactory.Default);
while (reader.Read())
{
polys.Add(reader.Geometry);
polygonArea += reader.Geometry.Area;
}
ShapefileDataReader reader2 = new ShapefileDataReader(gridfile, NetTopologySuite.Geometries.GeometryFactory.Default);
while (reader2.Read())
{
squares.Add(reader2.Geometry);
gridArea += reader2.Geometry.Area;
}
squares.TrimToSize();
polys.TrimToSize();
///Creating intersections ahead of time to make selections faster at runtime
foreach (GeoAPI.Geometries.IGeometry s in squares)
{
foreach (GeoAPI.Geometries.IGeometry p in polys)
{
if (p.Intersects(s) && !overlap.Contains(s))
{
overlap.Add(s);
}
}
}
overlap.TrimToSize();
///
label4.Text = "Area of NLDAS Grid: " + gridArea.ToString();
label4.Text += "\r\nArea of polygon: " + polygonArea.ToString();
double percent = (polygonArea / gridArea) * 100;
label4.Text += "\r\nPolygon covers " + percent.ToString() + "% of NLDAS Grid.";
}
private void btnFilterByPopState_Click(object sender, EventArgs e)
{
//check the number of layers from map control
if (map1.Layers.Count > 0)
{
//Delacre a MapPolygonLayer
MapPolygonLayer stateLayer = default(MapPolygonLayer);
//Type cast the FirstLayer of MapControl to MapPolygonLayer
stateLayer = (MapPolygonLayer)map1.Layers[0];
//Check the MapPolygonLayer ( Make sure that it has a polygon layer)
if (stateLayer == null)
{
MessageBox.Show("The layer is not a polygon layer.");
}
else
{
//!!!-------------------- this line is necessary otherwise the code doesn't work------------------------!!!!!!!!!!!!!!!!!!!!
}
stateLayer.DataSet.FillAttributes();
//Create a new PolygonScheme
PolygonScheme scheme = new PolygonScheme();
//Create a new PolygonCategory
PolygonCategory category = new PolygonCategory(Color.Yellow, Color.Red, 1);
//Declare a filter string
//[POP1990],[STATE_NAME] are attributes from the attribute table of the given shape file.
string filter = "[POP1990] > 10000000 OR [STATE_NAME] = 'Idaho'";
//Set/Assign the filter expression to PolygonCategory
category.FilterExpression = filter;
//Set the Legend Text
category.LegendText = "population > 10 Million";
//Add the PolygonCategory in to the PolygonScheme
scheme.AddCategory(category);
//Set the scheme in to the MapPolygonLayer's symbology
stateLayer.Symbology = scheme;
}
else
{
MessageBox.Show("Please add a layer to the map.");
}
}
private void DisableProgressReportingForLayers()
{
foreach (IMapLayer layer in App.Map.MapFrame.GetAllLayers())
{
layer.ProgressHandler = null;
MapPolygonLayer polyLay = layer as MapPolygonLayer;
if (polyLay != null)
{
polyLay.ProgressReportingEnabled = false;
}
}
App.Map.ProgressHandler = null;
}
public void DrawPolygonShape(IFeature fe, System.Drawing.Color FillColor, System.Drawing.Color OutlineColor, double OutlineWidth, Map MapCanvas)
{
FeatureSet fs = new FeatureSet(FeatureType.Polygon);
fs.Features.Add(fe);
MapPolygonLayer rangeRingAxis;
rangeRingAxis = new MapPolygonLayer(fs);
rangeRingAxis.Symbolizer = new PolygonSymbolizer(FillColor, OutlineColor, OutlineWidth);
MapCanvas.MapFrame.DrawingLayers.Add(rangeRingAxis);
MapCanvas.MapFrame.Invalidate();
// MapCanvas.MapFrame.Invalidate();
}
public void ConvertLayerProperties_MapPolygonDataWithThemeAndMetaDataNameNotInFeatures_OnlyAddsDefaultCategory()
{
// Setup
const string metadataAttribute = "Meta";
var random = new Random(21);
var theme = new MapTheme <PolygonCategoryTheme>("Other Meta", new[]
{
new PolygonCategoryTheme(ValueCriterionTestFactory.CreateValueCriterion(),
new PolygonStyle
{
FillColor = Color.FromKnownColor(random.NextEnum <KnownColor>()),
StrokeColor = Color.FromKnownColor(random.NextEnum <KnownColor>()),
StrokeThickness = random.Next(1, 48)
})
});
var polygonStyle = new PolygonStyle
{
FillColor = Color.FromKnownColor(random.NextEnum <KnownColor>()),
StrokeColor = Color.FromKnownColor(random.NextEnum <KnownColor>()),
StrokeThickness = random.Next(1, 48)
};
var mapPolygonData = new MapPolygonData("test", polygonStyle, theme)
{
Features = new[]
{
CreateMapFeatureWithMetaData(metadataAttribute)
}
};
var mapPolygonLayer = new MapPolygonLayer();
var converter = new MapPolygonDataConverter();
// Call
converter.ConvertLayerProperties(mapPolygonData, mapPolygonLayer);
// Assert
IPolygonSymbolizer expectedSymbolizer = CreateExpectedSymbolizer(polygonStyle);
IPolygonScheme appliedScheme = mapPolygonLayer.Symbology;
Assert.AreEqual(1, appliedScheme.Categories.Count);
IPolygonCategory baseCategory = appliedScheme.Categories[0];
AssertAreEqual(expectedSymbolizer, baseCategory.Symbolizer);
Assert.IsNull(baseCategory.FilterExpression);
}
//-------------------------------------------------------
public void AddProviderShapeFileLayers()
{
ProviderMap.Layers.Clear();
AddProviderBaseShapeFile();
MapPolygonLayer MPL = AddFieldLayer("PRVDCODE");
PolygonScheme BaseScheme = new PolygonScheme();
BaseScheme.EditorSettings.ClassificationType = ClassificationType.UniqueValues;
////Set the UniqueValue field name
BaseScheme.EditorSettings.FieldName = "PRVDCODE";
// Create Catagories based on data
BaseScheme.CreateCategories(MPL.DataSet.DataTable);
MPL.Symbology = BaseScheme;
}
private void dgvAttributeTable_SelectionChanged(object sender, EventArgs e)
{
foreach (DataGridViewRow row in dgvAttributeTable.SelectedRows)
{
MapPolygonLayer startLayer = default(MapPolygonLayer);
startLayer = (MapPolygonLayer)map1.Layers[0];
if (startLayer == null)
{
MessageBox.Show("The layer is not a polygon layer.");
}
else
{
startLayer.SelectByAttribute("[STATE_NAME] =" + "'" + row.Cells["STATE_NAME"].Value + "'");
}
}
}
private ILayer bufferLayer()
{
foreach (ILayer item in _map.MapFrame.DrawingLayers)
{
if (item.LegendText == "ROI")
{
return(item);
}
}
ILayer layer = new MapPolygonLayer();
layer.LegendText = "ROI";
(layer as IPolygonLayer).Symbolizer = GIS.FrameWork.ROIConfigure.bufferSymbolizer;
_map.MapFrame.DrawingLayers.Insert(0, layer);
return(layer);
}
private void addAColumnToolStripMenuItem_Click(object sender, EventArgs e)
{
//Declare a datatable
System.Data.DataTable dt = null;
//check the layers
if (map1.Layers.Count > 0)
{
//Declare a mappolygon layer
MapPolygonLayer stateLayer = default(MapPolygonLayer);
//Assign the mappolygon layer from the map
stateLayer = map1.Layers[0] as MapPolygonLayer;
if (stateLayer == null)
{
MessageBox.Show("The layer is not a polygon layer.");
}
else
{
//Get the shapefile's attribute table to our datatable dt
dt = stateLayer.DataSet.DataTable;
//Add new column
DataColumn column = new DataColumn("PercentMales");
dt.Columns.Add(column);
//calculate values
foreach (DataRow row in dt.Rows)
{
double males = Convert.ToDouble(row["males"]);
double females = Convert.ToDouble(row["females"]);
double malesPercentage = (males / (males + females)) * 100;
row["PercentMales"] = malesPercentage;
}
//Set the datagridview datasource from datatable dt
dgvAttributeTable.DataSource = dt;
}
}
else
{
MessageBox.Show("Please add a layer to the map.");
}
}
public void ConvertLayerProperties_MapPolygonDataWithStrokeThicknessZero_MapPolygonLayerOutlineColorTransparent()
{
// Setup
var converter = new MapPolygonDataConverter();
var mapPolygonLayer = new MapPolygonLayer();
Color expectedFillColor = Color.FromKnownColor(new Random(21).NextEnum <KnownColor>());
var mapPolygonData = new MapPolygonData("test", new PolygonStyle
{
FillColor = expectedFillColor,
StrokeColor = Color.ForestGreen,
StrokeThickness = 0
});
// Call
converter.ConvertLayerProperties(mapPolygonData, mapPolygonLayer);
// Assert
AssertAreEqual(new PolygonSymbolizer(expectedFillColor, Color.Transparent, 0), mapPolygonLayer.Symbolizer);
}
public void ConvertLayerFeatures_MapPolygonDataWithRingFeatureAndHoles_ConvertsFeatureToMapPolygonLayerAsPolygonData()
{
// Setup
var converter = new MapPolygonDataConverter();
var mapPolygonLayer = new MapPolygonLayer();
Point2D[] outerRingPoints = CreateRectangularRing(0.0, 10.0);
Point2D[] innerRing1Points = CreateRectangularRing(2.0, 3.0);
Point2D[] innerRing2Points = CreateRectangularRing(8.0, 5.0);
MapFeature[] mapFeatures =
{
new MapFeature(new[]
{
new MapGeometry(new[]
{
outerRingPoints,
innerRing1Points,
innerRing2Points
})
})
};
var mapPolygonData = new MapPolygonData("test data")
{
Features = mapFeatures
};
// Call
converter.ConvertLayerFeatures(mapPolygonData, mapPolygonLayer);
// Assert
IFeature feature = mapPolygonLayer.DataSet.Features[0];
Assert.AreEqual(mapPolygonData.Features.Count(), mapPolygonLayer.DataSet.Features.Count);
Assert.IsInstanceOf <Polygon>(feature.Geometry);
var polygonGeometry = (Polygon)mapPolygonLayer.FeatureSet.Features[0].Geometry;
Assert.AreEqual(1, polygonGeometry.NumGeometries);
CollectionAssert.AreEqual(outerRingPoints, polygonGeometry.Shell.Coordinates.Select(c => new Point2D(c.X, c.Y)));
Assert.AreEqual(2, polygonGeometry.Holes.Length);
CollectionAssert.AreEqual(innerRing1Points, polygonGeometry.Holes.ElementAt(0).Coordinates.Select(c => new Point2D(c.X, c.Y)));
CollectionAssert.AreEqual(innerRing2Points, polygonGeometry.Holes.ElementAt(1).Coordinates.Select(c => new Point2D(c.X, c.Y)));
}
private void saveColumnToolStripMenuItem_Click(object sender, EventArgs e)
{
if (map1.Layers.Count > 0)
{
MapPolygonLayer stateLayer = default(MapPolygonLayer);
stateLayer = map1.Layers[0] as MapPolygonLayer;
if (stateLayer == null)
{
MessageBox.Show("The layer is not a polygon layer.");
}
else
{
stateLayer.DataSet.Save();
}
}
else
{
MessageBox.Show("Please add a layer to the map.");
}
}
private void button1_Click(object sender, EventArgs e)
{
if (map1.Layers.Count > 0)
{
MapPolygonLayer startLayer = default(MapPolygonLayer);
startLayer = (MapPolygonLayer)map1.Layers[0];
if (startLayer == null)
{
MessageBox.Show("The layer is not a polygon layer.");
}
else
{
map1.AddLabels(startLayer, "[State_NAME]", new Font("Tahoma", (float)8.0), Color.Black);
}
}
else
{
MessageBox.Show("Please add a layer to the map.");
}
}
//------------------------------------------
internal MapPolygonLayer AddProviderShapeFile(string Name)
{
MapPolygonLayer MyLayer = null;
try
{
MyLayer = (MapPolygonLayer)ProviderMap.AddLayer(DataPath + ShapeFilename);
MyLayer.LegendText = Name;
DataTable LayerDT = MyLayer.DataSet.DataTable;
if (MyLayer == null)
{
MessageBox.Show("The Base ShapeFile is not a polygon layer.");
}
}
catch (Exception e)
{
MessageBox.Show("Error Loading Shape File:[ " + DataPath + ShapeFilename + "] :" + e.Message);
}
return(MyLayer);
}
public void createPolygonShape()
{
//initialize polyline feature set
//map.Cursor = Cursors.Cross;
polygonF = new FeatureSet(FeatureType.Polygon);
//set shape type
shapeType = "Polygon";
//set projection
polygonF.Projection = map.Projection;
//initialize the featureSet attribute table
DataColumn column = new DataColumn("ID");
polygonF.DataTable.Columns.Add(column);
//add the featureSet as map layer
MapPolygonLayer polygonLayer = (MapPolygonLayer)map.Layers.Add(polygonF);
PolygonSymbolizer symbol = new PolygonSymbolizer(Color.Green);
polygonLayer.Symbolizer = symbol;
polygonLayer.LegendText = "polygon";
firstClick = true;
}
public void ConvertLayerFeatures_MapPolygonDataWithMultipleFeatures_ConvertsAllFeaturesToMapPolygonLayer()
{
// Setup
var converter = new MapPolygonDataConverter();
var mapPolygonLayer = new MapPolygonLayer();
var mapPolygonData = new MapPolygonData("test")
{
Features = new[]
{
new MapFeature(Enumerable.Empty <MapGeometry>()),
new MapFeature(Enumerable.Empty <MapGeometry>()),
new MapFeature(Enumerable.Empty <MapGeometry>())
}
};
// Call
converter.ConvertLayerFeatures(mapPolygonData, mapPolygonLayer);
// Assert
Assert.AreEqual(mapPolygonData.Features.Count(), mapPolygonLayer.DataSet.Features.Count);
}
private void InitializeMap()
{
//throw new NotImplementedException();
choroplethMap = new ChoroplethMap();
mapBorderLayer = new MapBorderLayer();
mapBorderLayer.MapData = mapData;
mapPolygonLayer = new MapPolygonLayer();
mapPolygonLayer.MapData = mapData;
mapPolygonLayer.IndexMapper = stringIndexMapper;
mapPolygonLayer.ColorMap = colorMap;
choroplethMap.Position = new Vector2(0.5f, 0.23f);
choroplethMap.Zoom = -(0.75f);
choroplethMap.AddLayer(mapPolygonLayer);
choroplethMap.AddLayer(mapBorderLayer);
choroplethMap.AddSubComponent(interactiveColorLegend);
choroplethMap.VizComponentMouseDown += new EventHandler<VizComponentMouseEventArgs>(choroplethMap_VizComponentMouseDown);
choroplethMap.VizComponentMouseUp += new EventHandler<VizComponentMouseEventArgs>(choroplethMap_VizComponentMouseUp);
choroplethMap.VizComponentMouseMove += new EventHandler<VizComponentMouseEventArgs>(choroplethMap_VizComponentMouseMove);
choroplethMap.PositionInternallyChanged += new EventHandler(choroplethMap_PositionInternallyChanged);
choroplethMap.ZoomInternallyChanged += new EventHandler(choroplethMap_ZoomInternallyChanged);
}
public void TestSetViewExtents()
{
Map mainMap = new Map();
mainMap.Projection = KnownCoordinateSystems.Projected.World.WebMercator;
Extent defaultMapExtent = new Extent(-130, 5, -70, 60);
string baseMapFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "TestFiles");
//SetDefaultMapExtents(mainMap);
MapPolygonLayer layStates;
MapGroup baseGroup = new MapGroup(mainMap.Layers, mainMap.MapFrame, mainMap.ProgressHandler);
baseGroup.LegendText = "Base Map Data";
baseGroup.ParentMapFrame = mainMap.MapFrame;
baseGroup.MapFrame = mainMap.MapFrame;
baseGroup.IsVisible = true;
//load the 'Countries of the world' layer
try
{
string fileName = Path.Combine(baseMapFolder, "50m_admin_0_countries.shp");
IFeatureSet fsCountries = FeatureSet.OpenFile(fileName);
fsCountries.Reproject(mainMap.Projection);
MapPolygonLayer layCountries = new MapPolygonLayer(fsCountries);
layCountries.LegendText = "Countries";
PolygonScheme schmCountries = new PolygonScheme();
schmCountries.EditorSettings.StartColor = Color.Orange;
schmCountries.EditorSettings.EndColor = Color.Silver;
schmCountries.EditorSettings.ClassificationType =
ClassificationType.UniqueValues;
schmCountries.EditorSettings.FieldName = "NAME";
schmCountries.EditorSettings.UseGradient = true;
schmCountries.CreateCategories(layCountries.DataSet.DataTable);
layCountries.Symbology = schmCountries;
baseGroup.Layers.Add(layCountries);
layCountries.MapFrame = mainMap.MapFrame;
}
catch { }
//load U.S. states layer
try
{
string fileName = Path.Combine(baseMapFolder, "50mil_us_states.shp");
IFeatureSet fsStates = FeatureSet.OpenFile(fileName);
fsStates.Reproject(mainMap.Projection);
layStates = new MapPolygonLayer(fsStates);
PolygonScheme schmStates = new PolygonScheme();
layStates.IsVisible = true;
layStates.LegendText = "U.S. States";
schmStates.EditorSettings.StartColor = Color.LemonChiffon;
schmStates.EditorSettings.EndColor = Color.LightPink;
schmStates.EditorSettings.ClassificationType =
ClassificationType.UniqueValues;
schmStates.EditorSettings.FieldName = "NAME";
schmStates.EditorSettings.UseGradient = true;
schmStates.CreateCategories(layStates.DataSet.DataTable);
layStates.Symbology = schmStates;
baseGroup.Layers.Add(layStates);
layStates.MapFrame = mainMap.MapFrame;
}
catch { }
//load Canada Provinces layer
try
{
string fileName = Path.Combine(baseMapFolder, "50mil_canada_provinces.shp");
IFeatureSet fsProvince = FeatureSet.OpenFile(fileName);
fsProvince.Reproject(mainMap.Projection);
MapPolygonLayer layProvince = new MapPolygonLayer(fsProvince);
PolygonScheme schmProvince = new PolygonScheme();
layProvince.IsVisible = true;
layProvince.LegendText = "Canada Provinces";
schmProvince.EditorSettings.StartColor = Color.Green;
schmProvince.EditorSettings.EndColor = Color.Yellow;
schmProvince.EditorSettings.ClassificationType =
ClassificationType.UniqueValues;
schmProvince.EditorSettings.FieldName = "NAME";
schmProvince.EditorSettings.UseGradient = true;
schmProvince.CreateCategories(layProvince.DataSet.DataTable);
layProvince.Symbology = schmProvince;
baseGroup.Layers.Add(layProvince);
layProvince.MapFrame = mainMap.MapFrame;
}
catch { }
//theme data group
//create a new empty 'themes' data group
try
{
MapGroup themeGroup = new MapGroup(mainMap.Layers,
mainMap.MapFrame, mainMap.ProgressHandler);
themeGroup.ParentMapFrame = mainMap.MapFrame;
themeGroup.MapFrame = mainMap.MapFrame;
themeGroup.LegendText = "Themes";
}
catch { }
double[] xy = new double[4];
xy[0] = defaultMapExtent.MinX;
xy[1] = defaultMapExtent.MinY;
xy[2] = defaultMapExtent.MaxX;
xy[3] = defaultMapExtent.MaxY;
double[] z = new double[] { 0, 0 };
string esri = "GEOGCS[\"GCS_WGS_1984\",DATUM[\"D_WGS_1984\",SPHEROID[\"WGS_1984\",6378137,298.257223562997]],PRIMEM[\"Greenwich\",0],UNIT[\"Degree\",0.0174532925199433]]";
ProjectionInfo wgs84 = ProjectionInfo.FromEsriString(esri);
Reproject.ReprojectPoints(xy, z, wgs84, mainMap.Projection, 0, 2);
xy[0] = 1000000000000000;
xy[1] = 2000000000000000;
xy[2] = 3000000000000000;
xy[3] = 4000000000000000;
Extent ext = new Extent(xy);
mainMap.ViewExtents = ext;
}
