async void LoadMap()
{
Map myMap = new Map(Basemap.CreateImagery());
// Create uri to the map image layer
//var serviceUri = new Uri(
// "http://182.253.238.238:6080/arcgis/rest/services/Penutup_Lahan/MapServer");
var serviceUri = new Uri(
"http://182.253.238.238:6080/arcgis/rest/services/Penutup_Lahan_BW/MapServer");
// Create new image layer from the url
ArcGISMapImageLayer imageLayer = new ArcGISMapImageLayer(serviceUri);
await imageLayer.LoadAsync();
// Add created layer to the basemaps collection
myMap.Basemap.BaseLayers.Add(imageLayer);
// Assign the map to the MapView
MyMapView.Map = myMap;
await MyMapView.SetViewpointGeometryAsync(imageLayer.FullExtent);
}
// Function that loads the two point tables from the local geodatabase and displays them as feature layers
private async void LoadLocalGeodatabaseTables()
{
// Read the geodatabase tables and add them as layers
foreach (GeodatabaseFeatureTable table in _localGeodatabase.GeodatabaseFeatureTables)
{
// Load the table so the TableName can be read
await table.LoadAsync();
// Store a reference to the Birds table
if (table.TableName.ToLower().Contains("birds"))
{
_birdTable = table;
}
// Store a reference to the Marine table
if (table.TableName.ToLower().Contains("marine"))
{
_marineTable = table;
}
// Create a new feature layer to show the table in the map
var layer = new FeatureLayer(table);
Dispatcher.Invoke(() => MyMapView.Map.OperationalLayers.Add(layer));
}
// Handle the transaction status changed event
_localGeodatabase.TransactionStatusChanged += GdbTransactionStatusChanged;
// Zoom the map view to the extent of the generated local datasets
Dispatcher.Invoke(() =>
{
MyMapView.SetViewpointGeometryAsync(_marineTable.Extent);
StartEditingButton.IsEnabled = true;
});
}
private async Task FindServiceAreas()
{
try
{
// Create the service area task.
_serviceAreaTask = await ServiceAreaTask.CreateAsync(new Uri(NetworkAnalysisUrl));
// Create the default parameters for the service.
ServiceAreaParameters serviceAreaParameters = await _serviceAreaTask.CreateDefaultParametersAsync();
// Configure the service area parameters.
serviceAreaParameters.PolygonDetail = ServiceAreaPolygonDetail.High;
serviceAreaParameters.ReturnPolygons = true;
serviceAreaParameters.DefaultImpedanceCutoffs.Clear();
serviceAreaParameters.DefaultImpedanceCutoffs.Add(0);
serviceAreaParameters.DefaultImpedanceCutoffs.Add(3);
serviceAreaParameters.DefaultImpedanceCutoffs.Add(5);
// A query that finds all of the relevant facilities from the facilities feature service.
QueryParameters facilityQueryParameters = new QueryParameters();
facilityQueryParameters.WhereClause = "1=1";
// Provide the feature service and the query as parameters to the service area task.
serviceAreaParameters.SetFacilities(_facilitiesTable, facilityQueryParameters);
// Perform the service area analysis.
ServiceAreaResult result = await _serviceAreaTask.SolveServiceAreaAsync(serviceAreaParameters);
// Count the features in the facilities layer.
long facilityCount = await _facilitiesTable.QueryFeatureCountAsync(facilityQueryParameters);
// Get the service area for each facility.
for (int facilityIndex = 0; facilityIndex < facilityCount; facilityIndex++)
{
// Get each area polygon from the result for that facility.
List <ServiceAreaPolygon> areaPolygons = result.GetResultPolygons(facilityIndex).ToList();
// Add each service area polygon to the graphics overlay.
for (int polygonIndex = 0; polygonIndex < areaPolygons.Count; polygonIndex++)
{
// Get the polygon from the result.
Polygon resultingPolygon = areaPolygons[polygonIndex].Geometry;
// Choose a symbol for the polygon.
SimpleFillSymbol selectedSymbol = _fillSymbols[polygonIndex % _fillSymbols.Count];
// Create and add the graphic.
_resultOverlay.Graphics.Add(new Graphic(resultingPolygon, selectedSymbol));
}
}
// Zoom to the extent of the results.
await MyMapView.SetViewpointGeometryAsync(_resultOverlay.Extent, 50);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex);
ShowMessage("Error", "Couldn't complete service area analysis.");
}
}
private async void Initialize()
{
// Create a new map to display in the map view with a streets basemap.
MyMapView.Map = new Map(BasemapStyle.ArcGISStreets);
// Get the path to the downloaded mobile geodatabase (.geodatabase file).
string mobileGeodatabaseFilePath = GetMobileGeodatabasePath();
try
{
// Open the mobile geodatabase.
Geodatabase mobileGeodatabase = await Geodatabase.OpenAsync(mobileGeodatabaseFilePath);
// Get the 'Trailheads' geodatabase feature table from the mobile geodatabase.
GeodatabaseFeatureTable trailheadsGeodatabaseFeatureTable = mobileGeodatabase.GeodatabaseFeatureTable("Trailheads");
// Asynchronously load the 'Trailheads' geodatabase feature table.
await trailheadsGeodatabaseFeatureTable.LoadAsync();
// Create a feature layer based on the geodatabase feature table.
FeatureLayer trailheadsFeatureLayer = new FeatureLayer(trailheadsGeodatabaseFeatureTable);
// Add the feature layer to the operations layers collection of the map.
MyMapView.Map.OperationalLayers.Add(trailheadsFeatureLayer);
// Zoom the map to the extent of the feature layer.
await MyMapView.SetViewpointGeometryAsync(trailheadsFeatureLayer.FullExtent, 50);
}
catch (Exception e)
{
await Application.Current.MainPage.DisplayAlert("Error", e.ToString(), "OK");
}
}
private async void Initialize()
{
// Create a new map to display in the map view with a streets basemap
Map streetMap = new Map(Basemap.CreateStreetsVector());
// Get the path to the downloaded shapefile
string filepath = GetShapefilePath();
// Open the shapefile
ShapefileFeatureTable myShapefile = await ShapefileFeatureTable.OpenAsync(filepath);
// Read metadata about the shapefile and display it in the UI
ShapefileInfo fileInfo = myShapefile.Info;
InfoPanel.DataContext = fileInfo;
// Display the shapefile thumbnail in an image control
ShapefileThumbnailImage.Source = await Esri.ArcGISRuntime.UI.RuntimeImageExtensions.ToImageSourceAsync(fileInfo.Thumbnail);
// Create a feature layer to display the shapefile
FeatureLayer newFeatureLayer = new FeatureLayer(myShapefile);
await newFeatureLayer.LoadAsync();
// Zoom the map to the extent of the shapefile
MyMapView.SpatialReferenceChanged += async(s, e) =>
{
await MyMapView.SetViewpointGeometryAsync(newFeatureLayer.FullExtent);
};
// Add the feature layer to the map
streetMap.OperationalLayers.Add(newFeatureLayer);
// Show the map in the MapView
MyMapView.Map = streetMap;
}
private async void Initialize()
{
// Create the map with basemap.
MyMapView.Map = new Map(Basemap.CreateNavigationVector());
try
{
// Create the WFS feature table from URL and name.
WfsFeatureTable wfsTable = new WfsFeatureTable(new Uri(TableUrl), LayerName);
// Set the feature request mode to manual. Only calls to PopulateFromService will load features.
// Features will not be populated automatically when the user pans and zooms the layer.
wfsTable.FeatureRequestMode = FeatureRequestMode.ManualCache;
// Load the WFS feature table.
await wfsTable.LoadAsync();
// Create a feature layer to visualize the WFS feature table.
FeatureLayer statesLayer = new FeatureLayer(wfsTable);
// Add the layer to the map.
MyMapView.Map.OperationalLayers.Add(statesLayer);
// Populate the WFS feature table with the XML query.
await wfsTable.PopulateFromServiceAsync(XmlQuery, true);
// Zoom to the extent of the query results.
await MyMapView.SetViewpointGeometryAsync(wfsTable.Extent, 50);
}
catch (Exception e)
{
Debug.WriteLine(e.ToString());
await new MessageDialog2(e.ToString(), "Couldn't populate table with XML query.").ShowAsync();
}
}
private async void Initialize()
{
try
{
MyMapView.Map = new Map(Basemap.CreateTopographic());
// Create an overlay for visualizing tactical messages and add it to the map.
_tacticalMessageOverlay = new GraphicsOverlay();
MyMapView.GraphicsOverlays.Add(_tacticalMessageOverlay);
// Prevent graphics from showing up when zoomed too far out.
_tacticalMessageOverlay.MinScale = 1000000;
// Create a symbol dictionary following the mil2525d spec.
string symbolFilePath = DataManager.GetDataFolder("e34835bf5ec5430da7cf16bb8c0b075c", "mil2525d.stylx");
DictionarySymbolStyle mil2525DStyle = await DictionarySymbolStyle.OpenAsync("mil2525d", symbolFilePath);
// Use the dictionary symbol to render graphics in the overlay.
_tacticalMessageOverlay.Renderer = new DictionaryRenderer(mil2525DStyle);
// Load the military messages and render them.
LoadMilitaryMessages();
// Get the extent of the graphics.
Envelope graphicExtent = GeometryEngine.CombineExtents(_tacticalMessageOverlay.Graphics.Select(graphic => graphic.Geometry));
// Zoom to the extent of the graphics.
await MyMapView.SetViewpointGeometryAsync(graphicExtent, 10);
}
catch (Exception e)
{
Console.WriteLine(e);
await((Page)Parent).DisplayAlert("Error", e.ToString(), "OK");
}
}
private async void _localFeatureService_StatusChanged(object sender, StatusChangedEventArgs e)
{
// Load the map from the service once ready
if (e.Status == LocalServerStatus.Started)
{
// Get the path to the first layer - the local feature service url + layer ID
string layerUrl = _localFeatureService.Url + "/0";
// Create the ServiceFeatureTable
ServiceFeatureTable myFeatureTable = new ServiceFeatureTable(new Uri(layerUrl));
// Create the Feature Layer from the table
FeatureLayer myFeatureLayer = new FeatureLayer(myFeatureTable);
// Add the layer to the map
MyMapView.Map.OperationalLayers.Add(myFeatureLayer);
try
{
// Wait for the layer to load
await myFeatureLayer.LoadAsync();
// Set the viewpoint on the MapView to show the layer data
await MyMapView.SetViewpointGeometryAsync(myFeatureLayer.FullExtent, 50);
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), "Error");
}
}
}
public async void UpdateExtents(object sender, RoutedEventArgs e)
{
statusTextBlock.Text = "Updating Extents";
QueryParameters queryParams = new QueryParameters();
queryParams.WhereClause = "TaxID LIKE '" + _currTaxID + "'";
FeatureQueryResult queryResult = await sfFeatTable.QueryFeaturesAsync(queryParams);
List <Feature> features = queryResult.ToList();
if (features.Any())
{
EnvelopeBuilder envBuilder = new EnvelopeBuilder(SpatialReference.Create(102715));
foreach (Feature feature in features)
{
envBuilder.UnionOf(feature.Geometry.Extent);
newFeatureLayer.ClearSelection();
newFeatureLayer.SelectFeature(feature);
}
await MyMapView.SetViewpointGeometryAsync(envBuilder.ToGeometry(), 20);
statusTextBlock.Text = "";
}
else
{
statusTextBlock.Text = "No parcel found for current query";
}
}
private async void Initialize()
{
// Create new map with the dark gray canvas basemap
Map myMap = new Map(Basemap.CreateDarkGrayCanvasVector());
// Create a Uri to the image service raster
var myUri = new Uri("http://sampleserver6.arcgisonline.com/arcgis/rest/services/NLCDLandCover2001/ImageServer");
// Create new image service raster from the Uri
ImageServiceRaster myImageServiceRaster = new ImageServiceRaster(myUri);
// Load the image service raster
await myImageServiceRaster.LoadAsync();
// Get the service information (aka. metadata) about the image service raster
ArcGISImageServiceInfo myArcGISImageServiceInfo = myImageServiceRaster.ServiceInfo;
// Create a new raster layer from the image service raster
RasterLayer myRasterLayer = new RasterLayer(myImageServiceRaster);
// Add the raster layer to the maps layer collection
myMap.Basemap.BaseLayers.Add(myRasterLayer);
// Assign the map to the map view
MyMapView.Map = myMap;
// Zoom the map to the extent of the image service raster (which also the extent of the raster layer)
await MyMapView.SetViewpointGeometryAsync(myArcGISImageServiceInfo.FullExtent);
// NOTE: The sample zooms to the extent of the ImageServiceRaster. Currently the ArcGIS Runtime does not
// support zooming a RasterLayer out beyond 4 times it's published level of detail. The sample uses
// MapView.SetViewpointCenterAsync() method to ensure the image shows when the app starts. You can see
// the effect of the image service not showing when you zoom out to the full extent of the image and beyond. }
}
private async void Initialize()
{
// Add an imagery basemap
Map myMap = new Map(Basemap.CreateImagery());
// Get the file name
string filepath = GetRasterPath();
// Load the raster file
Raster myRasterFile = new Raster(filepath);
// Create the layer
RasterLayer myRasterLayer = new RasterLayer(myRasterFile);
// Add the layer to the map
myMap.OperationalLayers.Add(myRasterLayer);
// Add map to the mapview
MyMapView.Map = myMap;
try
{
// Wait for the layer to load
await myRasterLayer.LoadAsync();
// Set the viewpoint
await MyMapView.SetViewpointGeometryAsync(myRasterLayer.FullExtent);
}
catch (Exception e)
{
await Application.Current.MainPage.DisplayAlert("Error", e.ToString(), "OK");
}
}
private async void Initialize()
{
// Add an imagery basemap
Map myMap = new Map(BasemapStyle.ArcGISImageryStandard);
// Get the file name
string filepath = GetRasterPath();
// Load the raster file
Raster myRasterFile = new Raster(filepath);
// Create the layer
RasterLayer myRasterLayer = new RasterLayer(myRasterFile);
// Add the layer to the map
myMap.OperationalLayers.Add(myRasterLayer);
// Add map to the mapview
MyMapView.Map = myMap;
try
{
// Wait for the layer to load
await myRasterLayer.LoadAsync();
// Set the viewpoint
await MyMapView.SetViewpointGeometryAsync(myRasterLayer.FullExtent);
}
catch (Exception e)
{
await new MessageDialog(e.ToString(), "Error").ShowAsync();
}
}
private async void Initialize()
{
try
{
MyMapView.Map = new Map(BasemapStyle.ArcGISTopographic);
// Create an overlay for visualizing tactical messages and add it to the map.
_tacticalMessageOverlay = new GraphicsOverlay();
MyMapView.GraphicsOverlays.Add(_tacticalMessageOverlay);
// Prevent graphics from showing up when zoomed too far out.
_tacticalMessageOverlay.MinScale = 1000000;
// Create a symbol dictionary style following the mil2525d spec.
string symbolFilePath = DataManager.GetDataFolder("c78b149a1d52414682c86a5feeb13d30", "mil2525d.stylx");
DictionarySymbolStyle mil2525DStyle = await DictionarySymbolStyle.CreateFromFileAsync(symbolFilePath);
// Use the dictionary symbol style to render graphics in the overlay.
_tacticalMessageOverlay.Renderer = new DictionaryRenderer(mil2525DStyle);
// Load the military messages and render them.
LoadMilitaryMessages();
// Get the extent of the graphics.
Envelope graphicExtent = GeometryEngine.CombineExtents(_tacticalMessageOverlay.Graphics.Select(graphic => graphic.Geometry));
// Zoom to the extent of the graphics.
await MyMapView.SetViewpointGeometryAsync(graphicExtent, 10);
}
catch (Exception e)
{
Console.WriteLine(e);
await Application.Current.MainPage.DisplayAlert("Error", e.ToString(), "OK");
}
}
private async void Initialize()
{
// Create a new map to display in the map view with a streets basemap
MyMapView.Map = new Map(BasemapStyle.ArcGISStreets);
// Get the path to the downloaded shapefile
string filepath = GetShapefilePath();
try
{
// Open the shapefile
ShapefileFeatureTable myShapefile = await ShapefileFeatureTable.OpenAsync(filepath);
// Create a feature layer to display the shapefile
FeatureLayer newFeatureLayer = new FeatureLayer(myShapefile);
// Add the feature layer to the map
MyMapView.Map.OperationalLayers.Add(newFeatureLayer);
// Zoom the map to the extent of the shapefile
await MyMapView.SetViewpointGeometryAsync(newFeatureLayer.FullExtent, 50);
}
catch (Exception e)
{
await Application.Current.MainPage.DisplayAlert("Error", e.ToString(), "OK");
}
}
private async void MyMapView_Loaded(object sender, RoutedEventArgs e)
{
Map myMap = new Map();
myMap.Basemap = Basemap.CreateStreets();
MyMapView.Map = myMap;
await MyMapView.SetViewpointGeometryAsync(new Envelope(-78.691528, 35.799884, -78.601835, 35.760055, SpatialReferences.Wgs84));
ArcGISMapImageLayer imageLayer = new ArcGISMapImageLayer(new Uri(imageLayerUri));
await imageLayer.LoadAsync();
myMap.OperationalLayers.Add(imageLayer);
for (int i = 0; i < imageLayer.Sublayers.Count; i++)
{
var legendLayer = imageLayer.SublayerContents[i];
legendLayer.ShowInLegend = true;
var layerLegendInfo = await legendLayer.GetLegendInfosAsync();
foreach (var l in layerLegendInfo.ToList())
{
legendTree.Items.Add(l);
}
}
}
private async void Initialize()
{
// Create a new map to display in the map view with a streets basemap
MyMapView.Map = new Map(Basemap.CreateStreetsVector());
// Get the path to the downloaded shapefile
string filepath = GetShapefilePath();
try
{
// Open the shapefile
ShapefileFeatureTable myShapefile = await ShapefileFeatureTable.OpenAsync(filepath);
// Create a feature layer to display the shapefile
FeatureLayer newFeatureLayer = new FeatureLayer(myShapefile);
// Add the feature layer to the map
MyMapView.Map.OperationalLayers.Add(newFeatureLayer);
// Zoom the map to the extent of the shapefile
await MyMapView.SetViewpointGeometryAsync(newFeatureLayer.FullExtent, 50);
}
catch (Exception e)
{
MessageBox.Show(e.ToString(), "Error");
}
}
private async void Initialize()
{
// Create a new map to display in the map view with a streets basemap.
MyMapView.Map = new Map(Basemap.CreateStreets());
// Get the path to the downloaded mobile geodatabase (.geodatabase file).
string mobileGeodatabaseFilePath = GetMobileGeodatabasePath();
// Open the mobile geodatabase.
Geodatabase mobileGeodatabase = await Geodatabase.OpenAsync(mobileGeodatabaseFilePath);
// Get the 'Trailheads' geodatabase feature table from the mobile geodatabase.
GeodatabaseFeatureTable trailheadsGeodatabaseFeatureTable = mobileGeodatabase.GeodatabaseFeatureTable("Trailheads");
// Asynchronously load the 'Trailheads' geodatabase feature table.
await trailheadsGeodatabaseFeatureTable.LoadAsync();
// Create a feature layer based on the geodatabase feature table.
FeatureLayer trailheadsFeatureLayer = new FeatureLayer(trailheadsGeodatabaseFeatureTable);
// Add the feature layer to the operations layers collection of the map.
MyMapView.Map.OperationalLayers.Add(trailheadsFeatureLayer);
// Zoom the map to the extent of the feature layer.
await MyMapView.SetViewpointGeometryAsync(trailheadsFeatureLayer.FullExtent, 50);
}
private async void Initialize()
{
// Create a new map to display in the map view with a streets basemap
Map streetMap = new Map(Basemap.CreateStreets());
// Get the path to the downloaded shapefile
string filepath = GetShapefilePath();
try
{
// Open the shapefile
ShapefileFeatureTable myShapefile = await ShapefileFeatureTable.OpenAsync(filepath);
// Read metadata about the shapefile and display it in the UI
ShapefileInfo fileInfo = myShapefile.Info;
InfoPanel.BindingContext = fileInfo;
// Read the thumbnail image data into a byte array
Stream imageStream = await fileInfo.Thumbnail.GetEncodedBufferAsync();
byte[] imageData = new byte[imageStream.Length];
imageStream.Read(imageData, 0, imageData.Length);
// Create a new image source from the thumbnail data
ImageSource streamImageSource = ImageSource.FromStream(() => new MemoryStream(imageData));
// Create a new image to display the thumbnail
Image image = new Image()
{
Source = streamImageSource,
Margin = new Thickness(10)
};
// Show the thumbnail image in a UI control
ShapefileThumbnailImage.Source = image.Source;
// Create a feature layer to display the shapefile
FeatureLayer newFeatureLayer = new FeatureLayer(myShapefile);
await newFeatureLayer.LoadAsync();
// Zoom the map to the extent of the shapefile
MyMapView.SpatialReferenceChanged += async(s, e) =>
{
await MyMapView.SetViewpointGeometryAsync(newFeatureLayer.FullExtent);
};
// Add the feature layer to the map
streetMap.OperationalLayers.Add(newFeatureLayer);
// Show the map in the MapView
MyMapView.Map = streetMap;
}
catch (Exception e)
{
await((Page)Parent).DisplayAlert("Error", e.ToString(), "OK");
}
}
private async void Initialize()
{
Map myMap = new Map(BasemapType.TopographicVector, 43.3, -73.2, 8);
/*
* try
* {
* if(LocalServer.Instance.Status == LocalServerStatus.Started)
* {
* await LocalServer.Instance.StopAsync();
* }
*
* string tempDataPathRoot = Directory.GetParent(Environment.GetFolderPath(Environment.SpecialFolder.Windows)).FullName;
* string tempDataPath = System.IO.Path.Combine(tempDataPathRoot, "EsriSamples", "AppData");
* await LocalServer.Instance.StartAsync();
*
* }
* catch (Exception ex)
* {
* var localServerTypeInfo = typeof(LocalMapService).GetTypeInfo();
* var localServerVersion = FileVersionInfo.GetVersionInfo(localServerTypeInfo.Assembly.Location);
*
* MessageBox.Show($"Please ensure that local server {localServerVersion.FileVersion} is installed prior to usung this app. Thx bro.\n{ex}");
* return;
* }
*/
sfFeatTable = await ShapefileFeatureTable.OpenAsync("C://Users//benja//Desktop//ColumbiaCounty//ColumbiaCounty.shp");
// Create feature layer using this feature table. Make it slightly transparent.
newFeatureLayer = new FeatureLayer(sfFeatTable)
{
Opacity = 0.6,
// Work around service setting.
MaxScale = 10
};
// Create a new renderer for the States Feature Layer.
SimpleLineSymbol lineSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Black, 1);
SimpleFillSymbol fillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Transparent, lineSymbol);
// Set States feature layer renderer.
newFeatureLayer.Renderer = new SimpleRenderer(fillSymbol);
// Add feature layer to the map.
myMap.OperationalLayers.Add(newFeatureLayer);
MyMapView.Map = myMap;
try
{
await MyMapView.SetViewpointGeometryAsync(newFeatureLayer.FullExtent, 50);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error");
}
}
private async void LoadLayers_Clicked(object sender, RoutedEventArgs e)
{
// Skip if nothing selected.
if (OgcFeatureCollectionList.SelectedItems.Count < 1)
{
return;
}
// Show the progress bar.
LoadingProgressBar.Visibility = Visibility.Visible;
// Clear the existing layers.
MyMapView.Map.OperationalLayers.Clear();
try
{
// Get the selected collection.
OgcFeatureCollectionInfo selectedCollectionInfo = (OgcFeatureCollectionInfo)OgcFeatureCollectionList.SelectedItems[0];
// Create the OGC feature collection table.
OgcFeatureCollectionTable table = new OgcFeatureCollectionTable(selectedCollectionInfo);
// Set the feature request mode to manual (only manual is currently supported).
// In this mode, you must manually populate the table - panning and zooming won't request features automatically.
table.FeatureRequestMode = FeatureRequestMode.ManualCache;
// Populate the OGC feature collection table.
QueryParameters queryParamaters = new QueryParameters();
queryParamaters.MaxFeatures = 1000;
await table.PopulateFromServiceAsync(queryParamaters, false, null);
// Create a feature layer from the OGC feature collection table.
FeatureLayer ogcFeatureLayer = new FeatureLayer(table);
// Choose a renderer for the layer based on the table.
ogcFeatureLayer.Renderer = GetRendererForTable(table) ?? ogcFeatureLayer.Renderer;
// Add the layer to the map.
MyMapView.Map.OperationalLayers.Add(ogcFeatureLayer);
// Zoom to the extent of the selected collection.
if (selectedCollectionInfo.Extent is Envelope collectionExtent && !collectionExtent.IsEmpty)
{
await MyMapView.SetViewpointGeometryAsync(collectionExtent, 100);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
await new MessageDialog(ex.Message, "Error loading service").ShowAsync();
}
finally
{
// Hide the progress bar.
LoadingProgressBar.Visibility = Visibility.Collapsed;
}
}
private async void LoadLayers_Clicked(object sender, EventArgs e)
{
// Show the progress bar.
LoadingProgressBar.IsVisible = true;
// Clear the existing layers.
MyMapView.Map.OperationalLayers.Clear();
try
{
// Add the layer to the map.
WfsLayerInfo selectedLayerInfo = (WfsLayerInfo)WfsLayerList.SelectedItem;
// Create the WFS feature table.
WfsFeatureTable table = new WfsFeatureTable(selectedLayerInfo);
// Set the feature request mode to manual - only manual is supported at v100.5.
// In this mode, you must manually populate the table - panning and zooming won't request features automatically.
table.FeatureRequestMode = FeatureRequestMode.ManualCache;
// Set the axis order based on the UI.
if (AxisOrderSwapCheckbox.IsToggled)
{
table.AxisOrder = OgcAxisOrder.Swap;
}
else
{
table.AxisOrder = OgcAxisOrder.NoSwap;
}
// Populate the WFS table.
await table.PopulateFromServiceAsync(new QueryParameters(), false, null);
// Create a feature layer from the WFS table.
FeatureLayer wfsFeatureLayer = new FeatureLayer(table);
// Choose a renderer for the layer based on the table.
wfsFeatureLayer.Renderer = GetRandomRendererForTable(table) ?? wfsFeatureLayer.Renderer;
// Add the layer to the map.
MyMapView.Map.OperationalLayers.Add(wfsFeatureLayer);
// Zoom to the extent of the layer.
await MyMapView.SetViewpointGeometryAsync(selectedLayerInfo.Extent, 50);
}
catch (Exception exception)
{
Debug.WriteLine(exception);
await((Page)Parent).DisplayAlert("Failed to load layer", exception.ToString(), "OK");
}
finally
{
// Hide the progress bar.
LoadingProgressBar.IsVisible = false;
}
}
private void Initialize()
{
// Hook up the DrawStatusChanged event.
MyMapView.DrawStatusChanged += OnDrawStatusChanged;
// Construct the map and set the MapView.Map property.
Map map = new Map(Basemap.CreateLightGrayCanvasVector());
MyMapView.Map = map;
// Create a ClosestFacilityTask using the San Diego Uri.
_task = ClosestFacilityTask.CreateAsync(new Uri("http://sampleserver6.arcgisonline.com/arcgis/rest/services/NetworkAnalysis/SanDiego/NAServer/ClosestFacility")).Result;
// List of facilities to be placed around San Diego area.
_facilities = new List <Facility> {
new Facility(new MapPoint(-1.3042129900625112E7, 3860127.9479775648, SpatialReferences.WebMercator)),
new Facility(new MapPoint(-1.3042193400557665E7, 3862448.873041752, SpatialReferences.WebMercator)),
new Facility(new MapPoint(-1.3046882875518233E7, 3862704.9896770366, SpatialReferences.WebMercator)),
new Facility(new MapPoint(-1.3040539754780494E7, 3862924.5938606677, SpatialReferences.WebMercator)),
new Facility(new MapPoint(-1.3042571225655518E7, 3858981.773018156, SpatialReferences.WebMercator)),
new Facility(new MapPoint(-1.3039784633928463E7, 3856692.5980474586, SpatialReferences.WebMercator)),
new Facility(new MapPoint(-1.3049023883956768E7, 3861993.789732541, SpatialReferences.WebMercator))
};
// Center the map on the San Diego facilities.
Envelope fullExtent = GeometryEngine.CombineExtents(_facilities.Select(facility => facility.Geometry));
MyMapView.SetViewpointGeometryAsync(fullExtent, 50);
// Create a symbol for displaying facilities.
_facilitySymbol = new PictureMarkerSymbol(new Uri("http://static.arcgis.com/images/Symbols/SafetyHealth/Hospital.png"))
{
Height = 30,
Width = 30
};
// Incident symbol.
_incidentSymbol = new SimpleMarkerSymbol(SimpleMarkerSymbolStyle.Cross, System.Drawing.Color.FromArgb(255, 0, 0, 0), 30);
// Route to hospital symbol.
_routeSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, System.Drawing.Color.FromArgb(255, 0, 0, 255), 5.0f);
// Create Graphics Overlays for incidents and facilities.
_incidentGraphicsOverlay = new GraphicsOverlay();
_facilityGraphicsOverlay = new GraphicsOverlay();
// Create a graphic and add to graphics overlay for each facility.
foreach (Facility facility in _facilities)
{
_facilityGraphicsOverlay.Graphics.Add(new Graphic(facility.Geometry, _facilitySymbol));
}
// Add each graphics overlay to MyMapView.
MyMapView.GraphicsOverlays.Add(_incidentGraphicsOverlay);
MyMapView.GraphicsOverlays.Add(_facilityGraphicsOverlay);
}
private async void OnViewpointsClicked(object sender, EventArgs e)
{
try
{
// Show sheet and get title from the selection
string selectedMapTitle =
await((Page)Parent).DisplayActionSheet("Select viewpoint", "Cancel", null, titles);
// If selected cancel do nothing
if (selectedMapTitle == "Cancel")
{
return;
}
switch (selectedMapTitle)
{
case "Geometry":
// Set Viewpoint using Redlands envelope defined above and a padding of 20
await MyMapView.SetViewpointGeometryAsync(RedlandsEnvelope, 20);
break;
case "Center & Scale":
// Set Viewpoint so that it is centered on the London coordinates defined above
await MyMapView.SetViewpointCenterAsync(LondonCoords);
// Set the Viewpoint scale to match the specified scale
await MyMapView.SetViewpointScaleAsync(LondonScale);
break;
case "Animate":
// Navigate to full extent of the first baselayer before animating to specified geometry
await MyMapView.SetViewpointAsync(
new Viewpoint(MyMapView.Map.Basemap.BaseLayers.First().FullExtent));
// Create a new Viewpoint using the specified geometry
Viewpoint viewpoint = new Viewpoint(EdinburghEnvelope);
// Set Viewpoint of MapView to the Viewpoint created above and animate to it using a timespan of 5 seconds
await MyMapView.SetViewpointAsync(viewpoint, TimeSpan.FromSeconds(5));
break;
default:
break;
}
}
catch (Exception ex)
{
await Application.Current.MainPage.DisplayAlert("Error", ex.ToString(), "OK");
}
}
public DensifyAndGeneralize()
{
InitializeComponent();
// Create the map with a default basemap.
MyMapView.Map = new Map(Basemap.CreateStreetsNightVector());
// Create and add a graphics overlay.
GraphicsOverlay overlay = new GraphicsOverlay();
MyMapView.GraphicsOverlays.Add(overlay);
// Create the original geometry: some points along a river.
PointCollection points = CreateShipPoints();
// Show the original geometry as red dots on the map.
Multipoint originalMultipoint = new Multipoint(points);
Graphic originalPointsGraphic = new Graphic(originalMultipoint,
new SimpleMarkerSymbol(SimpleMarkerSymbolStyle.Circle, Colors.Red, 7));
overlay.Graphics.Add(originalPointsGraphic);
// Show a dotted red line connecting the original points.
_originalPolyline = new Polyline(points);
Graphic originalPolylineGraphic = new Graphic(_originalPolyline,
new SimpleLineSymbol(SimpleLineSymbolStyle.Dot, Colors.Red, 3));
overlay.Graphics.Add(originalPolylineGraphic);
// Show the result (densified or generalized) points as magenta dots on the map.
_resultPointGraphic = new Graphic
{
Symbol = new SimpleMarkerSymbol(SimpleMarkerSymbolStyle.Circle, Colors.Magenta, 7),
ZIndex = 999
};
overlay.Graphics.Add(_resultPointGraphic);
// Connect the result points with a magenta polyline.
_resultPolylineGraphic = new Graphic
{
Symbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Colors.Magenta, 3),
ZIndex = 1000
};
overlay.Graphics.Add(_resultPolylineGraphic);
// Listen for changes in state.
DeviationSlider.ValueChanged += (o, e) =>
UpdateGeometry("Generalize", SegmentLengthSlider.Value, DeviationSlider.Value);
SegmentLengthSlider.ValueChanged += (o, e) =>
UpdateGeometry("Densify", SegmentLengthSlider.Value, DeviationSlider.Value);
// Center the map.
MyMapView.SetViewpointGeometryAsync(_originalPolyline.Extent, 100);
}
private void Initialize()
{
// Create a map with 'Imagery with Labels' basemap.
Map myMap = new Map(Basemap.CreateStreetsVector());
// Assign the map to the MapView.
MyMapView.Map = myMap;
// Create a center point for the graphics.
MapPoint centerPoint = new MapPoint(-117.195800, 34.056295, SpatialReferences.Wgs84);
// Create an envelope from that center point.
Envelope pointExtent = new Envelope(centerPoint, .5, .5);
//get the four corners of the extent
MapPoint location1 = new MapPoint(pointExtent.XMax, pointExtent.YMax);
MapPoint location2 = new MapPoint(pointExtent.XMax, pointExtent.YMin);
MapPoint location3 = new MapPoint(pointExtent.XMin, pointExtent.YMax);
MapPoint location4 = new MapPoint(pointExtent.XMin, pointExtent.YMin);
// Create a collection of points in the extent
Esri.ArcGISRuntime.Geometry.PointCollection points = new Esri.ArcGISRuntime.Geometry.PointCollection(Calculate(location1, location2, location3, location4), SpatialReferences.Wgs84);
// Create overlay to where graphics are shown.
_graphicsOverlay = new GraphicsOverlay();
// Add points to the graphics overlay.
foreach (MapPoint point in points)
{
// Create new graphic and add it to the overlay.
_graphicsOverlay.Graphics.Add(new Graphic(point));
}
// Create symbol for points.
SimpleMarkerSymbol pointSymbol = new SimpleMarkerSymbol()
{
Color = System.Drawing.Color.Yellow,
Size = 30,
Style = SimpleMarkerSymbolStyle.Square
};
// Create simple renderer with symbol.
SimpleRenderer renderer = new SimpleRenderer(pointSymbol);
// Set renderer to graphics overlay.
_graphicsOverlay.Renderer = renderer;
// Add created overlay to the MapView.
MyMapView.GraphicsOverlays.Add(_graphicsOverlay);
// Center the MapView on the points.
MyMapView.SetViewpointGeometryAsync(pointExtent, 50);
}
private void Initialize()
{
// Create a map with 'Imagery with Labels' basemap.
Map myMap = new Map(Basemap.CreateImageryWithLabels());
// Assign the map to the MapView.
MyMapView.Map = myMap;
// Create a center point for the graphics.
MapPoint centerPoint = new MapPoint(-117.195800, 34.056295, SpatialReferences.Wgs84);
// Create an envelope from that center point.
Envelope pointExtent = new Envelope(centerPoint, .07, .035);
// Create a collection of points on the corners of the envelope.
PointCollection points = new PointCollection(SpatialReferences.Wgs84)
{
new MapPoint(pointExtent.XMax, pointExtent.YMax),
new MapPoint(pointExtent.XMax, pointExtent.YMin),
new MapPoint(pointExtent.XMin, pointExtent.YMax),
new MapPoint(pointExtent.XMin, pointExtent.YMin),
};
// Create overlay to where graphics are shown.
GraphicsOverlay overlay = new GraphicsOverlay();
// Add points to the graphics overlay.
foreach (MapPoint point in points)
{
// Create new graphic and add it to the overlay.
overlay.Graphics.Add(new Graphic(point));
}
// Create symbol for points.
SimpleMarkerSymbol pointSymbol = new SimpleMarkerSymbol()
{
Color = Color.Yellow,
Size = 30,
Style = SimpleMarkerSymbolStyle.Square
};
// Create simple renderer with symbol.
SimpleRenderer renderer = new SimpleRenderer(pointSymbol);
// Set renderer to graphics overlay.
overlay.Renderer = renderer;
// Add created overlay to the MapView.
MyMapView.GraphicsOverlays.Add(overlay);
// Center the MapView on the points.
MyMapView.SetViewpointGeometryAsync(pointExtent, 50);
}
private async void OnButtonClick(object sender, RoutedEventArgs e)
{
try
{
// Get .Content from the selected item
Button myButton = (Button)sender;
string selectedMapTitle = myButton.Content.ToString();
switch (selectedMapTitle)
{
case "Geometry":
// Set Viewpoint using Redlands envelope defined above and a padding of 20
await MyMapView.SetViewpointGeometryAsync(_redlandsEnvelope, 20);
break;
case "Center and Scale":
// Set Viewpoint so that it is centered on the London coordinates defined above
await MyMapView.SetViewpointCenterAsync(_londonCoords);
// Set the Viewpoint scale to match the specified scale
await MyMapView.SetViewpointScaleAsync(_londonScale);
break;
case "Animate":
// Navigate to full extent of the first baselayer before animating to specified geometry
await MyMapView.SetViewpointAsync(
new Viewpoint(MyMapView.Map.Basemap.BaseLayers.First().FullExtent));
// Create a new Viewpoint using the specified geometry
Viewpoint viewpoint = new Viewpoint(_edinburghEnvelope);
// Set Viewpoint of MapView to the Viewpoint created above and animate to it using a timespan of 5 seconds
await MyMapView.SetViewpointAsync(viewpoint, TimeSpan.FromSeconds(5));
break;
default:
break;
}
}
catch (Exception ex)
{
await new MessageDialog2(ex.ToString(), "Error").ShowAsync();
}
}
async void MyMapView_GeoViewTapped(System.Object sender, Esri.ArcGISRuntime.Xamarin.Forms.GeoViewInputEventArgs e)
{
// Clear any currently visible callouts, route graphics, or selections
MyMapView.DismissCallout();
_routeGraphicsOverlay.Graphics.Clear();
_placesGraphicsOverlay.ClearSelection();
// Get the place under the tap
IdentifyGraphicsOverlayResult idResult = await MyMapView.IdentifyGraphicsOverlayAsync(_placesGraphicsOverlay, e.Position, 12, false);
Graphic clickedElement = idResult.Graphics.FirstOrDefault();
if (clickedElement != null)
{
// Select the place to highlight it; get name and address
clickedElement.IsSelected = true;
string name = clickedElement.Attributes["Name"].ToString();
string address = clickedElement.Attributes["Address"].ToString();
// Create a callout definition that shows the name and address for the place; set the element as a tag
CalloutDefinition definition = new CalloutDefinition(name, address);
definition.Tag = clickedElement;
// Handle button clicks for the button on the callout
// This event receives the value assigned as the CalloutDefinition.Tag
// ** Fix API ref for this!
// https://developers.arcgis.com/net/latest/wpf/api-reference/html/P_Esri_ArcGISRuntime_UI_CalloutDefinition_OnButtonClick.htm
definition.OnButtonClick = new Action <object>(async(tag) =>
{
// Get the geoelement that represents the place
GeoElement poiElement = tag as GeoElement;
if (poiElement == null)
{
return;
}
// Call a function in the viewmodel that will route to this location
var routeGraphic = await _viewModel.RouteToPoiAsync(_deviceLocation, poiElement.Geometry as MapPoint, MyMapView.SpatialReference);
// Add the route graphic to the map view and zoom to its extent
_routeGraphicsOverlay.Graphics.Add(routeGraphic);
await MyMapView.SetViewpointGeometryAsync(routeGraphic.Geometry, 30);
});
// Set the button icon and show the callout at the click location
definition.ButtonImage = WalkIcon;
MyMapView.ShowCalloutAt(e.Location, definition);
}
}
private async Task QueryStateFeature(string stateName)
{
try
{
// Create a query parameters that will be used to Query the feature table
QueryParameters queryParams = new QueryParameters();
// Trim whitespace on the state name to prevent broken queries
string formattedStateName = stateName.Trim().ToUpper();
// Construct and assign the where clause that will be used to query the feature table
queryParams.WhereClause = "upper(STATE_NAME) LIKE '%" + formattedStateName + "%'";
// Query the feature table
FeatureQueryResult queryResult = await _featureTable.QueryFeaturesAsync(queryParams);
// Cast the QueryResult to a List so the results can be interrogated
List <Feature> features = queryResult.ToList();
if (features.Any())
{
// Create an envelope.
EnvelopeBuilder envBuilder = new EnvelopeBuilder(SpatialReferences.WebMercator);
foreach (Feature feature in features)
{
// Add the extent of each matching feature to the envelope.
envBuilder.UnionOf(feature.Geometry.Extent);
// Select each feature.
_featureLayer.SelectFeature(feature);
}
// Zoom to the extent of the selected feature(s).
await MyMapView.SetViewpointGeometryAsync(envBuilder.ToGeometry(), 50);
}
else
{
MessageDialog message = new MessageDialog("State Not Found!", "Add a valid state name.");
await message.ShowAsync();
}
}
catch (Exception ex)
{
MessageDialog message = new MessageDialog("Sample error: " + ex, "An error occurred");
await message.ShowAsync();
}
}
private async void SetViewpointBasedOnOperationalLayers()
{
foreach (var l in MyMapView.Map.OperationalLayers)
{
if (l is FeatureLayer)
{
var fl = (FeatureLayer)l;
if (fl.FullExtent != null)
{
await MyMapView.SetViewpointGeometryAsync(fl.FullExtent);
break;
}
}
}
}