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; }
/// <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; }