ProSnippets MapExploration

Language:              C#  
Subject:               MapExploration  
Contributor:           ArcGIS Pro SDK Team <arcgisprosdk@esri.com>  
Organization:          esri, http://www.esri.com  
Date:                  12/22/2017  
ArcGIS Pro:            2.1  
Visual Studio:         2015, 2017  
.NET Target Framework: 4.6.1  

Get the active map's name

public string GetActiveMapName()
{
  //Get the active map view.
  var mapView = MapView.Active;
  if (mapView == null)
    return null;

  //Return the name of the map currently displayed in the active map view.
  return mapView.Map.Name;
}

Select all feature layers in TOC

public void SelectAllFeatureLayersInTOC()
{
  //Get the active map view.
  var mapView = MapView.Active;
  if (mapView == null)
    return;

  //Zoom to the selected layers in the TOC
  var featureLayers = mapView.Map.Layers.OfType<FeatureLayer>();
  mapView.SelectLayers(featureLayers.ToList());
}

Flash selected features

public Task FlashSelectedFeaturesAsync()
{
  return QueuedTask.Run(() =>
  {
          //Get the active map view.
          var mapView = MapView.Active;
    if (mapView == null)
      return;

          //Get the selected features from the map and filter out the standalone table selection.
          var selectedFeatures = mapView.Map.GetSelection()
              .Where(kvp => kvp.Key is BasicFeatureLayer)
              .ToDictionary(kvp => (BasicFeatureLayer)kvp.Key, kvp => kvp.Value);

          //Flash the collection of features.
          mapView.FlashFeature(selectedFeatures);
  });
}

Test if the view is 3D

public bool IsView3D()
{
  //Get the active map view.
  var mapView = MapView.Active;
  if (mapView == null)
    return false;

  //Return whether the viewing mode is SceneLocal or SceneGlobal
  return mapView.ViewingMode == ArcGIS.Core.CIM.MapViewingMode.SceneLocal ||
         mapView.ViewingMode == ArcGIS.Core.CIM.MapViewingMode.SceneGlobal;
}

Rotate the map view

public void RotateView(double heading)
{
  //Get the active map view.
  var mapView = MapView.Active;
  if (mapView == null)
    return;

  //Get the camera for the view, adjust the heading and zoom to the new camera position.
  var camera = mapView.Camera;
  camera.Heading = heading;
  mapView.ZoomToAsync(camera, TimeSpan.Zero);
}

Show a pop-up for a feature

public void ShowPopup(MapMember mapMember, long objectID)
{
  //Get the active map view.
  var mapView = MapView.Active;
  if (mapView == null)
    return;

  mapView.ShowPopup(mapMember, objectID);
}

Show a custom pop-up

public void ShowCustomPopup()
{
  //Get the active map view.
  var mapView = MapView.Active;
  if (mapView == null)
    return;

  //Create custom popup content
  var popups = new List<PopupContent>
        {
            new PopupContent("<b>This text is bold.</b>", "Custom tooltip from HTML string"),
            new PopupContent(new Uri("http://www.esri.com/"), "Custom tooltip from Uri")
        };
  mapView.ShowCustomPopup(popups);
}

Zoom to an extent

public async Task<bool> ZoomToExtentAsync(double xMin, double yMin, double xMax, double yMax,
    ArcGIS.Core.Geometry.SpatialReference spatialReference)
{
  //Get the active map view.
  var mapView = MapView.Active;
  if (mapView == null)
    return false;

  //Create the envelope
  var envelope =
      await
          QueuedTask.Run(
              () =>
                  ArcGIS.Core.Geometry.EnvelopeBuilder.CreateEnvelope(xMin, yMin, xMax, yMax, spatialReference));

  //Zoom the view to a given extent.
  return await mapView.ZoomToAsync(envelope, TimeSpan.FromSeconds(2));
}

Zoom to visible layers

public Task<bool> ZoomToVisibleLayersAsync()
{
  //Get the active map view.
  var mapView = MapView.Active;
  if (mapView == null)
    return Task.FromResult(false);

  //Zoom to all visible layers in the map.
  var visibleLayers = mapView.Map.Layers.Where(l => l.IsVisible);
  return mapView.ZoomToAsync(visibleLayers);
}

