ProConcepts Geoprocessing - Esri/arcgis-pro-sdk GitHub Wiki

var path = @"C:\<ArcGIS Pro Install Path>\Resources\ArcToolBox\Toolboxes\Analysis Tools.tbx";
var long_tool_name = System.IO.Path.Combine(path, "Buffer");

var short_tool_name = "analysis.Buffer";

var path = @"C:\Data\DeepThought-ProAddin\Toolboxes\toolboxes\DeepThought.tbx";
var long_tool_name = System.IO.Path.Combine(path, "Answer");

// the tool to be executed has workspace as first parameter
// feature class name as second and feature type as third parameter
string outpath = Project.Current.DefaultGeodatabasePath;
string fcname = "accident_sites";
var sr = await QueuedTask.Run(() => {
    return SpatialReferenceBuilder.CreateSpatialReference(3857);
});
// must maintain the sequence and position of each parameter value
var parameters = Geoprocessing.MakeValueArray(outpath, fcname, "POINT", "", "", "", sr);

 var mv = MapView.Active;
 var tool_name = "analysis.Buffer";

 var val_array = await QueuedTask.Run(() =>  {

    var center_pt = MapPointBuilderEx.CreateMapPoint(mv.Camera.X, mv.Camera.Y, mv.Camera.SpatialReference);
    var poly = GeometryEngine.Instance.Buffer(center_pt, 2000);
    //add the geometry to a list before parameterizing
    var geom_values = new List<object>() { poly };
     return Geoprocessing.MakeValueArray(new object[] { geom_values, null, @"1000 Meters" });

 });
 //execute the tool with ExecuteToolAsync
 //Geoprocessing.ExecuteToolAsync(tool_name, val_array,
 //                      null, null, null, GPExecuteToolFlags.InheritGPOptions);

 //Invoke on the UI - show the tool dialog pre-populated with the parameter values
 Geoprocessing.OpenToolDialog(tool_name, val_array, null, false);

 var tool_name = "analysis.Clip";
 var extent = MapView.Active.Extent;
 var sel_layer = MapView.Active.Map.GetLayersAsFlattenedList()
                        .OfType<FeatureLayer>().FirstOrDefault(l => l.Name == "GreatLakes");
 if (sel_layer == null) return;

 var gdb = Project.Current.DefaultGeodatabasePath;
 var out_fc = System.IO.Path.Combine(gdb, "clipped_lakes_out");

 var val_array = await QueuedTask.Run(() => {
   var rect = GeometryEngine.Instance.Scale(extent, extent.Center, 0.5, 0.5) as Envelope;
   var clip_poly = PolygonBuilderEx.CreatePolygon(rect, rect.SpatialReference);

   //Add the geometry to a list before calling MakeValueArray
   //Envelope and Geometry types are supported
   var geom = new List<object>() { clip_poly };
   return Geoprocessing.MakeValueArray(new object[] { sel_layer, geom, out_fc });
 });
 Geoprocessing.ExecuteToolAsync(tool_name, val_array,
        null, null, null, GPExecuteToolFlags.InheritGPOptions);

// create the spatial reference object
var sp_ref = await QueuedTask.Run(() => {
    return SpatialReferenceBuilder.CreateSpatialReference(26911);  // UTM 83 11N: 26911
});

// create an extent object
var ext = "460532 3773964 525111 3827494";
// follow syntax env_name: env_value
// environment names will be available in the intellisense          
var environments = Geoprocessing.MakeEnvironmentArray(outputCoordinateSystem: sp_ref, extent: ext);

string tool1 = "analysis.Buffer";

// create multipoints
List<MapPoint> list = new List<MapPoint>();
list.Add(MapPointBuilderEx.CreateMapPoint(1.0, 1.0));
list.Add(MapPointBuilderEx.CreateMapPoint(1.0, 2.0));
Multipoint multiPoint = MultipointBuilderEx.CreateMultipoint(list);

var args = await QueuedTask.Run(() =>
{
  return Geoprocessing.MakeValueArray(multiPoint, "memory\\Buffers", "800 meters");
});

