private async Task DoGeodesicLength()
{
ResetButton.IsEnabled = false;
try
{
if (MyMapView.Editor.IsActive)
{
MyMapView.Editor.Cancel.Execute(null);
}
//Get the input polygon geometry from the user
inputGeom = await MyMapView.Editor.RequestShapeAsync(DrawShape.Polyline);
if (inputGeom != null)
{
//Add the polygon drawn by the user
var g = new Graphic
{
Geometry = inputGeom,
};
myGraphicsLayer.Graphics.Add(g);
//Get the label point for the input geometry
var length = GeometryEngine.GeodesicLength(inputGeom);
LineLengthTextBlock.Text = length.ToString("N2") + " m";
LineLengthTextBlock.Visibility = Windows.UI.Xaml.Visibility.Visible;
}
}
catch (Exception)
{
}
ResetButton.IsEnabled = true;
}
/// <summary>
/// Raises the <see cref="MeasureUpdated"/> and updates display based on <see cref="MeasureItemCollection"/>,
/// <see cref="TotalLength"/> and <see cref="Area"/> properties.
/// </summary>
private void UpdateDisplay(Polyline polyline)
{
Polygon area = null;
if (polyline != null && polyline.Parts[0].Count > 2)
{
area = new Polygon(polyline.Parts, polyline.SpatialReference);
}
OnMeasureUpdated((Geometry)area ?? polyline);
MapPoint previousPoint = null;
int coordinateIndex = 0;
foreach (var measureItem in MeasureItemCollection)
{
measureItem.CoordinateIndex = coordinateIndex++;
if (previousPoint != null)
{
measureItem.Length = GeometryEngine.GeodesicLength(
new Polyline(new MapPoint[] { previousPoint, measureItem.Location },
measureItem.Location.SpatialReference),
GeodeticCurveType.GreatElliptic);
}
previousPoint = measureItem.Location;
}
MeasureSummary.TotalLength = polyline == null || polyline.Parts[0].Count < 2
? 0
: GeometryEngine.GeodesicLength(polyline);
MeasureSummary.Area = area == null
? 0
: GeometryEngine.GeodesicArea(area);
}
// Draw and densify a user defined polygon
private async void DensifyButton_Click(object sender, RoutedEventArgs e)
{
try
{
resultsPanel.Visibility = Visibility.Collapsed;
inputGraphics.Graphics.Clear();
resultGraphics.Graphics.Clear();
// Request polygon or polyline from the user
DrawShape drawShape = (DrawShape)comboShapeType.SelectedItem;
var original = await mapView.Editor.RequestShapeAsync(drawShape, _fillSymbol);
// Add original shape vertices to input graphics layer
var coordsOriginal = ((IEnumerable <CoordinateCollection>)original).First();
foreach (var coord in coordsOriginal)
{
inputGraphics.Graphics.Add(new Graphic(new MapPoint(coord, original.SpatialReference), _origVertexSymbol));
}
// Densify the shape
var densify = GeometryEngine.GeodesicDensify(original, mapView.Extent.Width / 100, LinearUnits.Meters);
inputGraphics.Graphics.Add(new Graphic(densify, _fillSymbol));
// Add new vertices to result graphics layer
var coordsDensify = ((IEnumerable <CoordinateCollection>)densify).First();
foreach (var coord in coordsDensify)
{
resultGraphics.Graphics.Add(new Graphic(new MapPoint(coord, original.SpatialReference), _newVertexSymbol));
}
// Results
Dictionary <string, object> results = new Dictionary <string, object>();
results["Length"] = GeometryEngine.GeodesicLength(densify) * METERS_TO_MILES;
if (original is Polygon)
{
results["Area"] = GeometryEngine.GeodesicArea(densify) * SQUARE_METERS_TO_MILES;
}
else
{
results["Area"] = "N/A";
}
results["Vertices Before"] = coordsOriginal.Count();
results["Vertices After"] = coordsDensify.Count();
resultsListView.ItemsSource = results;
resultsPanel.Visibility = Visibility.Visible;
}
catch (TaskCanceledException)
{
}
catch (Exception ex)
{
MessageBox.Show("Densify Error: " + ex.Message, "Geodesic Densify Sample");
}
}
/// <summary>
/// Gets a point a certain distance down a polyline
/// </summary>
/// <param name="dist">Distance in meters along the line</param>
/// <param name="course"></param>
/// <returns></returns>
private double[] PointAlongLine(double dist, out double course)
{
double accDist = 0;
course = double.NaN;
if (dist > lineLength) //reached end - move to next direction, or start over
{
directionIndex++;
Route currDir;
if (directionIndex >= m_route.Routes.Count)
{
directionIndex = 0;
}
currDir = m_route.Routes[directionIndex];
lineLength = GeometryEngine.GeodesicLength(currDir.RouteGraphic.Geometry);
totalDistance = 0;
drivePath = currDir.RouteGraphic.Geometry as Polyline;
course = 0; dist = 0;
var start = drivePath.Paths[0][0];
}
//else
{
for (int j = 0; j < drivePath.Paths.Count; j++)
{
var part = drivePath.Paths[j];
for (int i = 0; i < part.Count - 1; i++)
{
var p1 = part[i];
var p2 = part[i + 1];
if (p1.X == p2.X && p2.Y == p2.Y)
{
continue;
}
Polyline linesegment = new Polyline()
{
SpatialReference = SpatialReferences.Wgs84
};
linesegment.Paths.AddPart(new Coordinate[] { new Coordinate(p1.X, p1.Y), new Coordinate(p2.X, p2.Y) });
double distToWaypoint = GeometryEngine.GeodesicLength(linesegment);
if (dist < accDist + distToWaypoint)
{
var distAlongSegment = dist - accDist;
double fraction = distAlongSegment / distToWaypoint;
course = GetTrueBearingGeodesic(p1.X, p1.Y, p2.X, p2.Y);
return(GetPointFromHeadingGeodesic(new double[] { p1.X, p1.Y }, distAlongSegment, course));
}
accDist += distToWaypoint;
}
}
}
return(null);
}
// Draw and densify a user defined polygon
private async void DensifyButton_Click(object sender, RoutedEventArgs e)
{
try
{
resultsPanel.Visibility = Visibility.Collapsed;
_inputGraphics.Graphics.Clear();
_resultGraphics.Graphics.Clear();
// Request polygon or polyline from the user
DrawShape drawShape = (DrawShape)comboShapeType.SelectedValue;
var original = await mapView.Editor.RequestShapeAsync(drawShape, _fillSymbol);
// Add original shape vertices to input graphics layer
var coordsOriginal = ((IEnumerable <CoordinateCollection>)original).First();
foreach (var coord in coordsOriginal)
{
_inputGraphics.Graphics.Add(new Graphic(new MapPoint(coord, original.SpatialReference), _origVertexSymbol));
}
// Densify the shape
var densify = GeometryEngine.GeodesicDensify(original, mapView.Extent.Width / 100, LinearUnits.Meters);
_inputGraphics.Graphics.Add(new Graphic(densify, _fillSymbol));
// Add new vertices to result graphics layer
var coordsDensify = ((IEnumerable <CoordinateCollection>)densify).First();
foreach (var coord in coordsDensify)
{
_resultGraphics.Graphics.Add(new Graphic(new MapPoint(coord, original.SpatialReference), _newVertexSymbol));
}
// Results
var results = new List <Tuple <string, object> >()
{
new Tuple <string, object>("Length", GeometryEngine.GeodesicLength(densify) * METERS_TO_MILES),
new Tuple <string, object>("Area",
(original is Polygon) ? (GeometryEngine.GeodesicArea(densify) * SQUARE_METERS_TO_MILES).ToString("0.000") : "N/A"),
new Tuple <string, object>("Vertices Before", coordsOriginal.Count()),
new Tuple <string, object>("Vertices After", coordsDensify.Count())
};
resultsListView.ItemsSource = results;
resultsPanel.Visibility = Visibility.Visible;
}
catch (TaskCanceledException)
{
}
catch (Exception ex)
{
var _ = new MessageDialog("Densify Error: " + ex.Message, "Sample Error").ShowAsync();
}
}
private static double GetDistance(Envelope extent)
{
// get the distance between the center of the current map extent and one of its corners
if (extent != null && !extent.IsEmpty)
{
var d = GeometryEngine.GeodesicLength(new Polyline(new Coordinate[] { extent.GetCenter().Coordinate, new Coordinate(extent.XMin, extent.YMin) },
extent.SpatialReference), GeodeticCurveType.GreatElliptic);
// to increase the chances of finding results make sure the smallest returned distance is 5 Kilometers.
return((d <= 5000.0) ? 5000.0 : d);
}
return(5000.0); // return a default distance of 5 Kilometers
}
private async void MyMapView_Tapped(object sender, Esri.ArcGISRuntime.Controls.MapViewInputEventArgs e)
{
_routeGraphicsOverlay = MyMapView.GraphicsOverlays["RouteGraphicsOverlay"];
_stopsGraphicsOverlay = MyMapView.GraphicsOverlays["StopsGraphicsOverlay"];
var graphicIdx = _stopsGraphicsOverlay.Graphics.Count + 1;
_stopsGraphicsOverlay.Graphics.Add(CreateStopGraphic(e.Location, graphicIdx));
if (_stopsGraphicsOverlay.Graphics.Count > 1)
{
try
{
progress.Visibility = Visibility.Visible;
var routeTask = new OnlineRouteTask(
new Uri("http://sampleserver6.arcgisonline.com/arcgis/rest/services/NetworkAnalysis/SanDiego/NAServer/Route"));
var routeParams = await routeTask.GetDefaultParametersAsync();
routeParams.SetStops(_stopsGraphicsOverlay.Graphics);
routeParams.UseTimeWindows = false;
routeParams.OutSpatialReference = MyMapView.SpatialReference;
routeParams.DirectionsLanguage = new CultureInfo("en-Us"); // CultureInfo.CurrentCulture;
var result = await routeTask.SolveAsync(routeParams);
if (result.Routes.Count > 0)
{
_routeGraphicsOverlay.Graphics.Clear();
var route = result.Routes.First().RouteFeature;
_routeGraphicsOverlay.Graphics.Add(new Graphic(route.Geometry));
var meters = GeometryEngine.GeodesicLength(route.Geometry, GeodeticCurveType.Geodesic);
txtDistance.Text = string.Format("{0:0.00} miles", LinearUnits.Miles.ConvertFromMeters(meters));
panelRouteInfo.Visibility = Visibility.Visible;
}
}
catch (Exception ex)
{
var _x = new MessageDialog(ex.Message, "Sample Error").ShowAsync();
}
finally
{
progress.Visibility = Visibility.Collapsed;
}
}
}
public async Task <RouteResult> GetRoute(IEnumerable <MapPoint> stops, CancellationToken cancellationToken)
{
if (stops == null)
{
throw new ArgumentNullException("stops");
}
List <Graphic> stopList = new List <Graphic>();
foreach (var stop in stops)
{
stopList.Add(new Graphic(stop));
}
if (stopList.Count < 2)
{
throw new ArgumentException("Not enough stops");
}
//determine which route service to use. Long distance routes should use the long-route service
Polyline line = new Polyline()
{
SpatialReference = SpatialReferences.Wgs84
};
line.Paths.AddPart(stops.Select(m => m.Coordinate));
var length = GeometryEngine.GeodesicLength(line);
string svc = routeService;
if (length > 200000)
{
svc = longRouteService;
}
//Calculate route
RouteTask task = new OnlineRouteTask(new Uri(svc))
{
HttpMessageHandler = messageHandler
};
var parameters = await task.GetDefaultParametersAsync().ConfigureAwait(false);
parameters.Stops = new Esri.ArcGISRuntime.Tasks.NetworkAnalyst.FeaturesAsFeature(stopList);
parameters.ReturnStops = true;
parameters.OutputLines = OutputLine.TrueShapeWithMeasure;
parameters.OutSpatialReference = SpatialReferences.Wgs84;
parameters.DirectionsLengthUnit = LinearUnits.Meters;
parameters.UseTimeWindows = false;
parameters.RestrictionAttributeNames = new List <string>(new string[] { "OneWay " });
return(await task.SolveAsync(parameters, cancellationToken));
}
private async Task CalculateRouteAsync()
{
try
{
progress.Visibility = Visibility.Visible;
RouteParameters routeParams = await _routeTask.GetDefaultParametersAsync();
routeParams.OutSpatialReference = MyMapView.SpatialReference;
routeParams.ReturnDirections = false;
routeParams.SetStops(_stopsGraphicsOverlay.Graphics);
RouteResult routeResult = await _routeTask.SolveAsync(routeParams);
if (routeResult.Routes.Count > 0)
{
_routeGraphicsOverlay.Graphics.Clear();
var route = routeResult.Routes.First().RouteFeature;
_routeGraphicsOverlay.Graphics.Add(new Graphic(route.Geometry));
var meters = GeometryEngine.GeodesicLength(route.Geometry, GeodeticCurveType.Geodesic);
txtDistance.Text = string.Format("{0:0.00} miles", LinearUnits.Miles.ConvertFromMeters(meters));
panelRouteInfo.Visibility = Visibility.Visible;
}
}
catch (AggregateException ex)
{
var innermostExceptions = ex.Flatten().InnerExceptions;
if (innermostExceptions != null && innermostExceptions.Count > 0)
{
MessageBox.Show(innermostExceptions[0].Message);
}
else
{
MessageBox.Show(ex.Message);
}
}
catch (System.Exception ex)
{
MessageBox.Show("Error: " + ex.Message);
}
finally
{
progress.Visibility = Visibility.Collapsed;
}
}
/// <summary>
/// Gets a point a certain distance down a polyline
/// </summary>
/// <param name="dist">Distance in meters along the line</param>
/// <param name="course"></param>
/// <returns></returns>
private double[] PointAlongLine(double dist, out double course)
{
double accDist = 0;
course = double.NaN;
if (dist > lineLength) //reached end - move to next direction, or start over
{
directionIndex++;
Route currDir;
if (directionIndex >= m_route.Routes.Count)
{
directionIndex = 0;
}
currDir = m_route.Routes[directionIndex];
lineLength = GeometryEngine.GeodesicLength(currDir.RouteFeature.Geometry);
totalDistance = 0;
drivePath = currDir.RouteFeature.Geometry as Polyline;
course = 0; dist = 0;
}
//else
{
var parts = drivePath.Parts.GetPartsAsPoints().ToList();
for (int j = 0; j < parts.Count; j++)
{
var part = parts[j].ToList();
for (int i = 0; i < part.Count - 1; i++)
{
var p1 = part[i];
var p2 = part[i + 1];
if (p1.X == p2.X && p2.Y == p2.Y)
{
continue;
}
double distToWaypoint = GeometryEngine.GeodesicDistance(p1, p2, LinearUnits.Meters);
if (dist < accDist + distToWaypoint)
{
var distAlongSegment = dist - accDist;
double fraction = distAlongSegment / distToWaypoint;
course = GetTrueBearingGeodesic(p1.X, p1.Y, p2.X, p2.Y);
return(GetPointFromHeadingGeodesic(new double[] { p1.X, p1.Y }, distAlongSegment, course));
}
accDist += distToWaypoint;
}
}
}
return(null);
}
/// <summary>
/// Creates a new camera offset from the provided camera around an ellipse.
/// </summary>
/// <param name="camera">The starting camera.</param>
/// <param name="ellipse">The ellipse around which the camera will rotate.</param>
/// <param name="centerPoint">The center point of the ellipse.</param>
/// <param name="percentAlong">The percentage around the ellipse to create the camera.</param>
private Camera OffsetCamera(Camera camera, Polyline ellipse, MapPoint centerPoint, double percentAlong)
{
camera = CloneCamera(camera);
var fromPoint = GeometryEngine.MovePointAlongLine(ellipse, percentAlong, true, 0);
var segment = LineBuilder.CreateLineSegment(new Coordinate2D(centerPoint.X, centerPoint.Y), new Coordinate2D(fromPoint.X, centerPoint.Y), centerPoint.SpatialReference);
var difX = GeometryEngine.GeodesicLength(PolylineBuilder.CreatePolyline(segment, segment.SpatialReference));
if (centerPoint.X - fromPoint.X < 0)
{
difX *= -1;
}
segment = LineBuilder.CreateLineSegment(new Coordinate2D(centerPoint.X, centerPoint.Y), new Coordinate2D(centerPoint.X, fromPoint.Y), centerPoint.SpatialReference);
var difY = GeometryEngine.GeodesicLength(PolylineBuilder.CreatePolyline(segment, segment.SpatialReference));
if (centerPoint.Y - fromPoint.Y < 0)
{
difY *= -1;
}
var radian = Math.Atan2(difX, difY);
var heading = radian * -180 / Math.PI;
camera.Heading = heading;
var difZ = centerPoint.Z - (camera.Z * ((camera.SpatialReference.IsGeographic) ? 1.0 : camera.SpatialReference.Unit.ConversionFactor));
var hypotenuse = GeometryEngine.GeodesicDistance(fromPoint, centerPoint);
radian = Math.Atan2(difZ, hypotenuse);
var pitch = radian * 180 / Math.PI;
camera.Pitch = pitch;
if (fromPoint.SpatialReference.Wkid != camera.SpatialReference.Wkid)
{
var transformation = ProjectionTransformation.Create(fromPoint.SpatialReference, camera.SpatialReference);
fromPoint = GeometryEngine.ProjectEx(fromPoint, transformation) as MapPoint;
}
camera.X = fromPoint.X;
camera.Y = fromPoint.Y;
return(camera);
}
private async void MeasureButton_Click(object sender, RoutedEventArgs e)
{
string message = null;
try
{
var geometry = await MyMapView.Editor.RequestShapeAsync(DrawShape.Polyline);
var polyline = geometry as Polyline;
if (polyline != null && polyline.Parts != null && polyline.Parts.Count > 0)
{
var vertices = polyline.Parts[0].GetPoints();
var count = vertices != null?vertices.Count() : 0;
if (count > 1)
{
var result = new StringBuilder();
var totalLength = GeometryEngine.GeodesicLength(polyline);
result.AppendFormat("Total Length\t:\t{0:0} m\n", totalLength);
if (count > 2)
{
var polygon = new Polygon(polyline.Parts, polyline.SpatialReference);
var area = GeometryEngine.GeodesicArea(polygon);
result.AppendFormat("Area\t\t:\t{0:0} m²\n", area);
}
if (result.Length > 0)
{
message = string.Format("Measure results:\n{0}", result);
}
}
}
}
catch (TaskCanceledException)
{
}
catch (Exception ex)
{
message = ex.Message;
}
if (!string.IsNullOrWhiteSpace(message))
{
await new MessageDialog(message).ShowAsync();
}
}
private async Task doCalculateAreaAndLength()
{
try
{
//Wait for user to draw
var geom = await mapView1.Editor.RequestShapeAsync(DrawShape.Polygon);
//show geometry on map
_graphicsOverlay.Graphics.Clear();
var g = new Graphic {
Geometry = geom, Symbol = LayoutRoot.Resources["DefaultFillSymbol"] as Esri.ArcGISRuntime.Symbology.Symbol
};
_graphicsOverlay.Graphics.Add(g);
//Calculate results
var areaPlanar = GeometryEngine.Area(geom);
ResultsAreaPlanar.Text = string.Format("{0} millas cuad.", (areaPlanar * toSqMilesConversion).ToString("n3"));
var perimPlanar = GeometryEngine.Length(geom);
ResultsPerimeterPlanar.Text = string.Format("{0} millas", (perimPlanar * toMilesConversion).ToString("n3"));
var areaGeodesic = GeometryEngine.GeodesicArea(geom);
ResultsAreaGeodesic.Text = string.Format("{0} millas cuad.", (areaGeodesic * toSqMilesConversion).ToString("n3"));
var perimGeodesic = GeometryEngine.GeodesicLength(geom);
ResultsPerimeterGeodesic.Text = string.Format("{0} millas cuad.", (perimGeodesic * toMilesConversion).ToString("n3"));
//Instructions.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
Results.Visibility = Windows.UI.Xaml.Visibility.Visible;
Reiniciar.IsEnabled = true;
}
catch (System.Threading.Tasks.TaskCanceledException)
{
var dlg = new MessageDialog("El trazado actual ha sido cancelado.", "Tarea Cancelada!");
var _x = dlg.ShowAsync();
}
}
private async Task DoCalculateAreaAndLengthAsync()
{
try
{
//Wait for user to draw
var geom = await MyMapView.Editor.RequestShapeAsync(DrawShape.Polygon);
//show geometry on map
_graphicsOverlay.Graphics.Clear();
var g = new Graphic
{
Geometry = geom,
Symbol = LayoutRoot.Resources["DefaultFillSymbol"] as Esri.ArcGISRuntime.Symbology.Symbol
};
_graphicsOverlay.Graphics.Add(g);
//Calculate results
var areaPlanar = GeometryEngine.Area(geom);
ResultsAreaPlanar.Text = string.Format("{0} sq. miles", (areaPlanar * toSqMilesConversion).ToString("n3"));
var perimPlanar = GeometryEngine.Length(geom);
ResultsPerimeterPlanar.Text = string.Format("{0} miles", (perimPlanar * toMilesConversion).ToString("n3"));
var areaGeodesic = GeometryEngine.GeodesicArea(geom);
ResultsAreaGeodesic.Text = string.Format("{0} sq. miles", (areaGeodesic * toSqMilesConversion).ToString("n3"));
var perimGeodesic = GeometryEngine.GeodesicLength(geom);
ResultsPerimeterGeodesic.Text = string.Format("{0} miles", (perimGeodesic * toMilesConversion).ToString("n3"));
Instructions.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
Results.Visibility = Windows.UI.Xaml.Visibility.Visible;
}
catch (TaskCanceledException)
{
var _x = new MessageDialog("Current sketch has been canceled.", "Task Canceled!").ShowAsync();
}
}
private async Task doCalculateAreaAndLength()
{
try
{
// Wait for user to draw
var geom = await mapView.Editor.RequestShapeAsync(DrawShape.Polygon);
// show geometry on map
graphicsLayer.Graphics.Clear();
var graphic = new Graphic {
Geometry = geom, Symbol = LayoutRoot.Resources["DefaultFillSymbol"] as Symbol
};
graphicsLayer.Graphics.Add(graphic);
// Calculate results
var areaPlanar = GeometryEngine.Area(geom);
ResultsAreaPlanar.Text = string.Format("{0} sq. miles", (areaPlanar * toSqMilesConversion).ToString("n3"));
var perimPlanar = GeometryEngine.Length(geom);
ResultsPerimeterPlanar.Text = string.Format("{0} miles", (perimPlanar * toMilesConversion).ToString("n3"));
var areaGeodesic = GeometryEngine.GeodesicArea(geom);
ResultsAreaGeodesic.Text = string.Format("{0} sq. miles", (areaGeodesic * toSqMilesConversion).ToString("n3"));
var perimGeodesic = GeometryEngine.GeodesicLength(geom);
ResultsPerimeterGeodesic.Text = string.Format("{0} miles", (perimGeodesic * toMilesConversion).ToString("n3"));
Instructions.Visibility = Visibility.Collapsed;
Results.Visibility = Visibility.Visible;
}
catch (TaskCanceledException)
{
MessageBox.Show("Current sketch has been canceled.", "Task Canceled!");
}
}
private void OnStatusUpdated(GeometryEditStatus status)
{
_measurements.Clear();
var polyline = status.NewGeometry as Polyline;
if (polyline == null || polyline.Parts == null || polyline.Parts.Count == 0)
{
return;
}
var vertices = polyline.Parts[0].GetPoints();
if (vertices == null || !vertices.Any())
{
return;
}
var count = vertices.Count();
if (count <= 1)
{
return;
}
MapPoint previous = null;
int i = 1;
foreach (var point in vertices)
{
if (previous == null)
{
previous = point;
continue;
}
var lineSegment = new Polyline(new MapPoint[] { previous, point }, polyline.SpatialReference);
var intermediateLength = GeometryEngine.GeodesicLength(lineSegment);
_measurements.Add(string.Format("[{0}-{1}]\t:\t{2:0} m\n", i, i + 1, intermediateLength));
previous = point;
i++;
}
var totalLength = GeometryEngine.GeodesicLength(polyline);
TotalLength.Text = string.Format("Total Length\t:\t{0:0} m\n", totalLength);
if (count <= 2)
{
return;
}
var layer = MyMapView.Map.Layers["ResultLayer"] as GraphicsLayer;
if (layer == null)
{
return;
}
var graphic = layer.Graphics.FirstOrDefault();
var polygon = new Polygon(vertices, polyline.SpatialReference);
if (graphic != null)
{
graphic.Geometry = polygon;
}
else
{
layer.Graphics.Add(new Graphic(polygon));
}
if (count <= 1)
{
return;
}
if (count <= 2)
{
return;
}
var area = GeometryEngine.GeodesicArea(polygon);
TotalArea.Text = string.Format("Area\t\t:\t{0:0} m²\n", area);
}
// Draw and densify a user defined polygon
private async void DensifyButton_Click(object sender, RoutedEventArgs e)
{
try
{
DensifyButton.IsEnabled = false;
resultsPanel.Visibility = Visibility.Collapsed;
_inputOverlay.Graphics.Clear();
_resultsOverlay.Graphics.Clear();
DrawShape drawShape;
drawShape = (RadioPolyline.IsChecked.Value) ? drawShape = DrawShape.Polyline : drawShape = DrawShape.Polygon;
// Use polyline as default
Symbol symbolToUse = _lineSymbol;
if (drawShape == DrawShape.Polygon)
{
symbolToUse = _fillSymbol;
}
var original = await MyMapView.Editor.RequestShapeAsync(drawShape, symbolToUse);
// Account for WrapAround
var normalized = GeometryEngine.NormalizeCentralMeridian(original);
// Add original shape vertices to input graphics layer
var coordsOriginal = (normalized as Multipart).Parts.First().GetPoints();
foreach (var coord in coordsOriginal)
{
_inputOverlay.Graphics.Add(new Graphic(coord, _origVertexSymbol));
}
// Get current viewpoints extent from the MapView
var currentViewpoint = MyMapView.GetCurrentViewpoint(ViewpointType.BoundingGeometry);
var viewpointExtent = currentViewpoint.TargetGeometry.Extent;
// Densify the shape
var densify = GeometryEngine.GeodesicDensify(normalized, viewpointExtent.Width / 100, LinearUnits.Meters);
if (densify.GeometryType == GeometryType.Polygon)
{
_inputOverlay.Graphics.Add(new Graphic(densify, _fillSymbol));
}
else
{
_inputOverlay.Graphics.Add(new Graphic(densify, _lineSymbol));
}
// Add new vertices to result graphics layer
var coordsDensify = (densify as Multipart).Parts.First().GetPoints();
foreach (var coord in coordsDensify)
{
_resultsOverlay.Graphics.Add(new Graphic(coord, _newVertexSymbol));
}
// Results
var results = new List <Tuple <string, object> >()
{
new Tuple <string, object>("Length", GeometryEngine.GeodesicLength(densify) * METERS_TO_MILES),
new Tuple <string, object>("Area",
(normalized is Polygon) ? (GeometryEngine.GeodesicArea(densify) * SQUARE_METERS_TO_MILES).ToString("0.000") : "N/A"),
new Tuple <string, object>("Vertices Before", coordsOriginal.Count()),
new Tuple <string, object>("Vertices After", coordsDensify.Count())
};
resultsListView.ItemsSource = results;
resultsPanel.Visibility = Visibility.Visible;
}
catch (TaskCanceledException) { }
catch (Exception ex)
{
var _x = new MessageDialog("Densify Error: " + ex.Message, "Sample Error").ShowAsync();
}
finally
{
DensifyButton.IsEnabled = true;
}
}
// Draw and densify a user defined polygon
private async void DensifyButton_Click(object sender, RoutedEventArgs e)
{
try
{
resultsPanel.Visibility = Visibility.Collapsed;
_inputOverlay.Graphics.Clear();
_resultsOverlay.Graphics.Clear();
// Request polygon or polyline from the user
DrawShape drawShape = (DrawShape)comboShapeType.SelectedValue;
// Use polyline as default
Symbol symbolToUse = _lineSymbol;
if (drawShape == DrawShape.Polygon)
{
symbolToUse = _fillSymbol;
}
var original = await MyMapView.Editor.RequestShapeAsync(drawShape, symbolToUse);
// Account for WrapAround
var normalized = GeometryEngine.NormalizeCentralMeridian(original);
// Add original shape vertices to input graphics layer
var coordsOriginal = (normalized as Multipart).Parts.First().GetPoints();
foreach (var mapPoint in coordsOriginal)
{
_inputOverlay.Graphics.Add(new Graphic(mapPoint, _origVertexSymbol));
}
// Get current viewpoints extent from the MapView
var currentViewpoint = MyMapView.GetCurrentViewpoint(ViewpointType.BoundingGeometry);
var viewpointExtent = currentViewpoint.TargetGeometry.Extent;
// Densify the shape
var densify = GeometryEngine.GeodesicDensify(normalized, viewpointExtent.Width / 100, LinearUnits.Meters);
if (densify.GeometryType == GeometryType.Polygon)
{
_inputOverlay.Graphics.Add(new Graphic(densify, _fillSymbol));
}
else
{
_inputOverlay.Graphics.Add(new Graphic(densify, _lineSymbol));
}
// Add new vertices to result graphics layer
var coordsDensify = (densify as Multipart).Parts.First().GetPoints();
foreach (var mapPoint in coordsDensify)
{
_resultsOverlay.Graphics.Add(new Graphic(mapPoint, _newVertexSymbol));
}
// Results
Dictionary <string, object> results = new Dictionary <string, object>();
results["Length"] = GeometryEngine.GeodesicLength(densify) * METERS_TO_MILES;
if (normalized is Polygon)
{
results["Area"] = GeometryEngine.GeodesicArea(densify) * SQUARE_METERS_TO_MILES;
}
else
{
results["Area"] = "N/A";
}
results["Vertices Before"] = coordsOriginal.Count();
results["Vertices After"] = coordsDensify.Count();
resultsListView.ItemsSource = results;
resultsPanel.Visibility = Visibility.Visible;
}
catch (TaskCanceledException) { }
catch (Exception ex)
{
MessageBox.Show("Densify Error: " + ex.Message, "Geodesic Densify Sample");
}
}