/// <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);
}
/// <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 <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);
}
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();
}
}
}
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);
}
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");
}
internal async void CreatePackage()
{
if (_outputMap == null)
{
var maps = Project.Current.GetItems <MapProjectItem>();
foreach (var mapProjectItem in maps)
{
if (!mapProjectItem.Name.Contains("Map"))
{
continue;
}
await QueuedTask.Run(() =>
{
_outputMap = mapProjectItem.GetMap();
});
break;
}
}
if (_outputMap == null)
{
return;
}
string[] values = { "Map", @"c:\temp\MobileMapPackage.mmpk", "", "", "", "", "", "", "Description" };
var gpResult = await Geoprocessing.ExecuteToolAsync("CreateMobileMapPackage_management", values);
Geoprocessing.ShowMessageBox(gpResult.Messages, "GP Messages",
gpResult.IsFailed ? GPMessageBoxStyle.Error : GPMessageBoxStyle.Default);
// ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Mobile map package created.","Geoprocessing Complete");
}
/// <summary>
/// Create a feature class in the default geodatabase of the project.
/// </summary>
/// <param name="featureclassName">Name of the feature class to be created.</param>
/// <param name="featureclassType">Type of feature class to be created. Options are:
/// <list type="bullet">
/// <item>POINT</item>
/// <item>MULTIPOINT</item>
/// <item>POLYLINE</item>
/// <item>POLYGON</item></list></param>
/// <returns></returns>
private static async Task CreateLayer(string featureclassName, string featureclassType)
{
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
featureclassType,
// no template
"",
// no z values
"DISABLED",
// no m values
"DISABLED"
};
await QueuedTask.Run(() =>
{
// spatial reference
arguments.Add(SpatialReferenceBuilder.CreateSpatialReference(3857));
});
IGPResult result = await Geoprocessing.ExecuteToolAsync("CreateFeatureclass_management", Geoprocessing.MakeValueArray(arguments.ToArray()));
}
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);
}
}
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);
}
}
/// <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);
}
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
}
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);
}
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);
}
}
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 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);
}
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);
});
}
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);
}
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);
}
}
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);
}
}
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 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);
}
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 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);
}
private async Task <bool> Project(string shapeFile, string outputPath)
{
var projectToolParams
= await QueuedTask.Run(() => Geoprocessing.MakeValueArray(shapeFile, outputPath, _targetReferenceSystem));
var result = await Geoprocessing.ExecuteToolAsync("management.Project", projectToolParams, null,
_cancelHandler.Progressor, GPExecuteToolFlags.None | GPExecuteToolFlags.GPThread);
return(!result.IsFailed);
}
private async Task <bool> Clip(string shapeFile, string outputPath)
{
var clipToolParams
= await QueuedTask.Run(() => Geoprocessing.MakeValueArray(shapeFile, _clipExtentShapeFile, outputPath));
var result = await Geoprocessing.ExecuteToolAsync("analysis.Clip", clipToolParams, null,
_cancelHandler.Progressor, GPExecuteToolFlags.None | GPExecuteToolFlags.GPThread);
return(!result.IsFailed);
}
private async Task <bool> CopyShapeFile(string shapeFile, string targetPath)
{
var copyToolParams
= await QueuedTask.Run(() => Geoprocessing.MakeValueArray(shapeFile, targetPath));
var result = await Geoprocessing.ExecuteToolAsync("management.CopyFeatures", copyToolParams, null,
_cancelHandler.Progressor, GPExecuteToolFlags.None | GPExecuteToolFlags.GPThread);
return(!result.IsFailed);
}
public async void ShowMessageBox()
{
#region message_box
var gp_result = await Geoprocessing.ExecuteToolAsync("management.GetCount", Geoprocessing.MakeValueArray(@"C:\data\f.gdb\hello"));
// this icon shows up left of content_header
string icon_src = @"C:\data\Icons\ModifyLink32.png";
Geoprocessing.ShowMessageBox(gp_result.Messages, "Content Header", GPMessageBoxStyle.Error, "Window Title", icon_src);
#endregion
}
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);
}