// example of using ArcGIS.Core.Geometry.SpatialReference object
var spatial_ref = await QueuedTask.Run(() => {
    return SpatialReferenceBuilder.CreateSpatialReference(3857);
});
// call MakeEnvironmentArray on spatial_ref so that ExecuteToolAsync can internally use the object
var env = Geoprocessing.MakeEnvironmentArray(outputCoordinateSystem: spatial_ref);

Geoprocessing.ExecuteToolAsync(tool1, args, env);

// code in the implementing method that Button's OnClick can call
string ozone_points = @"C:\data\ca_ozone.gdb\MarchValues";

var args = Geoprocessing.MakeValueArray(ozone_points, "OZONE", "", "in_memory\\raster", "300", "EMPIRICAL", 
               "300", "5", "5000",
               "NBRTYPE=StandardCircular RADIUS=310833.272442914 ANGLE=0 NBR_MAX=10 SECTOR_TYPE=ONE_SECTOR",
               "PREDICTION", "0.5", "EXCEED", "", "K_BESSEL" );

string tool_path = "ga.EmpiricalBayesianKriging";

// cancellation token variable is declared as a class member
System.Threading.CancellationTokenSource _cts = new System.Threading.CancellationTokenSource();

var result = Geoprocessing.ExecuteToolAsync(tool_path, args, null, _cts.Token,
    (event_name, o) =>  // implement delegate and handle events, o is message object.
    {
        switch (event_name){     
            case "OnValidate": // stop execute if any warnings
                if ((o as IGPMessage[]).Any(it => it.Type == GPMessageType.Warning))
                    _cts.Cancel();
                break;
            case "OnProgressMessage":
                string msg = string.Format("{0}: {1}", new object[] { event_name, (string)o });
                System.Windows.MessageBox.Show(msg);
                _cts.Cancel();
                break;
            case "OnProgressPos":
                string msg2 = string.Format("{0}: {1} %", new object[] { event_name, (int)o });
                System.Windows.MessageBox.Show(msg2);
                _cts.Cancel();
                break;
        }
    });

protected override async void OnClick()
{
    var progDlg = new ProgressDialog("Running Geoprocessing Tool", "Cancel", 100, true);
    progDlg.Show();

    var progSrc = new CancelableProgressorSource(progDlg);
    string infc = @"D:\data\california\california.gdb\ca_highways";
    string outfc = System.IO.Path.Combine(ArcGIS.Desktop.Core.Project.Current.DefaultGeodatabasePath, 
                                                                        "Clipped_points");
    var parameters = Geoprocessing.MakeValueArray(infc, outfc);
    await Geoprocessing.ExecuteToolAsync("management.CopyFeatures", parameters,
        null, new CancelableProgressorSource(progDlg).Progressor, GPExecuteToolFlags.Default);

    progDlg.Hide();
}

// get the model tool's parameter syntax from the model's help 
string input_roads = @"C:\data\Input.gdb\PlanA_Roads";
string buff_dist_field = "Distance";   // use the distance values from a field named Distance
string input_vegetation = @"C:\data\Input.gdb\vegtype";
string output_data = @"C:\data\Output.gdb\ClippedFC2";

// the tool path can also be a relative path such as tool_path = @"Default.atbx\Script"
string tool_path = @"C:\data\CompletedModels.tbx\ExtractVegetationforProposedRoads";

var args = Geoprocessing.MakeValueArray(input_roads, buff_dist_field, input_vegetation, output_data);

return Geoprocessing.ExecuteToolAsync(tool_path, args);

// pass the full path of the service
string tool_path = @"C:\data\agsonline.ags\Network/ESRI_DriveTime_US\CreateDriveTimePolygons";
string in_point = @"C:\MyProject\MyProject.gdb\apoint";

var result = await Geoprocessing.ExecuteToolAsync(tool_path, Geoprocessing.MakeValueArray(in_point, "3 9 12"),null,CancelableProgressor.None, GPExecuteToolFlags.GPThread);

