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(); } } }
public static async Task KeyPointsIntegration() { await QueuedTask.Run(() => { using (Geodatabase gdb1 = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(GeoDataTool.DefaultProject.DefaultGeodatabasePath)))) { gdb1.ApplyEdits(() => { FeatureClass voyageRiskKeyPoint = gdb1.OpenDataset <FeatureClass>(ConstDefintion.ConstFeatureClass_VoyageRiskKeyPoint); FeatureClassDefinition voyageRiskKeyPointDefinition = gdb1.GetDefinition <FeatureClassDefinition>(ConstDefintion.ConstFeatureClass_VoyageRiskKeyPoint); voyageRiskKeyPoint.DeleteRows(new QueryFilter() { WhereClause = "OBJECTID >= 1" }); string shapeFieldName = voyageRiskKeyPointDefinition.GetShapeField(); RiskAssessment(gdb1, voyageRiskKeyPoint, ConstDefintion.ConstFeatureClass_VoyageMaskInternalPoint, 1); RiskAssessment(gdb1, voyageRiskKeyPoint, ConstDefintion.ConstFeatureClass_VoyageMaskOutlinePoint, 0); double midLocaRisk = Math.Pow(0.5, 3.03); RiskAssessment(gdb1, voyageRiskKeyPoint, ConstDefintion.ConstFeatureClass_VoyageMaskLocaMidPoint, midLocaRisk); RiskAssessment(gdb1, voyageRiskKeyPoint, ConstDefintion.ConstFeatureClass_VoyageMaskRiskMidPoint, 0.5); }); } }); }
public async Task UpdateFeatureAsync(long uid, Geometry geometry) { await QueuedTask.Run(() => { using (FeatureClass featureClass = Layer.GetFeatureClass()) { FeatureClassDefinition definition = featureClass?.GetDefinition(); string objectIdField = definition?.GetObjectIDField(); QueryFilter filter = new QueryFilter { WhereClause = $"{objectIdField} = {uid}" }; using (RowCursor existsResult = featureClass?.Search(filter, false)) { while (existsResult?.MoveNext() ?? false) { using (Row row = existsResult.Current) { Feature feature = row as Feature; feature?.SetShape(geometry); feature?.Store(); } } } } }); }
public static async Task <bool> ZoomToExtentAsync(Uri aoiUri, double bufferFactor = 1) { //Get the active map view. var mapView = MapView.Active; if (mapView == null) { return(false); } string strFileName = null; string strFolderPath = null; if (aoiUri.IsFile) { strFileName = System.IO.Path.GetFileName(aoiUri.LocalPath); strFolderPath = System.IO.Path.GetDirectoryName(aoiUri.LocalPath); } Envelope zoomEnv = null; await QueuedTask.Run(() => { // Opens a file geodatabase. This will open the geodatabase if the folder exists and contains a valid geodatabase. using ( Geodatabase geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(strFolderPath)))) { // Use the geodatabase. FeatureClassDefinition fcDefinition = geodatabase.GetDefinition <FeatureClassDefinition>(strFileName); zoomEnv = fcDefinition.GetExtent().Expand(bufferFactor, bufferFactor, true); } }); //Zoom the view to a given extent. return(await mapView.ZoomToAsync(zoomEnv, null)); }
protected override async void OnClick() { var selectedLayer = MapView.Active.GetSelectedLayers().FirstOrDefault(); if (selectedLayer == null || !(selectedLayer is FeatureLayer)) { MessageBox.Show("You have to select a feature layer. The selected layer's database connection is then used to create the new FeatureClass."); return; } var selectedFeatureLayer = selectedLayer as FeatureLayer; await QueuedTask.Run(() => { var selectedLayerTable = selectedFeatureLayer.GetTable(); var stringFieldDescription = new ArcGIS.Core.Data.DDL.FieldDescription("TheString", FieldType.String); var intFieldDescription = new ArcGIS.Core.Data.DDL.FieldDescription("TheInteger", FieldType.Integer); var dblFieldDescription = new ArcGIS.Core.Data.DDL.FieldDescription("TheDouble", FieldType.Double) { Precision = 9, Scale = 5 }; var dateFieldDescription = new ArcGIS.Core.Data.DDL.FieldDescription("TheDate", FieldType.Date); using (var geoDb = selectedLayerTable.GetDatastore() as Geodatabase) { var fcName = selectedLayerTable.GetName(); try { FeatureClassDefinition originalFeatureClassDefinition = geoDb.GetDefinition <FeatureClassDefinition>(fcName); FeatureClassDescription originalFeatureClassDescription = new FeatureClassDescription(originalFeatureClassDefinition); // Assemble a list of all of new field descriptions var fieldDescriptions = new List <ArcGIS.Core.Data.DDL.FieldDescription>() { stringFieldDescription, intFieldDescription, dblFieldDescription, dateFieldDescription }; // Create a FeatureClassDescription object to describe the feature class to create var fcDescription = new FeatureClassDescription(fcName, fieldDescriptions, originalFeatureClassDescription.ShapeDescription); // Create a SchemaBuilder object SchemaBuilder schemaBuilder = new SchemaBuilder(geoDb); // Add the modification to the feature class to our list of DDL tasks schemaBuilder.Modify(fcDescription); // Execute the DDL bool success = schemaBuilder.Build(); } catch (Exception ex) { MessageBox.Show($@"Exception: {ex}"); } } }); }
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); }
/// <summary> /// Check to make sure the enviornment is set up correctly before processing the users request /// /// </summary> /// <returns></returns> private async Task <bool> CheckRequirements() { if (_selectedMap == null) { MessageBox.Show("Select A Map In Domain Appointer Settings"); return(false); } if (_selectedLayer == null) { MessageBox.Show("Select A Layer in Domain Appointer Settings"); return(false); } if (_selectedField == null) { MessageBox.Show("Select a Field in Domain Appointer Settings"); } bool canEditData = false; await QueuedTask.Run(() => { canEditData = _selectedLayer.CanEditData(); }); if (!canEditData) { MessageBox.Show("Feature Layer '" + _selectedLayer.Name + "' Is not Editable"); return(false); } IEnumerable <Field> fields = null; await QueuedTask.Run(() => { Table table = _selectedLayer.GetTable(); if (table is FeatureClass) { FeatureClass featureclass = table as FeatureClass; using (FeatureClassDefinition def = featureclass.GetDefinition()) { fields = def.GetFields(); } } }); var match = fields.FirstOrDefault(field => field.Name.ToLower().Contains(_selectedField.ToLower())); if (match == null) { MessageBox.Show("The field '" + _selectedField + "' is Missing From '" + _selectedLayer.Name + "' Feature Layer"); return(false); } return(true); }
protected override IAttributeReader CreateAttributeReaderCore(FeatureClassDefinition definition) { return(new AttributeReader(definition, Attributes.QualityConditionName, Attributes.IssueCodeDescription, Attributes.InvolvedObjects, Attributes.IssueSeverity, Attributes.IssueCode)); }
private async Task <Boolean> CheckRequirements() { if (_selectedMap == null) { MessageBox.Show("Select A Map In File Tile Opener Settings"); return(false); } if (_selectedFeatureLayer == null) { MessageBox.Show("Select A Layer in File Tile Opener Settings"); return(false); } if (_selectedField == null) { MessageBox.Show("Select a Field in File Tile Opener Settings"); } IEnumerable <Field> fields = null; await QueuedTask.Run(() => { Table table = _selectedFeatureLayer.GetTable(); if (table is FeatureClass) { FeatureClass featureclass = table as FeatureClass; using (FeatureClassDefinition def = featureclass.GetDefinition()) { fields = def.GetFields(); } } }); var match = fields.FirstOrDefault(field => field.Name.ToLower().Contains(_selectedField.ToLower())); if (match == null) { MessageBox.Show("This field '" + _selectedField + "' is Missing From '" + _selectedFeatureLayer.Name + "' Feature Layer", "Oops"); return(false); } // No need to check for whitespace. I disallow this in the 'view'. if (String.IsNullOrEmpty(_fileExtension)) { MessageBox.Show("Type or Choose a File Extension in File Tile Opener Settings"); return(false); } if (String.IsNullOrWhiteSpace(_fileWorkspace)) { MessageBox.Show("Type or Choose a File Workspace in File Tile Opener Settings"); return(false); } return(true); }
//[CanBeNull] //protected Table OpenFeatureClass2([NotNull] ISourceClass sourceClass) //{ // return GeodatabaseBySourceClasses.TryGetValue(sourceClass, out Geodatabase gdb) // ? sourceClass.OpenFeatureClass(gdb) // : null; //} private ISourceClass CreateSourceClass(GdbTableIdentity identity, FeatureClassDefinition definition) { IAttributeReader attributeReader = CreateAttributeReaderCore(definition); WorkListStatusSchema statusSchema = CreateStatusSchemaCore(definition); ISourceClass sourceClass = CreateSourceClassCore(identity, attributeReader, statusSchema); return(sourceClass); }
/// <summary> /// Create sample polygon feature using the point geometries from the multi-point feature using the /// ConvexHull method provided by the GeometryEngine. /// </summary> /// <param name="polygonLayer">Polygon geometry feature layer used to add the new feature.</param> /// <param name="lineLayer">The polyline feature layer containing the features used to construct the polygon.</param> /// <returns></returns> private void constructSamplePolygon(FeatureLayer polygonLayer, FeatureLayer lineLayer) { // execute the fine grained API calls on the CIM main thread //return QueuingTaskFactory.StartNew(() => //{ // get the feature classes and their definitions // get the underlying feature class for each layer var polygonFeatureClass = polygonLayer.GetTableAsync().Result as FeatureClass; var lineFeatureClass = lineLayer.GetTableAsync().Result as FeatureClass; FeatureClassDefinition polygonDefinition = null; FeatureClassDefinition polylineDefinition = null; // construct a cursor to retrieve the line features var lineCursor = lineFeatureClass.Search(null, false); // set up the edit operation for the feature creation var createOperation = EditingModule.CreateEditOperation(); createOperation.Name = "Create polygons"; // construct the polygon geometry from the convex hull of the combined polyline features // by contructing a convex hull // HINT: GeometryEngine.ConvexHull List <CoordinateCollection> combinedCoordinates = new List <CoordinateCollection>(); while (lineCursor.MoveNext()) { // TODO // add the feature geometry into the overall list of coordinate collections // retrieve the first feature //var lineFeature = ... use the current property of the cursor // add the coordinate collection of the current geometry into our overall list of collections //var polylineGeometry = lineFeature.Shape as Polyline; //combinedCoordinates.AddRange ... Hint: we want the part collection of the polyline } // TODO //construct a polygon geometry from the convex hull of the polyline //constructed from the list of coordinate collections combined from all the polylines //var polyLine = new Polyline(..., lineFeatureClass.SpatialReference) //var geom = GeometryEngine.ConvexHull(... //var newPolygon = Polygon.Clone(... // TODO // specify the create edit operation // TODO // execute the operation // TODO // save the edits //return EditingModule.SaveEditsAsync(); //}); }
/// <summary> /// Illustrates how to use the HasValueChanged() method. /// </summary> /// <returns></returns> private static async Task FileGeodatabaseWorkFlow() { using (Geodatabase fileGeodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(@"C:\Data\LocalGovernment.gdb")))) using (FeatureClass featureClass = fileGeodatabase.OpenDataset <FeatureClass>("PollingPlace")) { EditOperation editOperation = new EditOperation(); editOperation.Callback(context => { QueryFilter queryFilter = new QueryFilter { WhereClause = "FULLADD LIKE '///%Lily Cache Ln///%'" }; using (RowCursor rowCursor = featureClass.Search(queryFilter, false)) { FeatureClassDefinition featureClassDefinition = featureClass.GetDefinition(); int shapeFieldIndex = featureClassDefinition.FindField(featureClassDefinition.GetShapeField()); while (rowCursor.MoveNext()) { using (Feature feature = (Feature)rowCursor.Current) { MapPoint mapPoint = feature.GetShape() as MapPoint; // Will be false. bool beforeChange = feature.HasValueChanged(shapeFieldIndex); // In order to update the Map and/or the attribute table. // Has to be called before any changes are made to the row context.Invalidate(feature); MapPoint newShape = new MapPointBuilder(mapPoint.X + 10, mapPoint.Y, mapPoint.SpatialReference).ToGeometry(); feature.SetShape(newShape); // Will be true. bool afterChange = feature.HasValueChanged(shapeFieldIndex); feature.Store(); //Will be false. bool afterStore = feature.HasValueChanged(shapeFieldIndex); // Has to be called after the store too context.Invalidate(feature); } } } }, featureClass); bool editResult = editOperation.Execute(); //This is required to persist the changes to the disk. bool saveResult = await Project.Current.SaveEditsAsync(); } }
/// <summary> /// Validates Conditions for user before attempting to edit the data /// </summary> /// <returns></returns> private async Task <bool> PrepStatus() { if (_selectedMap == null) { MessageBox.Show("Select A Map In Inspector Settings"); return(false); } if (_selectedLayer == null) { MessageBox.Show("Select A Layer in Inspector Settings"); return(false); } IEnumerable <Field> fields = null; FeatureClass featureclass = null; await QueuedTask.Run(() => { // Get the fields Table table = (_selectedLayer as FeatureLayer).GetTable(); if (table is FeatureClass) { featureclass = table as FeatureClass; using (FeatureClassDefinition def = featureclass.GetDefinition()) { fields = def.GetFields(); } } }); var match = fields.FirstOrDefault(field => field.Name.ToLower().Contains(InpsectorFieldName.ToLower())); if (match == null) { MessageBox.Show("Add field named '" + InpsectorFieldName + "' to '" + _selectedLayer.Name + "' layer of type Integer"); return(false); } match = fields.FirstOrDefault(field => (field.FieldType == FieldType.SmallInteger || field.FieldType == FieldType.Integer)); if (match == null) { MessageBox.Show("Add field named '" + InpsectorFieldName + "' to '" + _selectedLayer.Name + "' layer of type Integer"); return(false); } return(true); }
double GetLength(FeatureClass fc, EnterpriseDatabaseType enterpriseDbType) { try { using (FeatureClassDefinition fcd = fc.GetDefinition()) { // the name of the length field changes depending on what enterprise geodatabase is used var areaFieldName = "Shape_Length"; switch (enterpriseDbType) { case EnterpriseDatabaseType.SQLServer: areaFieldName = "STLength"; break; } Field lengthField = fcd.GetFields().FirstOrDefault(x => x.Name.Contains(areaFieldName)); if (lengthField == null) { return(0); } System.Diagnostics.Debug.WriteLine(lengthField.Name); StatisticsDescription SumDesc = new StatisticsDescription(lengthField, new List <StatisticsFunction>() { StatisticsFunction.Sum }); TableStatisticsDescription tsd = new TableStatisticsDescription(new List <StatisticsDescription>() { SumDesc }); double sum = 0; try { sum = fc.CalculateStatistics(tsd).FirstOrDefault().StatisticsResults.FirstOrDefault().Sum; // exception is thrown on this line } catch { sum = Utilities.GetSumWorkAround(fc, lengthField.Name); } return(sum); } } catch (Exception ex) { ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show(ex.ToString(), "Error"); return(0); } }
public void MainMethodCode() { // Opening a Non-Versioned SQL Server instance. DatabaseConnectionProperties connectionProperties = new DatabaseConnectionProperties(EnterpriseDatabaseType.SQLServer) { AuthenticationMode = AuthenticationMode.DBMS, // Where testMachine is the machine where the instance is running and testInstance is the name of the SqlServer instance. Instance = @"testMachine\testInstance", // Provided that a database called LocalGovernment has been created on the testInstance and geodatabase has been enabled on the database. Database = "LocalGovernment", // Provided that a login called gdb has been created and corresponding schema has been created with the required permissions. User = "******", Password = "******", Version = "dbo.DEFAULT" }; using (Geodatabase geodatabase = new Geodatabase(connectionProperties)) using (FeatureClassDefinition featureClassDefinition = geodatabase.GetDefinition <FeatureClassDefinition>("LocalGovernment.GDB.ServiceRequestComment")) { int rankIndex = featureClassDefinition.FindField("RANK"); Field field = featureClassDefinition.GetFields()[rankIndex]; Domain domain = field.GetDomain(); RangeDomain rangeDomain = (RangeDomain)domain; // Will be "ServiceRequestRanking". string name = rangeDomain.GetName(); // Will be FieldType.Integer. FieldType fieldType = rangeDomain.GetFieldType(); // Will be "A factor assigned to unassigned service requests indicating importance". string description = rangeDomain.GetDescription(); // Will be 1. int minValue = Convert.ToInt32(rangeDomain.GetMinValue()); // Will be 5. int maxValue = Convert.ToInt32(rangeDomain.GetMaxValue()); } }
/// <summary> /// 指定されたファイルジオデータベースに同名称既存のレイヤーの存在を検査する /// </summary> public bool FeatureClassExists(string geodatabase, string featureClassName) { try { var fileGDBpath = new FileGeodatabaseConnectionPath(new Uri(geodatabase)); using (Geodatabase gdb = new Geodatabase(fileGDBpath)) { FeatureClassDefinition featureClassDefinition = gdb.GetDefinition <FeatureClassDefinition>(featureClassName); featureClassDefinition.Dispose(); return(true); } } catch { return(false); } }
private void RegisterDatasets(Dictionary <Geodatabase, List <Table> > tablesByGeodatabase) { foreach (var pair in tablesByGeodatabase) { Geodatabase geodatabase = pair.Key; var definitions = geodatabase.GetDefinitions <FeatureClassDefinition>().ToLookup(d => d.GetName()); foreach (Table table in pair.Value) { var identity = new GdbTableIdentity(table); FeatureClassDefinition definition = definitions[identity.Name].FirstOrDefault(); ISourceClass sourceClass = CreateSourceClass(identity, definition); GeodatabaseBySourceClasses.Add(sourceClass, geodatabase); } } }
public bool FeatureClassExists(string fileGDBPath, string featureClassName) { try { using (Geodatabase geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(fileGDBPath)))) { FeatureClassDefinition featureClassDefinition = geodatabase.GetDefinition <FeatureClassDefinition>(featureClassName); featureClassDefinition.Dispose(); System.Diagnostics.Debug.WriteLine($"Feature class exists"); return(true); } } catch { // GetDefinition throws an exception if the definition doesn't exist System.Diagnostics.Debug.WriteLine($"Feature class does not exist"); return(false); } }
private void OutputDefinition(Geodatabase geodatabase, TopologyDefinition topologyDefinition) { Console.WriteLine($"Topology cluster tolerance => {topologyDefinition.GetClusterTolerance()}"); Console.WriteLine($"Topology Z cluster tolerance => {topologyDefinition.GetZClusterTolerance()}"); IReadOnlyList <string> featureClassNames = topologyDefinition.GetFeatureClassNames(); Console.WriteLine($"There are {featureClassNames.Count} feature classes that are participating in the topology:"); foreach (string name in featureClassNames) { // Open each feature class that participates in the topology. using (FeatureClass featureClass = geodatabase.OpenDataset <FeatureClass>(name)) using (FeatureClassDefinition featureClassDefinition = featureClass.GetDefinition()) { Console.WriteLine($"\t{featureClass.GetName()} ({featureClassDefinition.GetShapeType()})"); } } }
public void MainMethodCode() { Uri serviceUrl = new Uri("https://arcgis.server.example.com:6443/arcgis/rest/services/FeatureServiceName/FeatureServer"); ServiceConnectionProperties arcGisServer = new ServiceConnectionProperties(serviceUrl) { User = "******", Password = "******" }; using (Geodatabase serverFeatureService = new Geodatabase(arcGisServer)) { FeatureClassDefinition featureClassDefinition = serverFeatureService.GetDefinition <FeatureClassDefinition>("0"); string shapeField = featureClassDefinition.GetShapeField(); IReadOnlyList <Field> fields = featureClassDefinition.GetFields(); TableDefinition tableDefinition = serverFeatureService.GetDefinition <TableDefinition>("4"); string objectIDField = tableDefinition.GetObjectIDField(); } }
double GetArea(FeatureClass fc) { try { using (FeatureClassDefinition fcd = fc.GetDefinition()) { // the name of the area field changes depending on what enterprise geodatabase is used var areaFieldName = "Shape_Area"; Field areaField = fcd.GetFields().FirstOrDefault(x => x.Name.Contains(areaFieldName)); if (areaField == null) { return(0); } System.Diagnostics.Debug.WriteLine(areaField.Name); // Output is "Shape.STArea()" as expected StatisticsDescription SumDesc = new StatisticsDescription(areaField, new List <StatisticsFunction>() { StatisticsFunction.Sum }); TableStatisticsDescription tsd = new TableStatisticsDescription(new List <StatisticsDescription>() { SumDesc }); double sum = 0; try { sum = fc.CalculateStatistics(tsd).FirstOrDefault().StatisticsResults.FirstOrDefault().Sum; // exception is thrown on this line } catch { sum = Utilities.GetSumWorkAround(fc, areaField.Name); } return(sum); } } catch (Exception ex) { ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show(ex.ToString(), "Error"); return(0); } }
/// <summary> /// workaround to get sum from enterprise gdb lenght/area fields /// see https://community.esri.com/message/889796-problem-using-shapestlength-field-in-the-calculatestatistics-method /// </summary> /// <param name="fc">feature class to get sum from</param> /// <param name="fieldName">fieldname to sum up</param> /// <returns>sum</returns> public static double GetSumWorkAround(FeatureClass fc, string fieldName) { try { using (FeatureClassDefinition fcd = fc.GetDefinition()) { double totalLen = 0.0; var cur = fc.Search(); while (cur.MoveNext()) { var feat = cur.Current; totalLen += Convert.ToDouble(feat[fieldName]); } return(totalLen); } } catch (Exception) { throw; } }
/// <summary> /// Gets all the field in the selected layer that meets requirement and adds them to the drop down list /// </summary> private async void PopulateLayerFields() { _fields.Clear(); IEnumerable <Field> fields = null; FeatureClass featureclass = null; await QueuedTask.Run(() => { Table table = _selectedLayer.GetTable(); if (table is FeatureClass) { featureclass = table as FeatureClass; using (FeatureClassDefinition def = featureclass.GetDefinition()) { fields = def.GetFields(); } foreach (Field field in fields) { Domain domain = field.GetDomain(); if (domain != null) { FieldType fieldType = domain.GetFieldType(); if (fieldType == FieldType.SmallInteger || fieldType == FieldType.Integer) { _fields.Add(field.Name); } ; } } } }); if (_fields.Count <= 0) { MessageBox.Show("No Valid Fields in '" + _selectedLayer.Name + "' Feature Layer"); } }
protected override WorkListStatusSchema CreateStatusSchemaCore(FeatureClassDefinition definition) { int fieldIndex; try { fieldIndex = definition.FindField(_statusFieldName); if (fieldIndex < 0) { throw new ArgumentException($"No field {_statusFieldName}"); } } catch (Exception e) { _msg.Error($"Error find field {_statusFieldName} in {definition.GetName()}", e); throw; } return(new WorkListStatusSchema(_statusFieldName, fieldIndex, (int)IssueCorrectionStatus.NotCorrected, (int)IssueCorrectionStatus.Corrected)); }
public async static Task <bool> AddAndFlashGeometryAsync(this FeatureLayer targetFeatureLayer, Geometry GeometryToAdd) { var targetFeatureClass = await targetFeatureLayer.GetTableAsync() as FeatureClass; FeatureClassDefinition targetClassDefinition = null; Feature newFeature = null; var editOperation = EditingModule.CreateEditOperation(); editOperation.Name = "Flash closest geometry"; editOperation.Callback(context => { targetClassDefinition = targetFeatureClass.Definition as FeatureClassDefinition; var targetGeometry = GeometryEngine.Project(GeometryToAdd, targetClassDefinition.SpatialReference); if (GeometryToAdd.GeometryType != targetClassDefinition.ShapeType) { return; } var featureBuffer = targetFeatureClass.CreateRowBuffer(); newFeature = targetFeatureClass.CreateRow(featureBuffer) as Feature; newFeature.Shape = targetGeometry; newFeature.Store(); context.invalidate(newFeature); }, targetFeatureClass); MappingModule.ActiveMapView.FlashFeature(targetFeatureLayer, Convert.ToInt32(newFeature.ObjectID)); return(true); }
private async void cboLayerList_SelectionChanged(object sender, SelectionChangedEventArgs e) { string lname = cboLayerList.SelectedItem.ToString(); var mv = MapView.Active; FeatureLayer fl = mv.Map.FindLayers(lname).FirstOrDefault() as FeatureLayer; var fields = await QueuedTask.Run(() => { FeatureClass fc = fl.GetFeatureClass(); FeatureClassDefinition fcdef = fc.GetDefinition(); return(fcdef.GetFields()); }); lstFields.Items.Clear(); for (int i = 0; i < fields.Count; i++) { Field fld = fields[i]; if (fld.FieldType == FieldType.String) { lstFields.Items.Add(fld.Name); } } lstFields.SelectAll(); }
/// <summary> /// Adds the selected feature layer's field to the '_fields' collection /// </summary> private async void PopulateFeatureLayerFields() { _fields.Clear(); IEnumerable <Field> fields = null; FeatureClass featureclass = null; await QueuedTask.Run(() => { Table table = _selectedFeatureLayer.GetTable(); if (table is FeatureClass) { featureclass = table as FeatureClass; using (FeatureClassDefinition def = featureclass.GetDefinition()) { fields = def.GetFields(); } foreach (Field field in fields) { FieldType fieldType = field.FieldType; // Change field type acceptance here if (fieldType == FieldType.SmallInteger || fieldType == FieldType.Integer || fieldType == FieldType.String || fieldType == FieldType.Double || fieldType == FieldType.Single || fieldType == FieldType.GUID) { _fields.Add(field.Name); } ; } } }); if (_fields.Count <= 0) { MessageBox.Show("No Valid Fields in '" + _selectedFeatureLayer.Name + "' Feature Layer"); } }
public static async Task <IList <BA_Objects.Interval> > GetUniqueSortedValuesAsync(Uri gdbUri, string featClassName, string valueFieldName, string nameFieldName, double upperBound, double lowerBound) { IList <BA_Objects.Interval> lstInterval = new List <BA_Objects.Interval>(); if (gdbUri.IsFile) { string strFolderPath = System.IO.Path.GetDirectoryName(gdbUri.LocalPath); if (System.IO.Directory.Exists(strFolderPath)) { await QueuedTask.Run(() => { //get Dictionary of unique elevations from the vector att IDictionary <String, String> dictElev = new Dictionary <String, String>(); using (Geodatabase geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(gdbUri))) using (FeatureClass featureClass = geodatabase.OpenDataset <FeatureClass>(featClassName)) { FeatureClassDefinition def = featureClass.GetDefinition(); int idxElev = def.FindField(valueFieldName); int idxName = def.FindField(nameFieldName); if (idxElev < 0 || idxName < 0) { Module1.Current.ModuleLogManager.LogError(nameof(GetUniqueSortedValuesAsync), "A required field was missing from " + featClassName + ". Process failed!"); return; } using (RowCursor rowCursor = featureClass.Search(new QueryFilter(), false)) { while (rowCursor.MoveNext()) { using (Feature feature = (Feature)rowCursor.Current) { string strElev = Convert.ToString(feature[idxElev]); string strName = ""; if (feature[idxName] == null) { strName = "Name missing"; } else { strName = Convert.ToString(feature[idxName]); if (String.IsNullOrEmpty(strName)) { strName = "Name missing"; } } if (dictElev.ContainsKey(strElev)) { strName = dictElev[strElev] + ", " + strName; dictElev[strElev] = strName; } else { dictElev.Add(strElev, strName); } } } } } List <double> lstValidValues = new List <double>(); int nuniquevalue = dictElev.Keys.Count; double value = -1.0F; bool bSuccess = false; foreach (var strElev in dictElev.Keys) { bSuccess = Double.TryParse(strElev, out value); if ((int)(value - 0.5) < (int)upperBound && (int)value + 0.5 > (int)lowerBound) { lstValidValues.Add(value); } else if (value > upperBound || value < lowerBound) //invalid data in the attribute field, out of bound { Module1.Current.ModuleLogManager.LogError(nameof(GetUniqueSortedValuesAsync), "WARNING!! A monitoring site is ignored in the analysis! The site's elevation (" + value + ") is outside the DEM range (" + lowerBound + ", " + upperBound + ")!"); } } //add upper and lower bnds to the dictionary if (!dictElev.ContainsKey(Convert.ToString(upperBound))) { dictElev.Add(Convert.ToString(upperBound), "Not represented"); lstValidValues.Add(upperBound); } if (!dictElev.ContainsKey(Convert.ToString(lowerBound))) { dictElev.Add(Convert.ToString(lowerBound), "Min Value"); lstValidValues.Add(lowerBound); } // Sort the list lstValidValues.Sort(); // Add lower bound to interval list for (int i = 0; i < lstValidValues.Count - 1; i++) { BA_Objects.Interval interval = new BA_Objects.Interval(); interval.Value = i + 1; interval.LowerBound = lstValidValues[i]; double nextItem = lstValidValues[i + 1]; interval.UpperBound = nextItem; interval.Name = dictElev[Convert.ToString(nextItem)]; // use the upperbnd name to represent the interval lstInterval.Add(interval); } }); } } return(lstInterval); }
public static async Task <BA_ReturnCode> UpdateFeatureAttributesAsync(Uri gdbUri, string featureClassName, QueryFilter oQueryFilter, IDictionary <string, string> dictEdits) { bool modificationResult = false; string errorMsg = ""; await QueuedTask.Run(() => { using (Geodatabase geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(gdbUri))) using (FeatureClass featureClass = geodatabase.OpenDataset <FeatureClass>(featureClassName)) { FeatureClassDefinition featureClassDefinition = featureClass.GetDefinition(); EditOperation editOperation = new EditOperation(); editOperation.Callback(context => { using (RowCursor rowCursor = featureClass.Search(oQueryFilter, false)) { while (rowCursor.MoveNext()) { using (Feature feature = (Feature)rowCursor.Current) { // In order to update the the attribute table has to be called before any changes are made to the row context.Invalidate(feature); // Loop through fields to update foreach (string strKey in dictEdits.Keys) { int idxRow = featureClassDefinition.FindField(strKey); if (idxRow > -1) { feature[idxRow] = dictEdits[strKey]; } } feature.Store(); // Has to be called after the store too context.Invalidate(feature); } } } }, featureClass); try { modificationResult = editOperation.Execute(); if (!modificationResult) { errorMsg = editOperation.ErrorMessage; } } catch (GeodatabaseException exObj) { errorMsg = exObj.Message; } } }); if (String.IsNullOrEmpty(errorMsg)) { await Project.Current.SaveEditsAsync(); return(BA_ReturnCode.Success); } else { if (Project.Current.HasEdits) { await Project.Current.DiscardEditsAsync(); } Module1.Current.ModuleLogManager.LogError(nameof(UpdateFeatureAttributesAsync), "Exception: " + errorMsg); return(BA_ReturnCode.UnknownError); } }
private async Task <string> AddFeatureToLayer(Geometry geom, EllipseAttributes attributes) { string message = String.Empty; if (attributes == null) { message = "Attributes are Empty"; // For debug does not need to be resource return(message); } FeatureClass ellipseFeatureClass = await GetFeatureClass(addToMapIfNotPresent : true); if (ellipseFeatureClass == null) { message = DistanceAndDirectionLibrary.Properties.Resources.ErrorFeatureClassNotFound + this.GetLayerName(); return(message); } bool creationResult = false; FeatureClassDefinition ellipseDefinition = ellipseFeatureClass.GetDefinition(); EditOperation editOperation = new EditOperation(); editOperation.Name = "Ellipse Feature Insert"; editOperation.Callback(context => { try { RowBuffer rowBuffer = ellipseFeatureClass.CreateRowBuffer(); if (ellipseDefinition.FindField("Major") >= 0) { rowBuffer["Major"] = attributes.majorAxis; // Text } if (ellipseDefinition.FindField("Minor") >= 0) { rowBuffer["Minor"] = attributes.minorAxis; // Double } if (ellipseDefinition.FindField("DistUnit") >= 0) { rowBuffer["DistUnit"] = attributes.distanceunit; // Text } if (ellipseDefinition.FindField("Angle") >= 0) { rowBuffer["Angle"] = attributes.angle; // Double } if (ellipseDefinition.FindField("AngleUnit") >= 0) { rowBuffer["AngleUnit"] = attributes.angleunit; // Text } if (ellipseDefinition.FindField("CenterX") >= 0) { rowBuffer["CenterX"] = attributes.centerx; // Double } if (ellipseDefinition.FindField("CenterY") >= 0) { rowBuffer["CenterY"] = attributes.centery; // Double } rowBuffer["Shape"] = GeometryEngine.Instance.Project(geom, ellipseDefinition.GetSpatialReference()); Feature feature = ellipseFeatureClass.CreateRow(rowBuffer); feature.Store(); //To indicate that the attribute table has to be updated context.Invalidate(feature); } catch (GeodatabaseException geodatabaseException) { message = geodatabaseException.Message; } catch (Exception ex) { message = ex.Message; } }, ellipseFeatureClass); await QueuedTask.Run(async() => { creationResult = await editOperation.ExecuteAsync(); }); if (!creationResult) { message = editOperation.ErrorMessage; } return(message); }