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);
});
}
});
}
/// <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();
}
}
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();
}
}
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()));
}
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 async Task SetupDefinitionDetailsAsync()
{
DefinitionDetails.Clear();
try
{
var lstDefs = await QueuedTask.Run <List <string> >(() =>
{
Definition datasetDefinition = Dataset.DatasetDefinition;
List <string> lstDefDetails = new List <string>();
if (datasetDefinition is TableDefinition)
{
TableDefinition tableDefinition = datasetDefinition as TableDefinition;
lstDefDetails.Add($"Object ID Field: {tableDefinition.GetObjectIDField()}");
StringBuilder stringBuilder = new StringBuilder();
if (!(_datastore is FileSystemDatastore))
{
lstDefDetails.Add($"Alias Name: {tableDefinition.GetAliasName()}");
lstDefDetails.Add($"CreatedAt Field: {tableDefinition.GetCreatedAtField()}");
lstDefDetails.Add($"Creator Field: {tableDefinition.GetCreatorField()}");
lstDefDetails.Add($"Subtype Field: {tableDefinition.GetSubtypeField()}");
lstDefDetails.Add($"Default Subtype Code: {tableDefinition.GetDefaultSubtypeCode()}");
lstDefDetails.Add($"EditedAt Field: {tableDefinition.GetEditedAtField()}");
lstDefDetails.Add($"Editor Field: {tableDefinition.GetEditorField()}");
lstDefDetails.Add($"Global ID Field: {tableDefinition.GetGlobalIDField()}");
lstDefDetails.Add($"Model Name: {tableDefinition.GetModelName()}");
foreach (var subtype in tableDefinition.GetSubtypes())
{
stringBuilder.Append(subtype.GetCode()).Append(": ").Append(subtype.GetName()).Append(Environment.NewLine);
}
lstDefDetails.Add($"Subtypes: {stringBuilder}");
}
stringBuilder = new StringBuilder();
foreach (Index index in tableDefinition.GetIndexes())
{
stringBuilder.Append(index.GetName()).Append(",");
string order = index.IsAscending() ? "Ascending" : "Descending";
stringBuilder.Append(order).Append(", ");
string unique = index.IsUnique() ? "Unique" : "Not Unique";
stringBuilder.Append(unique);
}
lstDefDetails.Add($"Indexes: {stringBuilder}");
}
if (datasetDefinition is FeatureClassDefinition)
{
FeatureClassDefinition featureClassDefinition = datasetDefinition as FeatureClassDefinition;
if (!(_datastore is FileSystemDatastore))
{
lstDefDetails.Add($"Area Field: {featureClassDefinition.GetAreaField()}");
lstDefDetails.Add($"Length Field: {featureClassDefinition.GetLengthField()}");
}
lstDefDetails.Add($"Shape Field: {featureClassDefinition.GetShapeField()}");
lstDefDetails.Add($"Shape Type: {featureClassDefinition.GetShapeType()}");
lstDefDetails.Add($"Spatial Reference Name: {featureClassDefinition.GetSpatialReference().Name}");
Envelope extent = featureClassDefinition.GetExtent();
lstDefDetails.Add($"Extent Details: XMin-{extent.XMin} XMax-{extent.XMax} YMin-{extent.YMin} YMax-{extent.YMax}");
}
if (datasetDefinition is FeatureDatasetDefinition)
{
FeatureDatasetDefinition featureDatasetDefinition = datasetDefinition as FeatureDatasetDefinition;
lstDefDetails.Add($"Spatial Reference Name: {featureDatasetDefinition.GetSpatialReference().Name}");
try
{
Envelope extent = featureDatasetDefinition.GetExtent();
lstDefDetails.Add($"Extent Details: XMin-{extent.XMin} XMax-{extent.XMax} YMin-{extent.YMin} YMax-{extent.YMax}");
}
catch (Exception)
{
lstDefDetails.Add("Could not get extent");
}
}
if (datasetDefinition is RelationshipClassDefinition)
{
RelationshipClassDefinition relationshipClassDefinition = datasetDefinition as RelationshipClassDefinition;
lstDefDetails.Add($"Alias Name: {relationshipClassDefinition.GetAliasName()}");
lstDefDetails.Add($"Cardinality: {relationshipClassDefinition.GetCardinality()}");
lstDefDetails.Add($"Origin Class: {relationshipClassDefinition.GetOriginClass()}");
lstDefDetails.Add($"Destination Class: {relationshipClassDefinition.GetDestinationClass()}");
lstDefDetails.Add($"Origin Primary Key: {relationshipClassDefinition.GetOriginKeyField()}");
lstDefDetails.Add($"Origin Foreign Key: {relationshipClassDefinition.GetOriginForeignKeyField()}");
lstDefDetails.Add($"Is Attachement?: {relationshipClassDefinition.IsAttachmentRelationship()}");
lstDefDetails.Add($"Is Composite Relationship?: {relationshipClassDefinition.IsComposite()}");
}
if (datasetDefinition is AttributedRelationshipClassDefinition)
{
AttributedRelationshipClassDefinition relationshipClassDefinition = datasetDefinition as AttributedRelationshipClassDefinition;
lstDefDetails.Add($"Destination Key: {relationshipClassDefinition.GetDestinationKeyField()}");
lstDefDetails.Add($"Destination Foreign Key: {relationshipClassDefinition.GetDestinationForeignKeyField()}");
lstDefDetails.Add($"Object ID Field: {relationshipClassDefinition.GetObjectIDField()}");
}
return(lstDefDetails);
});
DefinitionDetails.AddRange(lstDefs);
}
catch (Exception exObj)
{
MessageBox.Show(exObj.Message, "Error");
}
}
/// <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);
}
}
/// <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);
}
}
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();
}
}
// 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();
}
}
}
}
public void MainMethodCode()
{
using (Geodatabase fileGeodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(@"C:\Data\LocalGovernment.gdb"))))
using (Table table = fileGeodatabase.OpenDataset <Table>("luCodeInspection"))
{
QueryFilter queryFilter = new QueryFilter {
WhereClause = "ACTION = '1st Notice'"
};
using (RowCursor cursor = table.Search(queryFilter)) // Using Recycling.
{
bool hasRow = cursor.MoveNext();
using (Row currentRow = cursor.Current)
{
TableDefinition tableDefinition = table.GetDefinition();
int trivialFindField = currentRow.FindField(currentRow.GetFields()[0].Name); // This will (obviously) give 0.
int inspectIDIndex = currentRow.FindField("INSPECTID");
int violateKeyIndex = currentRow.FindField("violatekey");
int workKeyIndex = currentRow.FindField("WorkKey");
int subtypeFieldIndex = currentRow.FindField(tableDefinition.GetSubtypeField()); // Will be -1 since there are no subtypes.
int objectIdFieldIndex = currentRow.FindField(tableDefinition.GetObjectIDField());
int minusOne = currentRow.FindField("Gibberish"); // This will be -1.
}
}
}
// 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 landUseCaseFeatureClass = geodatabase.OpenDataset <FeatureClass>("LocalGovernment.GDB.LandUseCase"))
{
QueryFilter filter = new QueryFilter {
WhereClause = "CASETYPE = 'Rezoning'"
};
using (RowCursor landUseCursor = landUseCaseFeatureClass.Search(filter, false))
{
FeatureClassDefinition featureClassDefinition = landUseCaseFeatureClass.GetDefinition();
while (landUseCursor.MoveNext())
{
Feature rezoningUseCase = (Feature)landUseCursor.Current;
int caseIdIndex = rezoningUseCase.FindField("CASEID");
int caseNameIndex = rezoningUseCase.FindField("casename");
int applicantIndex = rezoningUseCase.FindField("Applicant");
int shapeFieldIndex = rezoningUseCase.FindField(featureClassDefinition.GetShapeField());
int subtypeIndex = rezoningUseCase.FindField(featureClassDefinition.GetSubtypeField()); // Will be -1 since there are no subtypes.
int objectIdIndex = rezoningUseCase.FindField(featureClassDefinition.GetObjectIDField());
break;
}
}
}
}
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 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();
}
}
}
}
}
});
}
}
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);
});
}
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();
}
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];
}
}
