/// <summary>
/// Disable map drawing after a shape is drawn
/// </summary>
private async void OnShapeDrawn(object sender, TrackEndedTrackInteractiveOverlayEventArgs e)
{
// Disable drawing mode and clear the drawing layer
mapView.TrackOverlay.TrackMode = TrackMode.None;
mapView.TrackOverlay.TrackShapeLayer.InternalFeatures.Clear();
// Validate shape size to avoid queries that are too large
// Maximum length of a line is 10km
// Maximum area of a polygon is 10km^2
if (e.TrackShape.GetWellKnownType() == WellKnownType.Polygon)
{
if (((PolygonShape)e.TrackShape).GetArea(GeographyUnit.Meter, AreaUnit.SquareKilometers) > 5)
{
await DisplayAlert("Error", "Please draw a smaller polygon (limit: 5km^2)", "OK");
return;
}
}
else if (e.TrackShape.GetWellKnownType() == WellKnownType.Line)
{
if (((LineShape)e.TrackShape).GetLength(GeographyUnit.Meter, DistanceUnit.Kilometer) > 5)
{
await DisplayAlert("Alert", "Please draw a shorter line (limit: 5km)", "OK");
return;
}
}
// Get elevation data for the drawn shape and update the UI
await PerformElevationQuery(e.TrackShape);
}
void winformsMap1_TrackEnded(object sender, TrackEndedTrackInteractiveOverlayEventArgs e)
{
RectangleShape rectangleShape = (RectangleShape)e.TrackShape;
ShapeFileFeatureLayer worldLayer = (ShapeFileFeatureLayer)winformsMap1.FindFeatureLayer("WorldLayer");
InMemoryFeatureLayer spatialQueryResultLayer = (InMemoryFeatureLayer)winformsMap1.FindFeatureLayer("SpatialQueryResultLayer");
//Spatial query to find the features intersecting the rectangle from the track rectangle.
Collection <Feature> spatialQueryResults;
worldLayer.Open();
spatialQueryResults = worldLayer.QueryTools.GetFeaturesIntersecting(rectangleShape, ReturningColumnsType.NoColumns);
worldLayer.Close();
//Adds the selected features to the InMemoryfeatureLayer
spatialQueryResultLayer.Open();
spatialQueryResultLayer.EditTools.BeginTransaction();
spatialQueryResultLayer.InternalFeatures.Clear();
foreach (Feature feature in spatialQueryResults)
{
spatialQueryResultLayer.EditTools.Add(feature);
}
spatialQueryResultLayer.EditTools.CommitTransaction();
spatialQueryResultLayer.Close();
//Refreshes the layers to show new result.
winformsMap1.TrackOverlay.TrackShapeLayer.InternalFeatures.Clear();
winformsMap1.Refresh(winformsMap1.TrackOverlay);
winformsMap1.Refresh(winformsMap1.Overlays["SpatialQueryResultOverlay"]);
}
private void TrackEnded(object sender, TrackEndedTrackInteractiveOverlayEventArgs e)
{
//Set to invisible the groupbox with dynamic info after ending the tracking
groupBoxInfo.Visible = false;
//Clears the Shapes from TrackOverlay.
winformsMap1.TrackOverlay.TrackShapeLayer.InternalFeatures.Clear();
}
protected override void OnTrackEnded(TrackEndedTrackInteractiveOverlayEventArgs e)
{
if (FileLinkable && (tempBaseShape == null || tempBaseShape.GetWellKnownText() != e.TrackShape.GetWellKnownText()))
{
OpenFileDialog openFileDialog = new OpenFileDialog();
openFileDialog.Multiselect = false;
Feature tempFeature = TrackShapeLayer.InternalFeatures.FirstOrDefault(f => f.GetWellKnownText().Equals(e.TrackShape.GetWellKnownText()));
if (openFileDialog.ShowDialog().GetValueOrDefault())
{
tempBaseShape = e.TrackShape;
SetLinkFileName(tempFeature, openFileDialog.FileName);
}
else
{
TrackShapeLayer.InternalFeatures.Remove(tempFeature);
}
SetDefaultColumnValue(AnnotaionStyleType.FileLinkStyle);
}
else
{
SetDefaultColumnValue();
}
var lastFeature = TrackShapeLayer.InternalFeatures.LastOrDefault();
if (lastFeature != null)
{
lastFeature.Id = NewFeatureName();
}
GisEditor.UIManager.BeginRefreshPlugins(new RefreshArgs(this, RefreshArgsDescription.OnTrackEndedDescription));
base.OnTrackEnded(e);
}
private void trackOverlay_TrackEnded(object sender, TrackEndedTrackInteractiveOverlayEventArgs e)
{
//Gets the shape from the tracked polygon. The tracked shapes can be found in the TrackShapeLayer of the TrackOverlay.
AreaBaseShape areaBaseShape = (AreaBaseShape)winformsMap1.TrackOverlay.TrackShapeLayer.InternalFeatures[0].GetShape();
//Gets the features of the counties that are completely within the tracked polygon.
LayerOverlay layerOverlay = (LayerOverlay)winformsMap1.Overlays["LayerOverlay"];
ShapeFileFeatureLayer shapeFileFeatureLayer = (ShapeFileFeatureLayer)layerOverlay.Layers["CountiesLayer"];
Collection <Feature> features = shapeFileFeatureLayer.QueryTools.GetFeaturesWithin(areaBaseShape, ReturningColumnsType.NoColumns);
//Adds the shape of the selected counties features to AreaBaseShape collection to perform the Union.
Collection <AreaBaseShape> areaBaseShapes = new Collection <AreaBaseShape>();
foreach (Feature feature in features)
{
areaBaseShapes.Add((AreaBaseShape)feature.GetShape());
}
MultipolygonShape unionMultipolygonShape = MultipolygonShape.Union(areaBaseShapes);
//Gets the MultiPolygonShape with the inner ring(s) being the result of the Union of the selected shapes.
MultipolygonShape resultMultiPolygonShape = areaBaseShape.GetDifference(unionMultipolygonShape);
//Adds the result to the InMemoryFeatureLayer for display on the map.
LayerOverlay dynamicOverlay = (LayerOverlay)winformsMap1.Overlays["DynamicOverlay"];
InMemoryFeatureLayer inMemoryFeatureLayer = (InMemoryFeatureLayer)dynamicOverlay.Layers["DynamicLayer"];
inMemoryFeatureLayer.InternalFeatures.Clear();
inMemoryFeatureLayer.InternalFeatures.Add(new Feature(resultMultiPolygonShape));
//We clear the tracked shape so that it does not show on the map.
winformsMap1.TrackOverlay.TrackShapeLayer.InternalFeatures.Clear();
winformsMap1.Refresh(winformsMap1.Overlays["DynamicOverlay"]);
}
private void TrackInteractiveOverlayOnTrackEnded(object sender, TrackEndedTrackInteractiveOverlayEventArgs args)
{
loadingView.StartAnimating();
Task.Factory.StartNew(() =>
{
MultipolygonShape resultShape = PolygonShape.Union(iOSMap.TrackOverlay.TrackShapeLayer.InternalFeatures);
ShapeFileFeatureLayer earthquakePointLayer = (ShapeFileFeatureLayer)Global.HighLightOverlay.Layers["EarthquakePointLayer"];
earthquakePointLayer.Open();
Collection <Feature> features = earthquakePointLayer.FeatureSource.GetFeaturesWithinDistanceOf(new Feature(resultShape), iOSMap.MapUnit, DistanceUnit.Meter, 0.0001, ReturningColumnsType.AllColumns);
Global.QueriedFeatures.Clear();
foreach (Feature feature in features)
{
Global.QueriedFeatures.Add(feature);
}
Global.FilterSelectedEarthquakeFeatures();
InvokeOnMainThread(() =>
{
Global.HighLightOverlay.Refresh();
loadingView.StopAnimating();
});
});
}
private void TrackOverlay_TrackEnded(object sender, TrackEndedTrackInteractiveOverlayEventArgs e)
{
MultipolygonShape resultShape = PolygonShape.Union(Global.MapView.TrackOverlay.TrackShapeLayer.InternalFeatures);
FeatureLayer featureLayer = earthquakePointLayer;
if (!featureLayer.IsOpen)
{
featureLayer.Open();
}
Collection <Feature> features = featureLayer.FeatureSource.GetFeaturesWithinDistanceOf(new Feature(resultShape), Global.MapView.MapUnit, DistanceUnit.Meter, 0.0001, ReturningColumnsType.AllColumns);
Global.BackupQueriedFeatures(features);
Global.FilterSelectedEarthquakeFeatures(Global.GetBackupQueriedFeatures());
}
/// <summary>
/// Disable drawing mode and draw the new query shape on the map when finished drawing a shape
/// </summary>
private void OnShapeDrawn(object sender, TrackEndedTrackInteractiveOverlayEventArgs e)
{
// Disable drawing mode and clear the drawing layer
mapView.TrackOverlay.TrackMode = TrackMode.None;
mapView.TrackOverlay.TrackShapeLayer.InternalFeatures.Clear();
// Get the query shape layer from the MapView
LayerOverlay queriedFeaturesOverlay = (LayerOverlay)mapView.Overlays["Queried Features Overlay"];
InMemoryFeatureLayer queryShapeFeatureLayer = (InMemoryFeatureLayer)queriedFeaturesOverlay.Layers["Query Shape Layer"];
// Add the newly drawn shape, then redraw the overlay
queryShapeFeatureLayer.InternalFeatures.Add(new Feature(e.TrackShape));
queriedFeaturesOverlay.Refresh();
PerformWorldMapsQuery();
}
private void TrackOverlay_TrackEnded(object sender, TrackEndedTrackInteractiveOverlayEventArgs e)
{
try
{
PolygonShape[] allPolygonFeatures = mapControl.TrackOverlay.TrackShapeLayer.InternalFeatures.Select(f => f.GetShape()).OfType <PolygonShape>().ToArray();
BaseShape trackedShape = SqlTypesGeometryHelper.Union(allPolygonFeatures);
if (trackedShape != null)
{
OnQueryAreaChanged(trackedShape);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
protected override void OnTrackEnded(TrackEndedTrackInteractiveOverlayEventArgs e)
{
base.OnTrackEnded(e);
Vertices.Clear();
#region Boudary Adjustment
if (isShiftKeyDown)
{
MouseDownCount = 0;
}
#endregion
OverlayCanvas.Children.Clear();
}
private void SelectionTrackOverlay_TrackEnded(object sender, TrackEndedTrackInteractiveOverlayEventArgs e)
{
if (SelectionOverlay.TrackMode == TrackMode.Point ||
SelectionOverlay.TrackMode == TrackMode.Rectangle ||
SelectionOverlay.TrackMode == TrackMode.Polygon ||
SelectionOverlay.TrackMode == TrackMode.Circle ||
SelectionOverlay.TrackMode == TrackMode.Line)
{
// Force execute all the commands's CanExecute()
CommandManager.InvalidateRequerySuggested();
}
if (SelectionOverlay.FilteredLayers.Count == 0)
{
System.Windows.Forms.MessageBox.Show(GisEditor.LanguageManager.GetStringResource("SelectionPluginNoLayerWarningMessage"), GisEditor.LanguageManager.GetStringResource("MessageBoxWarningTitle"));
}
}
private void TrackOverlay_TrackEnded(object sender, TrackEndedTrackInteractiveOverlayEventArgs e)
{
InMemoryFeatureLayer trackShapeLayer = wpfMap.TrackOverlay.TrackShapeLayer;
string localFilePath;
SaveFileDialog saveFileDialog = new SaveFileDialog();
saveFileDialog.Filter = "MB Tiles Database(*.mbtiles)|*.mbtiles";
if (saveFileDialog.ShowDialog().Value)
{
localFilePath = saveFileDialog.FileName.ToString();
if (File.Exists(localFilePath))
{
File.Delete(localFilePath);
}
PolygonShape extractingPolygon = new PolygonShape(trackShapeLayer.InternalFeatures.First().GetWellKnownBinary());
wpfMap.TrackOverlay.TrackMode = TrackMode.None;
pbExtractProgress.Visibility = Visibility.Visible;
pbExtractProgress.IsEnabled = true;
Task.Factory.StartNew(() =>
{
ExtractTiles(extractingPolygon, localFilePath);
Dispatcher.Invoke(() =>
{
pbExtractProgress.IsEnabled = false;
pbExtractProgress.Visibility = Visibility.Hidden;
trackShapeLayer.InternalFeatures.Clear();
wpfMap.Refresh(wpfMap.TrackOverlay);
wpfMap.TrackOverlay.TrackMode = TrackMode.Rectangle;
ThinkGeoMBTilesLayer thinkGeoMBTilesFeatureLayer = new ThinkGeoMBTilesLayer(localFilePath, new Uri(defaultJsonFilePath, UriKind.Relative));
thinkGeoMBTilesFeatureLayer.BitmapTileCache = null;
layerOverlay.Layers.Clear();
layerOverlay.Layers.Add(thinkGeoMBTilesFeatureLayer);
chkExtractingData.IsChecked = false;
wpfMap.Refresh(layerOverlay);
});
});
}
else
{
trackShapeLayer.InternalFeatures.Clear();
}
}
private void TrackOverlay_TrackEnded(object sender, TrackEndedTrackInteractiveOverlayEventArgs e)
{
Feature queryFeature = UnionTrackedShapes();
if (queryFeature == null)
{
return;
}
activeStyleLayer.FeatureSource.Open();
Collection <Feature> features = activeStyleLayer.FeatureSource.GetFeaturesWithinDistanceOf(queryFeature, map.MapUnit, DistanceUnit.Meter, 0.0001, ReturningColumnsType.AllColumns);
earthquakeItems.Clear();
foreach (Feature feature in features)
{
earthquakeItems.Add(new EarthquakeItem(feature));
}
FilterEarthquake();
}
private void TrackOverlay_TrackEnded(object sender, TrackEndedTrackInteractiveOverlayEventArgs e)
{
InMemoryFeatureLayer trackShapeLayer = Map1.TrackOverlay.TrackShapeLayer;
string localFilePath;
SaveFileDialog saveFileDialog = new SaveFileDialog();
saveFileDialog.Filter = "MB Tiles Database(*.mbtiles)|*.mbtiles";
if (saveFileDialog.ShowDialog() == DialogResult.OK)
{
localFilePath = saveFileDialog.FileName.ToString();
if (File.Exists(localFilePath))
{
File.Delete(localFilePath);
}
PolygonShape extractingPolygon = new PolygonShape(trackShapeLayer.InternalFeatures.First().GetWellKnownBinary());
Map1.TrackOverlay.TrackMode = TrackMode.None;
ExtractTiles(extractingPolygon, localFilePath);
trackShapeLayer.InternalFeatures.Clear();
Map1.Refresh(Map1.TrackOverlay);
Map1.TrackOverlay.TrackMode = TrackMode.Rectangle;
ThinkGeoMBTilesLayer thinkGeoMBTilesFeatureLayer = new ThinkGeoMBTilesLayer(localFilePath, new Uri(defaultJsonFilePath, UriKind.Relative));
thinkGeoMBTilesFeatureLayer.BitmapTileCache = null;
layerOverlay.Layers.Clear();
layerOverlay.Layers.Add(thinkGeoMBTilesFeatureLayer);
chkExtractingData.Checked = false;
Map1.Refresh(layerOverlay);
}
else
{
trackShapeLayer.InternalFeatures.Clear();
}
}
protected override void OnTrackEnded(TrackEndedTrackInteractiveOverlayEventArgs e)
{
textBlock.Visibility = Visibility.Collapsed;
base.OnTrackEnded(e);
bool hasArea = MeasureLastFeatureInLayer();
if (hasArea)
{
var lastTrackingFeature = TrackShapeLayer.InternalFeatures.LastOrDefault();
if (lastTrackingFeature != null)
{
lastTrackingFeature.Id = NewMeasurementName(lastTrackingFeature.ColumnValues["Result"]);
lastTrackingFeature.ColumnValues["DisplayName"] = lastTrackingFeature.Id;
var mapShape = GetMapShape(lastTrackingFeature);
ShapeLayer.MapShapes.Add(lastTrackingFeature.Id, mapShape);
}
TakeSnapshot();
GisEditor.UIManager.BeginRefreshPlugins(new RefreshArgs(this, RefreshArgsDescription.OnTrackEndedDescription));
}
TrackShapeLayer.InternalFeatures.Clear();
}
protected override void OnTrackEnded(TrackEndedTrackInteractiveOverlayEventArgs e)
{
isTracking = false;
base.OnTrackEnded(e);
}
/// <summary>
/// Performs the spatial query when a new polygon is drawn
/// </summary>
private void OnPolygonDrawn(object sender, TrackEndedTrackInteractiveOverlayEventArgs e)
{
GetFeaturesWithin((PolygonShape)e.TrackShape);
}
protected override void OnTrackEnded(TrackEndedTrackInteractiveOverlayEventArgs e)
{
isTracking = false;
base.OnTrackEnded(e);
if (TrackShapeLayer.InternalFeatures.Count != 0)
{
Collection <Feature> features = new Collection <Feature>();
Collection <ErrorFeatureInfo> errorInfo = new Collection <ErrorFeatureInfo>();
Dictionary <string, Collection <Feature> > currentSelectedFeatures = new Dictionary <string, Collection <Feature> >();
foreach (var trackedFeature in TrackShapeLayer.InternalFeatures)
{
Feature currentTrackedFeature = trackedFeature;
if (currentTrackedFeature.CanMakeValid && !currentTrackedFeature.IsValid())
{
currentTrackedFeature = currentTrackedFeature.MakeValid();
}
if (currentTrackedFeature.GetShape() != null && currentTrackedFeature.GetWellKnownType() == WellKnownType.Point)
{
PointShape trackedPoint = (PointShape)currentTrackedFeature.GetShape();
double resolution = MapArguments.CurrentResolution;
currentTrackedFeature = new Feature(new RectangleShape(trackedPoint.X - tolerance * resolution,
trackedPoint.Y + tolerance * resolution,
trackedPoint.X + tolerance * resolution,
trackedPoint.Y - tolerance * resolution).GetWellKnownBinary(), currentTrackedFeature.Id);
}
else if (currentTrackedFeature.GetShape() != null && currentTrackedFeature.GetWellKnownType() == WellKnownType.Line)
{
var toleranceDistance = MapUtils.GetResolutionFromScale(MapArguments.CurrentScale, GeographyUnit.Meter) * tolerance;
try
{
currentTrackedFeature = currentTrackedFeature.Buffer(toleranceDistance, MapArguments.MapUnit, DistanceUnit.Meter);
}
catch { }
}
foreach (var queryingFeatureLayer in TargetFeatureLayers.Where(l => FilteredLayers.Contains(l)))
{
IEnumerable <Feature> queriedFeatures = new Collection <Feature>();
if (currentTrackedFeature.GetShape() != null)
{
bool isClosed = false;
Monitor.Enter(queryingFeatureLayer);
if (!queryingFeatureLayer.IsOpen)
{
isClosed = true;
queryingFeatureLayer.Open();
}
try
{
Func <Feature, bool, Func <Feature, bool>, IEnumerable <Feature> > processSpatialQueryFunc
= new Func <Feature, bool, Func <Feature, bool>, IEnumerable <Feature> >((tmpTrackedFeature, filter, spatialQueryFunc) =>
{
var bbox = tmpTrackedFeature.GetBoundingBox();
Collection <Feature> featuresInsideOfBBox = null;
if (filter)
{
featuresInsideOfBBox = queryingFeatureLayer.QueryTools.GetFeaturesIntersecting(bbox, queryingFeatureLayer.GetDistinctColumnNames());
}
else
{
featuresInsideOfBBox = queryingFeatureLayer.QueryTools.GetAllFeatures(queryingFeatureLayer.GetDistinctColumnNames());
}
var featuresToProcessing = featuresInsideOfBBox.AsParallel().Where(featureToValidate =>
{
if (featureToValidate.IsValid())
{
return(true);
}
else
{
errorInfo.Add(new ErrorFeatureInfo {
FeatureId = featureToValidate.Id, Message = "Invalid feature"
});
return(false);
}
}).ToArray();
var resultQueriedFeatures = new Collection <Feature>();
foreach (var tmpFeature in featuresToProcessing)
{
var validFeature = MakeFeatureValidate(tmpFeature);
if (spatialQueryFunc(validFeature))
{
resultQueriedFeatures.Add(validFeature);
}
}
return(resultQueriedFeatures.GetVisibleFeatures(queryingFeatureLayer.ZoomLevelSet, MapArguments.CurrentExtent, MapArguments.ActualWidth, MapArguments.MapUnit));
});
currentTrackedFeature = currentTrackedFeature.MakeValid();
switch (spatialQueryMode)
{
case SpatialQueryMode.Touching:
queriedFeatures = processSpatialQueryFunc(currentTrackedFeature, true, tmpFeature
=> currentTrackedFeature.GetShape().Intersects(tmpFeature));
break;
case SpatialQueryMode.CompletelyContained:
queriedFeatures = processSpatialQueryFunc(currentTrackedFeature, true, tmpFeature
=> currentTrackedFeature.GetShape().Contains(tmpFeature));
break;
case SpatialQueryMode.Intersecting:
queriedFeatures = processSpatialQueryFunc(currentTrackedFeature, true, tmpFeature
=> currentTrackedFeature.GetShape().Intersects(tmpFeature));
break;
case SpatialQueryMode.Nearest:
queriedFeatures = queryingFeatureLayer.QueryTools.GetFeaturesNearestTo(currentTrackedFeature, GeographyUnit.DecimalDegree, 1, queryingFeatureLayer.GetDistinctColumnNames());
break;
case SpatialQueryMode.NotTouching:
queriedFeatures = processSpatialQueryFunc(currentTrackedFeature, false, tmpFeature
=> tmpFeature.GetShape().IsDisjointed(currentTrackedFeature));
break;
}
}
catch (Exception ex) { System.Windows.Forms.MessageBox.Show(ex.Message, "Invalid Features", MessageBoxButtons.OK, MessageBoxIcon.Error); }
if (isClosed)
{
queryingFeatureLayer.Close();
}
Monitor.Exit(queryingFeatureLayer);
foreach (var feature in queriedFeatures)
{
feature.Tag = queryingFeatureLayer;
features.Add(feature);
}
}
}
}
if (errorInfo.Count > 0)
{
System.Windows.Forms.MessageBox.Show(Resources.InvalidFeatures, "Invalid Features", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
TrackShapeLayer.InternalFeatures.Clear();
features = new Collection <Feature>(RenameFeatures(features).GroupBy(f => f.Id).Select(g => g.FirstOrDefault()).Where(f => f != null).ToList());
switch (selectionMode)
{
case SelectionMode.None:
UsingFeatureLayer(HighlightFeatureLayer, (layer) =>
{
layer.InternalFeatures.Clear();
foreach (var feature in features)
{
//if (!feature.ColumnValues.ContainsKey(featureIdColumnName))
//{
// //string featureIdColumn = LayerPluginHelper.GetFeatureIdColumn(ownerFeatureLayer);
// //if (feature.ColumnValues.ContainsKey(featureIdColumn))
// //{
// // header = feature.ColumnValues[featureIdColumn];
// //}
// string featureId = feature.Id;
// if (featureId.Contains(FeatureIdSeparator))
// {
// featureId = featureId.Split(new string[] { FeatureIdSeparator }, StringSplitOptions.RemoveEmptyEntries)[0];
// }
// feature.ColumnValues.Add(featureIdColumnName, featureId);
//}
layer.EditTools.Add(feature);
}
});
break;
case SelectionMode.Added:
UsingFeatureLayer(HighlightFeatureLayer, (layer) =>
{
ToggleExistingFeatures(features);
foreach (var feature in features)
{
if (!layer.InternalFeatures.Contains(feature))
{
layer.EditTools.Add(feature);
}
}
});
break;
case SelectionMode.Subtract:
UsingFeatureLayer(HighlightFeatureLayer, (layer) =>
{
foreach (var feature in features)
{
if (layer.InternalFeatures.Contains(feature))
{
layer.EditTools.Delete(feature.Id);
}
}
});
break;
}
this.selectionMode = SelectionMode.None;
OnFeatureSelected(this, new EventArgs());
}
}
private void TrackOverlay_TrackEnded(object sender, TrackEndedTrackInteractiveOverlayEventArgs e)
{
try
{
PolygonShape[] allPolygonFeatures = mapControl.TrackOverlay.TrackShapeLayer.InternalFeatures.Select(f => f.GetShape()).OfType<PolygonShape>().ToArray();
BaseShape trackedShape = SqlTypesGeometryHelper.Union(allPolygonFeatures);
if (trackedShape != null)
{
OnQueryAreaChanged(trackedShape);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
private void TrackOverlay_TrackEnded(object sender, TrackEndedTrackInteractiveOverlayEventArgs e)
{
currentTopologyTestCase.AddInputShape(e.TrackShape);
}
protected override void OnTrackEnded(TrackEndedTrackInteractiveOverlayEventArgs e)
{
textBlock.Visibility = Visibility.Collapsed;
base.OnTrackEnded(e);
}
private void TrackOverlay_TrackEnded(object sender, TrackEndedTrackInteractiveOverlayEventArgs e)
{
if (mapModel.MapControl.TrackOverlay.TrackMode == TrackMode.Polygon)
{
PolygonShape polygonShape = e.TrackShape as PolygonShape;
if (polygonShape != null)
{
double area = -1;
string areaUnit = "sq.m.";
switch (SelectedUnitSystem)
{
case UnitSystem.Metric:
areaUnit = "sq.m.";
area = polygonShape.GetArea(GeographyUnit.Meter, AreaUnit.SquareMeters);
break;
case UnitSystem.Imperial:
areaUnit = "ac.";
area = polygonShape.GetArea(GeographyUnit.Meter, AreaUnit.Acres);
break;
}
if (area > 0)
{
string content = string.Format(CultureInfo.InvariantCulture, "Area: {0} {1}", area.ToString("N1"), areaUnit);
ShowPopup(new PointShape(polygonShape.OuterRing.Vertices[polygonShape.OuterRing.Vertices.Count - 2]), content);
}
mapModel.MapControl.TrackOverlay.TrackShapeLayer.InternalFeatures.LastOrDefault().Tag = "Measure";
}
}
if (mapModel.MapControl.TrackOverlay.TrackMode == TrackMode.Line)
{
string unit = string.Empty;
LineShape lineShape = e.TrackShape as LineShape;
if (lineShape != null)
{
double lenth = 0;
if (SelectedUnitSystem == UnitSystem.Metric)
{
lenth = lineShape.GetLength(GeographyUnit.Meter, DistanceUnit.Meter);
unit = "m";
if (lenth >= 1000)
{
unit = "km";
lenth = Math.Round(lenth / 1000d, 1, MidpointRounding.AwayFromZero);
}
}
else if (SelectedUnitSystem == UnitSystem.Imperial)
{
lenth = lineShape.GetLength(GeographyUnit.Meter, DistanceUnit.Feet);
unit = "ft";
if (lenth >= 5280)
{
unit = "mi";
lenth = Math.Round(lenth / 5280d, 1, MidpointRounding.AwayFromZero);
}
}
string lengthString = lenth.ToString("N1");
string content = string.Format(CultureInfo.InvariantCulture, "Total Length: {0} {1}", lengthString, unit);
ShowPopup(new PointShape(lineShape.Vertices[lineShape.Vertices.Count - 1]), content);
mapModel.MapControl.TrackOverlay.TrackShapeLayer.InternalFeatures.LastOrDefault().Tag = "Measure";
}
}
}
protected override void OnTrackEnded(TrackEndedTrackInteractiveOverlayEventArgs e)
{
textBlock.Visibility = Visibility.Collapsed;
base.OnTrackEnded(e);
}
private void TrackOverlay_TrackEnded(object sender, TrackEndedTrackInteractiveOverlayEventArgs e)
{
if (mapModel.MapControl.TrackOverlay.TrackMode == TrackMode.Polygon)
{
PolygonShape polygonShape = e.TrackShape as PolygonShape;
if (polygonShape != null)
{
double area = -1;
string areaUnit = "sq.m.";
switch (SelectedUnitSystem)
{
case UnitSystem.Metric:
areaUnit = "sq.m.";
area = polygonShape.GetArea(GeographyUnit.Meter, AreaUnit.SquareMeters);
break;
case UnitSystem.Imperial:
areaUnit = "ac.";
area = polygonShape.GetArea(GeographyUnit.Meter, AreaUnit.Acres);
break;
}
if (area > 0)
{
string content = string.Format(CultureInfo.InvariantCulture, "Area: {0} {1}", area.ToString("N1"), areaUnit);
ShowPopup(new PointShape(polygonShape.OuterRing.Vertices[polygonShape.OuterRing.Vertices.Count - 2]), content);
}
mapModel.MapControl.TrackOverlay.TrackShapeLayer.InternalFeatures.LastOrDefault().Tag = "Measure";
}
}
if (mapModel.MapControl.TrackOverlay.TrackMode == TrackMode.Line)
{
string unit = string.Empty;
LineShape lineShape = e.TrackShape as LineShape;
if (lineShape != null)
{
double lenth = 0;
if (SelectedUnitSystem == UnitSystem.Metric)
{
lenth = lineShape.GetLength(GeographyUnit.Meter, DistanceUnit.Meter);
unit = "m";
if (lenth >= 1000)
{
unit = "km";
lenth = Math.Round(lenth / 1000d, 1, MidpointRounding.AwayFromZero);
}
}
else if (SelectedUnitSystem == UnitSystem.Imperial)
{
lenth = lineShape.GetLength(GeographyUnit.Meter, DistanceUnit.Feet);
unit = "ft";
if (lenth >= 5280)
{
unit = "mi";
lenth = Math.Round(lenth / 5280d, 1, MidpointRounding.AwayFromZero);
}
}
string lengthString = lenth.ToString("N1");
string content = string.Format(CultureInfo.InvariantCulture, "Total Length: {0} {1}", lengthString, unit);
ShowPopup(new PointShape(lineShape.Vertices[lineShape.Vertices.Count - 1]), content);
mapModel.MapControl.TrackOverlay.TrackShapeLayer.InternalFeatures.LastOrDefault().Tag = "Measure";
}
}
}
private void AnnotationOverlay_SelectionFinished(object sender, TrackEndedTrackInteractiveOverlayEventArgs e)
{
bool isShiftKeyDown = Keyboard.Modifiers == ModifierKeys.Shift;
if (!isShiftKeyDown)
{
AnnotationHelper.CommitEdit();
}
var selectionArea = e.TrackShape.GetBoundingBox();
CurrentAnnotationOverlay.TrackShapeLayer.SafeProcess(() =>
{
var tmpFeatureIdsToExclude = new Collection <string>();
foreach (var id in CurrentAnnotationOverlay.TrackShapeLayer.FeatureIdsToExclude)
{
tmpFeatureIdsToExclude.Add(id);
}
CurrentAnnotationOverlay.TrackShapeLayer.FeatureIdsToExclude.Clear();
var selectedFeatures = CurrentAnnotationOverlay.TrackShapeLayer.QueryTools.GetFeaturesInsideBoundingBox(selectionArea, CurrentAnnotationOverlay.TrackShapeLayer.GetDistinctColumnNames());
foreach (var id in tmpFeatureIdsToExclude)
{
CurrentAnnotationOverlay.TrackShapeLayer.FeatureIdsToExclude.Add(id);
}
bool needMarkerOverlayRefreshed = false;
foreach (var selectedFeature in selectedFeatures)
{
bool isEditing = true;
if (!CurrentAnnotationOverlay.TrackShapeLayer.FeatureIdsToExclude.Contains(selectedFeature.Id))
{
CurrentAnnotationOverlay.TrackShapeLayer.FeatureIdsToExclude.Add(selectedFeature.Id);
}
else
{
isEditing = false;
if (isShiftKeyDown)
{
CurrentAnnotationOverlay.TrackShapeLayer.FeatureIdsToExclude.Remove(selectedFeature.Id);
if (CurrentEditOverlay.EditShapesLayer.InternalFeatures.Contains(selectedFeature.Id))
{
CurrentEditOverlay.EditShapesLayer.InternalFeatures.Remove(selectedFeature.Id);
}
else if (MarkerHelper.CurrentMarkerOverlay.Markers.Contains(selectedFeature.Id))
{
MarkerHelper.CurrentMarkerOverlay.Markers.Remove(selectedFeature.Id);
needMarkerOverlayRefreshed = true;
}
}
}
if (needMarkerOverlayRefreshed)
{
MarkerHelper.CurrentMarkerOverlay.Refresh();
}
if (isEditing)
{
AnnotationHelper.SetAnnotationToEditMode(selectedFeature);
}
}
});
CurrentEditOverlay.CalculateAllControlPoints();
CurrentEditOverlay.Refresh();
CurrentAnnotationOverlay.Refresh();
SyncUIState();
TakeSnapshot();
}
private void AnnotationOverlay_TrackEnded(object sender, TrackEndedTrackInteractiveOverlayEventArgs e)
{
SyncUIState();
TakeSnapshot();
}
