private async Task ProcessAsync() { await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() => { IList <Layer> listLayers = MapView.Active.Map.GetLayersAsFlattenedList().ToList(); FeatureLayer l_ownShip = listLayers.First(l => l.Name == ConstDefintion.ConstLayer_OwnShipLayerName) as FeatureLayer; FeatureLayer l_targetShip = listLayers.First(l => l.Name == ConstDefintion.ConstLayer_TargetShipLayerName) as FeatureLayer; FeatureClass fc_ownShip = l_ownShip.GetFeatureClass(); FeatureClass fc_targetShip = l_targetShip.GetFeatureClass(); Feature f_ownShip; //获取本船的Feature QueryFilter qf = new QueryFilter() { ObjectIDs = new List <long>() { 1 } }; RowCursor rowCursor1 = fc_ownShip.Search(qf, false); rowCursor1.MoveNext(); Row row1 = rowCursor1.Current; f_ownShip = row1 as Feature; MapPoint p_ownship = f_ownShip.GetShape() as MapPoint; IList <MapPoint> points = new List <MapPoint>(); points.Add(CreateTargetShipPoint(p_ownship, -2, 6)); points.Add(CreateTargetShipPoint(p_ownship, 2, 6)); points.Add(CreateTargetShipPoint(p_ownship, -2, 2)); points.Add(CreateTargetShipPoint(p_ownship, 2, 2)); points.Add(CreateTargetShipPoint(p_ownship, -3, 1)); points.Add(CreateTargetShipPoint(p_ownship, 3, 1)); points.Add(CreateTargetShipPoint(p_ownship, -3, 5)); points.Add(CreateTargetShipPoint(p_ownship, 3, 5)); using (Geodatabase gdb = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(GeoDataTool.DefaultProject.DefaultGeodatabasePath)))) { foreach (MapPoint point in points) { gdb.ApplyEdits(() => { using (RowBuffer rowBuffer = fc_targetShip.CreateRowBuffer()) { rowBuffer["Shape"] = point; using (Feature feature = fc_targetShip.CreateRow(rowBuffer)) { feature.Store(); } } }); } } }); }
private static void InsertRow(FeatureClass featureClass, string shapeField, Geometry polygon, object description) { using (RowBuffer buffer = featureClass.CreateRowBuffer()) { buffer[shapeField] = polygon; buffer["Description"] = description; featureClass.CreateRow(buffer); } }
private async Task AddResultFeatures(FeatureClass fc) { EditOperation featOp = new EditOperation(); featOp.Callback(context => { foreach (Result result in Results) { using (RowBuffer row = fc.CreateRowBuffer()) { row["VehicleYear"] = result.Vehicle.Year; row["VehicleMake"] = result.Vehicle.Make; row["VehicleModel"] = result.Vehicle.Model; row["Vehicletype"] = result.Vehicle.Type; row["VehicleMPG"] = result.Vehicle.Mpg; row["OriginalSymbolColor"] = result.Color; row["PADDZone"] = result.PaddZone; row["DOEGasPricePerGallon"] = result.DollarsPerGallon; row["MilesPerDollar"] = result.MilesPerDollar; row["DriveDistanceMiles"] = result.DriveDistMi; row["ResultDateTime"] = result.ResultDateTimeUTC; row[fc.GetDefinition().GetShapeField()] = result.DriveServiceArea; using (Feature feat = fc.CreateRow(row)) { context.Invalidate(feat); } } } }, fc); bool success = await featOp.ExecuteAsync(); if (!success) { throw new Exception("Error adding result features: " + featOp.ErrorMessage); } success = await Project.Current.SaveEditsAsync(); if (!success) { throw new Exception("Failure while saving result features"); } }
private static void RiskAssessment(Geodatabase gdb, FeatureClass keyPoints, string maskPoint, double risk) { FeatureClass voyageMaskPoint = gdb.OpenDataset <FeatureClass>(maskPoint); using (RowCursor rowCursor = voyageMaskPoint.Search(null, false)) { while (rowCursor.MoveNext()) { using (Feature f = rowCursor.Current as Feature) { using (RowBuffer rowBuffer = keyPoints.CreateRowBuffer()) { rowBuffer[ConstDefintion.ConstFieldName_ddv] = risk; rowBuffer[ConstDefintion.ConstFieldName_Shape] = f.GetShape(); using (Feature feature = keyPoints.CreateRow(rowBuffer)) { feature.Store(); } } } } } }
private static void CreateSemiEvaluatePoint(int i, double angle, double semi, Coordinate2D point, FeatureClass fc_evaluatePoints) { double yStep = Math.Sin(angle) * semi; double xStep = Math.Cos(angle) * semi; double risk = CalCollisionRisk(i); Coordinate2D evaluatePoint = new Coordinate2D() { X = point.X + xStep, Y = point.Y + yStep }; MapPoint p = MapPointBuilder.CreateMapPoint(evaluatePoint, SpatialReferenceBuilder.CreateSpatialReference(3857)); using (RowBuffer rowBuffer = fc_evaluatePoints.CreateRowBuffer()) { // Either the field index or the field name can be used in the indexer. rowBuffer[ConstDefintion.ConstFieldName_r_estimate] = risk; rowBuffer[ConstDefintion.ConstFieldName_factor] = 0.05 * i; rowBuffer[ConstDefintion.ConstFieldName_Shape] = p; using (Feature feature = fc_evaluatePoints.CreateRow(rowBuffer)) { feature.Store(); } } }
/// <summary> /// Method used to create a mask for geoprocessing environment /// Will buffer around each observer at the max distance to create mask /// </summary> /// <param name="maskFeatureClassName"></param> /// <param name="bufferDistance"></param> /// <returns>Task</returns> private async Task CreateMask(string maskFeatureClassName, double minDistanceInMapUnits, double maxDistanceInMapUnits, double horizontalStartAngleInDegrees, double horizontalEndAngleInDegrees, SpatialReference surfaceSR, ObservableCollection <AddInPoint> observerPoints, bool constructRangeFans = false) { // create new await FeatureClassHelper.CreateLayer(FeatureDatasetName, maskFeatureClassName, "POLYGON", false, false); try { string message = String.Empty; bool creationResult = false; await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(async() => { using (Geodatabase geodatabase = new Geodatabase(FeatureClassHelper.FgdbFileToConnectionPath(CoreModule.CurrentProject.DefaultGeodatabasePath))) using (FeatureClass enterpriseFeatureClass = geodatabase.OpenDataset <FeatureClass>(maskFeatureClassName)) using (FeatureClassDefinition fcDefinition = enterpriseFeatureClass.GetDefinition()) { EditOperation editOperation = new EditOperation(); editOperation.Callback(context => { try { var shapeFieldName = fcDefinition.GetShapeField(); foreach (var observer in observerPoints) { using (var rowBuffer = enterpriseFeatureClass.CreateRowBuffer()) { // Either the field index or the field name can be used in the indexer. // project the point here or the buffer tool may use an angular unit and run forever var point = GeometryEngine.Instance.Project(observer.Point, surfaceSR); Geometry polygon = null; if (constructRangeFans) { polygon = GeometryHelper.ConstructRangeFan(point as MapPoint, minDistanceInMapUnits, maxDistanceInMapUnits, horizontalStartAngleInDegrees, horizontalEndAngleInDegrees, surfaceSR); } else { polygon = GeometryEngine.Instance.Buffer(point, maxDistanceInMapUnits); } rowBuffer[shapeFieldName] = polygon; Feature feature = enterpriseFeatureClass.CreateRow(rowBuffer); feature.Store(); context.Invalidate(feature); } // using } // for each } catch (GeodatabaseException exObj) { message = exObj.Message; } }, enterpriseFeatureClass); creationResult = await editOperation.ExecuteAsync(); if (!creationResult) { message = editOperation.ErrorMessage; } await Project.Current.SaveEditsAsync(); } }); if (!creationResult) { MessageBox.Show(message); } } catch (Exception ex) { Debug.Print(ex.Message); } }
// Illustrates creating a feature in a File GDB. 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")) { RowBuffer rowBuffer = null; Feature feature = null; try { EditOperation editOperation = new EditOperation(); editOperation.Callback(context => { FeatureClassDefinition featureClassDefinition = featureClass.GetDefinition(); int nameIndex = featureClassDefinition.FindField("NAME"); rowBuffer = featureClass.CreateRowBuffer(); // Either the field index or the field name can be used in the indexer. rowBuffer[nameIndex] = "New School"; rowBuffer["POLLINGID"] = "260"; rowBuffer["FULLADD"] = "100 New Street"; rowBuffer["CITY"] = "Naperville"; rowBuffer["STATE"] = "IL"; rowBuffer["OPERHOURS"] = "Yes"; rowBuffer["HANDICAP"] = "6.00am=7.00pm"; rowBuffer["NEXTELECT"] = "11/6/2012"; rowBuffer["REGDATE"] = "8/6/2012"; rowBuffer["PHONE"] = "815-740-4782"; rowBuffer["EMAIL"] = "*****@*****.**"; rowBuffer[featureClassDefinition.GetShapeField()] = new MapPointBuilder(1028367, 1809789).ToGeometry(); feature = featureClass.CreateRow(rowBuffer); //To Indicate that the Map has to draw this feature and/or the attribute table to be updated context.Invalidate(feature); // Do some other processing with the newly-created feature. }, featureClass); bool editResult = editOperation.Execute(); // At this point the changes are visible in the process, but not persisted/visible outside. long objectID = feature.GetObjectID(); MapPoint mapPoint = feature.GetShape() as MapPoint; // If the table is non-versioned this is a no-op. If it is versioned, we need the Save to be done for the edits to be persisted. bool saveResult = await Project.Current.SaveEditsAsync(); } catch (GeodatabaseException exObj) { Console.WriteLine(exObj); throw; } finally { if (rowBuffer != null) { rowBuffer.Dispose(); } if (feature != null) { feature.Dispose(); } } } }
private static async Task EnterpriseGeodabaseWorkFlow() { // 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 (FeatureClass enterpriseFeatureClass = geodatabase.OpenDataset <FeatureClass>("LocalGovernment.GDB.FacilitySite")) { EditOperation editOperation = new EditOperation(); editOperation.Callback(context => { RowBuffer rowBuffer = null; Feature feature = null; try { FeatureClassDefinition facilitySiteDefinition = enterpriseFeatureClass.GetDefinition(); int facilityIdIndex = facilitySiteDefinition.FindField("FACILITYID"); rowBuffer = enterpriseFeatureClass.CreateRowBuffer(); // Either the field index or the field name can be used in the indexer. rowBuffer[facilityIdIndex] = "FAC-400"; rowBuffer["NAME"] = "Griffith Park"; rowBuffer["OWNTYPE"] = "Municipal"; rowBuffer["FCODE"] = "Park"; // Add it to Public Attractions Subtype. rowBuffer[facilitySiteDefinition.GetSubtypeField()] = 820; List <Coordinate2D> newCoordinates = new List <Coordinate2D> { new Coordinate2D(1021570, 1880583), new Coordinate2D(1028730, 1880994), new Coordinate2D(1029718, 1875644), new Coordinate2D(1021405, 1875397) }; rowBuffer[facilitySiteDefinition.GetShapeField()] = new PolygonBuilder(newCoordinates).ToGeometry(); feature = enterpriseFeatureClass.CreateRow(rowBuffer); //To Indicate that the Map has to draw this feature and/or the attribute table to be updated context.Invalidate(feature); long objectID = feature.GetObjectID(); Polygon polygon = feature.GetShape() as Polygon; // Do some other processing with the newly-created feature. } catch (GeodatabaseException exObj) { Console.WriteLine(exObj); } finally { if (rowBuffer != null) { rowBuffer.Dispose(); } if (feature != null) { feature.Dispose(); } } }, enterpriseFeatureClass); bool editResult = editOperation.Execute(); // If the table is non-versioned this is a no-op. If it is versioned, we need the Save to be done for the edits to be persisted. bool saveResult = await Project.Current.SaveEditsAsync(); } }
static void Main(string[] args) { //Call Host.Initialize before constructing any objects from ArcGIS.Core Host.Initialize(); Console.WriteLine("CoreHost - Initilized"); try { // 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(@"D:\Projecten\GisTech\Git\Pro SDK\CoreHost\Nederland.gdb")))) { Console.WriteLine("CoreHost - File Geodatebase found"); FeatureClass countryFeatureClass = geodatabase.OpenDataset <FeatureClass>("Landsgrens"); FeatureClass slicesFeatureClass = geodatabase.OpenDataset <FeatureClass>("Slices"); FeatureClassDefinition countryFeatureClassDefinition = countryFeatureClass.GetDefinition(); FeatureClassDefinition slicesFeatureClassDefinition = slicesFeatureClass.GetDefinition(); Console.WriteLine("CoreHost - FeatureClasses found"); // Create new slices based on the poligon of the Netherlands IReadOnlyList <Polygon> slices = null; using (RowCursor curs = countryFeatureClass.Search()) { Console.WriteLine("CoreHost - GeometryEngine slicing features"); while (curs.MoveNext()) { if (curs.Current != null) { using (Feature feature = (Feature)curs.Current) { var polygon = curs.Current[countryFeatureClassDefinition.GetShapeField()] as Polygon; slices = GeometryEngine.Instance.SlicePolygonIntoEqualParts(polygon, 20, new Random().Next(0, 360), SliceType.Blocks); } } } } Console.WriteLine("CoreHost - Deleting old slices"); // Delete all existing items. geodatabase.ApplyEdits(() => { slicesFeatureClass.DeleteRows(new QueryFilter() { WhereClause = "42 = 42" }); }); Console.WriteLine("CoreHost - Saving features"); // Store new slices. geodatabase.ApplyEdits(() => { if (slices != null) { for (int i = 0; i < slices.Count; i++) { using (RowBuffer rowBuffer = slicesFeatureClass.CreateRowBuffer()) { // Either the field index or the field name can be used in the indexer. rowBuffer["Code"] = i.ToString(); rowBuffer["Landsnaam"] = "Nederland"; rowBuffer[slicesFeatureClassDefinition.GetShapeField()] = slices[i]; using (Feature feature = slicesFeatureClass.CreateRow(rowBuffer)) { feature.Store(); } } } } }); Console.WriteLine("CoreHost - Data saved"); } } catch (GeodatabaseNotFoundOrOpenedException) { Console.WriteLine("File GeoDataBase niet gevonden"); } catch (GeodatabaseEditingException) { Console.WriteLine("Kan niet schrijven naar de File GeoDataBase"); } catch (Exception ex) { Console.WriteLine($"Fout {ex}"); } Console.WriteLine("Press any key to continue..."); Console.ReadLine(); }
private async Task <string> AddFeatureToLayer(Geometry geom, LineAttributes attributes) { string message = String.Empty; if (attributes == null) { message = "Attributes are Empty"; // For debug does not need to be resource return(message); } FeatureClass lineFeatureClass = await GetFeatureClass(addToMapIfNotPresent : true); if (lineFeatureClass == null) { message = DistanceAndDirectionLibrary.Properties.Resources.ErrorFeatureClassNotFound + this.GetLayerName(); return(message); } bool creationResult = false; FeatureClassDefinition lineDefinition = lineFeatureClass.GetDefinition(); EditOperation editOperation = new EditOperation(); editOperation.Name = "Line Feature Insert"; editOperation.Callback(context => { try { RowBuffer rowBuffer = lineFeatureClass.CreateRowBuffer(); if (lineDefinition.FindField("Distance") >= 0) { rowBuffer["Distance"] = attributes.distance; // Double } if (lineDefinition.FindField("DistUnit") >= 0) { rowBuffer["DistUnit"] = attributes.distanceunit; // Text } if (lineDefinition.FindField("Angle") >= 0) { rowBuffer["Angle"] = attributes.angle; // Double } if (lineDefinition.FindField("AngleUnit") >= 0) { rowBuffer["AngleUnit"] = attributes.angleunit; // Text } if (lineDefinition.FindField("OriginX") >= 0) { rowBuffer["OriginX"] = attributes.originx; // Double } if (lineDefinition.FindField("OriginY") >= 0) { rowBuffer["OriginY"] = attributes.originy; // Double } if (lineDefinition.FindField("DestX") >= 0) { rowBuffer["DestX"] = attributes.destinationx; // Double } if (lineDefinition.FindField("DestY") >= 0) { rowBuffer["DestY"] = attributes.destinationy; // Double } // Ensure Geometry Has Z var geomZ = geom; if (!geom.HasZ) { PolylineBuilder pb = new PolylineBuilder((Polyline)geom); pb.HasZ = true; geomZ = pb.ToGeometry(); } rowBuffer["Shape"] = GeometryEngine.Instance.Project(geomZ, lineDefinition.GetSpatialReference()); Feature feature = lineFeatureClass.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; } }, lineFeatureClass); await QueuedTask.Run(async() => { creationResult = await editOperation.ExecuteAsync(); }); if (!creationResult) { message = editOperation.ErrorMessage; } return(message); }
private static void ExploreTopologyValidation(Geodatabase geodatabase, Topology topology) { // If the topology currently does not have dirty areas, calling Validate() returns an empty envelope. Console.WriteLine("***************************************************************************"); ValidationResult result = topology.Validate(new ValidationDescription(topology.GetExtent())); Console.WriteLine($"'AffectedArea' after validating a topology that has not been edited => {result.AffectedArea.ToJson()}"); // Now create a feature that purposely violates the "PointProperlyInsideArea" topology rule. This action will // create dirty areas. Feature newFeature = null; try { // Fetch the feature in the Campsites feature class whose objectID is 2. Then create a new geometry slightly // altered from this and use it to create a new feature. using (Feature featureViaCampsites2 = GetFeature(geodatabase, "Campsites", 2)) { Geometry currentGeometry = featureViaCampsites2.GetShape(); Geometry newGeometry = GeometryEngine.Instance.Move(currentGeometry, (currentGeometry.Extent.XMax / 8), (currentGeometry.Extent.YMax / 8)); using (FeatureClass campsitesFeatureClass = featureViaCampsites2.GetTable()) using (FeatureClassDefinition definition = campsitesFeatureClass.GetDefinition()) using (RowBuffer rowBuffer = campsitesFeatureClass.CreateRowBuffer()) { rowBuffer[definition.GetShapeField()] = newGeometry; geodatabase.ApplyEdits(() => { newFeature = campsitesFeatureClass.CreateRow(rowBuffer); }); } } // After creating a new feature in the 'Campsites' participating feature class, the topology's state should be // "Unanalyzed" because it has not been validated. Console.WriteLine($"The topology state after an edit has been applied => {topology.GetState()}"); // Now validate the topology. The result envelope corresponds to the dirty areas. result = topology.Validate(new ValidationDescription(topology.GetExtent())); Console.WriteLine($"'AffectedArea' after validating a topology that has just been edited => {result.AffectedArea.ToJson()}"); // After Validate(), the topology's state should be "AnalyzedWithErrors" because the topology currently has errors. Console.WriteLine($"The topology state after validate topology => {topology.GetState()}"); // If there are no dirty areas, the result envelope should be empty. result = topology.Validate(new ValidationDescription(topology.GetExtent())); Console.WriteLine($"'AffectedArea' after validating a topology that has just been validated => {result.AffectedArea.ToJson()}"); } finally { if (newFeature != null) { geodatabase.ApplyEdits(() => { newFeature.Delete(); }); newFeature.Dispose(); } } // Validate again after deleting the newly-created feature. topology.Validate(new ValidationDescription(topology.GetExtent())); }
private async Task <string> AddFeatureToLayer(Geometry geom, RangeAttributes attributes) { string message = String.Empty; if (attributes == null) { message = "Attributes are Empty"; // For debug does not need to be resource return(message); } FeatureClass ringFeatureClass = await GetFeatureClass(addToMapIfNotPresent : true); if (ringFeatureClass == null) { message = DistanceAndDirectionLibrary.Properties.Resources.ErrorFeatureClassNotFound + this.GetLayerName(); return(message); } bool creationResult = false; FeatureClassDefinition ringDefinition = ringFeatureClass.GetDefinition(); EditOperation editOperation = new EditOperation(); editOperation.Name = "Ring Feature Insert"; editOperation.Callback(context => { try { RowBuffer rowBuffer = ringFeatureClass.CreateRowBuffer(); if (ringDefinition.FindField("Distance") >= 0) { rowBuffer["Distance"] = attributes.distance; // Double } if (ringDefinition.FindField("DistUnit") >= 0) { rowBuffer["DistUnit"] = attributes.distanceunit; // Text } if (ringDefinition.FindField("Rings") >= 0) { rowBuffer["Rings"] = attributes.numRings; // Double } if (ringDefinition.FindField("CenterX") >= 0) { rowBuffer["CenterX"] = attributes.centerx; // Double } if (ringDefinition.FindField("CenterY") >= 0) { rowBuffer["CenterY"] = attributes.centery; // Double } if (ringDefinition.FindField("RRType") >= 0) { rowBuffer["RRType"] = attributes.ringorradial; // Double } // Ensure Z removed (this feature class does not have Z) var geoNoZ = geom; if (geom.HasZ) { PolylineBuilder pb = new PolylineBuilder((Polyline)geom); pb.HasZ = false; geoNoZ = pb.ToGeometry(); } rowBuffer["Shape"] = GeometryEngine.Instance.Project(geoNoZ, ringDefinition.GetSpatialReference()); Feature feature = ringFeatureClass.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; } }, ringFeatureClass); await QueuedTask.Run(async() => { creationResult = await editOperation.ExecuteAsync(); }); if (!creationResult) { message = editOperation.ErrorMessage; } return(message); }
/// <summary> /// Method used to create a mask for geoprocessing environment /// Will buffer around each observer at the max distance to create mask /// </summary> /// <param name="maskFeatureClassName"></param> /// <param name="bufferDistance"></param> /// <returns>Task</returns> private async Task CreateMask(string maskFeatureClassName, double bufferDistance, SpatialReference surfaceSR) { // create new await FeatureClassHelper.CreateLayer(maskFeatureClassName, "POLYGON", false, false); try { string message = String.Empty; bool creationResult = false; await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(async() => { using (Geodatabase geodatabase = new Geodatabase(CoreModule.CurrentProject.DefaultGeodatabasePath)) using (FeatureClass enterpriseFeatureClass = geodatabase.OpenDataset <FeatureClass>(maskFeatureClassName)) using (FeatureClassDefinition fcDefinition = enterpriseFeatureClass.GetDefinition()) { EditOperation editOperation = new EditOperation(); editOperation.Callback(context => { try { var shapeFieldName = fcDefinition.GetShapeField(); foreach (var observer in ObserverAddInPoints) { using (var rowBuffer = enterpriseFeatureClass.CreateRowBuffer()) { // Either the field index or the field name can be used in the indexer. // project the point here or the buffer tool may use an angular unit and run forever var point = GeometryEngine.Project(observer.Point, surfaceSR); var polygon = GeometryEngine.Buffer(point, bufferDistance); rowBuffer[shapeFieldName] = polygon; using (var feature = enterpriseFeatureClass.CreateRow(rowBuffer)) { //To Indicate that the attribute table has to be updated context.Invalidate(feature); } } } } catch (GeodatabaseException exObj) { message = exObj.Message; } }, enterpriseFeatureClass); creationResult = await editOperation.ExecuteAsync(); if (!creationResult) { message = editOperation.ErrorMessage; } await Project.Current.SaveEditsAsync(); } }); if (!creationResult) { MessageBox.Show(message); } } catch (Exception ex) { Debug.Print(ex.Message); } }
internal static async Task CreateOwnShipObstacleLine() { await QueuedTask.Run(() => { using (Geodatabase gdb = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(GeoDataTool.DefaultProject.DefaultGeodatabasePath)))) { FeatureClass fc_targetShip = gdb.OpenDataset <FeatureClass>(ConstDefintion.ConstFeatureClass_TargetShipObstacleLine); FeatureClass fc_ownShipObstacleLine = gdb.OpenDataset <FeatureClass>(ConstDefintion.ConstFeatureClass_OwnShipObstacleLine); fc_ownShipObstacleLine.DeleteRows(new QueryFilter() { WhereClause = "OBJECTID > 0" }); FeatureClass fc_ownShip = gdb.OpenDataset <FeatureClass>(ConstDefintion.ConstFeatureClass_OwnShip); MapPoint own_ship; double own_cog; double own_sog; using (RowCursor rowCursor = fc_ownShip.Search(null, false)) { rowCursor.MoveNext(); using (Feature row = rowCursor.Current as Feature) { own_ship = (row.GetShape() as MapPoint); own_sog = Convert.ToDouble(row[ConstDefintion.ConstFieldName_sog]); own_cog = Convert.ToDouble(row[ConstDefintion.ConstFieldName_cog]); } } Coordinate2D os_start_cdn = new Coordinate2D() { X = own_ship.X, Y = own_ship.Y }; double angle = 90 - own_cog; angle = angle / 180 * Math.PI; double xMove = 8 * 1852 * Math.Cos(angle); double yMove = 8 * 1852 * Math.Sin(angle); Coordinate2D os_end_cdn = new Coordinate2D() { X = own_ship.X + xMove, Y = own_ship.Y + yMove }; Polyline pl_1 = PolylineBuilder.CreatePolyline(new List <Coordinate2D>() { os_start_cdn, os_end_cdn }, SpatialReferenceBuilder.CreateSpatialReference(3857)); gdb.ApplyEdits(() => { //创建第一条线 using (RowBuffer rowBuffer = fc_ownShipObstacleLine.CreateRowBuffer()) { // Either the field index or the field name can be used in the indexer. rowBuffer[ConstDefintion.ConstFieldName_dcr] = 0; rowBuffer[ConstDefintion.ConstFieldName_tcr] = 0; rowBuffer[ConstDefintion.ConstFieldName_risk] = 0; rowBuffer[ConstDefintion.ConstFieldName_tdv1] = 0; rowBuffer[ConstDefintion.ConstFieldName_tdv2] = 0; rowBuffer[ConstDefintion.ConstFieldName_tmin] = 0; rowBuffer[ConstDefintion.ConstFieldName_Shape] = pl_1; using (Feature feature = fc_ownShipObstacleLine.CreateRow(rowBuffer)) { feature.Store(); } } //创建本船会遇冲突线 using (RowCursor rowCursor = fc_targetShip.Search(null, false)) { while (rowCursor.MoveNext()) { using (Feature ts_f = rowCursor.Current as Feature) { double dcr = (double)ts_f[ConstDefintion.ConstFieldName_dcr]; double tcr = (double)ts_f[ConstDefintion.ConstFieldName_tcr]; double risk = (double)ts_f[ConstDefintion.ConstFieldName_risk]; double tdv1 = (double)ts_f[ConstDefintion.ConstFieldName_tdv1]; double tdv2 = (double)ts_f[ConstDefintion.ConstFieldName_tdv2]; double tmin = (double)ts_f[ConstDefintion.ConstFieldName_tmin]; double xTDV1 = Math.Cos(angle) * own_sog *ConstDefintion.ConstDouble_mpersTOkn *tdv1 + own_ship.X; double yTDV1 = Math.Sin(angle) * own_sog *ConstDefintion.ConstDouble_mpersTOkn *tdv1 + own_ship.Y; double xTDV2 = Math.Cos(angle) * own_sog *ConstDefintion.ConstDouble_mpersTOkn *tdv2 + own_ship.X; double yTDV2 = Math.Sin(angle) * own_sog *ConstDefintion.ConstDouble_mpersTOkn *tdv2 + own_ship.Y; Coordinate2D crd_tdv1 = new Coordinate2D() { X = xTDV1, Y = yTDV1 }; Coordinate2D crd_tdv2 = new Coordinate2D() { X = xTDV2, Y = yTDV2 }; Polyline pl_t = PolylineBuilder.CreatePolyline(new List <Coordinate2D>() { crd_tdv1, crd_tdv2 }, SpatialReferenceBuilder.CreateSpatialReference(3857)); using (RowBuffer rowBuffer = fc_ownShipObstacleLine.CreateRowBuffer()) { // Either the field index or the field name can be used in the indexer. rowBuffer[ConstDefintion.ConstFieldName_dcr] = dcr; rowBuffer[ConstDefintion.ConstFieldName_tcr] = tcr; rowBuffer[ConstDefintion.ConstFieldName_risk] = risk; rowBuffer[ConstDefintion.ConstFieldName_tdv1] = tdv1; rowBuffer[ConstDefintion.ConstFieldName_tdv2] = tdv2; rowBuffer[ConstDefintion.ConstFieldName_tmin] = tmin; rowBuffer[ConstDefintion.ConstFieldName_Shape] = pl_t; using (Feature feature = fc_ownShipObstacleLine.CreateRow(rowBuffer)) { feature.Store(); } } } } } }); } }); }
public static async Task CreateKeyPoints(string maskName, string unionMaskName, string keyPointName, double factor) { await QueuedTask.Run(() => { StreamReader sr = new StreamReader(System.Environment.CurrentDirectory + ConstDefintion.ConstPath_TimeFilterConfig, Encoding.Default); String line; //读取状态 line = sr.ReadLine(); string filterStatus = line; line = sr.ReadLine(); int filterValue = Convert.ToInt32(line); sr.Close(); using (Geodatabase gdb = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(GeoDataTool.DefaultProject.DefaultGeodatabasePath)))) { gdb.ApplyEdits(() => { //置空原船舶领域图层 FeatureClass fc_targetShip = gdb.OpenDataset <FeatureClass>(ConstDefintion.ConstFeatureClass_TargetShip); FeatureClass voyageMask = gdb.OpenDataset <FeatureClass>(maskName); FeatureClassDefinition voyageMaskDefinition = gdb.GetDefinition <FeatureClassDefinition>(maskName); FeatureClass fc_ownShip = gdb.OpenDataset <FeatureClass>(ConstDefintion.ConstFeatureClass_OwnShip); FeatureClass TargetShipObstacleLine = gdb.OpenDataset <FeatureClass>(ConstDefintion.ConstFeatureClass_TargetShipObstacleLine); TargetShipObstacleLine.DeleteRows(new QueryFilter() { WhereClause = "OBJECTID >= 1" }); double own_x; double own_y; double own_cog; using (RowCursor rowCursor = fc_ownShip.Search(null, false)) { rowCursor.MoveNext(); using (Feature row = rowCursor.Current as Feature) { own_x = (row.GetShape() as MapPoint).X; own_y = (row.GetShape() as MapPoint).Y; own_cog = Convert.ToDouble(row[ConstDefintion.ConstFieldName_cog]); } } voyageMask.DeleteRows(new QueryFilter() { WhereClause = "OBJECTID >= 1" }); using (RowCursor rowCursor = fc_targetShip.Search(null, false)) { while (rowCursor.MoveNext()) { using (Row row = rowCursor.Current) { Feature ship = row as Feature; MapPoint p_ship = ship.GetShape() as MapPoint; double CollisionRisk = Convert.ToDouble(ship[ConstDefintion.ConstFieldName_CollisionRisk]); double asemi = Convert.ToDouble(ship[ConstDefintion.ConstFieldName_asemi]) * factor * 0.78; double bsemi = Convert.ToDouble(ship[ConstDefintion.ConstFieldName_bsemi]) * factor * 0.78; double aoffset = Convert.ToDouble(ship[ConstDefintion.ConstFieldName_aoffset]) * factor; double boffset = Convert.ToDouble(ship[ConstDefintion.ConstFieldName_boffset]) * factor; double cog = Convert.ToDouble(ship[ConstDefintion.ConstFieldName_cog]); double sog = Convert.ToDouble(ship[ConstDefintion.ConstFieldName_sog]); double tdv1 = Convert.ToDouble(ship[ConstDefintion.ConstFieldName_tdv1]); double tdv2 = Convert.ToDouble(ship[ConstDefintion.ConstFieldName_tdv2]); double ddv = Convert.ToDouble(ship[ConstDefintion.ConstFieldName_ddv]); double tcr = Convert.ToDouble(ship[ConstDefintion.ConstFieldName_tcr]); double tmin = Convert.ToDouble(ship[ConstDefintion.ConstFieldName_tmin]); long objectID = Convert.ToInt64(ship[voyageMaskDefinition.GetObjectIDField()]); cog = CommonMethod.GIScoord2ShipCoord(cog); Coordinate2D ellipseCenter = new Coordinate2D() { X = p_ship.X, Y = p_ship.Y }; if (!(CollisionRisk > 0)) { continue; } //根据时间过滤器 if (filterStatus != ConstDefintion.ConstStr_TimeFilterStatusOFF) { int time = filterValue * 60; if (tdv1 > time) { continue; } else { if (tdv2 > time) { tdv2 = time; } } } //if (CommonMethod.JungeLeft(own_x - ellipseCenter.X, own_y - ellipseCenter.Y, own_cog) && CollisionRisk != 1) continue; GeodesicEllipseParameter geodesic = new GeodesicEllipseParameter() { Center = ellipseCenter, SemiAxis1Length = asemi, SemiAxis2Length = bsemi, LinearUnit = LinearUnit.Meters, OutGeometryType = GeometryType.Polygon, AxisDirection = AngularUnit.Degrees.ConvertToRadians(cog), VertexCount = 800 }; //创建原始位置的椭圆 Geometry ellipse = GeometryEngine.Instance.GeodesicEllipse(geodesic, SpatialReferenceBuilder.CreateSpatialReference(3857)); double moveX = (aoffset *Math.Cos(AngularUnit.Degrees.ConvertToRadians(cog))) + boffset *Math.Sin(AngularUnit.Degrees.ConvertToRadians(cog)); double moveY = (aoffset *Math.Sin(AngularUnit.Degrees.ConvertToRadians(cog))) - boffset *Math.Cos(AngularUnit.Degrees.ConvertToRadians(cog)); Geometry moved_ellipse = GeometryEngine.Instance.Move(ellipse, moveX, moveY); Coordinate2D centerRevise = new Coordinate2D() { X = p_ship.X + moveX, Y = p_ship.Y + moveY }; //基于TDV创建船舶领域与动界 double moveXs = (tdv1 *sog *ConstDefintion.ConstDouble_mpersTOkn *Math.Cos(AngularUnit.Degrees.ConvertToRadians(cog))); double moveYs = (tdv1 *sog *ConstDefintion.ConstDouble_mpersTOkn *Math.Sin(AngularUnit.Degrees.ConvertToRadians(cog))); Geometry moved_start_ellipse = GeometryEngine.Instance.Move(moved_ellipse, moveXs, moveYs); Coordinate2D centerTs = new Coordinate2D() { X = centerRevise.X + moveXs, Y = centerRevise.Y + moveYs }; double moveXe = (tdv2 *sog *ConstDefintion.ConstDouble_mpersTOkn *Math.Cos(AngularUnit.Degrees.ConvertToRadians(cog))); double moveYe = (tdv2 *sog *ConstDefintion.ConstDouble_mpersTOkn *Math.Sin(AngularUnit.Degrees.ConvertToRadians(cog))); Geometry moved_end_ellipse = GeometryEngine.Instance.Move(moved_ellipse, moveXe, moveYe); Coordinate2D centerTe = new Coordinate2D() { X = centerRevise.X + moveXe, Y = centerRevise.Y + moveYe }; //最终图形由两个椭圆和连接椭圆的长方形组成 Geometry e_s_start = GeometryEngine.Instance.SimplifyAsFeature(moved_start_ellipse, false); Geometry e_s_end = GeometryEngine.Instance.SimplifyAsFeature(moved_end_ellipse, false); MapPoint p_1 = MapPointBuilder.CreateMapPoint(centerTs.X - (bsemi *Math.Sin(AngularUnit.Degrees.ConvertToRadians(cog))) * 1.29, centerTs.Y + (bsemi *Math.Cos(AngularUnit.Degrees.ConvertToRadians(cog))) * 1.29); MapPoint p_2 = MapPointBuilder.CreateMapPoint(centerTs.X + (bsemi *Math.Sin(AngularUnit.Degrees.ConvertToRadians(cog))) * 1.29, centerTs.Y - (bsemi *Math.Cos(AngularUnit.Degrees.ConvertToRadians(cog))) * 1.29); MapPoint p_3 = MapPointBuilder.CreateMapPoint(centerTe.X + (bsemi *Math.Sin(AngularUnit.Degrees.ConvertToRadians(cog))) * 1.29, centerTe.Y - (bsemi *Math.Cos(AngularUnit.Degrees.ConvertToRadians(cog))) * 1.29); MapPoint p_4 = MapPointBuilder.CreateMapPoint(centerTe.X - (bsemi *Math.Sin(AngularUnit.Degrees.ConvertToRadians(cog))) * 1.29, centerTe.Y + (bsemi *Math.Cos(AngularUnit.Degrees.ConvertToRadians(cog))) * 1.29); IList <MapPoint> p1_4 = GetInternPoints(p_1, p_4); IList <MapPoint> p2_3 = GetInternPoints(p_2, p_3); p2_3 = p2_3.Reverse <MapPoint>().ToList(); List <MapPoint> list2D = new List <MapPoint>(); list2D.Add(p_1); foreach (MapPoint p in p1_4) { list2D.Add(p); } list2D.Add(p_4); list2D.Add(p_3); foreach (MapPoint p in p2_3) { list2D.Add(p); } list2D.Add(p_2); Polygon connect_R = PolygonBuilder.CreatePolygon(list2D, SpatialReferenceBuilder.CreateSpatialReference(3857)); Geometry simple_r = GeometryEngine.Instance.SimplifyAsFeature(connect_R, false); //融合图形 IList <Geometry> g_List = new List <Geometry>() { e_s_start, simple_r, e_s_end }; Geometry ellInstance = GeometryEngine.Instance.Union(g_List); using (RowBuffer rowBuffer = voyageMask.CreateRowBuffer()) { // Either the field index or the field name can be used in the indexer. rowBuffer[ConstDefintion.ConstFieldName_ddv] = CollisionRisk; rowBuffer[ConstDefintion.ConstFieldName_tdv1] = tdv1; rowBuffer[ConstDefintion.ConstFieldName_tdv2] = tdv2; rowBuffer[ConstDefintion.ConstFieldName_asemi] = asemi; rowBuffer[ConstDefintion.ConstFieldName_bsemi] = bsemi; rowBuffer[ConstDefintion.ConstFieldName_cog] = cog; rowBuffer[ConstDefintion.ConstFieldName_sog] = sog; rowBuffer[ConstDefintion.ConstFieldName_centerX1] = centerTs.X; rowBuffer[ConstDefintion.ConstFieldName_centerY1] = centerTs.Y; rowBuffer[ConstDefintion.ConstFieldName_centerX2] = centerTe.X; rowBuffer[ConstDefintion.ConstFieldName_centerY2] = centerTe.Y; rowBuffer[voyageMaskDefinition.GetShapeField()] = ellInstance; using (Feature feature = voyageMask.CreateRow(rowBuffer)) { feature.Store(); } } //创建本船与他船的冲突路径 Coordinate2D ts_location = ellipseCenter; Coordinate2D ts_Ts = new Coordinate2D()//目标船冲突起点 { X = ts_location.X + moveXs, Y = ts_location.Y + moveYs }; Coordinate2D ts_Te = new Coordinate2D()//目标船冲突终点 { X = ts_location.X + moveXe, Y = ts_location.Y + moveYe }; List <Coordinate2D> ts_obstaclePointList = new List <Coordinate2D>() { ts_Ts, ts_Te }; Polyline ts_obstacleLine = PolylineBuilder.CreatePolyline(ts_obstaclePointList, SpatialReferenceBuilder.CreateSpatialReference(3857)); double kj_risk = 0; if (ddv > 1) { kj_risk = 0; } else if (ddv < 0.5) { kj_risk = 1; } else { kj_risk = Math.Pow(2 - 2 * ddv, 3.03); } using (RowBuffer rowBuffer = TargetShipObstacleLine.CreateRowBuffer()) { // Either the field index or the field name can be used in the indexer. rowBuffer[ConstDefintion.ConstFieldName_dcr] = kj_risk; rowBuffer[ConstDefintion.ConstFieldName_tcr] = tcr; rowBuffer[ConstDefintion.ConstFieldName_risk] = CollisionRisk; rowBuffer[ConstDefintion.ConstFieldName_tdv1] = tdv1; rowBuffer[ConstDefintion.ConstFieldName_tdv2] = tdv2; rowBuffer[ConstDefintion.ConstFieldName_tmin] = tmin; rowBuffer[ConstDefintion.ConstFieldName_Shape] = ts_obstacleLine; using (Feature feature = TargetShipObstacleLine.CreateRow(rowBuffer)) { feature.Store(); } } } } } }); } }); //创建航行位置Mask await QueuedTask.Run(async() => { //Mask边缘 //合并要素 using (Geodatabase gdb = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(GeoDataTool.DefaultProject.DefaultGeodatabasePath)))) { gdb.ApplyEdits(() => { using (FeatureClass u_VoyageMask = gdb.OpenDataset <FeatureClass>(unionMaskName)) { u_VoyageMask.DeleteRows(new QueryFilter() { WhereClause = "OBJECTID >= 1" }); using (FeatureClass voyageMask = gdb.OpenDataset <FeatureClass>(maskName)) { IList <Geometry> u_list = new List <Geometry>(); FeatureClassDefinition u_voyageMaskDefinition = gdb.GetDefinition <FeatureClassDefinition>(unionMaskName); using (RowCursor rowCursor = voyageMask.Search(null, false)) { while (rowCursor.MoveNext()) { using (Feature f = rowCursor.Current as Feature) { u_list.Add(f.GetShape()); } } //赋值 using (RowBuffer rowBuffer = u_VoyageMask.CreateRowBuffer()) { Geometry geometry = GeometryEngine.Instance.Union(u_list); rowBuffer[u_voyageMaskDefinition.GetShapeField()] = geometry; using (Feature feature = u_VoyageMask.CreateRow(rowBuffer)) { feature.Store(); } } } } } }); } //运行要素边缘转点 string inpath = GeoDataTool.DefaultProject.DefaultGeodatabasePath + "\\" + keyPointName; var args = Geoprocessing.MakeValueArray(inpath); var result = await Geoprocessing.ExecuteToolAsync("Delete_management", args, null, null, null); string inpath1 = GeoDataTool.DefaultProject.DefaultGeodatabasePath + "\\" + unionMaskName; string outpath = GeoDataTool.DefaultProject.DefaultGeodatabasePath + "\\" + keyPointName; var args1 = Geoprocessing.MakeValueArray(inpath1, outpath, "ALL"); var result1 = await Geoprocessing.ExecuteToolAsync("FeatureVerticesToPoints_management", args1, null, null, null); }); }
public async void CreateNewFeatureAsync(object parameter) { string message = String.Empty; bool creationResult = false; //Generate geometry if polygon or polyline, if adding new feature is from using coordinates and not the map tool if (Convert.ToBoolean(parameter) == true) { if (GeometryType == GeometryType.Polyline || GeometryType == GeometryType.Polygon) { GeneratePolyGeometry(); } } IEnumerable <GDBProjectItem> gdbProjectItems = Project.Current.GetItems <GDBProjectItem>(); await QueuedTask.Run(() => { foreach (GDBProjectItem gdbProjectItem in gdbProjectItems) { using (Datastore datastore = gdbProjectItem.GetDatastore()) { //Unsupported datastores (non File GDB and non Enterprise GDB) will be of type UnknownDatastore if (datastore is UnknownDatastore) { continue; } Geodatabase geodatabase = datastore as Geodatabase; // Use the geodatabase. string geodatabasePath = geodatabase.GetPath(); if (geodatabasePath.Contains(ProSymbolEditorModule.WorkspaceString)) { //Correct GDB, open the current selected feature class FeatureClass featureClass = geodatabase.OpenDataset <FeatureClass>(_currentFeatureClassName); using (featureClass) using (FeatureClassDefinition facilitySiteDefinition = featureClass.GetDefinition()) { EditOperation editOperation = new EditOperation(); editOperation.Name = "Military Symbol Insert"; editOperation.Callback(context => { try { RowBuffer rowBuffer = featureClass.CreateRowBuffer(); _symbolAttributeSet.PopulateRowBufferWithAttributes(ref rowBuffer); rowBuffer["Shape"] = GeometryEngine.Project(MapGeometry, facilitySiteDefinition.GetSpatialReference()); Feature feature = featureClass.CreateRow(rowBuffer); feature.Store(); //To Indicate that the attribute table has to be updated context.Invalidate(feature); } catch (GeodatabaseException geodatabaseException) { message = geodatabaseException.Message; } }, featureClass); var task = editOperation.ExecuteAsync(); creationResult = task.Result; if (!creationResult) { message = editOperation.ErrorMessage; } break; } } } } }); if (!creationResult) { MessageBox.Show(message); } }
public async Task 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 (RelationshipClass relationshipClass = geodatabase.OpenDataset <RelationshipClass>("LocalGovernment.GDB.OverviewToProject")) using (FeatureClass projectsFeatureClass = geodatabase.OpenDataset <FeatureClass>("LocalGovernment.GDB.CIPProjects")) using (FeatureClass overviewFeatureClass = geodatabase.OpenDataset <FeatureClass>("LocalGovernment.GDB.CIPProjectsOverview")) { FeatureClassDefinition overviewDefinition = overviewFeatureClass.GetDefinition(); // Because the following fields are used in 2 places, it is more inefficient to get their respective indexes so that they can be resued. int projectManagerIndex = overviewDefinition.FindField("PROJECTMAN"); int fundSourceIndex = overviewDefinition.FindField("FUNDSOUR"); RelationshipClassDefinition relationshipClassDefinition = relationshipClass.GetDefinition(); // This will be PROJNAME. This can be used to get the field index or used directly as the field name. string originKeyField = relationshipClassDefinition.GetOriginKeyField(); EditOperation editOperation = new EditOperation(); editOperation.Callback(context => { // The rows are being added to illustrate adding relationships. If one has existing rows, those can be used to add a relationship. RowBuffer projectsRowBuffer = projectsFeatureClass.CreateRowBuffer(); projectsRowBuffer["TOTCOST"] = 500000; RowBuffer overviewRowBufferWithoutPKValue = overviewFeatureClass.CreateRowBuffer(); overviewRowBufferWithoutPKValue[projectManagerIndex] = "John Doe"; overviewRowBufferWithoutPKValue[fundSourceIndex] = "Public"; RowBuffer overviewRowBuffer = overviewFeatureClass.CreateRowBuffer(); overviewRowBuffer["PROJNAME"] = "LibraryConstruction"; overviewRowBuffer[projectManagerIndex] = "John Doe"; overviewRowBuffer[fundSourceIndex] = "Public"; using (Row projectsRow = projectsFeatureClass.CreateRow(projectsRowBuffer)) using (Row overviewRowWithoutPKValue = overviewFeatureClass.CreateRow(overviewRowBufferWithoutPKValue)) using (Row overviewRow = overviewFeatureClass.CreateRow(overviewRowBuffer)) { try { Relationship failingRelationship = relationshipClass.CreateRelationship(overviewRowWithoutPKValue, projectsRow); } catch (GeodatabaseRelationshipClassException exception) { // This will have a message "Unable to obtain origin primary key value.". So, the origin row needs to have the origin *primary* // key value referenced by the origin *foreign* key value in the RelationshipClass. Console.WriteLine(exception); } Relationship relationship = relationshipClass.CreateRelationship(overviewRow, projectsRow); //To Indicate that the Map has to draw this feature/row and/or the attribute table has to be updated context.Invalidate(projectsRow); context.Invalidate(overviewRow); context.Invalidate(relationshipClass); } }, projectsFeatureClass, overviewFeatureClass); bool editResult = editOperation.Execute(); //If the table is non-versioned this is a no-op. If it is versioned, we need the Save to be done for the edits to be persisted. bool saveResult = await Project.Current.SaveEditsAsync(); } }
public async static void CreatePolygonExpantion() { await QueuedTask.Run(() => { using (Geodatabase gdb = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(GeoDataTool.DefaultProject.DefaultGeodatabasePath)))) { gdb.ApplyEdits(() => { using (FeatureClass fcStaticObstructPolygon = gdb.OpenDataset <FeatureClass>(ConstDefintion.ConstFeatureClass_StaticObstructPolygon)) { FeatureClassDefinition fcdStaticObstructPoint = gdb.GetDefinition <FeatureClassDefinition>(ConstDefintion.ConstFeatureClass_StaticObstructPolygon); FeatureClass fcSOPBuffer = gdb.OpenDataset <FeatureClass>(ConstDefintion.ConstFeatureClass_SOPBuffer); FeatureClass fc_SOPIDEPoint = gdb.OpenDataset <FeatureClass>(ConstDefintion.ConstFeatureClass_SOPIDEPoint); fc_SOPIDEPoint.DeleteRows(new QueryFilter() { WhereClause = "OBJECTID >= 1" }); using (RowCursor rc = fcStaticObstructPolygon.Search(null, false)) { while (rc.MoveNext()) { using (Feature f = rc.Current as Feature) { int affectDis = Convert.ToInt32(f[ConstDefintion.ConstFieldName_AffectDis]); double affectDegree = (double)f[ConstDefintion.ConstFieldName_AffectDegree]; MapPoint p = f[fcdStaticObstructPoint.GetShapeField()] as MapPoint; GeodesicEllipseParameter geodesic = new GeodesicEllipseParameter() { Center = p.Coordinate2D, SemiAxis1Length = affectDis, SemiAxis2Length = affectDis, LinearUnit = LinearUnit.Meters, OutGeometryType = GeometryType.Polygon, AxisDirection = 0, VertexCount = 800 }; Geometry circle = GeometryEngine.Instance.GeodesicEllipse(geodesic, SpatialReferenceBuilder.CreateSpatialReference(3857)); using (RowBuffer rowBuffer = fcSOPBuffer.CreateRowBuffer()) { // Either the field index or the field name can be used in the indexer. rowBuffer[ConstDefintion.ConstFieldName_AffectDegree] = 0; rowBuffer["Shape"] = circle; using (Feature feature = fcSOPBuffer.CreateRow(rowBuffer)) { feature.Store(); } } using (RowBuffer rowBuffer = fc_SOPIDEPoint.CreateRowBuffer()) { // Either the field index or the field name can be used in the indexer. rowBuffer[ConstDefintion.ConstFieldName_AffectDegree] = affectDegree; rowBuffer["Shape"] = p; using (Feature feature = fc_SOPIDEPoint.CreateRow(rowBuffer)) { feature.Store(); } } } } } } }); } }); }
private static void CreateAllDomain(FeatureClass fc_targetShip) { //创建船周围的船舶领域 using (Geodatabase gdb = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(GeoDataTool.DefaultProject.DefaultGeodatabasePath)))) { gdb.ApplyEdits(() => { //置空原船舶领域图层 FeatureClass shipDomain = gdb.OpenDataset <FeatureClass>(ConstDefintion.ConstFeatureClass_ShipDomianEllipse); FeatureClassDefinition shipDomainDefinition = gdb.GetDefinition <FeatureClassDefinition>(ConstDefintion.ConstFeatureClass_ShipDomianEllipse); shipDomain.DeleteRows(new QueryFilter() { WhereClause = "OBJECTID >= 1" }); using (RowCursor rowCursor = fc_targetShip.Search(null, false)) { while (rowCursor.MoveNext()) { using (Row row = rowCursor.Current) { Feature ship = row as Feature; MapPoint p_ship = ship.GetShape() as MapPoint; double asemi = Convert.ToDouble(ship[ConstDefintion.ConstFieldName_asemi]) / 2; double bsemi = Convert.ToDouble(ship[ConstDefintion.ConstFieldName_bsemi]) / 2; double aoffset = Convert.ToDouble(ship[ConstDefintion.ConstFieldName_aoffset]) / 2; double boffset = Convert.ToDouble(ship[ConstDefintion.ConstFieldName_boffset]) / 2; double DDV = Convert.ToDouble(ship[ConstDefintion.ConstFieldName_CollisionRisk]); double cog = Convert.ToDouble(ship[ConstDefintion.ConstFieldName_cog]); cog = CommonMethod.GIScoord2ShipCoord(cog); Coordinate2D ellipseCenter = new Coordinate2D() { X = p_ship.X, Y = p_ship.Y }; GeodesicEllipseParameter geodesic = new GeodesicEllipseParameter() { Center = ellipseCenter, SemiAxis1Length = asemi, SemiAxis2Length = bsemi, LinearUnit = LinearUnit.Meters, OutGeometryType = GeometryType.Polygon, AxisDirection = AngularUnit.Degrees.ConvertToRadians(cog), VertexCount = 800 }; Geometry ellipse = GeometryEngine.Instance.GeodesicEllipse(geodesic, SpatialReferenceBuilder.CreateSpatialReference(3857)); double moveX = (aoffset * Math.Cos(AngularUnit.Degrees.ConvertToRadians(cog)) + boffset * Math.Sin(AngularUnit.Degrees.ConvertToRadians(cog))); double moveY = (aoffset * Math.Sin(AngularUnit.Degrees.ConvertToRadians(cog)) - boffset * Math.Cos(AngularUnit.Degrees.ConvertToRadians(cog))); Geometry moved_ellipse = GeometryEngine.Instance.Move(ellipse, moveX, moveY); using (RowBuffer rowBuffer = shipDomain.CreateRowBuffer()) { // Either the field index or the field name can be used in the indexer. rowBuffer[ConstDefintion.ConstFieldName_asemi] = asemi; rowBuffer[ConstDefintion.ConstFieldName_bsemi] = bsemi; rowBuffer[ConstDefintion.ConstFieldName_aoffset] = aoffset; rowBuffer[ConstDefintion.ConstFieldName_CollisionRisk] = DDV; rowBuffer[shipDomainDefinition.GetShapeField()] = moved_ellipse; using (Feature feature = shipDomain.CreateRow(rowBuffer)) { feature.Store(); } } } } } }); } }
private async Task <string> AddFeatureToLayer(Geometry geom, CircleAttributes attributes) { string message = String.Empty; if (attributes == null) { message = "Attributes are Empty"; // For debug does not need to be resource return(message); } FeatureClass circleFeatureClass = await GetFeatureClass(addToMapIfNotPresent : true); if (circleFeatureClass == null) { message = DistanceAndDirectionLibrary.Properties.Resources.ErrorFeatureClassNotFound + this.GetLayerName(); return(message); } bool creationResult = false; FeatureClassDefinition circleDefinition = circleFeatureClass.GetDefinition(); EditOperation editOperation = new EditOperation(); editOperation.Name = "Circular Feature Insert"; editOperation.Callback(context => { try { RowBuffer rowBuffer = circleFeatureClass.CreateRowBuffer(); double distance = attributes.distance; if (IsDistanceCalcExpanded && (CircleType == CircleFromTypes.Diameter)) { distance *= 2.0; } if (circleDefinition.FindField("Distance") >= 0) { rowBuffer["Distance"] = distance; // Double } if (circleDefinition.FindField("DistUnit") >= 0) { rowBuffer["DistUnit"] = attributes.distanceunit; // Text } if (circleDefinition.FindField("DistType") >= 0) { rowBuffer["DistType"] = attributes.circletype; // Text } if (circleDefinition.FindField("CenterX") >= 0) { rowBuffer["CenterX"] = attributes.centerx; // Double } if (circleDefinition.FindField("CenterY") >= 0) { rowBuffer["CenterY"] = attributes.centery; // Double } rowBuffer["Shape"] = GeometryEngine.Instance.Project(geom, circleDefinition.GetSpatialReference()); Feature feature = circleFeatureClass.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; } }, circleFeatureClass); await QueuedTask.Run(async() => { creationResult = await editOperation.ExecuteAsync(); }); if (!creationResult) { message = editOperation.ErrorMessage; await Project.Current.DiscardEditsAsync(); } else { await Project.Current.SaveEditsAsync(); } return(message); }
public static async Task GenerateIDEKeyPointAsync(string fcName) { //1. await QueuedTask.Run(() => { using (Geodatabase gdb = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(GeoDataTool.DefaultProject.DefaultGeodatabasePath)))) { gdb.ApplyEdits(() => { using (FeatureClass fcStaticObstructPoint = gdb.OpenDataset <FeatureClass>(fcName)) { FeatureClassDefinition fcdStaticObstructPoint = gdb.GetDefinition <FeatureClassDefinition>(fcName); FeatureClass fcSOPBuffer = gdb.OpenDataset <FeatureClass>(ConstDefintion.ConstFeatureClass_SOPBuffer); FeatureClass fc_SOPIDEPoint = gdb.OpenDataset <FeatureClass>(ConstDefintion.ConstFeatureClass_SOPIDEPoint); fc_SOPIDEPoint.DeleteRows(new QueryFilter() { WhereClause = "OBJECTID >= 1" }); using (RowCursor rc = fcStaticObstructPoint.Search(null, false)) { while (rc.MoveNext()) { using (Feature f = rc.Current as Feature) { int affectDis = Convert.ToInt32(f[ConstDefintion.ConstFieldName_AffectDis]); double affectDegree = (double)f[ConstDefintion.ConstFieldName_AffectDegree]; MapPoint p = f[fcdStaticObstructPoint.GetShapeField()] as MapPoint; GeodesicEllipseParameter geodesic = new GeodesicEllipseParameter() { Center = p.Coordinate2D, SemiAxis1Length = affectDis, SemiAxis2Length = affectDis, LinearUnit = LinearUnit.Meters, OutGeometryType = GeometryType.Polygon, AxisDirection = 0, VertexCount = 800 }; Geometry circle = GeometryEngine.Instance.GeodesicEllipse(geodesic, SpatialReferenceBuilder.CreateSpatialReference(3857)); using (RowBuffer rowBuffer = fcSOPBuffer.CreateRowBuffer()) { // Either the field index or the field name can be used in the indexer. rowBuffer[ConstDefintion.ConstFieldName_AffectDegree] = 0; rowBuffer["Shape"] = circle; using (Feature feature = fcSOPBuffer.CreateRow(rowBuffer)) { feature.Store(); } } using (RowBuffer rowBuffer = fc_SOPIDEPoint.CreateRowBuffer()) { // Either the field index or the field name can be used in the indexer. rowBuffer[ConstDefintion.ConstFieldName_AffectDegree] = affectDegree; rowBuffer["Shape"] = p; using (Feature feature = fc_SOPIDEPoint.CreateRow(rowBuffer)) { feature.Store(); } } } } } } }); } }); //2.运行要素边缘转点 string inpath = GeoDataTool.DefaultProject.DefaultGeodatabasePath + "\\" + ConstDefintion.ConstFeatureClass_SOPBufferPoint; var args = Geoprocessing.MakeValueArray(inpath); var result = await Geoprocessing.ExecuteToolAsync("Delete_management", args, null, null, null); string inpath1 = GeoDataTool.DefaultProject.DefaultGeodatabasePath + "\\" + ConstDefintion.ConstFeatureClass_SOPBuffer; string outpath = GeoDataTool.DefaultProject.DefaultGeodatabasePath + "\\" + ConstDefintion.ConstFeatureClass_SOPBufferPoint; var args1 = Geoprocessing.MakeValueArray(inpath1, outpath, "ALL"); var result1 = await Geoprocessing.ExecuteToolAsync("FeatureVerticesToPoints_management", args1, null, null, null); //3. await QueuedTask.Run(() => { using (Geodatabase gdb = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(GeoDataTool.DefaultProject.DefaultGeodatabasePath)))) { gdb.ApplyEdits(() => { FeatureClass SOPIDEPoint = gdb.OpenDataset <FeatureClass>(ConstDefintion.ConstFeatureClass_SOPIDEPoint); FeatureClass SOPBufferPoint = gdb.OpenDataset <FeatureClass>(ConstDefintion.ConstFeatureClass_SOPBufferPoint); FeatureClassDefinition SOPIDEPointDefinition = gdb.GetDefinition <FeatureClassDefinition>(ConstDefintion.ConstFeatureClass_SOPIDEPoint); using (RowCursor rowCursor = SOPBufferPoint.Search(null, false)) { while (rowCursor.MoveNext()) { using (Feature f = rowCursor.Current as Feature) { using (RowBuffer rowBuffer = SOPIDEPoint.CreateRowBuffer()) { rowBuffer[ConstDefintion.ConstFieldName_AffectDegree] = 0; rowBuffer[SOPIDEPointDefinition.GetShapeField()] = f.GetShape(); using (Feature feature = SOPIDEPoint.CreateRow(rowBuffer)) { feature.Store(); } } } } } }); } }); }
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); }
public void MainMethodCode() { using (Geodatabase fileGeodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(@"C:\Data\LocalGovernment.gdb")))) using (FeatureClass featureClass = fileGeodatabase.OpenDataset <FeatureClass>("PollingPlace")) { QueryFilter queryFilter = new QueryFilter { WhereClause = "CITY = 'Plainfield'" }; Selection selection = featureClass.Select(queryFilter, SelectionType.ObjectID, SelectionOption.Normal); // The result is a mapping between those object ids which failed validation and the reason why the validation failed (a string message). IReadOnlyDictionary <long, string> validationResult = featureClass.Validate(selection); RowCursor rowCursor = featureClass.Search(queryFilter, false); List <Feature> features = new List <Feature>(); try { while (rowCursor.MoveNext()) { features.Add(rowCursor.Current as Feature); } // This is equivalent to the validation performed using the selection. IReadOnlyDictionary <long, string> equivalentValidationResult = featureClass.Validate(features); // Again this is equivalent to both the above results. IReadOnlyDictionary <long, string> anotherEquivalentResult = featureClass.Validate(queryFilter); SpatialQueryFilter spatialQueryFilter = new SpatialQueryFilter { FilterGeometry = new EnvelopeBuilder( new MapPointBuilder(1052803, 1812751).ToGeometry(), new MapPointBuilder(1034600, 1821320).ToGeometry()).ToGeometry(), SpatialRelationship = SpatialRelationship.Within }; IReadOnlyDictionary <long, string> spatialFilterBasedValidationResult = featureClass.Validate(spatialQueryFilter); } finally { rowCursor.Dispose(); Dispose(features); } } // 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 (FeatureClass enterpriseFeatureClass = geodatabase.OpenDataset <FeatureClass>("LocalGovernment.GDB.FacilitySite")) { QueryFilter parkFilter = new QueryFilter { WhereClause = "FCODE = 'Park'" }; Selection parkSelection = enterpriseFeatureClass.Select(parkFilter, SelectionType.ObjectID, SelectionOption.Normal); // Remember that validation cost is directly proprtional to the number of Features validated. So, select the set of features to be // validated judiciously. This will be empty because all the Park Features are valid. IReadOnlyDictionary <long, string> emptyDictionary = enterpriseFeatureClass.Validate(parkSelection); // We are adding an invalid feature to illustrate a case where the validation result is not empty. long invalidFeatureObjectID = -1; EditOperation editOperation = new EditOperation(); editOperation.Callback(context => { RowBuffer rowBuffer = null; Feature feature = null; try { FeatureClassDefinition facilitySiteDefinition = enterpriseFeatureClass.GetDefinition(); rowBuffer = enterpriseFeatureClass.CreateRowBuffer(); rowBuffer["FACILITYID"] = "FAC-400"; rowBuffer["NAME"] = "Griffith Park"; rowBuffer["OWNTYPE"] = "Municipal"; rowBuffer["FCODE"] = "Park"; // Note that this is an invalid subtype value. rowBuffer[facilitySiteDefinition.GetSubtypeField()] = 890; rowBuffer[facilitySiteDefinition.GetShapeField()] = new PolygonBuilder(new List <Coordinate2D> { new Coordinate2D(1021570, 1880583), new Coordinate2D(1028730, 1880994), new Coordinate2D(1029718, 1875644), new Coordinate2D(1021405, 1875397) }).ToGeometry(); feature = enterpriseFeatureClass.CreateRow(rowBuffer); invalidFeatureObjectID = feature.GetObjectID(); } catch (GeodatabaseException exObj) { Console.WriteLine(exObj); } finally { if (rowBuffer != null) { rowBuffer.Dispose(); } if (feature != null) { feature.Dispose(); } } }, enterpriseFeatureClass); editOperation.Execute(); // This will have one keypair value for the invalid row that was added. IReadOnlyDictionary <long, string> result = enterpriseFeatureClass.Validate(parkFilter); // This will say "invalid subtype code". string errorMessage = result[invalidFeatureObjectID]; } }