private async void OnDrop3D(DropInfo dropInfo) { string xlsName = dropInfo.Items[0].Data.ToString(); string xlsLayerName = Module1.GetUniqueLayerName(xlsName); string xlsSheetName = Module1.GetUniqueStandaloneTableName(xlsName); string xlsTableName = xlsName + "\\" + xlsSheetName; // set overwrite flag var environments = Geoprocessing.MakeEnvironmentArray(overwriteoutput: true); #region await Geoprocessing.ExecuteToolAsync(MakeXYEventLayer_management) var result = await Geoprocessing.ExecuteToolAsync("MakeXYEventLayer_management", new string[] { xlsTableName, "POINT_X", "POINT_Y", xlsLayerName, "WGS_1984" }, environments); #endregion #region await Geoprocessing.ExecuteToolAsync(ApplySymbologyFromLayer_management) result = await Geoprocessing.ExecuteToolAsync("ApplySymbologyFromLayer_management", new string[] { xlsLayerName, @"C:\Data\SDK\Default3DPointSymbols.lyrx" }); #endregion }
public async Task <bool> ExportKMLLayer(string layerName, string outputPath) { bool success = false; await QueuedTask.Run(async() => { List <object> arguments = new List <object>(); // TODO: if the user moves or renames this group, this layer name may no longer be valid arguments.Add("Distance And Direction" + @"\" + layerName); arguments.Add(outputPath); var parameters = Geoprocessing.MakeValueArray(arguments.ToArray()); var environments = Geoprocessing.MakeEnvironmentArray(overwriteoutput: true); string gpTool = "LayerToKML_conversion"; IGPResult result = await Geoprocessing.ExecuteToolAsync( gpTool, parameters, environments, null, null, GPExecuteToolFlags.Default); success = CheckResultAndReportMessages(result, gpTool, arguments); }); return(success); }
public static async Task <IList <double> > GetDemStatsAsync(string aoiPath, string maskPath, double adjustmentFactor) { IList <double> returnList = new List <double>(); try { string sDemPath = GeodatabaseTools.GetGeodatabasePath(aoiPath, GeodatabaseNames.Surfaces, true) + Constants.FILE_DEM_FILLED; double dblMin = -1; var parameters = Geoprocessing.MakeValueArray(sDemPath, "MINIMUM"); var environments = Geoprocessing.MakeEnvironmentArray(workspace: aoiPath, mask: maskPath); IGPResult gpResult = await Geoprocessing.ExecuteToolAsync("GetRasterProperties_management", parameters, environments, CancelableProgressor.None, GPExecuteToolFlags.AddToHistory); bool success = Double.TryParse(Convert.ToString(gpResult.ReturnValue), out dblMin); returnList.Add(dblMin - adjustmentFactor); double dblMax = -1; parameters = Geoprocessing.MakeValueArray(sDemPath, "MAXIMUM"); gpResult = await Geoprocessing.ExecuteToolAsync("GetRasterProperties_management", parameters, environments, CancelableProgressor.None, GPExecuteToolFlags.AddToHistory); success = Double.TryParse(Convert.ToString(gpResult.ReturnValue), out dblMax); returnList.Add(dblMax + adjustmentFactor); } catch (Exception e) { Module1.Current.ModuleLogManager.LogError(nameof(GetDemStatsAsync), "Exception: " + e.Message); } return(returnList); }
public static async Task <BA_ReturnCode> ClipRasterAsync(string strInputRaster, string strRectangle, string strOutputRaster, string strTemplateDataset, string strNoDataValue, bool bUseClippingGeometry, string strWorkspace, string strSnapRaster) { string strClippingGeometry = "NONE"; if (bUseClippingGeometry == true) { strClippingGeometry = "ClippingGeometry"; } IGPResult gpResult = await QueuedTask.Run(() => { var environments = Geoprocessing.MakeEnvironmentArray(workspace: strWorkspace, snapRaster: strSnapRaster); var parameters = Geoprocessing.MakeValueArray(strInputRaster, strRectangle, strOutputRaster, strTemplateDataset, strNoDataValue, strClippingGeometry); return(Geoprocessing.ExecuteToolAsync("Clip_management", parameters, null, CancelableProgressor.None, GPExecuteToolFlags.AddToHistory)); }); if (gpResult.IsFailed) { return(BA_ReturnCode.UnknownError); } else { return(BA_ReturnCode.Success); } }
private static async Task <string> CreateTheXYEventLayer(DropInfo dropInfo) { string xlsName = dropInfo.Items[0].Data.ToString(); string xlsLayerName = Module1.GetUniqueLayerName(xlsName); string xlsTableName = null; if (xlsName.ToUpper().EndsWith(".CSV")) { xlsTableName = xlsName; } else { string xlsSheetName = Module1.GetUniqueStandaloneTableName(xlsName); xlsTableName = xlsName + "\\" + xlsSheetName; } // set overwrite flag var environments = Geoprocessing.MakeEnvironmentArray(overwriteoutput: true); #region Geoprocessing.ExecuteToolAsync(MakeXYEventLayer_management) var result = await Geoprocessing.ExecuteToolAsync("MakeXYEventLayer_management", new string[] { xlsTableName, "X", "Y", xlsLayerName, "WGS_1984" }, environments); #endregion return(xlsLayerName); }
private async Task <bool> ExecuteAddFieldTool(BasicFeatureLayer theLayer, KeyValuePair <string, string> field, string fieldType, int?fieldLength = null, bool isNullable = true) { try { return(await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() => { var inTable = theLayer.Name; var table = theLayer.GetTable(); var dataStore = table.GetDatastore(); var workspaceNameDef = dataStore.GetConnectionString(); var workspaceName = workspaceNameDef.Split('=')[1]; var fullSpec = System.IO.Path.Combine(workspaceName, inTable); System.Diagnostics.Debug.WriteLine($@"Add {field.Key} from {fullSpec}"); var parameters = Geoprocessing.MakeValueArray(inTable, field.Key, fieldType.ToUpper(), null, null, fieldLength, field.Value, isNullable ? "NULABLE" : "NON_NULLABLE"); var env = Geoprocessing.MakeEnvironmentArray(workspace: workspaceName); var cts = new CancellationTokenSource(); var results = Geoprocessing.ExecuteToolAsync("management.AddField", parameters, env, cts.Token, (eventName, o) => { System.Diagnostics.Debug.WriteLine($@"GP event: {eventName}"); }); return true; })); } catch (Exception ex) { MessageBox.Show(ex.ToString()); return(false); } }
public static async Task <BA_ReturnCode> CreateGeodatabaseFoldersAsync(string strAoiPath, FolderType fType) { BA_ReturnCode success = BA_ReturnCode.UnknownError; await QueuedTask.Run(() => { var environments = Geoprocessing.MakeEnvironmentArray(workspace: strAoiPath); string[] arrGeodatabaseNames = GeodatabaseNames.AllNames; if (fType == FolderType.BASIN) { arrGeodatabaseNames = GeodatabaseNames.BasinNames; } { foreach (var item in arrGeodatabaseNames) { var parameters = Geoprocessing.MakeValueArray(strAoiPath, item); var gpResult = Geoprocessing.ExecuteToolAsync("CreateFileGDB_management", parameters, environments, CancelableProgressor.None, GPExecuteToolFlags.AddToHistory); if (gpResult.Result.IsFailed) { Module1.Current.ModuleLogManager.LogError(nameof(CreateGeodatabaseFoldersAsync), "Unable to create file geodatabase. Error code: " + gpResult.Result.ErrorCode); } else { success = BA_ReturnCode.Success; } } } }); return(success); }
public static async Task <IList <double> > GetDemStatsAsync(string aoiPath, double adjustmentFactor) { IList <double> returnList = new List <double>(); try { string sMask = GeodatabaseTools.GetGeodatabasePath(aoiPath, GeodatabaseNames.Aoi, true) + Constants.FILE_AOI_VECTOR; string sDemPath = GeodatabaseTools.GetGeodatabasePath(aoiPath, GeodatabaseNames.Surfaces, true) + Constants.FILE_DEM_FILLED; double dblMin = -1; var parameters = Geoprocessing.MakeValueArray(sDemPath, "MINIMUM"); var environments = Geoprocessing.MakeEnvironmentArray(workspace: aoiPath, mask: sMask); IGPResult gpResult = await Geoprocessing.ExecuteToolAsync("GetRasterProperties_management", parameters, environments, ArcGIS.Desktop.Framework.Threading.Tasks.CancelableProgressor.None, GPExecuteToolFlags.AddToHistory); bool success = Double.TryParse(Convert.ToString(gpResult.ReturnValue), out dblMin); returnList.Add(dblMin - adjustmentFactor); double dblMax = -1; parameters = Geoprocessing.MakeValueArray(sDemPath, "MAXIMUM"); gpResult = await Geoprocessing.ExecuteToolAsync("GetRasterProperties_management", parameters, environments, ArcGIS.Desktop.Framework.Threading.Tasks.CancelableProgressor.None, GPExecuteToolFlags.AddToHistory); success = Double.TryParse(Convert.ToString(gpResult.ReturnValue), out dblMax); returnList.Add(dblMax + adjustmentFactor); } catch (Exception e) { Debug.WriteLine("GetDemStatsAsync: " + e.Message); } return(returnList); }
public async Task <IGPResult> Execute_ApplySymbologyFromFeatureLayer() { var environments = Geoprocessing.MakeEnvironmentArray(overwriteoutput: true); var prj = Project.Current; var map = MapView.Active; var featLayers = map.Map.Layers.OfType <FeatureLayer>().Where(l => l.Name.StartsWith("Crimes", StringComparison.OrdinalIgnoreCase)); if (featLayers.Count() < 1) { MessageBox.Show("Unable to find Crimes layer: the topmost Crime layer is the target layer for the symbology, the symbology source is a lyrx file"); return(null); } // the first layer in TOC is without any symbology FeatureLayer targetLayer = featLayers.ElementAt(0); // the second layer has the symbology // symbology from the 2nd layer will be applied to the first layer //Create instance of BrowseProjectFilter using the id for Pro's Lyrx files filter BrowseProjectFilter bf = new BrowseProjectFilter("esri_browseDialogFilters_layers_lyrx"); //Display the filter in an Open Item dialog OpenItemDialog lyrxOpenDlg = new OpenItemDialog { Title = "Symbology Input Layer", MultiSelect = false, BrowseFilter = bf }; bool?ok = lyrxOpenDlg.ShowDialog(); if (!ok.HasValue || !ok.Value) { return(null); } // Full path for the lyrx file var lryxItem = lyrxOpenDlg.Items.FirstOrDefault().Path; var sourceField = "Major_Offense_Type"; var targetField = "Major_Offense_Type"; var fieldType = "VALUE_FIELD"; String fieldInfo = String.Format("{0} {1} {2}", fieldType, sourceField, targetField); // VALUE_FIELD NAME NAME") MessageBox.Show("Field Info for symbology: " + fieldInfo); var parameters = Geoprocessing.MakeValueArray(targetLayer, lryxItem, fieldInfo); //, symbologyFields, updateSymbology); // Does not Add outputs to Map as GPExecuteToolFlags.AddOutputsToMap is not used GPExecuteToolFlags executeFlags = GPExecuteToolFlags.RefreshProjectItems | GPExecuteToolFlags.GPThread | GPExecuteToolFlags.AddToHistory; IGPResult result = await Geoprocessing.ExecuteToolAsync("ApplySymbologyFromLayer_management", parameters, null, null, null, executeFlags); return(result); }
private async void OpenEucDistance() { await CommonMethod.OpenMap(ConstDefintion.ConstMap_SpaceAnalyzeMap); string projectDir = System.IO.Path.GetDirectoryName(Project.Current.Path); string path = projectDir + "\\" + ConstDefintion.ConstRaster_RaderRangeDsName; Envelope env = CommonMethod.GetRasterExtent(path).Result; var environments = Geoprocessing.MakeEnvironmentArray(extent: env, mask: ConstDefintion.ConstLayer_RaderRangeLayerName);; Geoprocessing.OpenToolDialog("sa.EucDistance", null, environments, true, null); }
public async Task IntersectTest() { IGPResult gpResult = null; Geometry lijnShape = null; Geometry buffer50Shape = null; Geometry buffer150Shape = null; FeatureLayer lineLayer = _map.Layers.First(layer => layer.Name.Equals("Lines")) as FeatureLayer; await QueuedTask.Run(async() => { FeatureLayer pointLayer = _map.Layers.First(layer => layer.Name.Equals("Points")) as FeatureLayer; string FLPath = pointLayer.GetFeatureClass().GetDatastore().GetPath().AbsolutePath; var FLPathCombine = Path.GetFullPath(FLPath); string name = pointLayer.GetFeatureClass().GetName(); string infc = Path.Combine(FLPathCombine, name); string outfc = Path.Combine(FLPathCombine, $"Buffer_{pointLayer.Name}_50"); // Place parameters into an array var parameters = Geoprocessing.MakeValueArray(infc, outfc, "50 Meter"); // Place environment settings in an array, in this case, OK to over-write var environments = Geoprocessing.MakeEnvironmentArray(overwriteoutput: true); // Execute the GP tool with parameters gpResult = await Geoprocessing.ExecuteToolAsync("Buffer_analysis", parameters, environments); var gdb = pointLayer.GetTable().GetDatastore() as Geodatabase; var fclBuffer50 = gdb.OpenDataset <FeatureClass>("Buffer_Points_50"); outfc = Path.Combine(FLPathCombine, $"Buffer_{pointLayer.Name}_150"); parameters = Geoprocessing.MakeValueArray(infc, outfc, "150 Meter"); gpResult = await Geoprocessing.ExecuteToolAsync("Buffer_analysis", parameters, environments); var fclBuffer150 = gdb.OpenDataset <FeatureClass>("Buffer_Points_150"); var temp = lineLayer.Search(); temp.MoveNext(); lijnShape = (temp.Current as Feature).GetShape(); temp = fclBuffer50.Search(); temp.MoveNext(); buffer50Shape = (temp.Current as Feature).GetShape(); temp = fclBuffer150.Search(); temp.MoveNext(); buffer150Shape = (temp.Current as Feature).GetShape(); }); Assert.IsNotNull(gpResult, "GPResult is null"); Assert.AreEqual(0, gpResult.ErrorCode, "GP Tool failed or cancelled"); Assert.IsTrue(GeometryEngine.Instance.Intersects(lijnShape, buffer150Shape), "De punten en lijnen intersecten niet op 150 meter"); Assert.IsTrue(GeometryEngine.Instance.Intersects(lijnShape, buffer50Shape), "De punten en lijnen intersecten niet op 50 meter"); }
private static async Task CreateFeatureClass(string dataset, string connection, SpatialReference spatialRef, List <MapPoint> mapPointList, MapView mapview, bool isKML = false) { try { List <object> arguments = new List <object>(); // store the results in the geodatabase arguments.Add(connection); // name of the feature class arguments.Add(dataset); // type of geometry arguments.Add("POINT"); // no template arguments.Add(""); // m values arguments.Add("DISABLED"); // no z values arguments.Add("DISABLED"); arguments.Add(spatialRef); var env = Geoprocessing.MakeEnvironmentArray(overwriteoutput: true); var valueArray = Geoprocessing.MakeValueArray(arguments.ToArray()); IGPResult result = await Geoprocessing.ExecuteToolAsync("CreateFeatureclass_management", valueArray, env, null, null, GPExecuteToolFlags.Default); await CreateFeatures(mapPointList); if (isKML) { await KMLUtils.ConvertLayerToKML(connection, dataset, MapView.Active); // Delete temporary Shapefile string[] extensionNames = { ".cpg", ".dbf", ".prj", ".shx", ".shp" }; string datasetNoExtension = Path.GetFileNameWithoutExtension(dataset); foreach (string extension in extensionNames) { string shapeFile = Path.Combine(connection, datasetNoExtension + extension); File.Delete(shapeFile); } } } catch (Exception ex) { MessageBox.Show(ex.ToString()); } }
//TODO: Fetch is required if <b>IsContainer</b> = <b>true</b> //public override void Fetch() // { //TODO Retrieve your child items //TODO child items must also derive from CustomItemBase //this.AddRangeToChildren(children); // } private async void CSVToPointFC(string path) { //Get the folder path string folderPath = System.IO.Path.GetDirectoryName(path); System.Diagnostics.Debug.WriteLine($"folderPath: {folderPath}"); var fileNameWithoutExtension = System.IO.Path.GetFileNameWithoutExtension(path); System.Diagnostics.Debug.WriteLine($"fileNameWithoutExtension: {fileNameWithoutExtension}"); //csv var csvFileName = $"{fileNameWithoutExtension}.csv"; var csvFullPath = $@"{System.IO.Path.Combine(folderPath, csvFileName)}"; //Delete the csv System.IO.File.Delete(csvFullPath);// C:\Users\uma2526\Documents\ArcGIS\Projects\CustomItemTest\AlaskaCitiesXY.csv"); System.Diagnostics.Debug.WriteLine($"Delete: {csvFullPath}"); //rename .uxh (custom item) to .csv. GP Tool only works with CSV files System.IO.File.Copy($@"{path}", csvFullPath, true); System.Diagnostics.Debug.WriteLine($"Rename: {csvFullPath}"); //args for GP Tool string input_table = @"C:\Users\uma2526\Documents\ArcGIS\Projects\CustomItemTest\AlaskaCitiesXY.csv"; var gbd = Project.Current.GetItems <GDBProjectItem>().FirstOrDefault().Path; string outputFC = $@"{gbd}\AlaskaCitiesPointConv"; string XField = "POINT_X"; string YField = "POINT_Y"; var sr = MapView.Active.Map.SpatialReference; var environments = Geoprocessing.MakeEnvironmentArray(overwriteoutput: true); var cts = new CancellationTokenSource(); //Make the GP Tool arg array var args = Geoprocessing.MakeValueArray(input_table, outputFC, XField, YField, "", sr); //Execute _ = await Geoprocessing.ExecuteToolAsync("XYTableToPoint_management", args, environments, cts.Token, (eventName, o) => { System.Diagnostics.Debug.WriteLine($@"GP event: {eventName}"); }, GPExecuteToolFlags.None); //No action is taken, so the new Feature class doesn't get added to the map }
public static async Task <BA_ReturnCode> IntersectUnrankedAsync(string strWorkspace, string[] arrInputLayers, string outputLayerPath, string joinAttributes) { IGPResult gpResult = await QueuedTask.Run(() => { var environments = Geoprocessing.MakeEnvironmentArray(workspace: strWorkspace); var parameters = Geoprocessing.MakeValueArray(arrInputLayers, outputLayerPath, joinAttributes); return(Geoprocessing.ExecuteToolAsync("Intersect_analysis", parameters, null, CancelableProgressor.None, GPExecuteToolFlags.AddToHistory)); }); if (gpResult.IsFailed) { return(BA_ReturnCode.UnknownError); } else { return(BA_ReturnCode.Success); } }
public static async Task <BA_ReturnCode> CopyFeaturesAsync(string strWorkspace, string copyFeatures, string outputFeatures) { IGPResult gpResult = await QueuedTask.Run(() => { var environments = Geoprocessing.MakeEnvironmentArray(workspace: strWorkspace); var parameters = Geoprocessing.MakeValueArray(copyFeatures, outputFeatures); return(Geoprocessing.ExecuteToolAsync("CopyFeatures_management", parameters, environments, CancelableProgressor.None, GPExecuteToolFlags.AddToHistory)); }); if (gpResult.IsFailed) { return(BA_ReturnCode.UnknownError); } else { return(BA_ReturnCode.Success); } }
// Snap Environment // Snap a line to polygon EDGE, END of another line and to points VERTEX // protected override async void OnClick() { GPExecuteToolFlags executeFlags = GPExecuteToolFlags.AddOutputsToMap | GPExecuteToolFlags.GPThread | GPExecuteToolFlags.AddToHistory; string toolName = "edit.Snap"; var environments = Geoprocessing.MakeEnvironmentArray(overwriteoutput: true); // make a copy of the input data - this data will be snapped to data specified in snap environment var inputFeatures = @"C:\\data\Snapping.gdb\otherline"; // snapEnvironment parameter is of ValueTable type var snapEnvironments = @"C:\\data\Snapping.gdb\poly EDGE '15 Meters';C:\\data\Snapping.gdb\line END '15 Meters';C:\\data\Snapping.gdb\points VERTEX '18 Meters'"; var parameters2 = Geoprocessing.MakeValueArray(inputFeatures, snapEnvironments); var gpResult = await Geoprocessing.ExecuteToolAsync(toolName, parameters2, environments, null, null, executeFlags); Geoprocessing.ShowMessageBox(gpResult.Messages, "GP Messages", gpResult.IsFailed ? GPMessageBoxStyle.Error : GPMessageBoxStyle.Default); }
private async void OnDrop2D(DropInfo dropInfo) { string xlsName = dropInfo.Items[0].Data.ToString(); string xlsLayerName = Module1.GetUniqueLayerName(xlsName); string xlsSheetName = Module1.GetUniqueStandaloneTableName(xlsName); string xlsTableName = xlsName + "\\" + xlsSheetName; // set overwrite flag var environments = Geoprocessing.MakeEnvironmentArray(overwriteoutput: true); //To use Excel files in Pro, you need Microsoft Access Database Engine 2016. //Refer to the Pro Help topic "Work with Microsoft Excel files" for more information on dowloading the required driver. //https://pro.arcgis.com/en/pro-app/help/data/excel/work-with-excel-in-arcgis-pro.htm #region Geoprocessing.ExecuteToolAsync(MakeXYEventLayer_management) var cts = new CancellationTokenSource(); var result = await Geoprocessing.ExecuteToolAsync("MakeXYEventLayer_management", new string[] { xlsTableName, "POINT_X", "POINT_Y", xlsLayerName, "WGS_1984" }, environments, cts.Token, (eventName, o) => { System.Diagnostics.Debug.WriteLine($@"GP event: {eventName}"); }); #endregion #region Assign Symbology (from Location layer) var featureLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType <FeatureLayer>().Where(fl => fl.Name.Contains(xlsLayerName)).FirstOrDefault(); await ModifyLayerSymbologyFromLyrFileAsync(featureLayer, @"C:\Data\SDK\Default2DPointSymbols.lyrx"); // @"C:\Data\SDK\Default2DPointSymbols.lyrx" #endregion }
protected override async void OnClick() { await QueuedTask.Run(async() => { var pointLayer = (MapView.Active.Map.Layers.First(layer => layer.Name.Equals("Points")) as FeatureLayer); if (pointLayer == null) { MessageBox.Show("Point layer can not be found...", "Error", System.Windows.MessageBoxButton.OK); return; } try { // Get the path to the layer's feature class and path to a new 200-foot buffer feature class string FLPath = pointLayer.GetFeatureClass().GetDatastore().GetPath().AbsolutePath; var FLPathCombine = Path.GetFullPath(FLPath); string name = pointLayer.GetFeatureClass().GetName(); string infc = Path.Combine(FLPathCombine, name); string outfc = Path.Combine(FLPathCombine, "Buffer_" + pointLayer.Name); // Place parameters into an array var parameters = Geoprocessing.MakeValueArray(infc, outfc, "100 Meter"); // Place environment settings in an array, in this case, OK to over-write var environments = Geoprocessing.MakeEnvironmentArray(overwriteoutput: true); // Execute the GP tool with parameters var gpResult = await Geoprocessing.ExecuteToolAsync("Buffer_analysis", parameters, environments); // Show a messagebox with the results Geoprocessing.ShowMessageBox(gpResult.Messages, "GP Meldingen", gpResult.IsFailed ? GPMessageBoxStyle.Error : GPMessageBoxStyle.Default); MessageBox.Show("Lets Unit test here.."); } catch (Exception exc) { // Catch any exception found and display in a message box MessageBox.Show("Exception caught while trying to run GP tool: " + exc.Message); return; } }); }
public async Task BufferPointLayerTest() { IGPResult gpResult = null; await QueuedTask.Run(async() => { FeatureLayer pointLayer = _map.Layers.First(layer => layer.Name.Equals("Points")) as FeatureLayer; string FLPath = pointLayer.GetFeatureClass().GetDatastore().GetPath().AbsolutePath; var FLPathCombine = Path.GetFullPath(FLPath); string name = pointLayer.GetFeatureClass().GetName(); string infc = Path.Combine(FLPathCombine, name); string outfc = Path.Combine(FLPathCombine, "Buffer_" + pointLayer.Name); // Place parameters into an array var parameters = Geoprocessing.MakeValueArray(infc, outfc, "100 Meter"); // Place environment settings in an array, in this case, OK to over-write var environments = Geoprocessing.MakeEnvironmentArray(overwriteoutput: true); // Execute the GP tool with parameters gpResult = await Geoprocessing.ExecuteToolAsync("Buffer_analysis", parameters, environments); }); Assert.IsNotNull(gpResult, "GPResult is null"); Assert.AreEqual(0, gpResult.ErrorCode, "GP Tool failed or cancelled"); }
public async Task <IGPResult> ExecuteSnap() { var environments = Geoprocessing.MakeEnvironmentArray(overwriteoutput: true); string toolName = @"Snap_edit"; // Snap tool takes multiple inputs each of which has // Three (3) parts: a feature class or layer, a string value and a distance // Each part is separated by a semicolon - you can get example of sytax from the tool documentation page var snapEnv = @"'C:/SnapProject/fgdb.gdb/line_1' END '2 Meters';'C:/SnapProject/fgdb.gdb/points_1' VERTEX '1 Meters';'C:/SnapProject/fgdb.gdb/otherline_1' END '20 Meters'"; var parameters = await QueuedTask.Run(() => { var infc = @"C:/SnapProject/fgdb.gdb/poly_1"; return(Geoprocessing.MakeValueArray(infc, snapEnv)); }); GPExecuteToolFlags tokens = GPExecuteToolFlags.RefreshProjectItems | GPExecuteToolFlags.GPThread | GPExecuteToolFlags.AddToHistory; var gpResult = await Geoprocessing.ExecuteToolAsync(toolName, parameters, environments, null, null, flags : tokens); return(gpResult); }
private static async Task <bool> ExecuteAsync([NotNull] string tool, [NotNull] IReadOnlyList <string> parameters) { Assert.ArgumentNotNullOrEmpty(tool, nameof(tool)); Assert.ArgumentNotNull(parameters, nameof(parameters)); Assert.ArgumentCondition(parameters.Count > 0, "no parameter"); _msg.VerboseDebug($"{tool}, Parameters: {StringUtils.Concatenate(parameters, ", ")}"); IReadOnlyList <KeyValuePair <string, string> > environments = Geoprocessing.MakeEnvironmentArray(overwriteoutput: true); IGPResult result = await Geoprocessing.ExecuteToolAsync(tool, parameters, environments); if (!result.IsFailed) { return(true); } _msg.Info( $"{tool} has failed: {StringUtils.Concatenate(Format(result.Messages), ", ")}, Parameters: {StringUtils.Concatenate(parameters, ", ")}"); return(false); }
public async Task <IGPResult> Execute_ApplySymbologyFromFeatureLayer() { var environments = Geoprocessing.MakeEnvironmentArray(overwriteoutput: true); var prj = Project.Current; var map = MapView.Active; if (map == null) { throw new Exception("No active map found!"); } var featLayers = map.Map.Layers.OfType <FeatureLayer>(); // the first layer in TOC is WITHOUT any symbology FeatureLayer targetLayer = featLayers.ElementAt(0); // the second layer HAS the symbology // symbology from the 2nd layer will be applied to the first layer FeatureLayer symbologyLayer = featLayers.ElementAt(1); // Make sure you have fields with the POP2000 name. var sourceField = "POP2000"; var targetField = "POP2000"; var fieldType = "VALUE_FIELD"; String fieldInfo = String.Format("{0} {1} {2}", fieldType, sourceField, targetField); // VALUE_FIELD NAME NAME") MessageBox.Show(fieldInfo); var parameters = Geoprocessing.MakeValueArray(targetLayer, symbologyLayer, fieldInfo); //, symbologyFields, updateSymbology); // Does not Add outputs to Map as GPExecuteToolFlags.AddOutputsToMap is not used GPExecuteToolFlags executeFlags = GPExecuteToolFlags.RefreshProjectItems | GPExecuteToolFlags.GPThread | GPExecuteToolFlags.AddToHistory; IGPResult result = await Geoprocessing.ExecuteToolAsync("ApplySymbologyFromLayer_management", parameters, null, null, null, executeFlags); return(result); }
// Setting environments, MakeEnvironmentArray public async void SetEnvironment() // Task<IGPResult> { #region gp_environments // get the syntax of the tool from Python window or from tool help page string in_features = @"C:\data\data.gdb\HighwaysWeb84"; string out_features = @"C:\data\data.gdb\HighwaysUTM"; var param_values = Geoprocessing.MakeValueArray(in_features, out_features); // crate the spatial reference object to pass as an argument to management.CopyFeatures tool var sp_ref = await QueuedTask.Run(() => { return(SpatialReferenceBuilder.CreateSpatialReference(26911)); // UTM 83 11N: 26911 }); // set output coordinate system environment var environments = Geoprocessing.MakeEnvironmentArray(outputCoordinateSystem: sp_ref); // set environments in the 3rd parameter var gp_result = await Geoprocessing.ExecuteToolAsync("management.CopyFeatures", param_values, environments, null, null, GPExecuteToolFlags.AddOutputsToMap); Geoprocessing.ShowMessageBox(gp_result.Messages, "Contents", GPMessageBoxStyle.Default, "Window Title"); //return gp_result; #endregion }
public override async Task <Table> ConvertCSVToTable(string inputPath, string outPath, string outName) { //ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Override for Biodiversidad has been done"); var progressDlg = new ProgressDialog("Leyendo datos del archivo CSV seleccionado", "Cancelar", false); progressDlg.Show(); var parameters_totable = Geoprocessing.MakeValueArray(inputPath, outPath, outName); var result_totable = await Geoprocessing.ExecuteToolAsync("conversion.TableToTable", parameters_totable, null, new CancelableProgressorSource(progressDlg).Progressor, GPExecuteToolFlags.None); var parameters_toxylayer = Geoprocessing.MakeValueArray(inputPath, "longitud", "latitud", "bioxy" + outName); var environments_xy = Geoprocessing.MakeEnvironmentArray(overwriteoutput: true, workspace: outPath); var result_toxylayer = await Geoprocessing.ExecuteToolAsync("management.MakeXYEventLayer", parameters_toxylayer, environments_xy, new CancelableProgressorSource(progressDlg).Progressor, GPExecuteToolFlags.None); var layer = result_toxylayer.Values[0]; var fc_name = "bio" + outName; var parameters_tofc = Geoprocessing.MakeValueArray(layer, outPath, fc_name); var environments_tofc = Geoprocessing.MakeEnvironmentArray(overwriteoutput: true, workspace: outPath); var result_tofc = await Geoprocessing.ExecuteToolAsync("conversion.FeatureClassToFeatureClass", parameters_tofc, environments_tofc, new CancelableProgressorSource(progressDlg).Progressor, GPExecuteToolFlags.None); var table = await QueuedTask.Run(() => { var geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(outPath))); Table tbl = geodatabase.OpenDataset <FeatureClass>(fc_name); return(tbl); }); Type = "File Geodatabase Feature Class"; progressDlg.Hide(); return(table); }
protected override async void OnClick() { await QueuedTask.Run(async() => { // Check to see if the selected layer is a feature layer, if not, then prompt and exit. if (!(MapView.Active.GetSelectedLayers().First() is FeatureLayer featLayer)) { MessageBox.Show("Selecteer een feature layer in de Contents pane.", "Info"); return; } try { // Get the path to the layer's feature class and path to a new 200-foot buffer feature class string FLPath = featLayer.GetFeatureClass().GetDatastore().GetPath().AbsolutePath; var FLPathCombine = Path.GetFullPath(FLPath); string name = featLayer.GetFeatureClass().GetName(); string infc = Path.Combine(FLPathCombine, name); string outfc = Path.Combine(FLPathCombine, "Buffer_" + featLayer.Name); // Place parameters into an array var parameters = Geoprocessing.MakeValueArray(infc, outfc, "100 Meter"); // Place environment settings in an array, in this case, OK to over-write var environments = Geoprocessing.MakeEnvironmentArray(overwriteoutput: true); // Execute the GP tool with parameters var gpResult = await Geoprocessing.ExecuteToolAsync("Buffer_analysis", parameters, environments); // Show a messagebox with the results Geoprocessing.ShowMessageBox(gpResult.Messages, "GP Meldingen", gpResult.IsFailed ? GPMessageBoxStyle.Error : GPMessageBoxStyle.Default); } catch (Exception exc) { // Catch any exception found and display in a message box MessageBox.Show("Exception caught while trying to run GP tool: " + exc.Message); return; } }); }
protected override async void OnClick() { string databasePath = @"E:\GISTech\2021\ProProjects\GPSTracks\GPSTracks.gdb"; string gpxFile = @"E:\GISTech\2021\ProScripts\clubrit.gpx"; string outfc = Path.Combine(databasePath, "GPSTracks"); await QueuedTask.Run(async() => { try { // Place parameters into an array var parameters = Geoprocessing.MakeValueArray(gpxFile, outfc); // Place environment settings in an array, in this case, OK to over-write var environments = Geoprocessing.MakeEnvironmentArray(overwriteoutput: true); // Execute the GP tool with parameters var gpResult = await Geoprocessing.ExecuteToolAsync("GPXtoFeatures_conversion", parameters, environments); if (gpResult.IsFailed == false) { parameters = Geoprocessing.MakeValueArray(outfc, "NEW_SELECTION", "\"Type\" = 'TRKPT'"); gpResult = await Geoprocessing.ExecuteToolAsync("SelectLayerByAttribute_management", parameters, environments, null, null, GPExecuteToolFlags.None); if (gpResult.IsFailed != true) { parameters = Geoprocessing.MakeValueArray(outfc, Path.Combine(databasePath, "MyRide"), "Name"); gpResult = await Geoprocessing.ExecuteToolAsync("PointsToLine_management", parameters, environments); } } } catch (Exception exc) { // Catch any exception found and display in a message box MessageBox.Show("Exception caught while trying to run GP tool: " + exc.Message); return; } }); }
private async Task <bool> ExecuteDeleteFieldTool(BasicFeatureLayer theLayer, string fieldName) { try { return(await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() => { var inTable = theLayer.Name; var table = theLayer.GetTable(); var dataStore = table.GetDatastore(); var workspaceNameDef = dataStore.GetConnectionString(); var workspaceName = workspaceNameDef.Split('=')[1]; var fullSpec = System.IO.Path.Combine(workspaceName, inTable); System.Diagnostics.Debug.WriteLine($@"Delete {fieldName} from {fullSpec}"); var parameters = Geoprocessing.MakeValueArray(fullSpec, fieldName); var env = Geoprocessing.MakeEnvironmentArray(workspace: workspaceName); var cts = new CancellationTokenSource(); var results = Geoprocessing.ExecuteToolAsync("management.DeleteField", parameters, env, cts.Token, (eventName, o) => { System.Diagnostics.Debug.WriteLine($@"GP event: {eventName}"); if (eventName == "OnMessage") { System.Diagnostics.Debug.WriteLine($@"Msg: {o}"); } }); return true; })); } catch (Exception ex) { MessageBox.Show(ex.ToString()); return(false); } }
public async void CalculateVolume() { // Update the viewmodel with values await FrameworkApplication.SetCurrentToolAsync("esri_mapping_exploreTool"); // Check for an active mapview if (MapView.Active == null) { ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("No MapView currently active. Exiting...", "Info"); return; } // Prompt before proceeding with calculation work var response = ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Save edits and calculate volume on selected features?", "Calculate Volume", System.Windows.MessageBoxButton.YesNo, System.Windows.MessageBoxImage.Question); if (response == MessageBoxResult.No) { return; } // Save edits for reading by GP Tool await Project.Current.SaveEditsAsync(); try { await QueuedTask.Run((Func <Task>)(async() => { var featLayer = MapView.Active.Map.FindLayers("Clip_Polygon_Asphalt").FirstOrDefault() as FeatureLayer; // Get the selected records, and check/exit if there are none: var featSelectionOIDs = featLayer.GetSelection().GetObjectIDs(); if (featSelectionOIDs.Count == 0) { ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("No records selected for layer, " + featLayer.Name + ". Exiting...", "Info"); return; } // Ensure value for reference plane direction combobox else if (SceneCalcVM.ReferencePlaneDirection == string.Empty) { ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Choose the reference plane direction for volume calculation. Exiting...", "Value Needed"); return; } // Ensure there is a valid reference plane height/elevation value for all selected records RowCursor cursorPolygons = featLayer.GetSelection().Search(null); while (cursorPolygons.MoveNext()) { using (Row currentRow = cursorPolygons.Current) { // Get values for dockpane if (currentRow["PlaneHeight"] == null || Convert.ToDouble(currentRow["PlaneHeight"]) == 0) { string currentObjectID = Convert.ToString(currentRow["ObjectID"]); ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Empty or invalid Plane Height value for polygon ObjectID: " + currentObjectID + ". Exiting...", "Value Needed"); return; } } } // Get the name of the attribute to update, and the value to set: double refPlaneElevation = SceneCalcVM.ReferencePlaneElevation; string refPlaneDirection = SceneCalcVM.ReferencePlaneDirection; // Start progress dialog var progDialog = new ProgressDialog("Calculating Volume"); var progSource = new ProgressorSource(progDialog); progDialog.Show(); // Prepare for run of GP tool -- Get the path to the LAS point layer string surfaceLASDataset = "Asphalt3D_132_point_cloud.las"; var inspector = new ArcGIS.Desktop.Editing.Attributes.Inspector(true); inspector.Load(featLayer, featSelectionOIDs); inspector["PlaneDirection"] = refPlaneDirection; inspector["DateOfCapture"] = DateTime.Today; inspector["ElevationMeshFile"] = "Asphalt3D_132_3d_mesh.slpk"; inspector["PointCloudFile"] = surfaceLASDataset; var editOp = new EditOperation(); editOp.Name = "Edit " + featLayer.Name + ", " + Convert.ToString(featSelectionOIDs.Count) + " records."; editOp.Modify(inspector); await editOp.ExecuteAsync(); await Project.Current.SaveEditsAsync(); // Get the path to the layer's feature class string infc = featLayer.Name; // Place parameters into an array var parameters = Geoprocessing.MakeValueArray(surfaceLASDataset, infc, "PlaneHeight", refPlaneDirection); // Place environment settings in an array, in this case, OK to over-write var environments = Geoprocessing.MakeEnvironmentArray(overwriteoutput: true); // Execute the GP tool with parameters var gpResult = await Geoprocessing.ExecuteToolAsync("PolygonVolume_3d", parameters, environments); // Save edits again await Project.Current.SaveEditsAsync(); // var selFeatures = featLayer.GetSelection().GetCount(); RowCursor cursorPolygons2 = featLayer.GetSelection().Search(null); double totalVolumeValue = 0; double totalAreaValue = 0; double totalWeightInTons = 0; double currentVolume; double currentSArea; double currentWeightInTons; long currentOID; while (cursorPolygons2.MoveNext()) { using (Row currentRow = cursorPolygons2.Current) { // Get values for dockpane currentOID = currentRow.GetObjectID(); // Convert volume in cubic meters from source data to cubic feet: currentVolume = Convert.ToDouble(currentRow["Volume"]) * 35.3147; // Convert surface area value from square meters from source data to square feet: currentSArea = Convert.ToDouble(currentRow["SArea"]) * 10.7639; // Calculate estimated weight in tons = (volume in square foot * 103.7 pounds per square foot) / 2000 pounds per ton currentWeightInTons = (currentVolume * 103.7) / 2000; // Update the new cubic feet and square feet values for the feature: inspector.Load(featLayer, currentOID); inspector["Volume"] = currentVolume; inspector["SArea"] = currentSArea; inspector["EstWeightInTons"] = currentWeightInTons; await inspector.ApplyAsync(); // Combine values for display of total volume and surface area values in the dockpane: totalVolumeValue = totalVolumeValue + currentVolume; totalAreaValue = totalAreaValue + currentSArea; totalWeightInTons = totalWeightInTons + currentWeightInTons; } } // Apply the values and refresh selection update await Project.Current.SaveEditsAsync(); FeatureSelectionChanged(); // Close progress dialog progDialog.Hide(); progDialog.Dispose(); })); } catch (Exception exc) { // Catch any exception found and display a message box. ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Exception caught while trying to perform update: " + exc.Message); return; } }
private async void sensitivity_Click(object sender, EventArgs e) { if ((combo1.SelectedIndex == -1) || (combo2.SelectedIndex == -1)) { MessageBox.Show("Cannot Perform SA unless criteria and simulations are selected"); return; } Stream myStream; SaveFileDialog saveFileDialog1 = new SaveFileDialog(); saveFileDialog1.Filter = "csv file (*.csv)|*.csv|txt file (*.txt)|*.txt|All files (*.*)|*.*"; saveFileDialog1.FilterIndex = 2; saveFileDialog1.RestoreDirectory = true; saveFileDialog1.OverwritePrompt = true; saveFileDialog1.AddExtension = true; saveFileDialog1.InitialDirectory = @"D:\"; saveFileDialog1.Title = "Save your Weights"; if (saveFileDialog1.ShowDialog() == DialogResult.OK) { if ((myStream = saveFileDialog1.OpenFile()) != null) { myStream.Close(); } } else if (saveFileDialog1.ShowDialog() == DialogResult.Cancel) { MessageBox.Show("Save your csv file"); } string fp = saveFileDialog1.FileName; // Defining new array rowSum1 with length as rowSum double[] rowSum1 = new double[rowSum.Length]; for (int i = -Convert.ToInt16(combo2.SelectedItem) / 2; i <= Convert.ToInt16(combo2.SelectedItem) / 2; i++) { //Copy contents of rowSum to rowSum1 starting from 0 rowSum.CopyTo(rowSum1, 0); if (i == 0) { continue; } for (int j = 0; j < combo1.Items.Count; j++) { //Positive Increment if (i > 0) { rowSum1[combo1.SelectedIndex] = rowSum1[combo1.SelectedIndex] * (1 + 0.01 * i); if (j != combo1.SelectedIndex) { System.Diagnostics.Debug.WriteLine(i); rowSum1[j] = rowSum1[j] * (1 - 0.01 * i); } } //Negative increment else { rowSum1[combo1.SelectedIndex] = rowSum1[combo1.SelectedIndex] * (1 + 0.01 * i); if (j != combo1.SelectedIndex) { System.Diagnostics.Debug.WriteLine(i); rowSum1[j] = rowSum1[j] * (1 - 0.01 * i); } } //Skip iteration when i=0 } // Writing to a csv file string delimiter = ","; int length = rowSum1.Length; //using (TextWriter writer = File.CreateText(filepath)) using (TextWriter writer = File.AppendText(fp)) //StringBuilder csv = new StringBuilder(); { if (i == -Convert.ToInt16(combo2.SelectedItem) / 2) { writer.Write(string.Join(delimiter, "% Change", "\t")); for (int a = 0; a < combo1.Items.Count; a++) { writer.Write(string.Join(delimiter, combo1.Items[a], "\t")); } } writer.Write("\n"); writer.Write(string.Join(delimiter, i, "\t")); for (int index = 0; index < length; index++) { writer.Write(string.Join(delimiter, Math.Round(rowSum1[index], 3), "\t")); } } List <string> paths = new List <string>(); List <string> myinputs = new List <string>(); TreeNode test = Goal.TopNode; //Geoprocessing starts here await QueuedTask.Run(() => // Task t = QueuedTask.Run(() => { for (int k = 0; k < test.Nodes.Count; k++) { var rlyrs = MapView.Active.Map.Layers.OfType <RasterLayer>(); //All raster layers in Map View //System.Diagnostics.Debug.WriteLine(test.Nodes[k].Tag.ToString()); for (int m = 0; m < rlyrs.Count(); m++) { RasterLayer rlyr = rlyrs.ElementAt(m); //raster layer at specific position Datastore dataStore = rlyr.GetRaster().GetRasterDataset().GetDatastore(); //getting datasource if (test.Nodes[k].Tag.ToString() == rlyr.Name) { paths.Add(dataStore.GetPath().AbsolutePath);//getting path System.Diagnostics.Debug.WriteLine(rlyr.Name); System.Diagnostics.Debug.WriteLine(paths); // adding paths to input array, value and weights myinputs.Add(paths.ElementAt(k) + "/" + rlyr.GetRaster().GetRasterDataset().GetName() + " VALUE " + Math.Round(rowSum1[k], 3)); System.Diagnostics.Debug.WriteLine(rowSum1); } } } }); //t.Wait(); System.Diagnostics.Debug.WriteLine(i); if (i < 0) { string output_raster = System.IO.Path.Combine(Project.Current.DefaultGeodatabasePath, "SuitedRaster" + Math.Abs(i) + "down"); System.Diagnostics.Debug.WriteLine(output_raster); var param_values = Geoprocessing.MakeValueArray(myinputs, output_raster); string toolpath = "sa.WeightedSum"; var env = Geoprocessing.MakeEnvironmentArray(scratchWorkspace: Project.Current.DefaultGeodatabasePath); await Geoprocessing.ExecuteToolAsync(toolpath, param_values, env, null, null, GPExecuteToolFlags.None); progressLabel.Text = "Reclassification Started for " + Math.Abs(i).ToString() + " % decrease"; List <string> remap = new List <string>(); remap.Add("0 0.6 1"); remap.Add("0.6 0.8 2"); remap.Add("0.8 1 3"); string output_raster2 = System.IO.Path.Combine(Project.Current.DefaultGeodatabasePath, "SuitedRaster" + Math.Abs(i) + "downreclass"); var kufli = Geoprocessing.MakeValueArray(output_raster, "VALUE", remap, output_raster2); //Geoprocessing.OpenToolDialog("sa.Reclassify", kufli); await Geoprocessing.ExecuteToolAsync("sa.Reclassify", kufli, env, null, null, GPExecuteToolFlags.AddOutputsToMap); progressLabel.Text = "Reclassification Finished for " + Math.Abs(i).ToString() + " % decrease. Check in TOC"; } else { string output_raster = System.IO.Path.Combine(Project.Current.DefaultGeodatabasePath, "SuitedRaster" + i + "up"); System.Diagnostics.Debug.WriteLine(output_raster); var param_values = Geoprocessing.MakeValueArray(myinputs, output_raster); string toolpath = "sa.WeightedSum"; var env = Geoprocessing.MakeEnvironmentArray(scratchWorkspace: Project.Current.DefaultGeodatabasePath); await Geoprocessing.ExecuteToolAsync(toolpath, param_values, env, null, null, GPExecuteToolFlags.None); progressLabel.Text = "Reclassification Started for " + Math.Abs(i).ToString() + " % increase"; List <string> remap = new List <string>(); remap.Add("0 0.6 1"); remap.Add("0.6 0.8 2"); remap.Add("0.8 1 3"); string output_raster2 = System.IO.Path.Combine(Project.Current.DefaultGeodatabasePath, "SuitedRaster" + Math.Abs(i) + "upreclass"); var kufli = Geoprocessing.MakeValueArray(output_raster, "VALUE", remap, output_raster2); //Geoprocessing.OpenToolDialog("sa.Reclassify", kufli); await Geoprocessing.ExecuteToolAsync("sa.Reclassify", kufli, env, null, null, GPExecuteToolFlags.AddOutputsToMap); progressLabel.Text = "Reclassification Finished for " + Math.Abs(i).ToString() + " % increase. Check in TOC"; } foreach (var Item in rowSum1) { System.Diagnostics.Debug.WriteLine(Item.ToString()); } // Clear the array so that new values will be populated based on original Array.Clear(rowSum1, 0, rowSum1.Length); //Clear inputs myinputs.Clear(); } }
//Click to create suitability map private async void Map_Click(object sender, EventArgs e) { var mapView = MapView.Active; List <string> paths = new List <string>(); List <string> myinputs = new List <string>(); TreeNode test = Goal.TopNode; //using await instead of .wait() for asynchronous execution (Wait for the results) await QueuedTask.Run(() => { for (int k = 0; k < test.Nodes.Count; k++) { var rlyrs = MapView.Active.Map.Layers.OfType <RasterLayer>(); //All raster layers for (int m = 0; m < rlyrs.Count(); m++) { RasterLayer rlyr = rlyrs.ElementAt(m); //raster layer at specific position Datastore dataStore = rlyr.GetRaster().GetRasterDataset().GetDatastore(); //getting datasource if (test.Nodes[k].Tag.ToString() == rlyr.Name) { paths.Add(dataStore.GetPath().AbsolutePath); myinputs.Add(paths.ElementAt(k) + "/" + rlyr.GetRaster().GetRasterDataset().GetName() + " VALUE " + Math.Round(rowSum[k], 2)); } } } }); //t.Wait(); //For Showing Progress Window (Optional) var progDlgWS = new ProgressDialog("Weighted Sum Progress", "Cancel", 100, true); progDlgWS.Show(); var progSrc = new CancelableProgressorSource(progDlgWS); string weightedSumRaster = System.IO.Path.Combine(Project.Current.DefaultGeodatabasePath, "SuitedRaster"); var param_values = Geoprocessing.MakeValueArray(myinputs, weightedSumRaster); //use toolBoxNameAlias.toolName.Alias string toolpath = "sa.WeightedSum"; var env = Geoprocessing.MakeEnvironmentArray(scratchWorkspace: Project.Current.DefaultGeodatabasePath); //Uncomment below line if you want GP tool to open in Pro //Geoprocessing.OpenToolDialog(toolpath, param_values); progressLabel.Text = "Performing Weighted Sum, please wait..."; //Not adding weighted sum result to map since its intermediate result await Geoprocessing.ExecuteToolAsync(toolpath, param_values, env, new CancelableProgressorSource(progDlgWS).Progressor, GPExecuteToolFlags.AddOutputsToMap); progressLabel.Text = "Weighted Sum processing complete. Reclassification started"; //Hide the progress once done. progDlgWS.Hide(); //----Use this if you want to see GP result messages---// //---The flow doesnt progress forward unless you close this box-----// //Geoprocessing.ShowMessageBox(wsresult.Messages, "GP Messages", //wsresult.IsFailed ? GPMessageBoxStyle.Error : GPMessageBoxStyle.Default); //Creating a list string to store reclass values List <string> remap = new List <string>(); //Classifying into 3 classes, values can be modified as per user needs. remap.Add("0 0.6 1"); //Least Suitable remap.Add("0.6 0.8 2"); //Moderately Suitable remap.Add("0.8 1 3"); //Highly Suitable string output_raster2 = System.IO.Path.Combine(Project.Current.DefaultGeodatabasePath, "SuitedRaster" + "reclass0"); var reclassedRaster = Geoprocessing.MakeValueArray(weightedSumRaster, "VALUE", remap, output_raster2); await Geoprocessing.ExecuteToolAsync("sa.Reclassify", reclassedRaster, env, null, null, GPExecuteToolFlags.AddOutputsToMap); progressLabel.Text = "Reclassification Completed. Check in TOC"; //Geoprocessing.OpenToolDialog("sa.Reclassify", reclassedRaster); }