Zoom to selected layers in TOC

public Task<bool> ZoomToTOCSelectedLayersAsync()
{
  //Get the active map view.
  var mapView = MapView.Active;
  if (mapView == null)
    return Task.FromResult(false);

  //Zoom to the selected layers in the TOC
  var selectedLayers = mapView.GetSelectedLayers();
  return mapView.ZoomToAsync(selectedLayers);
}

Zoom to previous camera

public Task<bool> ZoomToPreviousCameraAsync()
{
  //Get the active map view.
  var mapView = MapView.Active;
  if (mapView == null)
    return Task.FromResult(false);

  //Zoom to the selected layers in the TOC
  if (mapView.HasPreviousCamera())
    return mapView.PreviousCameraAsync();

  return Task.FromResult(false);
}

Zoom to a bookmark with a given name

public Task<bool> ZoomToBookmarkAsync(string bookmarkName)
{
  return QueuedTask.Run(() =>
  {
          //Get the active map view.
          var mapView = MapView.Active;
    if (mapView == null)
      return false;

          //Get the first bookmark with the given name.
          var bookmark = mapView.Map.GetBookmarks().FirstOrDefault(b => b.Name == bookmarkName);
    if (bookmark == null)
      return false;

          //Zoom the view to the bookmark.
          return mapView.ZoomTo(bookmark);
  });
}

Create a new bookmark using the active map view

public Task<Bookmark> AddBookmarkAsync(string name)
{
  return QueuedTask.Run(() =>
  {
          //Get the active map view.
          var mapView = MapView.Active;
    if (mapView == null)
      return null;

          //Adding a new bookmark using the active view.
          return mapView.Map.AddBookmark(mapView, name);
  });
}

Remove bookmark with a given name

public Task RemoveBookmarkAsync(Map map, string name)
{
  return QueuedTask.Run(() =>
  {
          //Find the first bookmark with the name
          var bookmark = map.GetBookmarks().FirstOrDefault(b => b.Name == name);
    if (bookmark == null)
      return;

          //Remove the bookmark
          map.RemoveBookmark(bookmark);
  });
}

Get the collection of bookmarks for the project

public Task<ReadOnlyObservableCollection<Bookmark>> GetProjectBookmarksAsync()
{
  //Get the collection of bookmarks for the project.
  return QueuedTask.Run(() => Project.Current.GetBookmarks());
}

Change the thumbnail for a bookmark

public Task SetThumbnailAsync(Bookmark bookmark, string imagePath)
{
  //Set the thumbnail to an image on disk, ie. C:\Pictures\MyPicture.png.
  BitmapImage image = new BitmapImage(new Uri(imagePath, UriKind.RelativeOrAbsolute));
  return QueuedTask.Run(() => bookmark.SetThumbnail(image));
}

Project camera into a new spatial reference

public Task<Camera> ProjectCamera(Camera camera, ArcGIS.Core.Geometry.SpatialReference spatialReference)
{
  return QueuedTask.Run(() =>
  {
    var mapPoint = MapPointBuilder.CreateMapPoint(camera.X, camera.Y, camera.Z, camera.SpatialReference);
    var newPoint = GeometryEngine.Instance.Project(mapPoint, spatialReference) as MapPoint;
    var newCamera = new Camera()
    {
      X = newPoint.X,
      Y = newPoint.Y,
      Z = newPoint.Z,
      Scale = camera.Scale,
      Pitch = camera.Pitch,
      Heading = camera.Heading,
      Roll = camera.Roll,
      Viewpoint = camera.Viewpoint,
      SpatialReference = spatialReference
    };
    return newCamera;
  });
}

Step forward in time by 1 month

public void StepMapTime()
{
  //Get the active view
  MapView mapView = MapView.Active;
  if (mapView == null)
    return;

  //Step current map time forward by 1 month
  TimeDelta timeDelta = new TimeDelta(1, TimeUnit.Months);
  mapView.Time = mapView.Time.Offset(timeDelta);
}

