private void Mapview1_ExtentChanged(object sender, EventArgs e)
{
Esri.ArcGISRuntime.Geometry.Geometry ext = GeometryEngine.NormalizeCentralMeridian(Mapview1.Extent);
var vp = new Esri.ArcGISRuntime.Controls.Viewpoint(ext);
SceneView1.SetViewAsync(vp);
}
/// <summary>
/// 点击地图上 显示信息 如地震信息
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void MyMapView_OnMapViewTapped(object sender, MapViewInputEventArgs e)
{
List <EarthquakeMsg> list = earthquake.EarthquakeMsgs;
if (list == null)
{
return;
}
for (int i = 0; i < list.Count; i++)
{
var normalizedPoint = GeometryEngine.NormalizeCentralMeridian(e.Location);
var projectedCenter = GeometryEngine.Project(normalizedPoint, SpatialReferences.Wgs84) as MapPoint;
float.Parse(projectedCenter.X.ToString("0.00"));
if (float.Parse(projectedCenter.X.ToString("0.00")) == list[i].longitude && float.Parse(projectedCenter.Y.ToString("0.00")) == list[i].latitude)
{
double margin_left = e.Position.X - this.earthquakeMsgDetailBorder.ActualWidth;
double margin_top = e.Position.Y - this.earthquakeMsgDetailBorder.ActualHeight * 0.5;
double margin_right = this.MyMapView.ActualWidth - margin_left - this.earthquakeMsgDetailBorder.ActualWidth;
double margin_bottom = this.MyMapView.ActualHeight - margin_top - this.earthquakeMsgDetailBorder.ActualHeight;
this.earthquakeMsgDetailBorder.Margin = new Thickness(margin_left, margin_top, margin_right, margin_bottom);
this.earthquakeMsgDetailBorder.Visibility = Visibility.Visible;
this.earthquakeMsgDetailBorder.DataContext = list[i];
return;
}
}
}
// Intersects feature geometries with a user defined polygon.
private async void IntersectButton_Click(object sender, RoutedEventArgs e)
{
try
{
_resultGraphics.Graphics.Clear();
// wait for user to draw a polygon
Polygon userpoly = await MyMapView.Editor.RequestShapeAsync(DrawShape.Polygon) as Polygon;
Polygon poly = GeometryEngine.NormalizeCentralMeridian(userpoly) as Polygon;
// get intersecting features from the feature layer
SpatialQueryFilter filter = new SpatialQueryFilter();
filter.Geometry = GeometryEngine.Project(poly, _statesLayer.FeatureTable.SpatialReference);
filter.SpatialRelationship = SpatialRelationship.Intersects;
filter.MaximumRows = 52;
var stateFeatures = await _statesLayer.FeatureTable.QueryAsync(filter);
// Intersect the feature geometries and add to graphics layer
var states = stateFeatures.Select(feature => feature.Geometry);
var intersectGraphics = states
.Select(state => GeometryEngine.Intersection(state, poly))
.Select(geo => new Graphic(geo, _fillSymbol));
_resultGraphics.Graphics.AddRange(intersectGraphics);
}
catch (Exception ex)
{
var _x = new MessageDialog("Intersection Error: " + ex.Message, "Sample Error").ShowAsync();
}
}
//맵뷰 클릭이벤트 핸들러 - 이동처리(ServiceFeature)
public async void handlerGeoViewTappedMoveFeature_org(object sender, GeoViewInputEventArgs e)
{
//이동처리
if (_selectedFeature != null)
{
try
{
// Get the MapPoint from the EventArgs for the tap.
MapPoint destinationPoint = e.Location;
// Normalize the point - needed when the tapped location is over the international date line.
destinationPoint = (MapPoint)GeometryEngine.NormalizeCentralMeridian(destinationPoint);
// Load the feature.
//await _selectedFeature.LoadAsync();
// Update the geometry of the selected feature.
_selectedFeature.Geometry = destinationPoint;
// Apply the edit to the feature table.
await _selectedFeature.FeatureTable.UpdateFeatureAsync(_selectedFeature);
_selectedFeature.Refresh();
// Push the update to the service. - Save버튼에서 최종저장
//ServiceFeatureTable serviceTable = (ServiceFeatureTable)_selectedFeature.FeatureTable;
//await serviceTable.ApplyEditsAsync();
//MessageBox.Show("Moved feature " + _selectedFeature.Attributes["objectid"], "Success!");
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), "Error when moving feature.");
}
}
}
private void MapView_ExtentChanged(object sender, EventArgs e)
{
Envelope newExtent = null;
if (MyMapView.WrapAround)
{
Geometry normalizedExtent = GeometryEngine.NormalizeCentralMeridian(MyMapView.Extent);
if (normalizedExtent is Polygon)
{
var normalizedPolygon = (Polygon)normalizedExtent;
if (normalizedPolygon.Parts.Count == 1)
{
newExtent = normalizedPolygon.Extent;
}
else
{
var newExtentBuilder = new EnvelopeBuilder(MyMapView.SpatialReference);
foreach (var p in normalizedPolygon.Parts[0].GetPoints())
{
if (p.X < newExtentBuilder.XMin || double.IsNaN(newExtentBuilder.XMin))
{
newExtentBuilder.XMin = p.X;
}
if (p.Y < newExtentBuilder.YMin || double.IsNaN(newExtentBuilder.YMin))
{
newExtentBuilder.YMin = p.Y;
}
}
foreach (var p in normalizedPolygon.Parts[1].GetPoints())
{
if (p.X > newExtentBuilder.XMax || double.IsNaN(newExtentBuilder.XMax))
{
newExtentBuilder.XMax = p.X;
}
if (p.Y > newExtentBuilder.YMax || double.IsNaN(newExtentBuilder.YMax))
{
newExtentBuilder.YMax = p.Y;
}
}
newExtent = newExtentBuilder.ToGeometry();
}
}
else if (normalizedExtent is Envelope)
{
newExtent = normalizedExtent as Envelope;
}
}
else
{
newExtent = MyMapView.Extent;
}
MinXNormalized.Text = newExtent.XMin.ToString("0.000");
MinYNormalized.Text = newExtent.YMin.ToString("0.000");
MaxXNormalized.Text = newExtent.XMax.ToString("0.000");
MaxYNormalized.Text = newExtent.YMax.ToString("0.000");
}
// Cuts feature geometries with a user defined cut polyline.
private async void CutButton_Click(object sender, RoutedEventArgs e)
{
try
{
_resultGraphicsOverlay.Graphics.Clear();
// wait for user to draw cut line
var cutLine = await MyMapView.Editor.RequestShapeAsync(DrawShape.Polyline, _cutLineSymbol) as Polyline;
Polyline polyline = GeometryEngine.NormalizeCentralMeridian(cutLine) as Polyline;
// get intersecting features from the feature layer
SpatialQueryFilter filter = new SpatialQueryFilter();
filter.Geometry = GeometryEngine.Project(polyline, _statesLayer.FeatureTable.SpatialReference);
filter.SpatialRelationship = SpatialRelationship.Crosses;
filter.MaximumRows = 52;
var stateFeatures = await _statesLayer.FeatureTable.QueryAsync(filter);
// Cut the feature geometries and add to graphics layer
var states = stateFeatures.Select(feature => feature.Geometry);
var cutGraphics = states
.Where(geo => !GeometryEngine.Within(polyline, geo))
.SelectMany(state => GeometryEngine.Cut(state, polyline))
.Select(geo => new Graphic(geo, _cutFillSymbol));
_resultGraphicsOverlay.Graphics.AddRange(cutGraphics);
}
catch (TaskCanceledException) { }
catch (Exception ex)
{
var _x = new MessageDialog("Cut Error: " + ex.Message, "Sample Error").ShowAsync();
}
}
private void AnimateGraphic()
{
MapPoint userStartPoint = _userInteractionLayer.Graphics[0].Geometry as MapPoint;
MapPoint userFinishPoint = _userInteractionLayer.Graphics[1].Geometry as MapPoint;
MapPoint startPoint = GeometryEngine.NormalizeCentralMeridian(userStartPoint) as MapPoint;
MapPoint finishPoint = GeometryEngine.NormalizeCentralMeridian(userFinishPoint) as MapPoint;
var animatingGraphic = new Graphic(new MapPoint(startPoint.X, startPoint.Y));
_animatingLayer.Graphics.Add(animatingGraphic);
// Framework easing objects may be used to calculate progressive values
// - i.e. QuinticEase, BackEase, BounceEase, ElasticEase, etc.
var easing = new QuinticEase()
{
EasingMode = EasingMode.EaseInOut
};
var animateStartTime = DateTime.Now;
var animationTimer = new DispatcherTimer();
animationTimer.Interval = TimeSpan.FromMilliseconds(33);
animationTimer.Tick += (s, ex) =>
{
double fraction = easing.Ease((DateTime.Now - animateStartTime).TotalMilliseconds / AnimationDuration);
var x = (finishPoint.X - startPoint.X) * fraction + startPoint.X;
var y = (finishPoint.Y - startPoint.Y) * fraction + startPoint.Y;
animatingGraphic.Geometry = new MapPoint(x, y);
};
animationTimer.Start();
}
public async void MyMapView_OnMapViewTapped(object sender, MapViewInputEventArgs e)
{
try
{
var normalizedPoint = GeometryEngine.NormalizeCentralMeridian(e.Location);
var point = GeometryEngine.Project(normalizedPoint, SpatialReferences.Wgs84) as MapPoint;
if (isDelete)
{
await DeleteScenic(e.Position);
//return;
}
if (isAdd)
{
await AddScenic(point);
//return;
}
if (isAlter)
{
await AlterScenic(e.Position);
//return;
}
}
catch (Exception ex)
{
MessageBox.Show("HitTest Error: " + ex.Message, "Graphics Layer Hit Testing");
}
}
private async void MapView_GeoViewTappedAsync(object sender, GeoViewInputEventArgs e)
{
try
{
double tolerance = 10;
double mapTolerance = tolerance * mapView.UnitsPerPixel;
MapPoint geometry = e.Location;
if (mapView.IsWrapAroundEnabled)
{
geometry = GeometryEngine.NormalizeCentralMeridian(geometry) as MapPoint;
}
var selectionEnvelope = new Envelope(geometry.X - mapTolerance, geometry.Y - mapTolerance, geometry.X + mapTolerance,
geometry.Y + mapTolerance, mapView.Map.SpatialReference);
var queryParams = new QueryParameters();
queryParams.Geometry = selectionEnvelope;
SelectTagByTypoAsync(_featureLayer, "TAP", queryParams);
SelectTagByTypoAsync(featureLayerNAP, "NAP", queryParams);
SelectTagByTypoAsync(featureLayerMDU, "MDU", queryParams);
await featureLayerCableCoaxial.SelectFeaturesAsync(queryParams, SelectionMode.New);
}
catch (Exception ex)
{
Log.Info("Error", ex.Message);
GenerateAlertError("Error buscando el tap");
}
}
private void MyMapView_MapViewTapped(object sender, MapViewInputEventArgs e)
{
try
{
_graphicsOverlay.Graphics.Clear();
var point = e.Location;
var buffer = GeometryEngine.GeodesicBuffer(
GeometryEngine.NormalizeCentralMeridian(point), //Normalize in case we we're too far west/east of the world bounds
500, LinearUnits.Miles);
var pointGraphic = new Graphic {
Geometry = point, Symbol = _pinSymbol
};
_graphicsOverlay.Graphics.Add(pointGraphic);
var bufferGraphic = new Graphic {
Geometry = buffer, Symbol = _bufferSymbol
};
_graphicsOverlay.Graphics.Add(bufferGraphic);
}
catch (Exception ex)
{
var _x = new MessageDialog(ex.Message, "Sample Error").ShowAsync();
}
}
// 피처추가
public void handlerGeoViewTappedAddFeature(object sender, GeoViewInputEventArgs e)
{
try
{
// Get the MapPoint from the EventArgs for the tap.
MapPoint destinationPoint = e.Location;
// Normalize the point - needed when the tapped location is over the international date line.
destinationPoint = (MapPoint)GeometryEngine.NormalizeCentralMeridian(destinationPoint);
// 1.레이어에 위치추가
AddFeatureToLayer(destinationPoint);
//MessageBox.Show("Added feature ", "Success!");
//이벤트핸들러원복
mapView.GeoViewTapped -= handlerGeoViewTappedMoveFeature;
mapView.GeoViewTapped -= handlerGeoViewTappedAddFeature;
mapView.GeoViewTapped -= handlerGeoViewTapped;
mapView.GeoViewTapped += handlerGeoViewTapped;
/*
* 시설물DB 저장
*/
Messages.ShowInfoMsgBox("위치정보가 추가되었습니다. 해당시설물의 상세정보를 저장하세요");
}
catch (Exception ex)
{
Messages.ShowErrMsgBox(ex.ToString());
}
}
private async void MyMapView_GeoViewTapped(object sender, Esri.ArcGISRuntime.Xamarin.Forms.GeoViewInputEventArgs e)
{
// Indicate that the geoprocessing is running
SetBusy();
// Clear previous user click location and the viewshed geoprocessing task results
_inputOverlay.Graphics.Clear();
_resultOverlay.Graphics.Clear();
// Get the tapped point
MapPoint geometry = e.Location;
// Create a marker graphic where the user clicked on the map and add it to the existing graphics overlay
Graphic myInputGraphic = new Graphic(geometry);
_inputOverlay.Graphics.Add(myInputGraphic);
// Normalize the geometry if wrap-around is enabled
// This is necessary because of how wrapped-around map coordinates are handled by Runtime
// Without this step, the task may fail because wrapped-around coordinates are out of bounds.
if (MyMapView.IsWrapAroundEnabled)
{
geometry = (MapPoint)GeometryEngine.NormalizeCentralMeridian(geometry);
}
try
{
// Execute the geoprocessing task using the user click location
await CalculateViewshed(geometry);
}
catch (Exception ex)
{
await((Page)Parent).DisplayAlert("Error", ex.ToString(), "OK");
}
}
private async Task DoCutPolygons()
{
if (statesOverlay != null && resultsOverlay != null)
{
resultsOverlay.Graphics.Clear();
// Get the user's input
var cutPolyLine = (await mapView1.Editor.RequestShapeAsync(DrawShape.Polyline)) as Polyline;
// Normalize for WrapAround
Polyline polyline = GeometryEngine.NormalizeCentralMeridian(cutPolyLine) as Polyline;
// Iterate over the graphics in the GraphicsOverlay. If the graphic intersects with the polyline we will cut it
// and create Graphic objects from the results. Next we add those Graphics resulting to a List<Graphic>.
List <Graphic> cutGraphics = new List <Graphic>();
foreach (var g in statesOverlay.Graphics)
{
if (GeometryEngine.Intersects(g.Geometry, polyline))
{
var cutPolygonGeometries = GeometryEngine.Cut(g.Geometry, polyline);
var cutPolygonGraphics = cutPolygonGeometries.Select(x => new Graphic {
Geometry = x
});
cutGraphics.AddRange(cutPolygonGraphics);
}
}
// Add the results to the GraphicsOverlay
resultsOverlay.Graphics.AddRange(cutGraphics);
}
}
private async void OnMapViewTapped(object sender, GeoViewInputEventArgs e)
{
_inputOverlay.Graphics.Clear();
_resultOverlay.Graphics.Clear();
// Get the tapped point
MapPoint geometry = new MapPoint(e.Location.X, e.Location.Y, e.Location.SpatialReference);
Console.WriteLine(geometry.ToString());
// Create a marker graphic where the user clicked on the map and add it to the existing graphics overlay
Graphic myInputGraphic = new Graphic(geometry);
_inputOverlay.Graphics.Add(myInputGraphic);
// Normalize the geometry if wrap-around is enabled
// This is necessary because of how wrapped-around map coordinates are handled by Runtime
// Without this step, the task may fail because wrapped-around coordinates are out of bounds.
if (MainWindow.View.Map2D.IsWrapAroundEnabled)
{
geometry = (MapPoint)GeometryEngine.NormalizeCentralMeridian(geometry);
}
try
{
// Execute the geoprocessing task using the user click location
await CalculateViewshed(geometry);
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), "Error");
}
}
// Process elevation data requests by the user
private async Task ProcessUserRequests()
{
try
{
// Get user rectangle
var userEnvelope = await MyMapView.Editor.RequestShapeAsync(DrawShape.Envelope) as Envelope;
if (userEnvelope.Height == 0 || userEnvelope.Width == 0)
{
throw new ArgumentNullException("Please click and drag a box to define an extent.");
}
// Display the graphics
_graphicsLayer.Graphics.Add(new Graphic(userEnvelope));
// Take account of WrapAround
var polygon = GeometryEngine.NormalizeCentralMeridian(userEnvelope) as Polygon;
Envelope envelope = polygon.Extent;
// Retrieve elevation data from the service
ElevationData elevationData = await GetElevationData(envelope);
// Create the image for the display
WriteableBitmap writeableBitmapElevation = await CreateElevationImageAsync(elevationData);
ElevationImage.Source = writeableBitmapElevation;
ElevationView.Visibility = Visibility.Visible;
}
catch (Exception ex)
{
var _x = new MessageDialog(ex.Message, "Sample Error").ShowAsync();
}
}
private async void MapView_Tapped(object sender, GeoViewInputEventArgs e)
{
try
{
// Create the feature.
ArcGISFeature feature = (ArcGISFeature)_damageFeatureTable.CreateFeature();
// Get the normalized geometry for the tapped location and use it as the feature's geometry.
MapPoint tappedPoint = (MapPoint)GeometryEngine.NormalizeCentralMeridian(e.Location);
feature.Geometry = tappedPoint;
// Set feature attributes.
feature.SetAttributeValue("typdamage", "Minor");
feature.SetAttributeValue("primcause", "Earthquake");
// Add the feature to the table.
await _damageFeatureTable.AddFeatureAsync(feature);
// Apply the edits to the service.
await _damageFeatureTable.ApplyEditsAsync();
// Update the feature to get the updated objectid - a temporary ID is used before the feature is added.
feature.Refresh();
// Confirm feature addition.
MessageBox.Show("Created feature " + feature.Attributes["objectid"], "Success!");
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), "Error adding feature");
}
}
private void MyMapView_MapViewTapped(object sender, MapViewInputEventArgs e)
{
var normalizedPoint = GeometryEngine.NormalizeCentralMeridian(e.Location);
var projectedCenter = GeometryEngine.Project(normalizedPoint, SpatialReferences.Wgs84) as MapPoint;
_clickOverlay.DataContext = projectedCenter;
}
private void MyMapView_MouseMove(object sender, MouseEventArgs e)
{
try
{
// Convert screen point to map point
var point = MyMapView.ScreenToLocation(e.GetPosition(MyMapView));
if (point == null)
{
return;
}
var buffer = GeometryEngine.GeodesicBuffer(
GeometryEngine.NormalizeCentralMeridian(point), //Normalize in case we we're too far west/east of the world bounds
500, LinearUnits.Miles);
Graphic bufferGraphic = null;
if (_graphicsOverlay.Graphics.Count == 0)
{
bufferGraphic = new Graphic {
Geometry = buffer, Symbol = _bufferSymbol
};
_graphicsOverlay.Graphics.Add(bufferGraphic);
}
else
{
bufferGraphic = _graphicsOverlay.Graphics[0];
}
bufferGraphic.Geometry = buffer;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Geometry Engine Failed!");
}
}
// Clips feature geometries with a user defined clipping rectangle.
private async void ClipButton_Click(object sender, RoutedEventArgs e)
{
try
{
_clippedGraphicsOverlay.Graphics.Clear();
// wait for user to draw clip rect
var rect = await MyMapView.Editor.RequestShapeAsync(DrawShape.Rectangle);
Polygon polygon = GeometryEngine.NormalizeCentralMeridian(rect) as Polygon;
// get intersecting features from the feature layer
SpatialQueryFilter filter = new SpatialQueryFilter();
filter.Geometry = GeometryEngine.Project(polygon, _statesLayer.FeatureTable.SpatialReference);
filter.SpatialRelationship = SpatialRelationship.Intersects;
filter.MaximumRows = 52;
var stateFeatures = await _statesLayer.FeatureTable.QueryAsync(filter);
// Clip the feature geometries and add to graphics layer
var states = stateFeatures.Select(feature => feature.Geometry);
var clipGraphics = states
.Select(state => GeometryEngine.Clip(state, polygon.Extent))
.Select(geo => new Graphic(geo, _clipSymbol));
_clippedGraphicsOverlay.Graphics.AddRange(clipGraphics);
}
catch (TaskCanceledException) { }
catch (Exception ex)
{
var _x = new MessageDialog("Clip Error: " + ex.Message, "Clip Geometry").ShowAsync();
}
}
private async void MyMapView_GeoViewTapped(object sender, GeoViewInputEventArgs e)
{
// Clear previous user click location and the viewshed geoprocessing task results.
_inputOverlay.Graphics.Clear();
_resultOverlay.Graphics.Clear();
// Get the tapped point.
MapPoint geometry = e.Location;
// Create a marker graphic where the user clicked on the map and add it to the existing graphics overlay.
Graphic inputGraphic = new Graphic(geometry);
_inputOverlay.Graphics.Add(inputGraphic);
// Normalize the geometry if wrap-around is enabled.
// This is necessary because of how wrapped-around map coordinates are handled by Runtime.
// Without this step, the task may fail because wrapped-around coordinates are out of bounds.
if (_myMapView.IsWrapAroundEnabled)
{
geometry = (MapPoint)GeometryEngine.NormalizeCentralMeridian(geometry);
}
try
{
// Execute the geoprocessing task using the user click location.
await CalculateViewshed(geometry);
}
catch (Exception ex)
{
new UIAlertView("Error", ex.ToString(), (IUIAlertViewDelegate)null, "OK", null).Show();
}
}
private async void OnMapViewTapped(object sender, GeoViewInputEventArgs e)
{
// Define the selection tolerance.
double tolerance = 15;
// Convert the tolerance to map units.
double mapTolerance = tolerance * _myMapView.UnitsPerPixel;
// Get the tapped point.
MapPoint geometry = e.Location;
// Normalize the geometry if wrap-around is enabled.
// This is necessary because of how wrapped-around map coordinates are handled by Runtime.
// Without this step, querying may fail because wrapped-around coordinates are out of bounds.
if (_myMapView.IsWrapAroundEnabled)
{
geometry = (MapPoint)GeometryEngine.NormalizeCentralMeridian(geometry);
}
// Define the envelope around the tap location for selecting features.
Envelope selectionEnvelope = new Envelope(geometry.X - mapTolerance, geometry.Y - mapTolerance, geometry.X + mapTolerance,
geometry.Y + mapTolerance, _myMapView.Map.SpatialReference);
// Define the query parameters for selecting features.
QueryParameters queryParams = new QueryParameters
{
// Set the geometry to selection envelope for selection by geometry.
Geometry = selectionEnvelope
};
// Select the features based on query parameters defined above.
await _featureLayer.SelectFeaturesAsync(queryParams, SelectionMode.New);
}
private void MyMapView_GeoViewTapped(object sender, GeoViewInputEventArgs geoViewInputEventArgs)
{
// Get the tapped location.
MapPoint tappedLocation = (MapPoint)GeometryEngine.NormalizeCentralMeridian(geoViewInputEventArgs.Location);
// Show the tapped location.
_tappedLocationGraphic.Geometry = tappedLocation;
// Get the nearest vertex in the polygon.
ProximityResult nearestVertexResult = GeometryEngine.NearestVertex(_polygonGraphic.Geometry, tappedLocation);
// Get the nearest coordinate in the polygon.
ProximityResult nearestCoordinateResult =
GeometryEngine.NearestCoordinate(_polygonGraphic.Geometry, tappedLocation);
// Get the distance to the nearest vertex in the polygon.
int distanceVertex = (int)(nearestVertexResult.Distance / 1000);
// Get the distance to the nearest coordinate in the polygon.
int distanceCoordinate = (int)(nearestCoordinateResult.Distance / 1000);
// Show the nearest vertex in blue.
_nearestVertexGraphic.Geometry = nearestVertexResult.Coordinate;
// Show the nearest coordinate in red.
_nearestCoordinateGraphic.Geometry = nearestCoordinateResult.Coordinate;
// Show the distances in the UI.
_distanceLabel.Text = $"Vertex dist: {distanceVertex} km, Point dist: {distanceCoordinate} km";
}
private async void OnMapViewTapped(object sender, GeoViewInputEventArgs e)
{
// The geoprocessing task is still executing, don't do anything else (i.e. respond to
// more user taps) until the processing is complete.
if (_isExecutingGeoprocessing)
{
return;
}
// Indicate that the geoprocessing is running
SetBusy();
// Clear previous user click location and the viewshed geoprocessing task results
_inputOverlay.Graphics.Clear();
_resultOverlay.Graphics.Clear();
// Get the tapped point
MapPoint geometry = e.Location;
// Create a marker graphic where the user clicked on the map and add it to the existing graphics overlay
Graphic myInputGraphic = new Graphic(geometry);
_inputOverlay.Graphics.Add(myInputGraphic);
// Normalize the geometry if wrap-around is enabled
// This is necessary because of how wrapped-around map coordinates are handled by Runtime
// Without this step, the task may fail because wrapped-around coordinates are out of bounds.
if (MyMapView.IsWrapAroundEnabled)
{
geometry = GeometryEngine.NormalizeCentralMeridian(geometry) as MapPoint;
}
// Execute the geoprocessing task using the user click location
await CalculateViewshed(geometry);
}
private void MapViewTapped(object sender, GeoViewInputEventArgs geoViewInputEventArgs)
{
// Get the tapped location
MapPoint tappedLocation = (MapPoint)GeometryEngine.NormalizeCentralMeridian(geoViewInputEventArgs.Location);
// Show the tapped location
_tappedLocationGraphic.Geometry = tappedLocation;
// Get the nearest vertex in the polygon
ProximityResult nearestVertexResult = GeometryEngine.NearestVertex(_polygonGraphic.Geometry, tappedLocation);
// Get the nearest coordinate in the polygon
ProximityResult nearestCoordinateResult =
GeometryEngine.NearestCoordinate(_polygonGraphic.Geometry, tappedLocation);
// Get the distance to the nearest vertex in the polygon
int distanceVertex = (int)(nearestVertexResult.Distance / 1000);
// Get the distance to the nearest coordinate in the polygon
int distanceCoordinate = (int)(nearestCoordinateResult.Distance / 1000);
// Show the nearest vertex in blue
_nearestVertexGraphic.Geometry = nearestVertexResult.Coordinate;
// Show the nearest coordinate in red
_nearestCoordinateGraphic.Geometry = nearestCoordinateResult.Coordinate;
// Show the distances in the UI
ResultsLabel.Content =
string.Format("Vertex dist: {0} km, Point dist: {1} km", distanceVertex, distanceCoordinate);
}
// Unions feature geometries with a user defined polygon.
private async void UnionButton_Click(object sender, RoutedEventArgs e)
{
try
{
_resultGraphics.Graphics.Clear();
// wait for user to draw a polygon
var poly = await MyMapView.Editor.RequestShapeAsync(DrawShape.Polygon);
// Take account of WrapAround
var normalizedPoly = GeometryEngine.NormalizeCentralMeridian(poly) as Polygon;
// get intersecting features from the feature layer
SpatialQueryFilter filter = new SpatialQueryFilter();
filter.Geometry = GeometryEngine.Project(normalizedPoly, _statesLayer.FeatureTable.SpatialReference);
filter.SpatialRelationship = SpatialRelationship.Intersects;
filter.MaximumRows = 52;
var stateFeatures = await _statesLayer.FeatureTable.QueryAsync(filter);
// Union the geometries and add to graphics layer
var states = stateFeatures.Select(feature => feature.Geometry);
var unionPolys = states.ToList();
var unionPoly = GeometryEngine.Union(unionPolys);
var unionGraphic = new Graphic(unionPoly, _fillSymbol);
_resultGraphics.Graphics.Add(unionGraphic);
}
catch (Exception ex)
{
var _x = new MessageDialog("Union Error: " + ex.Message, "Sample Error").ShowAsync();
}
}
public void MapView_MouseDown(object sender, MouseButtonEventArgs e)
{
System.Windows.Point screenPoint = e.GetPosition(mainMapView);
MapPoint mapPoint = mainMapView.ScreenToLocation(screenPoint);
if (mainMapView.WrapAround)
{
mapPoint = GeometryEngine.NormalizeCentralMeridian(mapPoint) as MapPoint;
}
switch (mapOperationType)
{
case MapOperationType.AddPerson:
var personAddDialogViewModel = new PersonAddDialogViewModel(personService, imgService);
personAddDialogViewModel.FamousPerson.BornX = mapPoint.X;
personAddDialogViewModel.FamousPerson.BornY = mapPoint.Y;
new PersonAddDialog(personAddDialogViewModel).ShowDialog();
break;
case MapOperationType.AddEvent:
var eventAddDialogViewModel = new EventAddDialogViewModel(historyEventService, imgService);
eventAddDialogViewModel.HistoryEvent.OccurX = mapPoint.X;
eventAddDialogViewModel.HistoryEvent.OccurY = mapPoint.Y;
new EventAddDialog(eventAddDialogViewModel).ShowDialog();
break;
default:
break;
}
}
private async void MySceneView_MouseLeftDown(object sender, MouseEventArgs e)
{
if (edit == true && (type == "line" || type == "area"))
{
if (MySceneView.GetCurrentViewpoint(ViewpointType.BoundingGeometry) == null)
{
return;
}
_mapViewModel.Clear(type);
System.Windows.Point screenPoint = e.GetPosition(MySceneView);
MapPoint mapPoint = await MySceneView.ScreenToLocationAsync(screenPoint);
if (mapPoint.X != 0 && mapPoint.Y != 0 && mapPoint.Z != 0)
{
mapPoint = GeometryEngine.NormalizeCentralMeridian(mapPoint) as MapPoint;
mapPoint_list.Add(new MapPoint(mapPoint.X, mapPoint.Y));
if (mapPoint_list.Count > 1)
{
var boatPositions = new PolylineBuilder(SpatialReferences.Wgs84);
boatPositions.AddPoint(new MapPoint(mapPoint_list[mapPoint_list.Count - 2].X, mapPoint_list[mapPoint_list.Count - 2].Y));
boatPositions.AddPoint(new MapPoint(mapPoint_list[mapPoint_list.Count - 1].X, mapPoint_list[mapPoint_list.Count - 1].Y));
var boatRoute = boatPositions.ToGeometry();
_mapViewModel.Line(boatRoute, "temp");;
}
}
}
}
// 点选Popup属性
private async void myMapViewGetAttributeValue(object sender, Esri.ArcGISRuntime.UI.Controls.GeoViewInputEventArgs e)
{
IdentifyLayerResult myShapeFileResult = await myMapView.IdentifyLayerAsync(tempPopupLayer, e.Position, 20, false);
try
{
Feature tempGeoElement = (Feature)myShapeFileResult.GeoElements[0];
// 遍历全部属性
List <ArcGISApp1.Utils.ShapefileAttribution> attrList = new List <ArcGISApp1.Utils.ShapefileAttribution>();
foreach (KeyValuePair <string, object> keyValuePair in tempGeoElement.Attributes)
{
ArcGISApp1.Utils.ShapefileAttribution temp = new ArcGISApp1.Utils.ShapefileAttribution(keyValuePair.Key, (keyValuePair.Value).ToString());
attrList.Add(temp);
}
Popup myPopup = (Popup)mainWindow.FindName("myPopup");
DataGrid myDataGrid = (DataGrid)mainWindow.FindName("myDataGrid");
myPopup.IsOpen = false;
myPopup.IsOpen = true;
myDataGrid.AutoGenerateColumns = false;
myDataGrid.ItemsSource = attrList;
}
catch
{
TextBlock myTest = (TextBlock)mainWindow.FindName("myTest");
myTest.Text = "当前无要素被选中。";
}
// 要素选择高亮
try
{
double tolerance = 0.0000001;
double mapTolerance = tolerance * myMapView.UnitsPerPixel;
MapPoint geometry = e.Location;
if (myMapView.IsWrapAroundEnabled)
{
geometry = (MapPoint)GeometryEngine.NormalizeCentralMeridian(geometry);
}
Envelope selectionEnvelope = new Envelope(geometry.X - mapTolerance, geometry.Y - mapTolerance, geometry.X + mapTolerance, geometry.Y + mapTolerance, myMapView.Map.SpatialReference);
QueryParameters queryParams = new QueryParameters
{
Geometry = selectionEnvelope
//Geometry = geometry
};
FeatureQueryResult queryResult = await tempPopupLayer.SelectFeaturesAsync(queryParams, Esri.ArcGISRuntime.Mapping.SelectionMode.New);
//IEnumerator<Feature> resultFeatures = queryResult.GetEnumerator();
//List<Feature> features = new List<Feature>();
//while (resultFeatures.MoveNext())
//{
// features.Add(resultFeatures.Current);
//}
//MessageBox.Show(geometry.X + "\n" + geometry.Y + "\n" + features.Count);
}
catch (Exception ex)
{
MessageBox.Show("要素选择错误: ", ex.ToString());
}
}
private void Button_Click(object sender, RoutedEventArgs e)
{
Envelope ext = GeometryEngine.NormalizeCentralMeridian(Mapview1.Extent).Extent;
MapPoint ptnMin = new MapPoint(ext.XMin, ext.YMin, Mapview1.SpatialReference);
MapPoint nptnMin = GeometryEngine.Project(ptnMin, new SpatialReference(4326)) as MapPoint;
MapPoint ptnMax = new MapPoint(ext.XMax, ext.YMax, Mapview1.SpatialReference);
MapPoint nptnMax = GeometryEngine.Project(ptnMax, new SpatialReference(4326)) as MapPoint;
SetLocation(sender, string.Format("{0},{1},{2},{3}", nptnMin.X, nptnMin.Y, nptnMax.X, nptnMax.Y));
}
void AssociatedObject_MouseMove(object sender, System.Windows.Input.MouseEventArgs e)
{
MapView mapView = sender as MapView;
System.Windows.Point screenPoint = e.GetPosition(mapView);
MapPoint mapPoint = mapView.ScreenToLocation(screenPoint);
if (mapView.WrapAround)
{
mapPoint = GeometryEngine.NormalizeCentralMeridian(mapPoint) as MapPoint;
}
}