GPExecuteToolFlags.AddOutputsToMap
GPExecuteToolFlags.AddToHistory
GPExecuteToolFlags.RefreshProjectItems
GPExecuteToolFlags.Default

//On the UI thread
string input_points = @"C:\data\ca_ozone.gdb\ozone_points";
string output_polys = @"C:\data\ca_ozone.gdb\ozone_buff";
string buffer_dist = "2000 Meters";
var param_values = Geoprocessing.MakeValueArray(input_points, output_polys, buffer_dist);

Geoprocessing.OpenToolDialog("analysis.Buffer", param_values);

//On the UI thread
string input_points = @"C:\data\ca_ozone.gdb\ozone_points";
string output_polys = @"C:\data\ca_ozone.gdb\ozone_buff";
string buffer_dist = "";
var param_values = Geoprocessing.MakeValueArray(input_points, output_polys, buffer_dist);
 
Geoprocessing.OpenToolDialog("analysis.Buffer", param_values);

//On the UI
string input_points = "";
string output_polys = "";
string buffer_dist = "";
var param_values = Geoprocessing.MakeValueArray(input_points, output_polys, buffer_dist);
 
Geoprocessing.OpenToolDialog("analysis.Buffer", param_values);

 var mv = MapView.Active;

 //configure parameters on the QueuedTask
 var val_array = await QueuedTask.Run(() =>  {

    var center_pt = MapPointBuilderEx.CreateMapPoint(mv.Camera.X, mv.Camera.Y, mv.Camera.SpatialReference);
    var poly = GeometryEngine.Instance.Buffer(center_pt, 2000);
    //add the geometry to a list before parameterizing
    var geom_values = new List<object>() { poly };
     return Geoprocessing.MakeValueArray(new object[] { geom_values, null, @"1000 Meters" });

 });

 //show the tool dialog pre-populated with the parameter values on the UI thread
 Geoprocessing.OpenToolDialog("analysis.Buffer", val_array, null, false);

string tool_path = @"Default.atbx\Script";
Geoprocessing.OpenToolDialogAsync(tool_path );

// gp_result is the returned result object from a call to ExecuteToolAsync
// displays error messages if the tool fails, otherwise shows the default messages
Geoprocessing.ShowMessageBox(gp_result.Messages, "GP Messages", 
                gp_result.IsFailed ? GPMessageBoxStyle.Error : GPMessageBoxStyle.Default);

// Open a project with data inside
string openProjectPath = @"D\DATA"\IGPHistoryItemTestProject\IGPHistoryItemTestProject.aprx";
await Project.OpenAsync(openProjectPath); 

// Run  the Geoprocessing tool using the data in the project, remember to use GPExecuteToolFlags.AddToHistory to add the execution messages to History
MapProjectItem mapProjItem = Project.Current.GetItems<MapProjectItem>().FirstOrDefault(item => item.Name.Equals("Map", StringComparison.CurrentCultureIgnoreCase));
var map = await QueuedTask.Run(() => mapProjItem.GetMap());
var ftrLayer = map.Layers[0] as FeatureLayer;
string tool1 = "management.GetCount";     
var args1 = Geoprocessing.MakeValueArray(ftrLayer);
var env = Geoprocessing.MakeEnvironmentArray(overwriteoutput: true);          
GPExecuteToolFlags executeFlags = GPExecuteToolFlags.AddToHistory;
var t = await Geoprocessing.ExecuteToolAsync(tool1, args1,env,null,null,executeFlags);

// Get the IGPHistoryItem and its properties
String hitemID="";
String hitemToolPath="" ;
IGPResult hitemGPResult=null;
DateTime hitemTimeStamp;

foreach (var hitem in hisItems)
{
    // common IGPHistoryItem and Item properties
    hitemID = (hitem as Item).ID;
    hitemToolPath = hitem.ToolPath;
    hitemGPResult = hitem.GPResult;
    hitemTimeStamp = hitem.TimeStamp;
}

## Handle Geoprocessing event

