private void UpdateFeatureByScale(double percentage, bool isScaleUp)
{
LayerOverlay inMemoryOverlay = (LayerOverlay)androidMap.Overlays["InMemoryOverlay"];
InMemoryFeatureLayer inMemoryLayer = (InMemoryFeatureLayer)inMemoryOverlay.Layers["InMemoryFeatureLayer"];
inMemoryLayer.Open();
inMemoryLayer.EditTools.BeginTransaction();
if (isScaleUp)
{
inMemoryLayer.EditTools.ScaleUp("135", percentage);
}
else
{
inMemoryLayer.EditTools.ScaleDown("135", percentage);
}
inMemoryLayer.EditTools.CommitTransaction();
inMemoryLayer.Close();
androidMap.Overlays["InMemoryOverlay"].Refresh();
}
private void TestForm_Load(object sender, EventArgs e)
{
//Sets timer properties
timer.Interval = 750;
timer.Tick += new EventHandler(timer_Tick);
winformsMap1.MapUnit = GeographyUnit.DecimalDegree;
winformsMap1.CurrentExtent = new RectangleShape(-97.7591, 30.3126, -97.7317, 30.2964);
winformsMap1.BackgroundOverlay.BackgroundBrush = new GeoSolidBrush(GeoColor.FromArgb(255, 198, 255, 255));
//Displays the World Map Kit as a background.
ThinkGeo.MapSuite.DesktopEdition.WorldMapKitWmsDesktopOverlay worldMapKitDesktopOverlay = new ThinkGeo.MapSuite.DesktopEdition.WorldMapKitWmsDesktopOverlay();
winformsMap1.Overlays.Add(worldMapKitDesktopOverlay);
//Adds the inMemoryFeatureLayer for car icon and label.
InMemoryFeatureLayer inMemoryFeatureLayer = new InMemoryFeatureLayer();
//Adds column to InMemoryFeatureLayer.
inMemoryFeatureLayer.Open();
inMemoryFeatureLayer.Columns.Add(new FeatureSourceColumn("VehiclePosition"));
inMemoryFeatureLayer.Close();
//Sets PointStyle and TextStyle for the InMemoryFeatureLayer.
inMemoryFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle.PointType = PointType.Bitmap;
inMemoryFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle = TextStyles.CreateSimpleTextStyle("VehiclePosition", "Arial", 8, DrawingFontStyles.Bold,
GeoColor.StandardColors.Black, 20, 0);
inMemoryFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle.Mask = new AreaStyle(new GeoPen(GeoColor.StandardColors.DarkGray, 1),
new GeoSolidBrush(GeoColor.FromArgb(150, GeoColor.StandardColors.LightGoldenrodYellow)));
inMemoryFeatureLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
//Adds the Feature for the car.
inMemoryFeatureLayer.InternalFeatures.Add("Car", new Feature(new PointShape()));
LayerOverlay dynamicOverlay = new LayerOverlay();
dynamicOverlay.Layers.Add("CarLayer", inMemoryFeatureLayer);
winformsMap1.Overlays.Add("DynamicOverlay", dynamicOverlay);
winformsMap1.Refresh();
timer.Start();
}
public void DifferenceFeature(Map map, GeoCollection <object> args)
{
if (null != map)
{
InMemoryFeatureLayer mapShapeLayer = (InMemoryFeatureLayer)((LayerOverlay)map.CustomOverlays["OverLayer"]).Layers["InMemoryFeatureLayer"];
if (mapShapeLayer.InternalFeatures.Count > 1)
{
AreaBaseShape targetShape = (AreaBaseShape)mapShapeLayer.InternalFeatures["AreaShape1"].GetShape();
mapShapeLayer.Open();
mapShapeLayer.EditTools.BeginTransaction();
mapShapeLayer.EditTools.GetDifference("AreaShape2", targetShape);
mapShapeLayer.EditTools.Delete("AreaShape1");
mapShapeLayer.EditTools.CommitTransaction();
mapShapeLayer.Close();
mapShapeLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.FillSolidBrush.Color = GeoColor.FromArgb(100, GeoColor.StandardColors.Blue);
}
((LayerOverlay)map.CustomOverlays["OverLayer"]).Redraw();
}
}
//Finds the five nearest dams using FeatureIdsToExclude.
private void radioButtonWith_CheckedChanged(object sender, EventArgs e)
{
LayerOverlay layerOverlay = (LayerOverlay)winformsMap1.Overlays[1];
InMemoryFeatureLayer inMemoryFeatureLayer = (InMemoryFeatureLayer)layerOverlay.Layers[0];
//Adds the features to exlude using the feature id.
//Will exclude the dam 24 and dam 31 from the search.
inMemoryFeatureLayer.FeatureIdsToExclude.Add("Dam 24");
inMemoryFeatureLayer.FeatureIdsToExclude.Add("Dam 31");
InMemoryFeatureLayer inMemoryFeatureLayer2 = (InMemoryFeatureLayer)layerOverlay.Layers[1];
PointShape pointShape = (PointShape)inMemoryFeatureLayer2.InternalFeatures[0].GetShape();
inMemoryFeatureLayer.Open();
int numberToFind = 5;
Collection <Feature> nearestFeatures = inMemoryFeatureLayer.QueryTools.GetFeaturesNearestTo(pointShape, GeographyUnit.DecimalDegree, numberToFind, ReturningColumnsType.NoColumns);
//We may have to adjust numberOfItemsToFind parameter to find the nearest 5 features.
if (nearestFeatures.Count < numberToFind)
{
numberToFind = numberToFind + (numberToFind - nearestFeatures.Count);
nearestFeatures = inMemoryFeatureLayer.QueryTools.GetFeaturesNearestTo(pointShape, GeographyUnit.DecimalDegree, numberToFind, ReturningColumnsType.NoColumns);
}
//Before refreshing the map, we clear the FeatureIdsToExclude so that all the features of the InMemoryFeatureLayer will be drawn.
inMemoryFeatureLayer.FeatureIdsToExclude.Clear();
inMemoryFeatureLayer.Close();
InMemoryFeatureLayer highllightInMemoryFeatureLayer = (InMemoryFeatureLayer)layerOverlay.Layers[2];
highllightInMemoryFeatureLayer.InternalFeatures.Clear();
//Adds the result features to the InMemoryFeatureLayer for displaying.
foreach (Feature feature in nearestFeatures)
{
highllightInMemoryFeatureLayer.InternalFeatures.Add(feature);
}
winformsMap1.Refresh(layerOverlay);
}
private void Form_Load(object sender, EventArgs e)
{
// Set the map's unit of measurement to meters(Spherical Mercator)
mapView.MapUnit = GeographyUnit.Meter;
// Add Cloud Maps as a background overlay
var thinkGeoCloudVectorMapsOverlay = new ThinkGeoCloudVectorMapsOverlay("itZGOI8oafZwmtxP-XGiMvfWJPPc-dX35DmESmLlQIU~", "bcaCzPpmOG6le2pUz5EAaEKYI-KSMny_WxEAe7gMNQgGeN9sqL12OA~~", ThinkGeoCloudVectorMapsMapType.Light);
mapView.Overlays.Add(thinkGeoCloudVectorMapsOverlay);
InMemoryFeatureLayer railway = new InMemoryFeatureLayer();
InMemoryFeatureLayer subLineLayer = new InMemoryFeatureLayer();
LayerOverlay layerOverlay = new LayerOverlay();
// Add the rail line feature to the railway layer
railway.InternalFeatures.Add(new Feature("LineString (-10776730.91861553490161896 3925750.69222266925498843, -10778989.31895966082811356 3915278.00731692276895046, -10781766.12723691388964653 3909228.15506267035380006, -10782065.98029803484678268 3907458.59967381786555052, -10781867.48601813986897469 3905465.21030976390466094)"));
// Style railway layer
railway.ZoomLevelSet.ZoomLevel01.DefaultLineStyle = LineStyle.CreateSimpleLineStyle(GeoColors.Red, 2, false);
railway.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
// Style the subLineLayer
subLineLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle = LineStyle.CreateSimpleLineStyle(GeoColors.Green, 2, false);
subLineLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
// Add railway to the layerOverlay
layerOverlay.Layers.Add("railway", railway);
// Add subLineLayer to the layerOverlay
layerOverlay.Layers.Add("subLineLayer", subLineLayer);
// Set the map extent to the railway layer bounding box
railway.Open();
mapView.CurrentExtent = railway.GetBoundingBox();
railway.Close();
// Add LayerOverlay to Map
mapView.Overlays.Add("layerOverlay", layerOverlay);
}
private void btnRoute_Click(object sender, EventArgs e)
{
Algorithm algorithm = new AStarAlgorithm();
RoutingSource routingSource = new CustomRoutingSource(new ShapeFileFeatureSource(@"..\..\App_Data\Austinstreets.shp"));
Collection <Road> pathIDs = algorithm.GetShortestPath(routingSource, txtStartId.Text, txtEndId.Text);
Collection <Feature> features = new Collection <Feature>();
Dictionary <string, ShapeFileFeatureSource> featureSources = new Dictionary <string, ShapeFileFeatureSource>();
for (int i = 0; i < pathIDs.Count; i++)
{
FeatureSource featureSource = routingSource.GetFeatureSourceByroadId(pathIDs[i].Id);
featureSource.Open();
features.Add(featureSource.GetFeatureById(routingSource.GetFeatureIdByroadId(pathIDs[i].Id).ToString(), ReturningColumnsType.NoColumns));
featureSource.Close();
}
winformsMap1.Overlays["RoutingOverlay"].Lock.EnterWriteLock();
try
{
InMemoryFeatureLayer inmemoryLayer = (InMemoryFeatureLayer)((LayerOverlay)winformsMap1.Overlays["RoutingOverlay"]).Layers["RoutingLayer"];
inmemoryLayer.InternalFeatures.Clear();
foreach (Feature feature in features)
{
inmemoryLayer.InternalFeatures.Add(feature);
}
inmemoryLayer.Open();
winformsMap1.CurrentExtent = inmemoryLayer.GetBoundingBox();
inmemoryLayer.Close();
}
finally
{
winformsMap1.Overlays["RoutingOverlay"].Lock.ExitWriteLock();
}
winformsMap1.Refresh();
}
private void mapView_MapClick(object sender, MapClickMapViewEventArgs e)
{
FeatureLayer worldLayer = mapView.FindFeatureLayer("RoadLayer");
InMemoryFeatureLayer highlightLayer = (InMemoryFeatureLayer)mapView.FindFeatureLayer("HighlightLayer");
Overlay highlightOverlay = mapView.Overlays["HighlightOverlay"];
// Find the road the user clicked on.
worldLayer.Open();
Collection <Feature> selectedFeatures = worldLayer.QueryTools.GetFeaturesNearestTo(e.WorldLocation, GeographyUnit.Meter, 1, new string[1] {
"FENAME"
});
worldLayer.Close();
//Determine the length of the road.
if (selectedFeatures.Count > 0)
{
LineBaseShape lineShape = (LineBaseShape)selectedFeatures[0].GetShape();
highlightLayer.Open();
highlightLayer.InternalFeatures.Clear();
highlightLayer.InternalFeatures.Add(new Feature(lineShape));
highlightLayer.Close();
ProjectionConverter project = new ProjectionConverter(3857, 4326);
project.Open();
double length = ((LineBaseShape)project.ConvertToExternalProjection(lineShape)).GetLength(GeographyUnit.DecimalDegree, DistanceUnit.Meter);
project.Close();
string lengthMessage = string.Format(CultureInfo.InvariantCulture, "{0} has a length of {1:F2} meters.", selectedFeatures[0].ColumnValues["FENAME"].Trim(), length);
Popup popup = new Popup(e.WorldLocation);
popup.Content = lengthMessage;
PopupOverlay popupOverlay = (PopupOverlay)mapView.Overlays["PopupOverlay"];
popupOverlay.Popups.Clear();
popupOverlay.Popups.Add(popup);
highlightOverlay.Refresh();
popupOverlay.Refresh();
}
}
/// <summary>
/// Draw reprojected features on the map
/// </summary>
private void ClearMapAndAddFeatures(Collection <Feature> reprojectedFeatures)
{
// Get the layer we prepared from the MapView
InMemoryFeatureLayer reprojectedFeatureLayer = (InMemoryFeatureLayer)mapView.FindFeatureLayer("Reprojected Features Layer");
// Clear old features from the feature layer and add the newly reprojected features
reprojectedFeatureLayer.InternalFeatures.Clear();
foreach (Feature sphericalMercatorFeature in reprojectedFeatures)
{
reprojectedFeatureLayer.InternalFeatures.Add(sphericalMercatorFeature);
}
// Set the map extent to zoom into the feature and refresh the map
reprojectedFeatureLayer.Open();
mapView.CurrentExtent = reprojectedFeatureLayer.GetBoundingBox();
ZoomLevelSet standardZoomLevelSet = new ZoomLevelSet();
mapView.ZoomToScale(standardZoomLevelSet.ZoomLevel18.Scale);
reprojectedFeatureLayer.Close();
mapView.Refresh();
}
/// <summary>
/// When a hotel is selected in the UI, center the map on it
/// </summary>
private void lsbHotels_SelectionChanged(object sender, SelectedItemChangedEventArgs selectedItemChangedEventArgs)
{
InMemoryFeatureLayer highlightedHotelLayer = (InMemoryFeatureLayer)mapView.FindFeatureLayer("Highlighted Hotel");
highlightedHotelLayer.Open();
highlightedHotelLayer.InternalFeatures.Clear();
// Get the selected location
Hotel hotel = lsbHotels.SelectedItem as Hotel;
if (hotel != null)
{
highlightedHotelLayer.InternalFeatures.Add(new Feature(hotel.Location));
// Center the map on the chosen location
mapView.CurrentExtent = hotel.Location.GetBoundingBox();
ZoomLevelSet standardZoomLevelSet = new ZoomLevelSet();
mapView.ZoomToScale(standardZoomLevelSet.ZoomLevel18.Scale);
mapView.Refresh();
}
highlightedHotelLayer.Close();
}
/// <summary>
/// Highlight the features that were found by the spatial query
/// </summary>
private void HighlightQueriedFeatures(IEnumerable <Feature> features)
{
// Find the layers we will be modifying in the MapView dictionary
LayerOverlay layerOverlay = (LayerOverlay)mapView.Overlays["Layer Overlay"];
InMemoryFeatureLayer highlightedFeaturesLayer = (InMemoryFeatureLayer)layerOverlay.Layers["Highlighted Features"];
// Clear the currently highlighted features
highlightedFeaturesLayer.Open();
highlightedFeaturesLayer.InternalFeatures.Clear();
// Add new features to the layer
foreach (var feature in features)
{
highlightedFeaturesLayer.InternalFeatures.Add(feature);
}
highlightedFeaturesLayer.Close();
// Refresh the overlay so the layer is redrawn
layerOverlay.Refresh();
// Update the number of matching features found in the UI
txtNumberOfFeaturesFound.Text = $"Number of features within the drawn shape: {features.Count()}";
}
private void Route()
{
RtgRoutingSource routingSource = new RtgRoutingSource(Path.Combine(rootPath, "DallasCounty-4326.shortest.rtg"));
FeatureSource featureSource = new ShapeFileFeatureSource(Path.Combine(rootPath, "DallasCounty-4326.shp"));
RoutingEngine routingEngine = new RoutingEngine(routingSource, featureSource);
float averageSpeed = float.Parse(txtAverageSpeed.Text);
int drivingMinutes = int.Parse(txtDrivingMinutes.Text);
SpeedUnit speedUnit = GetSpeedUnit();
PolygonShape polygonShape = routingEngine.GenerateServiceArea(txtStartId.Text, new TimeSpan(0, drivingMinutes, 0), averageSpeed, speedUnit);
InMemoryFeatureLayer routingLayer = (InMemoryFeatureLayer)((LayerOverlay)winformsMap1.Overlays["RoutingOverlay"]).Layers["RoutingLayer"];
routingLayer.InternalFeatures.Remove("ServiceArea");
if (polygonShape.Validate(ShapeValidationMode.Simple).IsValid)
{
routingLayer.InternalFeatures.Add("ServiceArea", new Feature(polygonShape));
routingLayer.Open();
winformsMap1.CurrentExtent = routingLayer.GetBoundingBox();
routingLayer.Close();
}
winformsMap1.Refresh(winformsMap1.Overlays["RoutingOverlay"]);
}
private void MulitFeaturesButtonClick(object sender, EventArgs e)
{
Collection <string> featureIDs = new Collection <string>();
featureIDs.Add("63"); // For US
featureIDs.Add("6"); // For Canada
featureIDs.Add("137"); // For Mexico
LayerOverlay worldOverlay = (LayerOverlay)androidMap.Overlays["WorldOverlay"];
FeatureLayer worldLayer = (FeatureLayer)worldOverlay.Layers["WorldLayer"];
LayerOverlay highlightOverlay = (LayerOverlay)androidMap.Overlays["HighlightOverlay"];
InMemoryFeatureLayer highlightLayer = (InMemoryFeatureLayer)highlightOverlay.Layers["HighlightLayer"];
lock (worldLayer)
{
if (!worldLayer.IsOpen)
{
worldLayer.Open();
}
Collection <Feature> features = worldLayer.FeatureSource.GetFeaturesByIds(featureIDs, new string[0]);
androidMap.CurrentExtent = ExtentHelper.GetBoundingBoxOfItems(features);
highlightLayer.Open();
highlightLayer.InternalFeatures.Clear();
if (features.Count > 0)
{
foreach (var feature in features)
{
highlightLayer.InternalFeatures.Add(feature);
}
}
highlightLayer.Close();
}
androidMap.Refresh();
}
private void getSubLine_Click(object sender, EventArgs e)
{
LayerOverlay layerOverlay = (LayerOverlay)mapView.Overlays["layerOverlay"];
InMemoryFeatureLayer railway = (InMemoryFeatureLayer)layerOverlay.Layers["railway"];
InMemoryFeatureLayer subLineLayer = (InMemoryFeatureLayer)layerOverlay.Layers["subLineLayer"];
// Query the railway layer to get all the features
railway.Open();
var feature = railway.QueryTools.GetAllFeatures(ReturningColumnsType.NoColumns).First();
railway.Close();
// Get the subLine from the railway line shape
var subLine = ((LineShape)feature.GetShape()).GetLineOnALine(StartingPoint.FirstPoint, Convert.ToDouble(startingOffset.Text), Convert.ToDouble(distance.Text), GeographyUnit.Meter,
DistanceUnit.Meter);
// Add the subLine into an InMemoryFeatureLayer to display the result.
subLineLayer.InternalFeatures.Clear();
subLineLayer.InternalFeatures.Add(new Feature(subLine));
// Redraw the layerOverlay to see the subLine on the map
layerOverlay.Refresh();
}
private void btnRoute_Click(object sender, EventArgs e)
{
RoutingLayer routingLayer = (RoutingLayer)((LayerOverlay)winformsMap1.Overlays["RoutingOverlay"]).Layers["RoutingLayer"];
routingLayer.Routes.Clear();
routingLayer.Routes.Add(routingEngine.GetRoute(txtStartId.Text, txtEndId.Text).Route);
InMemoryFeatureLayer POIsOnRouteLayer = new InMemoryFeatureLayer();
MemoryStream stream = new MemoryStream();
Properties.Resources.Gas_Station.Save(stream, ImageFormat.Png);
POIsOnRouteLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle = new PointStyle(new GeoImage(stream));
POIsOnRouteLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
LayerOverlay POIsOnRouteOverlay = new LayerOverlay();
POIsOnRouteOverlay.Layers.Add(POIsOnRouteLayer);
winformsMap1.Overlays.Add(POIsOnRouteOverlay);
ShapeFileFeatureLayer poiLayer = (ShapeFileFeatureLayer)((LayerOverlay)winformsMap1.Overlays["POIoverlay"]).Layers["POIlayer"];
poiLayer.Open();
Collection <Feature> features = poiLayer.QueryTools.GetFeaturesWithinDistanceOf(routingLayer.Routes[0], GeographyUnit.DecimalDegree, DistanceUnit.Meter,
100, ReturningColumnsType.NoColumns);
poiLayer.Close();
POIsOnRouteLayer.Open();
POIsOnRouteLayer.EditTools.BeginTransaction();
foreach (Feature feature in features)
{
POIsOnRouteLayer.EditTools.Add(feature);
}
POIsOnRouteLayer.EditTools.CommitTransaction();
POIsOnRouteLayer.Close();
winformsMap1.Refresh(winformsMap1.Overlays["RoutingOverlay"]);
}
private void wpfMap1_MapClick(object sender, MapClickWpfMapEventArgs e)
{
try
{
//Uses the WrapDatelineProjection to create the target pointshape for GetFeatureNearestTo spatial query function.
WrapDatelineProjection wrapDatelineProjection = new WrapDatelineProjection();
//Sets the HalfExtentWidth of the wrapdateline overlay we want to apply the projection on.
//Here it is 180 because, the full extent width is 360.
wrapDatelineProjection.HalfExtentWidth = wpfMap1.Overlays["WMK"].GetBoundingBox().Width / 2;//180;
//Gets the valid world coordinate regardless to where the user click on the map
wrapDatelineProjection.Open();
Vertex projVertex = wrapDatelineProjection.ConvertToExternalProjection(e.WorldX, e.WorldY);
wrapDatelineProjection.Close();
//Here we just use the feature source of the shapefile because we don't display it, we just use it for doing the spatial query.
ShapeFileFeatureSource shapeFileFeatureSource = new ShapeFileFeatureSource(@"../../data/countries02.shp");
shapeFileFeatureSource.Open();
//Uses the projected X and Y values for the Spatial Query.
Collection <Feature> features = shapeFileFeatureSource.GetFeaturesNearestTo(new PointShape(projVertex), wpfMap1.MapUnit, 1, ReturningColumnsType.NoColumns);
shapeFileFeatureSource.Close();
LayerOverlay dynamicOverlay = (LayerOverlay)wpfMap1.Overlays["DynamicOverlay"];
InMemoryFeatureLayer inMemoryFeatureLayer = (InMemoryFeatureLayer)dynamicOverlay.Layers["SelectLayer"];
//Clears the InMemoryFeatureLayer and add the feature as the result of the spatial query.
inMemoryFeatureLayer.Open();
inMemoryFeatureLayer.InternalFeatures.Clear();
inMemoryFeatureLayer.InternalFeatures.Add(features[0]);
inMemoryFeatureLayer.Close();
//Refreshes only the overlay with the updated InMemoryFeatureLayer.
wpfMap1.Refresh(dynamicOverlay);
}
catch { }
}
private InMemoryFeatureLayer CreateInMemoryFeatureLayerFromTextFile(string textFile)
{
InMemoryFeatureLayer inMemoryFeatureLayer = new InMemoryFeatureLayer();
StreamReader hotelReader = new StreamReader(textFile);
//Reads the header of the text file to add the columns to the InMemoryFeatureLayer
string nameColumn = ""; string addressColumn = ""; string roomsColumn = "";
string header = hotelReader.ReadLine();
if (header.Trim() != "/")
{
string[] strSplit = header.Split(',');
nameColumn = strSplit[0]; addressColumn = strSplit[1]; roomsColumn = strSplit[2];
}
inMemoryFeatureLayer.Open();
inMemoryFeatureLayer.Columns.Add(new FeatureSourceColumn(nameColumn, DbfColumnType.Character.ToString(), 30));
inMemoryFeatureLayer.Columns.Add(new FeatureSourceColumn(addressColumn, DbfColumnType.Character.ToString(), 40));
inMemoryFeatureLayer.Columns.Add(new FeatureSourceColumn(roomsColumn, DbfColumnType.Numeric.ToString(), 30));
//Read every line of the text file to add the point based features with the column values.
inMemoryFeatureLayer.EditTools.BeginTransaction();
string name = ""; string address = ""; string rooms = ""; string geom = "";
using (hotelReader)
{
String line;
// Read and display lines from the file until the end of
// the file is reached.
while ((line = hotelReader.ReadLine()) != null)
{
string[] strSplit = line.Split(';');
name = strSplit[0]; address = strSplit[1]; rooms = strSplit[2]; geom = strSplit[3];
Feature feature = new Feature(new PolygonShape(geom));
feature.ColumnValues.Add(nameColumn, name);
feature.ColumnValues.Add(addressColumn, address);
feature.ColumnValues.Add(roomsColumn, rooms);
inMemoryFeatureLayer.EditTools.Add(feature);
}
}
inMemoryFeatureLayer.EditTools.CommitTransaction();
inMemoryFeatureLayer.Close();
inMemoryFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.FillSolidBrush.Color = GeoColor.FromArgb(100, GeoColor.StandardColors.RoyalBlue);
inMemoryFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Blue;
inMemoryFeatureLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
////Sets the class break styles and text styles of the InMemoryFeatureLayer.
//ClassBreakStyle cbs = new ClassBreakStyle(roomsColumn);
//cbs.BreakValueInclusion = BreakValueInclusion.IncludeValue;
//cbs.ClassBreaks.Add(new ClassBreak(double.MinValue, PointStyles.CreateSimplePointStyle(PointSymbolType.Circle,
// GeoColor.FromArgb(150, GeoColor.StandardColors.Blue), GeoColor.StandardColors.Black, 8)));
//cbs.ClassBreaks.Add(new ClassBreak(100, PointStyles.CreateSimplePointStyle(PointSymbolType.Circle,
// GeoColor.FromArgb(150, GeoColor.StandardColors.Blue), GeoColor.StandardColors.Black, 12)));
//cbs.ClassBreaks.Add(new ClassBreak(200, PointStyles.CreateSimplePointStyle(PointSymbolType.Circle,
// GeoColor.FromArgb(150, GeoColor.StandardColors.Blue), GeoColor.StandardColors.Black, 16)));
//cbs.ClassBreaks.Add(new ClassBreak(300, PointStyles.CreateSimplePointStyle(PointSymbolType.Circle,
// GeoColor.FromArgb(150, GeoColor.StandardColors.Blue), GeoColor.StandardColors.Black, 20)));
//TextStyle textStyle = new TextStyle(nameColumn, new GeoFont("Arial", 10, DrawingFontStyles.Bold), new GeoSolidBrush(GeoColor.StandardColors.Black));
//textStyle.HaloPen = new GeoPen(GeoColor.StandardColors.White, 1);
//textStyle.XOffsetInPixel = 10;
//inMemoryFeatureLayer.ZoomLevelSet.ZoomLevel01.CustomStyles.Add(cbs);
//inMemoryFeatureLayer.ZoomLevelSet.ZoomLevel01.CustomStyles.Add(textStyle);
//inMemoryFeatureLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
return(inMemoryFeatureLayer);
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
Proj4Projection proj4 = new Proj4Projection();
proj4.ExternalProjectionParametersString = Proj4Projection.GetEpsgParametersString(2178);
proj4.InternalProjectionParametersString = Proj4Projection.GetEpsgParametersString(2178);
//proj4.ExternalProjectionParametersString = Proj4Projection.GetGoogleMapParametersString();
proj4.Open();
//WorldStreetsAndImageryProjection x = new WorldStreetsAndImageryProjection();
//WpfMap.MapUnit = ThinkGeo.MapSuite.GeographyUnit.DecimalDegree;
WpfMap.MapUnit = ThinkGeo.MapSuite.GeographyUnit.Meter;
WpfMap.CurrentExtent = new RectangleShape(6534300.78, 5593416.28, 6534296.12, 5593426.45);
//var x = new WorldStreetsAndImageryOverlay()
//WpfMap.Overlays.Add(x);
WpfMap.Refresh();
InMemoryFeatureLayer inMemoryFeatureLayer = CreateInMemoryFeatureLayerFromTextFile(@"..\..\data\FriscoHotels.txt");
inMemoryFeatureLayer.FeatureSource.Projection = proj4;
LayerOverlay layerOverlay = new LayerOverlay();
layerOverlay.TileType = TileType.SingleTile;
layerOverlay.Layers.Add(inMemoryFeatureLayer);
WpfMap.Overlays.Add(layerOverlay);
//LayerOverlay layerOverlay = new LayerOverlay();
//layerOverlay.TileType = TileType.SingleTile;
//var polygonLayer = new InMemoryFeatureLayer();
//Feature feature2 = new Feature(new PolygonShape("POLYGON((20.030485999999996 50.00571917079107,20.030485999999996 49.998476,20.03997000000004 49.998476,20.03997000000004 49.998476,20.040292010620078 50.00568354029431,20.030485999999996 50.00571917079107))"));
//polygonLayer.Open();
//polygonLayer.EditTools.BeginTransaction();
//polygonLayer.EditTools.Add(feature2);
////layerOverlay.Layers.Add(inMemoryFeatureLayer);
//layerOverlay.Layers.Add(polygonLayer);
//WpfMap.Overlays.Add(layerOverlay);
//polygonLayer.EditTools.CommitTransaction();
//polygonLayer.Close();
InMemoryFeatureLayer inMemoryLayer = new InMemoryFeatureLayer();
inMemoryLayer.FeatureSource.Projection = proj4;
inMemoryLayer.InternalFeatures.Add("Polygon", new Feature(BaseShape.CreateShapeFromWellKnownData("POLYGON((6534300.78 5593416.28, 6534296.12 5593426.45, 6534280.56 5593419.19, 6534283.49 5593412.92, 6534285.3 5593409.04, 6534300.78 5593416.28))")));
inMemoryLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.FillSolidBrush.Color = GeoColor.FromArgb(100, GeoColor.StandardColors.RoyalBlue);
inMemoryLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Blue;
inMemoryLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
LayerOverlay layerOverlay2 = new LayerOverlay();
layerOverlay2.TileType = TileType.SingleTile;
layerOverlay2.Layers.Add(inMemoryLayer);
//WpfMap.Overlays.Add(layerOverlay);
inMemoryLayer.Open();
WpfMap.CurrentExtent = inMemoryLayer.GetBoundingBox();
inMemoryLayer.Close();
WpfMap.Refresh();
}
/// <summary>
/// Use the TimezoneCloudClient to query for timezone information
/// </summary>
private async Task GetTimeZoneInfo(double lon, double lat)
{
CloudTimeZoneResult result;
try
{
// Show a loading graphic to let users know the request is running
loadingIndicator.IsRunning = true;
loadingLayout.IsVisible = true;
// Get timezone info based on the lon, lat, and input projection (Spherical Mercator in this case)
result = await timeZoneCloudClient.GetTimeZoneByCoordinateAsync(lon, lat, 3857);
}
catch (Exception ex)
{
await DisplayAlert("Error", ex.Message, "OK");
return;
}
finally
{
loadingIndicator.IsRunning = false;
loadingLayout.IsVisible = false;
}
// Get the timezone info popup overlay from the mapview
PopupOverlay timezoneInfoPopupOverlay = (PopupOverlay)mapView.Overlays["Timezone Info Popup Overlay"];
// Clear the existing info popups from the map
timezoneInfoPopupOverlay.Popups.Clear();
// Build a string description of the timezone
StringBuilder timezoneInfoString = new StringBuilder();
timezoneInfoString.AppendLine($"Time Zone: {result.TimeZone}");
timezoneInfoString.AppendLine($"Current Local Time: {result.CurrentLocalTime}");
timezoneInfoString.AppendLine($"Daylight Savings Active: {result.DaylightSavingsActive}");
// Display the timezone info on a popup on the map
Popup popup = new Popup();
popup.Content = timezoneInfoString.ToString();
popup.Position = new PointShape(lon, lat);
timezoneInfoPopupOverlay.Popups.Add(popup);
// Clear the timezone feature layer of previous features
InMemoryFeatureLayer timezonesFeatureLayer = (InMemoryFeatureLayer)mapView.FindFeatureLayer("Timezone Feature Layer");
timezonesFeatureLayer.Open();
timezonesFeatureLayer.InternalFeatures.Clear();
// Use a ProjectionConverter to convert the shape to Spherical Mercator
ProjectionConverter converter = new ProjectionConverter(3857, 4326);
converter.Open();
// Add the new timezone polygon to the map
timezonesFeatureLayer.InternalFeatures.Add(new Feature(converter.ConvertToInternalProjection(result.Shape)));
converter.Close();
timezonesFeatureLayer.Close();
// Refresh and redraw the map
mapView.Refresh();
}
/// <summary>
/// Set up the map with the ThinkGeo Cloud Maps overlay and a feature layer containing Frisco zoning data
/// </summary>
protected override void OnAppearing()
{
base.OnAppearing();
// Create the background world maps using vector tiles requested from the ThinkGeo Cloud Service.
ThinkGeoCloudVectorMapsOverlay thinkGeoCloudVectorMapsOverlay = new ThinkGeoCloudVectorMapsOverlay("9ap16imkD_V7fsvDW9I8r8ULxgAB50BX_BnafMEBcKg~", "vtVao9zAcOj00UlGcK7U-efLANfeJKzlPuDB9nw7Bp4K4UxU_PdRDg~~", ThinkGeoCloudVectorMapsMapType.Light);
thinkGeoCloudVectorMapsOverlay.VectorTileCache = new FileVectorTileCache(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "cache"), "CloudMapsVector");
mapView.Overlays.Add(thinkGeoCloudVectorMapsOverlay);
// Set the Map Unit to meters (used in Spherical Mercator)
mapView.MapUnit = GeographyUnit.Meter;
// Create a feature layer to hold and display the zoning data
InMemoryFeatureLayer zoningLayer = new InMemoryFeatureLayer();
// Add a style to use to draw the Frisco zoning polygons
zoningLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
zoningLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyle.CreateSimpleAreaStyle(GeoColor.FromArgb(50, GeoColors.MediumPurple), GeoColors.MediumPurple, 2);
// Import the features from the Frisco zoning data shapefile
ShapeFileFeatureSource zoningDataFeatureSource = new ShapeFileFeatureSource(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Data/Shapefile/Zoning.shp"));
// Create a ProjectionConverter to convert the shapefile data from North Central Texas (2276) to Spherical Mercator (3857)
ProjectionConverter projectionConverter = new ProjectionConverter(3857, 2276);
// For this sample, we have to reproject the features before adding them to the feature layer
// This is because the topological equality query often does not work when used on a feature layer with a ProjectionConverter, due to rounding issues between projections
zoningDataFeatureSource.Open();
projectionConverter.Open();
foreach (Feature zoningFeature in zoningDataFeatureSource.GetAllFeatures(ReturningColumnsType.AllColumns))
{
Feature reprojectedFeature = projectionConverter.ConvertToInternalProjection(zoningFeature);
zoningLayer.InternalFeatures.Add(reprojectedFeature);
}
zoningDataFeatureSource.Close();
projectionConverter.Close();
// Set the map extent to Frisco, TX
//mapView.CurrentExtent = new RectangleShape(-10781137.28, 3917162.59, -10774579.34, 3911241.35);
// Create a layer to hold the feature we will perform the spatial query against
InMemoryFeatureLayer queryFeatureLayer = new InMemoryFeatureLayer();
queryFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyle.CreateSimpleAreaStyle(GeoColor.FromArgb(75, GeoColors.LightRed), GeoColors.LightRed);
queryFeatureLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
// Create a layer to hold features found by the spatial query
InMemoryFeatureLayer highlightedFeaturesLayer = new InMemoryFeatureLayer();
highlightedFeaturesLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyle.CreateSimpleAreaStyle(GeoColor.FromArgb(90, GeoColors.MidnightBlue), GeoColors.MidnightBlue);
highlightedFeaturesLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
// Add each feature layer to it's own overlay
// We do this so we can control and refresh/redraw each layer individually
LayerOverlay layerOverlay = new LayerOverlay();
layerOverlay.Layers.Add("Frisco Zoning", zoningLayer);
layerOverlay.Layers.Add("Query Feature", queryFeatureLayer);
layerOverlay.Layers.Add("Highlighted Features", highlightedFeaturesLayer);
mapView.Overlays.Add("Layer Overlay", layerOverlay);
// Create a sample shape using vertices from an existing feature, to ensure that it is touching other features
zoningLayer.Open();
MultipolygonShape firstFeatureShape = (MultipolygonShape)zoningLayer.FeatureSource.GetAllFeatures(ReturningColumnsType.NoColumns).First().GetShape();
// Get vertices from an existing feature
var vertices = firstFeatureShape.Polygons.First().OuterRing.Vertices;
// Create a new feature using a subset of those vertices
MultipolygonShape sampleShape = new MultipolygonShape(new Collection <PolygonShape> {
new PolygonShape(new RingShape(new Collection <Vertex> {
vertices[0], vertices[1], vertices[2]
}))
});
queryFeatureLayer.InternalFeatures.Add(new Feature(sampleShape));
zoningLayer.Close();
GetFeaturesTouching(sampleShape);
// Set the map extent to the sample shape
mapView.CurrentExtent = new RectangleShape(-10778499.3056056, 3920951.91647677, -10774534.1347853, 3917536.13679426);
mapView.Refresh();
}
void Timer_Tick(object sender, EventArgs e)
{
if (Startup.busPoints == null)
{
return;
}
LayerOverlay vehicleOverlay = (LayerOverlay)winformsMap1.Overlays["VehicleOverlay"];
InMemoryFeatureLayer carLayer = vehicleOverlay.Layers["CarLayer"] as InMemoryFeatureLayer;
carLayer.Open();
carLayer.EditTools.BeginTransaction();
//Gets the next GPS info
List <string> busEntityStrings = new List <string>();
foreach (System.Collections.Generic.KeyValuePair <EntityId, PointShape> KVPair in Startup.busPoints)
{
EntityId entityId = KVPair.Key;
string entityString = entityId.ToString();
busEntityStrings.Add(entityString);
PointShape carNextPosition = KVPair.Value;
double lng = carNextPosition.X;
double lat = carNextPosition.Y;
PointShape prevLatLong;
if (previousLatLong.ContainsKey(entityId))
{
prevLatLong = previousLatLong[entityId];
}
else
{
prevLatLong = new PointShape(lat, lng);
}
if (carLayer.InternalFeatures.Contains(entityString))
{
PointShape pointShape = carLayer.InternalFeatures[entityString].GetShape() as PointShape;
//Gets the angle based on the current GPS position and the previous one to get the direction of the vehicle.
double angle = GetAngleFromTwoVertices(new Vertex(prevLatLong.Y, prevLatLong.X), new Vertex(lng, lat));
carLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle.RotationAngle = 90 - (float)angle;
pointShape.X = lng;
pointShape.Y = lat;
pointShape.Id = entityString;
carLayer.EditTools.Update(pointShape);
}
else
{
carLayer.EditTools.Add(new Feature(new PointShape(lng, lat)
{
Id = entityString
}));
}
previousLatLong[entityId] = new PointShape(lat, lng);
}
foreach (string id in carLayer.InternalFeatures.GetKeys())
{
if (!busEntityStrings.Contains(id))
{
PointShape pointShape = carLayer.InternalFeatures[id].GetShape() as PointShape;
pointShape.X = 0;
pointShape.Y = 0;
pointShape.Id = id;
carLayer.EditTools.Update(pointShape);
}
}
carLayer.EditTools.CommitTransaction();
carLayer.Close();
winformsMap1.Refresh(vehicleOverlay);
}
/// <summary>
/// Get elevation data using the ElevationCloudClient and update the UI
/// </summary>
private async Task PerformElevationQuery(BaseShape queryShape)
{
// Get feature layers from the MapView
LayerOverlay elevationPointsOverlay = (LayerOverlay)mapView.Overlays["Elevation Features Overlay"];
InMemoryFeatureLayer drawnShapesLayer = (InMemoryFeatureLayer)elevationPointsOverlay.Layers["Drawn Shape Layer"];
InMemoryFeatureLayer elevationPointsLayer = (InMemoryFeatureLayer)elevationPointsOverlay.Layers["Elevation Points Layer"];
// Clear the existing shapes from the map
elevationPointsLayer.Open();
elevationPointsLayer.Clear();
elevationPointsLayer.Close();
drawnShapesLayer.Open();
drawnShapesLayer.Clear();
drawnShapesLayer.Close();
// Add the drawn shape to the map
drawnShapesLayer.InternalFeatures.Add(new Feature(queryShape));
// Set options from the UI and run the query using the ElevationCloudClient
Collection <CloudElevationPointResult> elevationPoints = new Collection <CloudElevationPointResult>();
int projectionInSrid = 3857;
// Show a loading graphic to let users know the request is running
loadingIndicator.IsRunning = true;
loadingLayout.IsVisible = true;
// The point interval distance determines how many elevation points are retrieved for line and area queries
int pointIntervalDistance = (int)intervalDistance.Value;
switch (queryShape.GetWellKnownType())
{
case WellKnownType.Point:
PointShape drawnPoint = (PointShape)queryShape;
double elevation = await elevationCloudClient.GetElevationOfPointAsync(drawnPoint.X, drawnPoint.Y, projectionInSrid);
// The API for getting the elevation of a single point returns a double, so we manually create a CloudElevationPointResult to use as a data source for the Elevations list
elevationPoints.Add(new CloudElevationPointResult(elevation, drawnPoint));
// Update the UI with the average, highest, and lowest elevations
txtAverageElevation.Text = $"Average Elevation: {elevation:0.00} feet";
txtHighestElevation.Text = $"Highest Elevation: {elevation:0.00} feet";
txtLowestElevation.Text = $"Lowest Elevation: {elevation:0.00} feet";
break;
case WellKnownType.Line:
LineShape drawnLine = (LineShape)queryShape;
var result = await elevationCloudClient.GetElevationOfLineAsync(drawnLine, projectionInSrid, pointIntervalDistance, DistanceUnit.Meter, DistanceUnit.Feet);
elevationPoints = result.ElevationPoints;
// Update the UI with the average, highest, and lowest elevations
txtAverageElevation.Text = $"Average Elevation: {result.AverageElevation:0.00} feet";
txtHighestElevation.Text = $"Highest Elevation: {result.HighestElevationPoint.Elevation:0.00} feet";
txtLowestElevation.Text = $"Lowest Elevation: {result.LowestElevationPoint.Elevation:0.00} feet";
break;
case WellKnownType.Polygon:
PolygonShape drawnPolygon = (PolygonShape)queryShape;
result = await elevationCloudClient.GetElevationOfAreaAsync(drawnPolygon, projectionInSrid, pointIntervalDistance, DistanceUnit.Meter, DistanceUnit.Feet);
elevationPoints = result.ElevationPoints;
// Update the UI with the average, highest, and lowest elevations
txtAverageElevation.Text = $"Average Elevation: {result.AverageElevation:0.00} feet";
txtHighestElevation.Text = $"Highest Elevation: {result.HighestElevationPoint.Elevation:0.00} feet";
txtLowestElevation.Text = $"Lowest Elevation: {result.LowestElevationPoint.Elevation:0.00} feet";
break;
default:
break;
}
// Add the elevation result points to the map and list box
foreach (CloudElevationPointResult elevationPoint in elevationPoints)
{
elevationPointsLayer.InternalFeatures.Add(new Feature(elevationPoint.Point));
}
lsbElevations.ItemsSource = elevationPoints;
// Hide the loading graphic
loadingIndicator.IsRunning = false;
loadingLayout.IsVisible = false;
// Set the map extent to the elevation query feature
drawnShapesLayer.Open();
mapView.CenterAt(drawnShapesLayer.GetBoundingBox().GetCenterPoint());
drawnShapesLayer.Close();
mapView.Refresh();
}
private void TestForm_Load(object sender, EventArgs e)
{
winformsMap1.MapUnit = GeographyUnit.DecimalDegree;
winformsMap1.CurrentExtent = new RectangleShape(-95.2982, 38.9632, -95.2843, 38.955);
winformsMap1.BackgroundOverlay.BackgroundBrush = new GeoSolidBrush(GeoColor.FromArgb(255, 198, 255, 255));
//Displays the World Map Kit as a background.
ThinkGeo.MapSuite.DesktopEdition.WorldMapKitWmsDesktopOverlay worldMapKitDesktopOverlay = new ThinkGeo.MapSuite.DesktopEdition.WorldMapKitWmsDesktopOverlay();
winformsMap1.Overlays.Add(worldMapKitDesktopOverlay);
//InMemoryFeatureLayer for the two reference points en red.
InMemoryFeatureLayer pointLayer = new InMemoryFeatureLayer();
pointLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle = PointStyles.CreateSimpleCircleStyle(GeoColor.StandardColors.Red, 12, GeoColor.StandardColors.Black);
pointLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
Feature feature1 = new Feature(new PointShape(-95.2949, 38.957));
Feature feature2 = new Feature(new PointShape(-95.2883, 38.957));
pointLayer.InternalFeatures.Add(feature1);
pointLayer.InternalFeatures.Add(feature2);
LayerOverlay pointOverlay = new LayerOverlay();
pointOverlay.Layers.Add("PointLayer", pointLayer);
winformsMap1.Overlays.Add("PointOverlay", pointOverlay);
//--------------------------------------------------
//Collection of PointShapes for the GPS locations.
GPSlocations.Add(new PointShape(-95.2946, 38.9602));
GPSlocations.Add(new PointShape(-95.2928, 38.9602));
GPSlocations.Add(new PointShape(-95.2903, 38.9602));
GPSlocations.Add(new PointShape(-95.2883, 38.9602));
GPSlocations.Add(new PointShape(-95.2883, 38.9587));
GPSlocations.Add(new PointShape(-95.2883, 38.957));
GPSlocations.Add(new PointShape(-95.2897, 38.957));
GPSlocations.Add(new PointShape(-95.2918, 38.957));
GPSlocations.Add(new PointShape(-95.2934, 38.957));
GPSlocations.Add(new PointShape(-95.2947, 38.957));
GPSlocations.Add(new PointShape(-95.2946, 38.9582));
GPSlocations.Add(new PointShape(-95.2946, 38.9593));
InMemoryFeatureLayer vehicleLayer = new InMemoryFeatureLayer();
vehicleLayer.Open();
vehicleLayer.Columns.Add(new FeatureSourceColumn("DETECT", "string", 3));
vehicleLayer.Close();
// Draw features based on values
ValueStyle valueStyle = new ValueStyle();
valueStyle.ColumnName = "DETECT";
valueStyle.ValueItems.Add(new ValueItem("No", new PointStyle(new GeoImage(@"..\..\Data\Top.png"))));
valueStyle.ValueItems.Add(new ValueItem("yes", new PointStyle(new GeoImage(@"..\..\Data\Top2.png"))));
vehicleLayer.ZoomLevelSet.ZoomLevel01.CustomStyles.Add(valueStyle);
vehicleLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
Feature GPSfeature = new Feature(GPSlocations[0]);
GPSfeature.ColumnValues.Add("DETECT", "No");
vehicleLayer.InternalFeatures.Add("GPSFeature1", GPSfeature);
LayerOverlay vehicleOverlay = new LayerOverlay();
vehicleOverlay.Layers.Add("VehicleLayer", vehicleLayer);
winformsMap1.Overlays.Add("VehicleOverlay", vehicleOverlay);
//Sets timer properties
timer.Interval = 1500;
timer.Tick += new EventHandler(timer_Tick);
winformsMap1.Refresh();
timer.Start();
}
private void TestForm_Load(object sender, EventArgs e)
{
winformsMap1.MapUnit = GeographyUnit.Meter;
winformsMap1.BackgroundOverlay.BackgroundBrush = new GeoSolidBrush(GeoColor.FromArgb(255, 198, 255, 255));
GoogleMapsOverlay googleOverlay = new GoogleMapsOverlay(); //(@"Insert your key here!", @"C:\GoogleCache");
googleOverlay.MapType = GoogleMapsMapType.Terrain;
winformsMap1.Overlays.Add(googleOverlay);
// This sets the zoom levels to map to Googles. We next make sure we snap to the zoomlevels
winformsMap1.ZoomLevelSet = new GoogleMapsZoomLevelSet();
InMemoryFeatureLayer pointLayer = new InMemoryFeatureLayer();
pointLayer.Open();
pointLayer.Columns.Add(new FeatureSourceColumn("Text"));
pointLayer.Close();
//Sets the projection parameters to go from Geodetic (EPSG 4326) or decimal degrees to Google Map projection (Spherical Mercator).
Proj4Projection proj4 = new Proj4Projection();
proj4.InternalProjectionParametersString = Proj4Projection.GetEpsgParametersString(4326);
proj4.ExternalProjectionParametersString = Proj4Projection.GetGoogleMapParametersString();
//Applies the projection to the InMemoryFeatureLayer so that the point in decimal degrees (Longitude/Latitude) can be
//match the projection of Google Map.
pointLayer.FeatureSource.Projection = proj4;
//Values in Longitude and Latitude.
double Longitude = -95.2809;
double Latitude = 38.9543;
//Creates the feature made of a PointShape with the Longitude and Latitude values.
Feature GPSFeature = new Feature(new PointShape(Longitude, Latitude));
//Format the Longitude and Latitude into a nice string as Degrees Minutes and Seconds
string LongLat = DecimalDegreesHelper.GetDegreesMinutesSecondsStringFromDecimalDegreePoint(GPSFeature);
//Sets the InMemoryFeatureLayer to have it displayed with Square symbol and with text.
GPSFeature.ColumnValues.Add("Text", LongLat);
pointLayer.InternalFeatures.Add(GPSFeature);
pointLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle = PointStyles.CreateSimplePointStyle(PointSymbolType.Square,
GeoColor.StandardColors.Red, GeoColor.StandardColors.Black, 2, 12);
pointLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle = TextStyles.CreateSimpleTextStyle("Text", "Arial", 12, DrawingFontStyles.Bold,
GeoColor.StandardColors.Black, GeoColor.StandardColors.White, 3, -10, 10);
pointLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
LayerOverlay pointOverlay = new LayerOverlay();
pointOverlay.Layers.Add("PointLayer", pointLayer);
winformsMap1.Overlays.Add("PointOverlay", pointOverlay);
//Sets the extend of the map based on the GPS point.
proj4.Open();
Vertex projVertex = proj4.ConvertToExternalProjection(Longitude, Latitude);
proj4.Close();
double extendWidth = 2300;
double extendHeight = 1200;
winformsMap1.CurrentExtent = new RectangleShape((projVertex.X - extendWidth), (projVertex.Y + extendHeight),
(projVertex.X + extendWidth), (projVertex.Y - extendHeight));
winformsMap1.Refresh();
}
/// <summary>
/// Get features from the WorldMapsQuery service based on the UI parameters
/// </summary>
private async void PerformWorldMapsQuery()
{
// Get the feature layers from the MapView
LayerOverlay queriedFeaturesOverlay = (LayerOverlay)mapView.Overlays["Queried Features Overlay"];
InMemoryFeatureLayer queryShapeFeatureLayer = (InMemoryFeatureLayer)queriedFeaturesOverlay.Layers["Query Shape Layer"];
InMemoryFeatureLayer queriedFeaturesLayer = (InMemoryFeatureLayer)queriedFeaturesOverlay.Layers["Queried Features Layer"];
// Show an error if trying to query with no query shape
if (queryShapeFeatureLayer.InternalFeatures.Count == 0)
{
await DisplayAlert("Alert", "Please draw a shape to use for the query", "OK");
return;
}
// Set the MapsQuery parameters based on the drawn query shape and the UI
BaseShape queryShape = queryShapeFeatureLayer.InternalFeatures[0].GetShape();
int projectionInSrid = 3857;
string queryLayer = ((string)cboQueryLayer.SelectedItem).ToLower();
CloudMapsQueryResult result = new CloudMapsQueryResult();
// Show a loading graphic to let users know the request is running
loadingIndicator.IsRunning = true;
loadingLayout.IsVisible = true;
// Perform the world maps query
try
{
switch ((string)cboQueryType.SelectedItem)
{
case "Containing":
result = await mapsQueryCloudClient.GetFeaturesContainingAsync(queryLayer, queryShape, projectionInSrid, new CloudMapsQuerySpatialQueryOptions()
{
MaxResults = Convert.ToInt32(maxResults.Text)
});
break;
case "Nearest":
result = await mapsQueryCloudClient.GetFeaturesNearestAsync(queryLayer, queryShape, projectionInSrid, Convert.ToInt32(maxResults.Text));
break;
case "Intersecting":
result = await mapsQueryCloudClient.GetFeaturesIntersectingAsync(queryLayer, queryShape, projectionInSrid, new CloudMapsQuerySpatialQueryOptions()
{
MaxResults = Convert.ToInt32(maxResults.Text)
});
break;
case "Overlapping":
result = await mapsQueryCloudClient.GetFeaturesOverlappingAsync(queryLayer, queryShape, projectionInSrid, new CloudMapsQuerySpatialQueryOptions()
{
MaxResults = Convert.ToInt32(maxResults.Text)
});
break;
case "Within":
result = await mapsQueryCloudClient.GetFeaturesWithinAsync(queryLayer, queryShape, projectionInSrid, new CloudMapsQuerySpatialQueryOptions()
{
MaxResults = Convert.ToInt32(maxResults.Text)
});
break;
default:
break;
}
}
catch (Exception ex)
{
// Handle any errors returned from the maps query service
if (ex is ArgumentException)
{
await DisplayAlert("Error", ex.Message, "OK");
mapView.Refresh();
return;
}
else
{
await DisplayAlert("Alert", ex.Message, "OK");
mapView.Refresh();
return;
}
}
finally
{
// Hide the loading graphic
loadingIndicator.IsRunning = false;
loadingLayout.IsVisible = false;
}
if (result.Features.Count > 0)
{
// Add any features found by the query to the map
foreach (Feature feature in result.Features)
{
queriedFeaturesLayer.InternalFeatures.Add(feature);
}
// Set the map extent to the extent of the query results
queriedFeaturesLayer.Open();
mapView.CurrentExtent = queriedFeaturesLayer.GetBoundingBox();
queriedFeaturesLayer.Close();
}
else
{
await DisplayAlert("Alert", "No features found in the selected area", "OK");
}
// Refresh and redraw the map
mapView.Refresh();
}
private void TestForm_Load(object sender, EventArgs e)
{
winformsMap1.MapUnit = GeographyUnit.DecimalDegree;
winformsMap1.CurrentExtent = new RectangleShape(-97.7591, 30.3126, -97.7317, 30.2964);
winformsMap1.BackgroundOverlay.BackgroundBrush = new GeoSolidBrush(GeoColor.FromArgb(255, 198, 255, 255));
//Displays the World Map Kit as a background.
ThinkGeo.MapSuite.DesktopEdition.WorldMapKitWmsDesktopOverlay worldMapKitDesktopOverlay = new ThinkGeo.MapSuite.DesktopEdition.WorldMapKitWmsDesktopOverlay();
winformsMap1.Overlays.Add(worldMapKitDesktopOverlay);
string fileName1 = @"..\..\data\polygon.txt";
StreamReader sr1 = new StreamReader(fileName1);
string fileName2 = @"..\..\data\line.txt";
StreamReader sr2 = new StreamReader(fileName2);
//DragtInteractiveOverlay for setting the PointStyles of the control points and dragged points.
DragInteractiveOverlay dragInteractiveOverlay = new DragInteractiveOverlay();
dragInteractiveOverlay.ReferenceShape = BaseShape.CreateShapeFromWellKnownData(sr1.ReadLine());
dragInteractiveOverlay.EditShapesLayer.InternalFeatures.Add("MultiLine", new Feature(BaseShape.CreateShapeFromWellKnownData(sr2.ReadLine())));
//Sets the PointStyle for the non dragged control points.
dragInteractiveOverlay.ControlPointStyle = new PointStyle(PointSymbolType.Circle, new GeoSolidBrush(GeoColor.StandardColors.PaleGoldenrod), new GeoPen(GeoColor.StandardColors.Black), 8);
//Sets the PointStyle for the dragged control points.
dragInteractiveOverlay.DraggedControlPointStyle = new PointStyle(PointSymbolType.Circle, new GeoSolidBrush(GeoColor.StandardColors.Red), new GeoPen(GeoColor.StandardColors.Orange, 2), 10);
// Add the point feature and specify text style.
dragInteractiveOverlay.EditShapesLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle = new TextStyle("LabelColumn", new GeoFont("Arial", 12), new GeoSolidBrush(GeoColor.SimpleColors.Black));
dragInteractiveOverlay.CanAddVertex = false;
dragInteractiveOverlay.CanDrag = false;
dragInteractiveOverlay.CanRemoveVertex = false;
dragInteractiveOverlay.CanResize = false;
dragInteractiveOverlay.CanRotate = false;
dragInteractiveOverlay.CalculateAllControlPoints();
winformsMap1.EditOverlay = dragInteractiveOverlay;
//InMemoryFeatureLayer for the geometry of the reference shape
InMemoryFeatureLayer inMemoryFeatureLayer = new InMemoryFeatureLayer();
inMemoryFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.CreateSimpleAreaStyle(GeoColor.StandardColors.Red, GeoColor.StandardColors.Black);
inMemoryFeatureLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
Feature newFeature = new Feature(dragInteractiveOverlay.ReferenceShape);
inMemoryFeatureLayer.Open();
inMemoryFeatureLayer.EditTools.BeginTransaction();
inMemoryFeatureLayer.EditTools.Add(newFeature);
inMemoryFeatureLayer.EditTools.CommitTransaction();
inMemoryFeatureLayer.Close();
LayerOverlay referenceOverlay = new LayerOverlay();
referenceOverlay.Layers.Add("Reference", inMemoryFeatureLayer);
winformsMap1.Overlays.Add(referenceOverlay);
winformsMap1.Refresh();
}
private void winformsMap1_MouseMove(object sender, MouseEventArgs e)
{
InMemoryFeatureLayer inMemoryLayer = (InMemoryFeatureLayer)((LayerOverlay)winformsMap1.Overlays["RoutingOverlay"]).Layers["RoutingLayer"];
InMemoryFeatureLayer mouseMoveLayer = (InMemoryFeatureLayer)((LayerOverlay)winformsMap1.Overlays["MouseMoveOverlay"]).Layers["MouseMoveLayer"];
//winformsMap1.Overlays["MouseMoveOverlay"].Lock.EnterWriteLock();
//try
//{
mouseMoveLayer.InternalFeatures.Clear();
//}
//finally
//{
// winformsMap1.Overlays["MouseMoveOverlay"].Lock.ExitWriteLock();
//}
winformsMap1.Overlays["MouseMoveOverlay"].Lock.IsDirty = true;
if (isPointSelected)
{
timer.Stop();
InMemoryFeatureLayer stopLayer = (InMemoryFeatureLayer)((LayerOverlay)winformsMap1.Overlays["StopOverlay"]).Layers["StopLayer"];
PointShape currentShape = ExtentHelper.ToWorldCoordinate(winformsMap1.CurrentExtent, ((MouseEventArgs)e).X, ((MouseEventArgs)e).Y, winformsMap1.Width, winformsMap1.Height);
// Find the routeSegment which is nearest to the current mouse position
FeatureLayer austinstreetsLayer = winformsMap1.FindFeatureLayer("AustinstreetsLayer");
austinstreetsLayer.Open();
Collection <Feature> tempFeatures = austinstreetsLayer.QueryTools.GetFeaturesNearestTo(currentShape, GeographyUnit.DecimalDegree, 1, new string[] { });
Feature stopRoad = tempFeatures[0];
austinstreetsLayer.Close();
Feature stopPoint = new Feature(stopRoad.GetShape().GetCenterPoint().GetWellKnownBinary(), stopRoad.Id);
//winformsMap1.Overlays["StopOverlay"].Lock.EnterWriteLock();
//try
//{
stopLayer.InternalFeatures[currentStopId] = stopPoint;
//}
//finally
//{
// winformsMap1.Overlays["StopOverlay"].Lock.ExitWriteLock();
//}
winformsMap1.Overlays["StopOverlay"].Lock.IsDirty = true;
}
else
{
if (string.IsNullOrEmpty(currentStopId))
{
PointShape targetPointShape = ExtentHelper.ToWorldCoordinate(winformsMap1.CurrentExtent, e.X, e.Y, winformsMap1.Width, winformsMap1.Height);
double searchingTolerance = GetControlPointOffsetRadius(winformsMap1.Width, winformsMap1.CurrentExtent.Width, 10);
RectangleShape searchingArea = new RectangleShape(targetPointShape.X - searchingTolerance, targetPointShape.Y + searchingTolerance, targetPointShape.X + searchingTolerance, targetPointShape.Y - searchingTolerance);
inMemoryLayer.Open();
Collection <Feature> features = inMemoryLayer.FeatureSource.GetAllFeatures(ReturningColumnsType.NoColumns);
inMemoryLayer.Close();
foreach (Feature item in features)
{
Collection <LineShape> lines = ConvertLineBaseShapeToLines((LineBaseShape)item.GetShape());
Feature feature = GetPointFromLines(lines, targetPointShape, searchingArea);
if (!string.IsNullOrEmpty(feature.Id))
{
//winformsMap1.Overlays["MouseMoveOverlay"].Lock.EnterWriteLock();
//try
//{
mouseMoveLayer.InternalFeatures.Add(feature);
//}
//finally
//{
// winformsMap1.Overlays["MouseMoveOverlay"].Lock.ExitWriteLock();
//}
winformsMap1.Overlays["MouseMoveOverlay"].Lock.IsDirty = true;
winformsMap1.Refresh();
break;
}
}
}
}
winformsMap1.Refresh();
timer.Start();
}
void timer_Tick(object sender, EventArgs e)
{
//Gets the GPS info from the textfile.
DataTable carData = GetCarData();
double angle;
LayerOverlay vehicleOverlay = (LayerOverlay)winformsMap1.Overlays["VehicleOverlay"];
InMemoryFeatureLayer carLayer = vehicleOverlay.Layers["CarLayer"] as InMemoryFeatureLayer;
PointShape pointShape = carLayer.InternalFeatures[0].GetShape() as PointShape;
// Get the Row of Data we are working with.
DataRow carDataRow = carData.Rows[0];
double Lat = Convert.ToDouble(carDataRow["LAT"]);
double Long = Convert.ToDouble(carDataRow["LONG"]);
if (previousLong == 0)
{
previousLong = Long;
previousLat = Lat;
}
double Xdiff = previousLong - Long;
double Ydiff = previousLat - Lat;
//Gets the angle based on the current GPS position and the previous one to get the direction of the vehicle.
angle = GetAngleFromTwoVertices(new Vertex(previousLong, previousLat), new Vertex(Long, Lat));
carLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle.RotationAngle = 90 - (float)angle;
pointShape.X = Long;
pointShape.Y = Lat;
pointShape.Id = "Car";
carLayer.Open();
carLayer.EditTools.BeginTransaction();
carLayer.EditTools.Update(pointShape);
carLayer.EditTools.CommitTransaction();
carLayer.Close();
previousLong = Long;
previousLat = Lat;
//Function to center the map to a point (the moving moving vehicle feature)if it goes outside the tolerance.
RectangleShape toleranceRectangleShape = new RectangleShape(winformsMap1.CurrentExtent.UpperLeftPoint, winformsMap1.CurrentExtent.LowerRightPoint);
toleranceRectangleShape.ScaleDown(60);
if (toleranceRectangleShape.Contains(new PointShape(Long, Lat)) == false)
{
winformsMap1.CenterAt(new PointShape(Long, Lat));
//Resets the RectangleShape of the tolerance layer (for displaying only)
LayerOverlay toleranceOverlay = (LayerOverlay)winformsMap1.Overlays["ToleranceOverlay"];
InMemoryFeatureLayer toleranceLayer = toleranceOverlay.Layers["ToleranceLayer"] as InMemoryFeatureLayer;
RectangleShape newToleranceRectangleShape = new RectangleShape(winformsMap1.CurrentExtent.UpperLeftPoint, winformsMap1.CurrentExtent.LowerRightPoint);
newToleranceRectangleShape.ScaleDown(60);
newToleranceRectangleShape.Id = "Tolerance";
toleranceLayer.Open();
toleranceLayer.EditTools.BeginTransaction();
toleranceLayer.EditTools.Update(newToleranceRectangleShape);
toleranceLayer.EditTools.CommitTransaction();
toleranceLayer.Close();
winformsMap1.Refresh();
}
else
{
winformsMap1.Refresh(vehicleOverlay);
}
}
