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);
}
}
/// <summary>
/// Get GUID from Layer
/// </summary>
/// <param name="Fl">BasicFeatureLayer</param>
/// <param name="SelectedFeatures">Selection</param>
/// <returns></returns>
private static List <Guid> GetGuidFromLayer(BasicFeatureLayer Fl, Selection SelectedFeatures)
{
List <Guid> listIds = new List <Guid>();
// Some SGDB having limitations on the list size when using WHERE IN clauses, the list is cut in smaller lists
List <string> lEid = FormatOidToString(SelectedFeatures.GetObjectIDs().ToList());
TableDefinition tbl = Fl.GetTable().GetDefinition();
string FieldName = tbl.GetObjectIDField();
QueryFilter qf = new QueryFilter
{
SubFields = "*"
};
//List<long> lselected = new List<long>();
foreach (string se in lEid)
{
qf.WhereClause = String.Format("{0} IN ({1})", FieldName, se);
try
{
RowCursor rc = Fl.Search(qf);
while (rc.MoveNext())
{
listIds.Add(rc.Current.GetGlobalID());
}
}
catch { }
}
return(listIds);
}
protected override async Task <bool> OnSketchCompleteAsync(Geometry geometry)
{
//1 select features based on geometry
System.Windows.Point bottomRight = new System.Windows.Point();
Dictionary <BasicFeatureLayer, List <long> > allfeatures = new Dictionary <BasicFeatureLayer, List <long> >();
await QueuedTask.Run(() =>
{
allfeatures = ActiveMapView.SelectFeatures(geometry, SelectionCombinationMethod.New, false, false);
});
//2 build a context menu with the layers and (re)select by user's layer-choice
ShowContextMenu(bottomRight, allfeatures);
//3
BasicFeatureLayer bfl = null;
foreach (KeyValuePair <BasicFeatureLayer, List <long> > entry in allfeatures)
{
if (entry.Key.SelectionCount > 0)
{
bfl = entry.Key;
}
}
return(true);
}
public static IEnumerable <Feature> GetSelectedFeatures([CanBeNull] BasicFeatureLayer layer)
{
Selection selection = layer?.GetSelection();
if (selection == null)
{
yield break;
}
RowCursor cursor = selection.Search(null, false);
try
{
while (cursor.MoveNext())
{
var feature = (Feature)cursor.Current;
yield return(feature);
}
}
finally
{
cursor.Dispose();
}
}
private void CutBuilding(MapViewMouseButtonEventArgs e)
{
QueuedTask.Run(() =>
{
Dictionary <MapMember, List <long> > selectedItems = GetSelectedItems(e);
EditOperation editOperation = new EditOperation();
foreach (KeyValuePair <MapMember, List <long> > item in selectedItems)
{
BasicFeatureLayer layer = item.Key as BasicFeatureLayer;
if (layer.ShapeType != ArcGIS.Core.CIM.esriGeometryType.esriGeometryPolygon)
{
continue;
}
foreach (long oid in item.Value)
{
var feature = layer.Inspect(oid);
Geometry geometry = feature.Shape.Clone();
Polyline polyLine = GetCutPolyLine(geometry);
var splitItems = GeometryEngine.Cut(geometry, polyLine);
feature.Shape = splitItems.First();
editOperation.Modify(feature);
Layer pointLayer = MapView.Active.Map.Layers[0];
editOperation.Create(pointLayer, geometry.Extent.Center);
}
editOperation.Execute();
}
MapView.Active.Map.SetSelection(null);
});
}
public static GeodatabaseType?GetGeodatabaseType(this BasicFeatureLayer layer)
{
if (layer.ConnectionStatus == ConnectionStatus.Broken)
{
return(null);
}
GeodatabaseType?gdbType = GeodatabaseType.FileSystem;
using (var dataset = layer.GetTable())
{
using (var gdb = dataset.GetDatastore())
{
//new at 2.3
if (gdb is PluginDatastore)
{
return(null);
}
//Note shapefile will be "FileSystemDatastore"
if (gdb is Geodatabase)
{
gdbType = ((Geodatabase)gdb).GetGeodatabaseType();
}
}
}
return(gdbType);
}
protected override async void OnClick()
{
try
{
BasicFeatureLayer layer = null;
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
//find selected layer
if (MapView.Active.GetSelectedLayers().Count == 0)
{
MessageBox.Show("Select a feature class from the Content 'Table of Content' first.");
return;
}
layer = MapView.Active.GetSelectedLayers()[0] as BasicFeatureLayer;
});
if (layer == null)
{
MessageBox.Show("Unable to find a feature class at the first layer of the active map");
}
else
{
MessageBox.Show($@"{layer.Name} was found .... adding a new Field");
await
ExecuteAddFieldTool(layer, new KeyValuePair <string, string>("AddedField", "Alias Name Added Field"), "Text", 50);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
private void MoveWalls(MapViewMouseButtonEventArgs e)
{
QueuedTask.Run(() =>
{
Dictionary <MapMember, List <long> > selectedItems = GetSelectedItems(e);
EditOperation editOperation = new EditOperation();
foreach (KeyValuePair <MapMember, List <long> > item in selectedItems)
{
BasicFeatureLayer layer = item.Key as BasicFeatureLayer;
if (layer.ShapeType != ArcGIS.Core.CIM.esriGeometryType.esriGeometryPolygon)
{
continue;
}
foreach (long oid in item.Value)
{
var feature = layer.Inspect(oid);
double hoogte = double.Parse(feature["PandHoogte"].ToString());
int verdieping = int.Parse(feature["Verdieping"].ToString());
Geometry geom = feature.Shape.Clone();
Geometry removeGeometry = GeometryEngine.Scale(geom, geom.Extent.Center, 1.2, 1.2);
Geometry wallGeometry = GeometryEngine.Scale(geom, geom.Extent.Center, 1.3, 1.3);
editOperation.Scale(selectedItems, feature.Shape.Extent.Center, 0.9, 0.9);
editOperation.Create(layer, wallGeometry, new Action <long>(x => OnExtractWalls(x, layer, removeGeometry, hoogte, verdieping)));
}
editOperation.Execute();
}
MapView.Active.Map.SetSelection(null);
});
}
private string GetImageFileName(BasicFeatureLayer layer)
{
string imageFileName = "";
switch (layer.ShapeType)
{
case ArcGIS.Core.CIM.esriGeometryType.esriGeometryPoint:
case ArcGIS.Core.CIM.esriGeometryType.esriGeometryMultipoint:
imageFileName = "esri_PntFeature.png";
break;
case ArcGIS.Core.CIM.esriGeometryType.esriGeometryLine:
case ArcGIS.Core.CIM.esriGeometryType.esriGeometryPolyline:
case ArcGIS.Core.CIM.esriGeometryType.esriGeometryPath:
case ArcGIS.Core.CIM.esriGeometryType.esriGeometryCircularArc:
case ArcGIS.Core.CIM.esriGeometryType.esriGeometryEllipticArc:
case ArcGIS.Core.CIM.esriGeometryType.esriGeometryMultiPatch:
imageFileName = "esri_LinFeature.png";
break;
case ArcGIS.Core.CIM.esriGeometryType.esriGeometryEnvelope:
case ArcGIS.Core.CIM.esriGeometryType.esriGeometryPolygon:
imageFileName = "esri_PolFeature.png";
break;
default:
imageFileName = "esri_PntFeature.png";
break;
}
return(imageFileName);
}
private string GetImageFileName(BasicFeatureLayer layer)
{
string imageFileName = "";
switch (layer.ShapeType)
{
case ArcGIS.Core.CIM.esriGeometryType.esriGeometryPoint:
case ArcGIS.Core.CIM.esriGeometryType.esriGeometryMultipoint:
imageFileName = "esri_PntFeature.png";
break;
case ArcGIS.Core.CIM.esriGeometryType.esriGeometryLine:
case ArcGIS.Core.CIM.esriGeometryType.esriGeometryPolyline:
case ArcGIS.Core.CIM.esriGeometryType.esriGeometryPath:
case ArcGIS.Core.CIM.esriGeometryType.esriGeometryCircularArc:
case ArcGIS.Core.CIM.esriGeometryType.esriGeometryEllipticArc:
case ArcGIS.Core.CIM.esriGeometryType.esriGeometryMultiPatch:
imageFileName = "esri_LinFeature.png";
break;
case ArcGIS.Core.CIM.esriGeometryType.esriGeometryEnvelope:
case ArcGIS.Core.CIM.esriGeometryType.esriGeometryPolygon:
imageFileName = "esri_PolFeature.png";
break;
default:
imageFileName = "esri_PntFeature.png";
break;
}
return imageFileName;
}
private static IEnumerable <Feature> GetFeatures([CanBeNull] BasicFeatureLayer layer,
[NotNull] List <long> oids,
bool recycling = false)
{
if (layer == null)
{
yield break;
}
// TODO: Use layer search (there might habe been an issue with recycling?!)
var featureClass = layer.GetTable();
var filter = new QueryFilter
{
WhereClause =
$"{featureClass.GetDefinition().GetObjectIDField()} IN ({StringUtils.Concatenate(oids, ", ")})"
};
filter.OutputSpatialReference = layer.GetSpatialReference();
foreach (var feature in GdbQueryUtils.GetFeatures(featureClass, filter, recycling))
{
yield return(feature);
}
}
protected override async void OnClick()
{
try
{
BasicFeatureLayer layer = null;
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
//find selected layer
if (MapView.Active.GetSelectedLayers().Count == 0)
{
MessageBox.Show("Select a feature class from the Content 'Table of Content' first.");
return;
}
layer = MapView.Active.GetSelectedLayers()[0] as BasicFeatureLayer;
});
if (layer == null)
{
MessageBox.Show("Unable to find a feature class at the first layer of the active map");
}
else
{
var dataSource = await GetDataSource(layer);
MessageBox.Show($@"{dataSource} was found .... deleting the newly added field");
await
ExecuteDeleteFieldTool(layer, "AddedField");
}
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
/// <summary>
/// Initialize a QueryBuilderControlProperties with the specified mapMember. Use the current definition query of that mapMember (if it exists) to extend the
/// initialization.
/// </summary>
/// <param name="mapMember">MapMember to initialize the QueryBuilderControlProperties. </param>
private void BuildControlProperties(MapMember mapMember)
{
// find the current definition query for the mapMember
string expression = "";
BasicFeatureLayer fLayer = mapMember as BasicFeatureLayer;
StandaloneTable table = mapMember as StandaloneTable;
if (fLayer != null)
{
expression = fLayer.DefinitionQuery;
}
else if (table != null)
{
expression = table.DefinitionQuery;
}
// create it
var props = new QueryBuilderControlProperties()
{
MapMember = mapMember,
Expression = expression,
};
// set the binding properties
this.ControlProperties = props;
MapMemberName = mapMember?.Name ?? "";
// keep track of the original expression
_origExpression = expression;
}
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;
}
}
protected override async void OnClick()
{
try
{
BasicFeatureLayer layer = null;
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
//find selected layer
if (MapView.Active.GetSelectedLayers().Count == 0)
{
MessageBox.Show("Select a feature class from the Content 'Table of Content' first.");
return;
}
layer = MapView.Active.GetSelectedLayers()[0] as BasicFeatureLayer;
});
if (layer == null)
{
MessageBox.Show("Unable to find a feature class at the first layer of the active map");
}
else
{
var dataSource = await GetDataSource(layer);
string newLine = Environment.NewLine;
MessageBox.Show("Click 'OK' to add new excel file to:" + newLine + $@"{dataSource}");
await
ExecuteAddExcelTool(layer, new KeyValuePair <string, string>("AddedField1", "Alias Text"), "Text", 50);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
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>
/// Get the list of selected features GUID from the layer
/// </summary>
/// <param name="fl">Layer</param>
/// <param name="selectedFeatures">Selected features</param>
/// <returns>List of GUID</returns>
private static List <Guid> GetGuidFromLayer(BasicFeatureLayer fl, Selection selectedFeatures)
{
List <Guid> listIds = new List <Guid>();
// some data have restriction of element number in a clause IN, so we cut the in smaller list
List <string> lEid = FormatOidToString(selectedFeatures.GetObjectIDs().ToList());
TableDefinition tbl = fl.GetTable().GetDefinition();
string FieldName = tbl.GetObjectIDField();
QueryFilter qf = new QueryFilter
{
SubFields = "*"
};
foreach (string se in lEid)
{
qf.WhereClause = String.Format("{0} IN ({1})", FieldName, se);
try
{
RowCursor rc = fl.Search(qf);
while (rc.MoveNext())
{
listIds.Add(rc.Current.GetGlobalID());
}
}
catch { }
}
return(listIds);
}
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);
}
}
protected override Task OnToolActivateAsync(bool active)
{
if (_vm == null)
{
_vm = this.OverlayEmbeddableControl as OverlayControlViewModel;
}
if (_overlaySymbol == null)
{
QueuedTask.Run(() => {
_overlaySymbol = SymbolFactory.ConstructPointSymbol(ColorFactory.Red, 12.0, SimpleMarkerStyle.Circle);
});
}
if (_trees == null)
{
_trees = ActiveMapView.Map.GetLayersAsFlattenedList().FirstOrDefault((lyr) => lyr.Name == "Tree") as BasicFeatureLayer;
}
if (_theInspector == null)
{
_theInspector = new Inspector();
var tuple = _theInspector.CreateEmbeddableControl();
_vm.InspectorView = tuple.Item2;
_vm.InspectorViewModel = tuple.Item1;
}
return(base.OnToolActivateAsync(active));
}
public async static void DeleteAllFeatures(BasicFeatureLayer layer)
{
var deleteOp = new EditOperation();
deleteOp.Delete(layer, SharedFunctions.GetAllIdsFromLayer(layer));
await deleteOp.ExecuteAsync();
}
private async Task <Geodatabase> GetGDBFromLyrAsync(BasicFeatureLayer lyr)
{
Geodatabase geodatabase = null;
await QueuedTask.Run(() => geodatabase = (lyr.GetTable().GetDatastore() as Geodatabase));
return(geodatabase);
}
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 void Difference(this EditOperation editOp, BasicFeatureLayer layer,
IEnumerable <long> oids, Geometry diffGeom)
{
foreach (var oid in oids)
{
editOp.Difference(layer, oid, diffGeom);
}
}
//protected override void OnClick(int index)
//{
// BasicFeatureLayer bfl = _selectedFeatures[index].Item1;
// long oid = _selectedFeatures[index].Item2;
// System.Windows.MessageBox.Show(
// string.Format("You clicked on {0}: {1}", bfl.Name, oid));
// base.OnClick(index);
//}
void OnFeatureSelected(BasicFeatureLayer layer, long oid)
{
var mapView = MapView.Active;
mapView?.FlashFeature(layer, oid);
Thread.Sleep(1000);
mapView?.FlashFeature(layer, oid);
}
public static EditOperationType?GetEditOperationType(this BasicFeatureLayer layer)
{
if (layer.ConnectionStatus == ConnectionStatus.Broken)
{
return(null);
}
var gdbType = layer.GetGeodatabaseType();
var regType = layer.GetRegistrationType();
//Plugin - new at 2.3
if (gdbType == null)
{
return(null);
}
//FileSystem
if (gdbType == GeodatabaseType.FileSystem)
{
return(EditOperationType.Long);
}
//LocalDatabase
if (gdbType == GeodatabaseType.LocalDatabase)
{
return(EditOperationType.Long);
}
//RemoteDatabase, Versioned
if (gdbType == GeodatabaseType.RemoteDatabase && (
regType == RegistrationType.Versioned || regType == RegistrationType.VersionedWithMoveToBase))
{
return(EditOperationType.Long);
}
//RemoteDatabase, NonVersioned
if (gdbType == GeodatabaseType.RemoteDatabase && regType == RegistrationType.Nonversioned)
{
return(EditOperationType.Short);
}
//Service, NonVersioned
if (gdbType == GeodatabaseType.Service && regType == RegistrationType.Nonversioned)
{
return(EditOperationType.Short);
}
//Service, Versioned, Default
EditOperationType forBranch = EditOperationType.Long;
if (gdbType == GeodatabaseType.Service && regType == RegistrationType.Versioned)
{
using (var dataset = layer.GetTable())
using (var gdb = dataset.GetDatastore() as Geodatabase)
using (var vmgr = gdb.GetVersionManager())
using (var vers = vmgr.GetCurrentVersion())
using (var parent = vers.GetParent())
{
//non-default supports undo/redo and save/discard. Default does not
forBranch = parent != null ? EditOperationType.Long : EditOperationType.Short;
}
}
return(forBranch);
}
public static IEnumerable <Feature> GetFeatures(
KeyValuePair <BasicFeatureLayer, List <long> > layerOids)
{
BasicFeatureLayer layer = layerOids.Key;
foreach (var feature in GetFeatures(layer, layerOids.Value))
{
yield return(feature);
}
}
public SelectedFeature(BasicFeatureLayer featureLayer, long objectId)
{
FeatureLayer = featureLayer;
if (featureLayer != null)
{
FeatureLayerName = featureLayer.Name;
}
ObjectId = objectId;
}
//protected override void OnClick(int index)
//{
// BasicFeatureLayer bfl = _selectedFeatures[index].Item1;
// long oid = _selectedFeatures[index].Item2;
// System.Windows.MessageBox.Show(
// string.Format("You clicked on {0}: {1}", bfl.Name, oid));
// base.OnClick(index);
//}
void OnFeatureSelected(BasicFeatureLayer layer, long oid)
{
var mapView = MapView.Active;
mapView?.FlashFeature(layer, oid);
Thread.Sleep(1000);
mapView?.FlashFeature(layer, oid);
//Show pop-up of feature
mapView?.ShowPopup(layer, oid);
}
private async Task <Geodatabase> GetGDBFromLayer(BasicFeatureLayer layer)
{
if (layer == null)
{
return(null);
}
Geodatabase geodatabase = null;
await QueuedTask.Run(() => geodatabase = (layer.GetTable().GetDatastore() as Geodatabase));
return(geodatabase);
}
protected override async void OnClick()
{
try
{
BasicFeatureLayer layer = null;
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
//find selected layer
if (MapView.Active.GetSelectedLayers().Count == 0)
{
MessageBox.Show("Select a feature class from the Content 'Table of Content' first.");
return;
}
layer = MapView.Active.GetSelectedLayers()[0] as BasicFeatureLayer;
});
if (layer == null)
{
MessageBox.Show("Unable to find a feature class at the first layer of the active map");
}
else
{
var dataSource = await GetDataSource(layer);
string newLine = Environment.NewLine;
MessageBox.Show("Click 'OK' to add new fields to:" + newLine + $@"{dataSource}");
await
ExecuteAddFieldTool(layer, new KeyValuePair <string, string>("AddedField1", "Polygon_Code"), "Text", 255);
await
ExecuteAddFieldTool(layer, new KeyValuePair <string, string>("AddedField2", "Survey_Year"), "Short");
await
ExecuteAddFieldTool(layer, new KeyValuePair <string, string>("AddedField3", "Survey_Season"), "Text", 6);
await
ExecuteAddFieldTool(layer, new KeyValuePair <string, string>("AddedField4", "Survey_Month"), "Text", 3);
await
ExecuteAddFieldTool(layer, new KeyValuePair <string, string>("AddedField5", "Comments"), "Text", 50);
await
ExecuteAddFieldTool(layer, new KeyValuePair <string, string>("AddedField6", "Length_ft"), "Double");
await
ExecuteAddFieldTool(layer, new KeyValuePair <string, string>("AddedField7", "Width_ft"), "Double");
await
ExecuteAddFieldTool(layer, new KeyValuePair <string, string>("AddedField8", "Collector"), "String", 50);
await
ExecuteAddFieldTool(layer, new KeyValuePair <string, string>("AddedField9", "ID_Code"), "String", 50);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
/// <summary>
/// Calculate viewpoint coordinates from vector points.
/// </summary>
/// <param name="viewpointLayer">Layer which contains the viewpoints.</param>
/// <returns></returns>
private HashSet <SpatialUtils.ViewpointProps> GetPoints(BasicFeatureLayer viewpointLayer)
{
HashSet <SpatialUtils.ViewpointProps> result = new HashSet <SpatialUtils.ViewpointProps>(); //using hash set to prevent duplicates, possible speed up with array
Table table = viewpointLayer.GetTable();
string query = "POINT_X, POINT_Y";
if (!SettingsManager.Instance.CurrentSettings.OffsetGlobal)
{
query += ", OFFSET";
}
if (SettingsManager.Instance.CurrentSettings.WeightedViewpoints)
{
query += ", WEIGHT";
}
QueryFilter queryFilter = new QueryFilter {
SubFields = query
};
using (RowCursor rowCursor = table.Search(queryFilter, false)) {
while (rowCursor.MoveNext())
{
using (Row row = rowCursor.Current) {
double pointX = Convert.ToDouble(row["POINT_X"]);
double pointY = Convert.ToDouble(row["POINT_Y"]);
Tuple <int, int> point = inputRaster.MapToPixel(pointX, pointY);
double altOffset = 0;
double weight = 1;
if (!SettingsManager.Instance.CurrentSettings.OffsetGlobal)
{
altOffset = Convert.ToDouble(row["OFFSET"]);
}
if (SettingsManager.Instance.CurrentSettings.WeightedViewpoints)
{
weight = Convert.ToDouble(row["WEIGHT"]);
}
result.Add(new SpatialUtils.ViewpointProps()
{
X = point.Item1,
Y = point.Item2,
ElevationOffset = altOffset,
Weight = weight
});
}
}
}
return(result);
}
public static void Difference(this EditOperation editOp, BasicFeatureLayer layer,
long oid, Geometry diffGeom)
{
var insp = new Inspector();
insp.Load(layer, oid);
//do the difference
var geom = GeometryEngine.Instance.Difference((Geometry)insp["SHAPE"], diffGeom);
insp["SHAPE"] = geom;
//call modify
editOp.Modify(insp);
}
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;
}
}
/// <summary>
/// Sets the layer and objectid of the selected feature
/// </summary>
/// <param name="layer"></param>
/// <param name="oid"></param>
public void SetSelected(BasicFeatureLayer layer, long oid) {
_theSymbolView.SelectedFeature = new Tuple<BasicFeatureLayer, long>(layer, oid);
}
public SelectedFeature(BasicFeatureLayer featureLayer, long objectId)
{
FeatureLayer = featureLayer;
FeatureLayerName = featureLayer.Name;
ObjectId = objectId;
}
//protected override void OnClick(int index)
//{
// BasicFeatureLayer bfl = _selectedFeatures[index].Item1;
// long oid = _selectedFeatures[index].Item2;
// System.Windows.MessageBox.Show(
// string.Format("You clicked on {0}: {1}", bfl.Name, oid));
// base.OnClick(index);
//}
void OnFeatureSelected(BasicFeatureLayer layer, long oid)
{
var mapView = MapView.Active;
mapView?.FlashFeature(layer, oid);
Thread.Sleep(1000);
mapView?.FlashFeature(layer, oid);
//Show pop-up of feature
mapView?.ShowPopup(layer, oid);
}
/// <summary>
/// Check if the given layer supports the Mil2525d spec.
/// </summary>
/// <remarks>Currently checks for symbolset</remarks>
/// <param name="layer"></param>
/// <returns></returns>
public static Task<bool> HasMil2525Attributes(BasicFeatureLayer layer) {
return QueuedTask.Run(() => {
var fdescs = layer.GetFieldDescriptions();
foreach (var fdesc in fdescs) {
if (fdesc.Name.ToLower() == "symbolset")
return true;
}
return false;
});
}
private async Task<Geodatabase> GetGDBFromLyrAsync(BasicFeatureLayer lyr)
{
Geodatabase geodatabase = null;
await QueuedTask.Run(() => geodatabase = (lyr.GetTable().GetDatastore() as Geodatabase));
return geodatabase;
}
public SelectedLayerInfo(BasicFeatureLayer selectedLayer, long? selectedOID)
{
SelectedLayer = selectedLayer;
SelectedOID = selectedOID;
}
