public async void ProgressDialogExample()
{
#region progress_dialog
var progDlg = new ProgressDialog("Running Geoprocessing Tool", "Cancel", 100, true);
progDlg.Show();
var progSrc = new CancelableProgressorSource(progDlg);
// prepare input parameter values to CopyFeatures tool
string input_data = @"C:\data\california.gdb\ca_highways";
string out_workspace = ArcGIS.Desktop.Core.Project.Current.DefaultGeodatabasePath;
string out_data = System.IO.Path.Combine(out_workspace, "ca_highways2");
// make a value array of strings to be passed to ExecuteToolAsync
var parameters = Geoprocessing.MakeValueArray(input_data, out_data);
// execute the tool
await Geoprocessing.ExecuteToolAsync("management.CopyFeatures", parameters,
null, new CancelableProgressorSource(progDlg).Progressor, GPExecuteToolFlags.Default);
// dialog hides itself once the execution is complete
progDlg.Hide();
#endregion
}
protected override void OnClick()
{
try
{
// Install the toolbox locally and set path to the toolbox
var toolPath = AutoUpdater.UpdateToolbar() + @"\DownloadMapTemplate";
//launch script tool from gp pane
//https://github.com/esri/arcgis-pro-sdk/wiki/ProConcepts-Geoprocessing#open-the-tool-dialog-in-the-geoprocessing-pane
// Set value array (empty values allow user full control) and launch tool
var dir = "";
var mapReqID = "";
var projectName = "";
var exorNew = "";
var pathtoEx = "";
var copyOldData = "";
var PAGX_Template = "";
var toolParams = Geoprocessing.MakeValueArray(
dir, mapReqID, projectName, exorNew, pathtoEx, copyOldData, PAGX_Template);
Geoprocessing.OpenToolDialog(toolPath, toolParams);
}
catch (Exception e)
{
MessageBox.Show("Something went wrong " + e);
}
}
protected override async void OnClick()
{
string inputDEM = Parameter.DEMCombo.SelectedItem.ToString();
string tinLayer = "TIN";
var args = Geoprocessing.MakeValueArray(inputDEM, tinLayer);
await SharedFunctions.RunModel(args, "CreateTIN");
}
/// <summary>
/// Execute a tool in A
/// </summary>
/// <param name="toolName"></param>
/// <param name="args"></param>
/// <returns></returns>
private static async Task <IGPResult> ExecuteTool(String toolName, params object[] args)
{
var toolArgs = Geoprocessing.MakeValueArray(args);
Task <IGPResult> result = Geoprocessing.ExecuteToolAsync(toolName, toolArgs, null, null, null);
return(await result);
}
private async void SelectCourse()
{
string fieldName = string.Empty;
var oidField = QueuedTask.Run(() =>
{
string name;
using (Geodatabase geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(GeoDataTool.DefaultProject.DefaultGeodatabasePath))))
{
FeatureClassDefinition fcd = geodatabase.GetDefinition <FeatureClassDefinition>(ConstDefintion.ConstFeatureClass_Course);
name = fcd.GetObjectIDField();
}
return(name);
}).Result;
string path = ConstDefintion.ConstFeatureClass_Course;
string whereClause = $"{oidField} = {CourseListSelectedItem}";
ProgressDialog progressDialogDomain = new ProgressDialog($"切换选择中", ConstDefintion.ConstStr_GeoprocessCancling, false);
var arg = Geoprocessing.MakeValueArray(path, "NEW_SELECTION", whereClause);
var task = await Geoprocessing.ExecuteToolAsync("SelectLayerByAttribute_management", arg, null, new CancelableProgressorSource(progressDialogDomain).Progressor);
if (!task.IsFailed)
{
if (!(MapView.Active == null))
{
await MapView.Active.ZoomToSelectedAsync();
}
}
}
protected override async void OnClick()
{
string timestamp = DateTime.Now.ToString("yyyyMMddHHmmss");
string featureClassName = "AOI_Polygon_" + timestamp;
List <object> arguments = new List <object>
{
// store the results in the default geodatabase
CoreModule.CurrentProject.DefaultGeodatabasePath,
// name of the feature class
featureClassName,
// type of geometry
"POLYGON", //POINT,POLYLINE,POLYGON...
// no template
"",
// no z values
"DISABLED",
// no m values
"DISABLED"
};
await QueuedTask.Run(() =>
{
// spatial reference
arguments.Add(SpatialReferenceBuilder.CreateSpatialReference(4326)); //3857
});
var parameters = Geoprocessing.MakeValueArray(arguments.ToArray());
Geoprocessing.OpenToolDialog("management.CreateFeatureclass", parameters);
//await CreateAOILayer();
}
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 <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 async void ExecuteCreatePoint()
{
if (_featureClassName == null || _featureClassName == "" || _selectedPolygonAndLineLayer == null)
{
return;
}
// 既存のフィーチャクラス存在チェック
var check = await QueuedTask.Run(() =>
{
return(FeatureClassExists(_gdbPath, _featureClassName));
});
if (check == true)
{
MessageBox.Show("同じ名前のフィーチャクラスが存在します。");
return;
}
var manipulatedlayer = _selectedPolygonAndLineLayer;
// フィーチャクラス作成
await ExecuteGeoprocessingTool("CreateFeatureclass_management", Geoprocessing.MakeValueArray(_gdbPath,
_featureClassName,
"POINT",
manipulatedlayer,
"DISABLED",
"DISABLED",
manipulatedlayer));
// ジオメトリ処理の実行
ManipulateGeometry(manipulatedlayer);
}
public static async Task <BA_ReturnCode> BufferLinesAsync(string strInputFeatures, string strOutputFeatures, string strDistance,
string strLineSide, string strLineEndOption, string strDissolveOption)
{
if (String.IsNullOrEmpty(strLineSide))
{
strLineSide = "FULL";
}
if (String.IsNullOrEmpty(strLineEndOption))
{
strLineEndOption = "ROUND";
}
if (String.IsNullOrEmpty(strDissolveOption))
{
strDissolveOption = "ALL";
}
IGPResult gpResult = await QueuedTask.Run(() =>
{
var parameters = Geoprocessing.MakeValueArray(strInputFeatures, strOutputFeatures, strDistance, strLineSide,
strLineEndOption, strDissolveOption);
return(Geoprocessing.ExecuteToolAsync("Buffer_analysis", parameters, null,
CancelableProgressor.None, GPExecuteToolFlags.AddToHistory));
});
if (gpResult.IsFailed)
{
Module1.Current.ModuleLogManager.LogError(nameof(BufferLinesAsync),
"Unable to buffer features. Error code: " + gpResult.ErrorCode);
return(BA_ReturnCode.UnknownError);
}
else
{
Module1.Current.ModuleLogManager.LogDebug(nameof(BufferLinesAsync), "Lines buffered successfully");
return(BA_ReturnCode.Success);
}
}
/// <summary>
/// The MakeQueryLayer Geoprocessing tool is used to create a Query Layer consisting of
/// all the datasets which reference the selected domain
/// </summary>
/// <param name="item">The newly selected combo box item</param>
protected override void OnSelectionChange(ComboBoxItem item)
{
if (item == null)
{
return;
}
if (string.IsNullOrEmpty(item.Text))
{
return;
}
if (String.IsNullOrEmpty(gdbItemsOwner))
{
return;
}
// HACK: Currently the API does not have any Getters for obtaining the Connection Properties or any other info. This will be fixed soon.
// Until then we are getting the first enterprise connection to make the GP call.
string physicalPath = Project.Current.GetItems <GDBProjectItem>().First(projectItem => projectItem.Path != null && projectItem.Path.Contains(".sde")).Path;
string QueryLayerName = String.Format("RelatedDomains{0}", item.Text);
string Query = String.Format("SELECT ClassItems.Name, ClassItems.Path FROM (SELECT Relationships.OriginID AS ClassID, Relationships.DestID AS DomainID FROM {1}.GDB_ITEMRELATIONSHIPS AS Relationships INNER JOIN {1}.GDB_ITEMRELATIONSHIPTYPES AS RelationshipTypes ON Relationships.Type = RelationshipTypes.UUID WHERE RelationshipTypes.Name = 'DomainInDataset') AS DomainRelationships INNER JOIN {1}.GDB_ITEMS AS DomainItems ON DomainRelationships.DomainID = DomainItems.UUID INNER JOIN {1}.GDB_ITEMS AS ClassItems ON DomainRelationships.ClassID = ClassItems.UUID WHERE DomainItems.Name = '{0}'", item.Text, gdbItemsOwner);
IReadOnlyList <string> valueArray = Geoprocessing.MakeValueArray(new object[] { physicalPath, QueryLayerName, Query, "Name" });
Geoprocessing.ExecuteToolAsync("management.MakeQueryLayer", valueArray);
}
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);
}
protected override async void OnClick()
{
var rasterLayer =
MapView.Active.Map.GetLayersAsFlattenedList().OfType <ImageServiceLayer>().FirstOrDefault();
if (rasterLayer == null)
{
MessageBox.Show("Please add a raster as layer 0", "Cannot find layer");
return;
}
await QueuedTask.Run(async() =>
{
var renderer = rasterLayer.GetColorizer();
var parametersMin = Geoprocessing.MakeValueArray(rasterLayer, "MINIMUM");
var parametersMax = Geoprocessing.MakeValueArray(rasterLayer, "MAXIMUM");
var minRes = await Geoprocessing.ExecuteToolAsync("GetRasterProperties_management", parametersMin);
var maxRes = await Geoprocessing.ExecuteToolAsync("GetRasterProperties_management", parametersMax);
var min = Convert.ToDouble(minRes.Values[0]);
var max = Convert.ToDouble(maxRes.Values[0]);
var layerCimRenderer = CreateStretchRendererFromScratch(min, max);
//For examination in the debugger..
string xmlDef = renderer.ToXml();
string xmlDef2 = layerCimRenderer.ToXml();
rasterLayer.SetColorizer(layerCimRenderer);
});
}
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(fullSpec, field.Key, fieldType.ToUpper(), null, null,
fieldLength, field.Value, isNullable ? "NULABLE" : "NON_NULLABLE");
var cts = new CancellationTokenSource();
var results = Geoprocessing.ExecuteToolAsync("management.AddField", parameters, null, 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 <bool> ExecuteAddFieldTool(BasicFeatureLayer layer, string field, string fieldType, int?fieldLength = null, bool isNullable = true)
{
try
{
return(await QueuedTask.Run(() =>
{
var layerName = layer.Name;
var table = layer.GetTable();
var dataStore = table.GetDatastore();
var workspaceNameDef = dataStore.GetConnectionString();
var workspaceName = workspaceNameDef.Split('=')[1];
var fullSpec = System.IO.Path.Combine(workspaceName, layerName);
Log($@"{field} added -> {fullSpec}");
var parameters = Geoprocessing.MakeValueArray(fullSpec, field, fieldType.ToUpper(), null, null, fieldLength, null, isNullable ? "NULLABLE" : "NON_NULLABLE");
var results = Geoprocessing.ExecuteToolAsync("management.AddField", parameters, null, new CancellationTokenSource().Token,
(eventName, o) =>
{
//OnProgressPos
});
return true;
}));
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
return(false);
}
}
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);
}
/// <summary>
/// This method calls Geoprocessing to create a new version for the Workspace corresponding to the table
/// </summary>
/// <param name="table"></param>
/// <returns></returns>
private async Task <string> CreateVersion(Table table)
{
try
{
Version defaultVersion = (table.GetDatastore() as Geodatabase).GetVersionManager().GetVersions().FirstOrDefault(version =>
{
string name = version.GetName();
return(name.ToLowerInvariant().Equals("dbo.default") || name.ToLowerInvariant().Equals("sde.default"));
});
if (defaultVersion == null)
{
return(null);
}
using (defaultVersion)
{
IReadOnlyList <string> valueArray = Geoprocessing.MakeValueArray(new object[] { table, defaultVersion.GetName(), string.Format("NewVersion{0}", random.Next()), "private" });
List <string> values = new List <String>
{
valueArray[0].Remove(valueArray[0].LastIndexOf("\\", StringComparison.Ordinal)),
valueArray[1],
valueArray[2],
valueArray[3]
};
await Geoprocessing.ExecuteToolAsync("management.CreateVersion", values);
return(valueArray[2]);
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
return(null);
}
protected override void OnClick()
{
setupGP.init();
var param_values = Geoprocessing.MakeValueArray(DataAssistant.Dockpane1View.getXmlFileName());
Geoprocessing.OpenToolDialog(setupGP.getToolbox("ReplaceData"), param_values);
}
private async void OnGetJsonSelectionFinished(GetJsonSelectionFinishedEventArgs args)
{
//fill the textbox with info
DockpaneGJViewModel.UpdateText("Processing...");
//execute the geoprocessing tool for creating json
Task <IGPResult> myTsk = QueuedTask.Run(() =>
{
BasicFeatureLayer bfl = args.BasicFL;
var flist = new List <object>()
{
bfl,
};
Task <IGPResult> taskRes =
Geoprocessing.ExecuteToolAsync("conversion.FeaturesToJSON", Geoprocessing.MakeValueArray(flist, null, "FORMATTED"));
return(taskRes);
});
IGPResult resultaat = await myTsk;
if (!(resultaat.IsFailed || resultaat.IsCanceled))
{
////filename
string filename = myTsk.Result.ReturnValue;
//read the file
string contents = File.ReadAllText(@filename);
//fill the textbox
DockpaneGJViewModel.UpdateText(contents);
//delete the file
File.Delete(filename);
}
else
{
DockpaneGJViewModel.UpdateText("Sorry, but features can't be converted to JSON. " + Environment.NewLine + "Response: " + resultaat.ReturnValue);
}
}
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);
}
protected async Task <string> AddSchema(string tableName, string[] fieldNames, string[] fieldTypes, string[] splitter, string csvFilePath)
{
// loop to create table schema
/* Note field properties are: tableName, fieldName, DataType: [Text, Short, Long, Float, Date, Blob, Raster Guid, Double],
* Domain, Default, fieldLength [number of characters ie, 32], AliasName, "NULLABLE", "NON_REQUIRED", null
* ref: https://community.esri.com/thread/246461-arcgis-pro-sdk-create-and-add-new-standalone-table
*/
for (int i = 0; i < fieldNames.Length; i++)
{
IReadOnlyList <string> addFieldParams = Geoprocessing.MakeValueArray(new object[] { tableName, fieldNames[i], fieldTypes[i],
null, null, 255, "", "NULLABLE", "NON_REQUIRED", null });
IGPResult result = await Geoprocessing.ExecuteToolAsync("management.AddField", addFieldParams);
if (result.IsFailed)
{
ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Unable to create Field");
}
}
var dataLoad = LoadData(splitter, fieldTypes, csvFilePath);
return("ok");
}
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 cts = new CancellationTokenSource();
var results = Geoprocessing.ExecuteToolAsync("management.DeleteField", parameters, null, 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);
}
}
internal async void BuildNetwork()
{
var mapView = MapView.Active;
if (_networkDatasetLayer == null)
{
var layers = mapView.Map.GetLayersAsFlattenedList();
foreach (var layer in layers)
{
if (!(layer is NetworkDatasetLayer))
{
continue;
}
_networkDatasetLayer = layer as NetworkDatasetLayer;
break;
}
}
if (_networkDatasetLayer == null)
{
return;
}
var values = Geoprocessing.MakeValueArray(_networkDatasetLayer);
await Geoprocessing.ExecuteToolAsync("BuildNetwork_na", values);
}
private async Task <IGPResult> ExtraObstacle(double distance)
{
string fieldName = string.Empty;
var oidField = QueuedTask.Run(() =>
{
string name;
using (Geodatabase geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(GeoDataTool.DefaultProject.DefaultGeodatabasePath))))
{
FeatureClassDefinition fcd = geodatabase.GetDefinition <FeatureClassDefinition>(ConstDefintion.ConstFeatureClass_Course);
name = fcd.GetObjectIDField();
}
return(name);
}).Result;
string path = GeoDataTool.DefaultProject.DefaultGeodatabasePath + "\\" + ConstDefintion.ConstFeatureClass_Course;
string outpath = GeoDataTool.DefaultProject.DefaultGeodatabasePath + "\\" + ConstDefintion.ConstFeatureClass_SelectedCourse;
string whereClause = $"{oidField} = {CourseListSelectedItem}";
ProgressDialog progressDialogDomain = new ProgressDialog($"正在创建被选择航线图层", ConstDefintion.ConstStr_GeoprocessCancling, false);
var arg = Geoprocessing.MakeValueArray(path, outpath, whereClause);
var gp = await Geoprocessing.ExecuteToolAsync("Select_analysis", arg, null, new CancelableProgressorSource(progressDialogDomain).Progressor);
if (!gp.IsFailed)
{
ProgressDialog progressDialog1 = new ProgressDialog($"正在构造缓冲区", ConstDefintion.ConstStr_GeoprocessCancling, false);
string outBufferpath = GeoDataTool.DefaultProject.DefaultGeodatabasePath + "\\" + ConstDefintion.ConstFeatureClass_CourseBuffer;
string str_distance = $"{distance} NauticalMiles";
var arg1 = Geoprocessing.MakeValueArray(outpath, outBufferpath, str_distance);
var gp1 = await Geoprocessing.ExecuteToolAsync("Buffer_analysis", arg1, null, new CancelableProgressorSource(progressDialog1).Progressor);
if (!gp1.IsFailed)
{
ProgressDialog progressDialog2 = new ProgressDialog($"正在提取碍航物", ConstDefintion.ConstStr_GeoprocessCancling, false);
string insArgs = $"{ObstaclePath} 1;{outBufferpath} 2";
string outcourseObstacle = GeoDataTool.DefaultProject.DefaultGeodatabasePath + "\\" + ConstDefintion.ConstFeatureClass_CourseObstacle;
var arg2 = Geoprocessing.MakeValueArray(insArgs, outcourseObstacle);
var gp2 = await Geoprocessing.ExecuteToolAsync("Intersect_analysis", arg2, null, new CancelableProgressorSource(progressDialog2).Progressor);
if (!gp2.IsFailed)
{
ProgressDialog progressDialog3 = new ProgressDialog($"正在创建泰森多边形", ConstDefintion.ConstStr_GeoprocessCancling, false);
string outCourseObstacle_Thiessen = GeoDataTool.DefaultProject.DefaultGeodatabasePath + "\\" + ConstDefintion.ConstFeatureClass_CourseObstacleThiessen;
var arg3 = Geoprocessing.MakeValueArray(outcourseObstacle, outCourseObstacle_Thiessen);
var gp3 = await Geoprocessing.ExecuteToolAsync("CreateThiessenPolygons_analysis", arg3, null, new CancelableProgressorSource(progressDialog3).Progressor);
if (!gp3.IsFailed)
{
ProgressDialog progressDialog4 = new ProgressDialog($"正在裁剪", ConstDefintion.ConstStr_GeoprocessCancling, false);
string inCourseObstacle_Thiessen = outCourseObstacle_Thiessen;
string inBuffer = outBufferpath;
string outClipThiessen = GeoDataTool.DefaultProject.DefaultGeodatabasePath + "\\" + ConstDefintion.ConstFeatureClass_CourseObstacleThiessenClip;
var arg4 = Geoprocessing.MakeValueArray(inCourseObstacle_Thiessen, inBuffer, outClipThiessen);
var gp4 = await Geoprocessing.ExecuteToolAsync("Clip_analysis", arg4, null, new CancelableProgressorSource(progressDialog4).Progressor);
return(gp4);
}
}
}
}
return(null);
}
protected override void OnClick()
{
string input_raster = "";
string output = "";
var parameters = Geoprocessing.MakeValueArray(input_raster, output, "POLYGON");
Geoprocessing.OpenToolDialog("3d.RasterDomain", parameters);
}
protected override void OnClick()
{
var parameters = Geoprocessing.MakeValueArray("", "", "POLYGON");
Geoprocessing.OpenToolDialog("conversion.JSONToFeatures", parameters);
//await AddGeoJSON();
}
protected async Task DefineProjectionAsync(string CadFileName, SpatialReference SpatialRef, CancelableProgressorSource cps)
{
//GP Define Projection
GPExecuteToolFlags flags = GPExecuteToolFlags.Default; // | GPExecuteToolFlags.GPThread;
var parameters = Geoprocessing.MakeValueArray(CadFileName, SpatialRef.Wkt);
await Geoprocessing.ExecuteToolAsync("management.DefineProjection", parameters,
null, cps.Progressor, flags);
}
protected override async void OnClick()
{
MessageBox.Show("truncate 3");
string output_polys = System.IO.Path.Combine(System.IO.Path.Combine(ArcGIS.Desktop.Core.Project.Current.HomeFolderPath, "bufferOutPuts.gdb"), "buffer_100miles"); // @"C:\data\ca_ozone.gdb\ozone_buff";
var param_values = Geoprocessing.MakeValueArray(output_polys);
//Geoprocessing.OpenToolDialog("TruncateTable_management", param_values);
var result = await Geoprocessing.ExecuteToolAsync("TruncateTable_management", param_values);
}
protected override async void OnClick()
{
string inputDEM = Parameter.DEMCombo.SelectedItem.ToString();
string contourInterval = Parameter.ContourIntervalBox.Text;
string PointInterval = Parameter.PointIntervalBox.Text + " meters";
string Workspace = Project.Current.DefaultGeodatabasePath;
var args = Geoprocessing.MakeValueArray(contourInterval, PointInterval, Workspace, inputDEM);
await SharedFunctions.RunModel(args, "Prepare Contours");
}
private static IReadOnlyList <string> makeValueArray(string featureClass, string fieldName, string fieldType)
{
List <object> arguments = new List <object>();
arguments.Add(featureClass);
arguments.Add(fieldName);
arguments.Add(fieldType);
return(Geoprocessing.MakeValueArray(arguments.ToArray()));
}