ArcGIS.Desktop.Core.Events.GPExecuteToolEvent and GPExecuteToolEventArgs can be used to handle Geoprocessing event. 
```csharp
ArcGIS.Desktop.Core.Events.GPExecuteToolEvent.Subscribe(e =>
            {
                string id = e.ID;                   // Same as history ID
                if (e.IsStarting == false)  // Execute completed
                    _ = e.GPResult.ReturnValue;
                System.Windows.MessageBox.Show("event triggered.");
            });
var t = await Geoprocessing.ExecuteToolAsync("management.GetCount", Core.Geoprocessing.Geoprocessing.MakeValueArray(@"c:\shape_file.shp"));

object myCommand = "python " + @"C:\scripts\test1.py";
System.Diagnostics.ProcessStartInfo procStartInfo = 
               new System.Diagnostics.ProcessStartInfo("cmd", "/c" + myCommand );

procStartInfo.RedirectStandardOutput = true;
procStartInfo.UseShellExecute = false;
procStartInfo.CreateNoWindow = true;

System.Diagnostics.Process proc = new System.Diagnostics.Process();
proc.StartInfo = procStartInfo;
proc.Start();

string result = proc.StandardOutput.ReadToEnd();

System.Windows.MessageBox.Show(result);

 //ArcGIS.Desktop.Core.GeoprocessingOptions 
 //Gets and sets the available application geoprocessing options
 public class GeoprocessingOptions {
   //Gets whether geoprocessing tools can overwrite existing data, layers, or files when run.
   public bool OverwriteExistingDatasets { get; }
   //Gets whether layers in a map are removed if their source datasets are deleted
   //by a geoprocessing tool that overwrites output.
   public bool RemoveOverwrittenLayers { get; }
   //Gets whether output datasets created by geoprocessing tools should be automatically
   //added to an open map.
   public bool AddOutputDatasetsToOpenMap { get; }
   //Gets whether the tools being run are added to the current project's geoprocessing history.
   public bool WriteGPOperationsToHistory { get; }

   //Sets whether geoprocessing tools can overwrite existing data, layers, or files
   //when run. This method must be called on the MCT. Use QueuedTask.Run.
   public void SetOverwriteExistingDatasets(bool overwriteExistingDatasets);

   //Sets whether layers in a map are removed if their source datasets are deleted by a geoprocessing 
   //tool that overwrites output. This method must be called on the MCT. Use QueuedTask.Run.
   public void SetRemoveOverwrittenLayers(bool removeOverwrittenLayers);

   //Sets whether output datasets created by geoprocessing tools should be automatically
   //added to an open map. This method must be called on the MCT. Use QueuedTask.Run.
   public void SetAddOutputDatasetsToOpenMap(bool addOutputDatasetsToOpenMap);

   //Sets whether the tools being run are added to the current project's geoprocessing
   //history. This method must be called on the MCT. Use QueuedTask.Run.
   public void SetWriteGPOperationsToHistory(bool writeGPOperationsToHistory);	
}

 //Get the current option values
 var overwrite_gp = ApplicationOptions.GeoprocessingOptions.OverwriteExistingDatasets;
 var remove_gp = ApplicationOptions.GeoprocessingOptions.RemoveOverwrittenLayers;
 var addoutput_gp = ApplicationOptions.GeoprocessingOptions.AddOutputDatasetsToOpenMap;
 var history_gp = ApplicationOptions.GeoprocessingOptions.WriteGPOperationsToHistory;

 //Setting GeoprocessingOptions requires the QueuedTask. We are modifying the behavior
 //of interactive GP tools _only_.
 QueuedTask.Run(() => {
   ApplicationOptions.GeoprocessingOptions.SetOverwriteExistingDatasets(true);
   ApplicationOptions.GeoprocessingOptions.SetRemoveOverwrittenLayers(false);
   ApplicationOptions.GeoprocessingOptions.SetAddOutputDatasetsToOpenMap(true);
   ApplicationOptions.GeoprocessingOptions.SetWriteGPOperationsToHistory(false);
 });