Graphic Overlay

public async void GraphicOverlaySnippetTest()
{
  // get the current mapview and point
  var mapView = MapView.Active;
  if (mapView == null)
    return;
  var myextent = mapView.Extent;
  var point = myextent.Center;

  // add point graphic to the overlay at the center of the mapView
  var disposable = await QueuedTask.Run(() =>
  {
          //add these to the overlay
          return mapView.AddOverlay(point,
              SymbolFactory.Instance.ConstructPointSymbol(
                      ColorFactory.Instance.RedRGB, 30.0, SimpleMarkerStyle.Star).MakeSymbolReference());
  });

  // update the overlay with new point graphic symbol
  MessageBox.Show("Now to update the overlay...");
  await QueuedTask.Run(() =>
  {
    mapView.UpdateOverlay(disposable, point, SymbolFactory.Instance.ConstructPointSymbol(
                                  ColorFactory.Instance.BlueRGB, 20.0, SimpleMarkerStyle.Circle).MakeSymbolReference());
  });

  // clear the overlay display by disposing of the graphic
  MessageBox.Show("Now to clear the overlay...");
  disposable.Dispose();

}

Change symbol for a sketch tool

internal class SketchTool_WithSymbol : MapTool
{
  public SketchTool_WithSymbol()
  {
    IsSketchTool = true;
    SketchOutputMode = SketchOutputMode.Map; //Changing the Sketch Symbol is only supported with map sketches.
    SketchType = SketchGeometryType.Rectangle;
  }

  protected override Task OnToolActivateAsync(bool hasMapViewChanged)
  {
    return QueuedTask.Run(() =>
    {
            //Set the Sketch Symbol if it hasn't already been set.
            if (SketchSymbol != null)
        return;
      var polygonSymbol = SymbolFactory.Instance.ConstructPolygonSymbol(ColorFactory.Instance.CreateRGBColor(24, 69, 59),
                        SimpleFillStyle.Solid,
                      SymbolFactory.Instance.ConstructStroke(ColorFactory.Instance.BlackRGB, 1.0, SimpleLineStyle.Dash));
      SketchSymbol = polygonSymbol.MakeSymbolReference();
    });
  }
}

Create a tool to the return coordinates of the point clicked in the map

internal class GetMapCoordinates : MapTool
{
  protected override void OnToolMouseDown(MapViewMouseButtonEventArgs e)
  {
    if (e.ChangedButton == System.Windows.Input.MouseButton.Left)
      e.Handled = true; //Handle the event args to get the call to the corresponding async method
  }

  protected override Task HandleMouseDownAsync(MapViewMouseButtonEventArgs e)
  {
    return QueuedTask.Run(() =>
    {
            //Convert the clicked point in client coordinates to the corresponding map coordinates.
            var mapPoint = MapView.Active.ClientToMap(e.ClientPoint);
      ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show(string.Format("X: {0} Y: {1} Z: {2}",
                mapPoint.X, mapPoint.Y, mapPoint.Z), "Map Coordinates");
    });
  }
}

Create a tool to identify the featutes that intersect the sketch geometry

internal class CustomIdentify : MapTool
{
  public CustomIdentify()
  {
    IsSketchTool = true;
    SketchType = SketchGeometryType.Rectangle;

    //To perform a interactive selection or identify in 3D or 2D, sketch must be created in screen coordinates.
    SketchOutputMode = SketchOutputMode.Screen;
  }

  protected override Task<bool> OnSketchCompleteAsync(Geometry geometry)
  {
    return QueuedTask.Run(() =>
    {
      var mapView = MapView.Active;
      if (mapView == null)
        return true;

            //Get all the features that intersect the sketch geometry and flash them in the view. 
            var results = mapView.GetFeatures(geometry);
      mapView.FlashFeature(results);

            //Show a message box reporting each layer the number of the features.
            MessageBox.Show(
                String.Join("\n", results.Select(kvp => String.Format("{0}: {1}", kvp.Key.Name, kvp.Value.Count()))),
                "Identify Result");
      return true;
    });
  }
}