public async Task UpdateFeatureAsync(long uid, Geometry geometry)
{
await QueuedTask.Run(() =>
{
using (FeatureClass featureClass = Layer.GetFeatureClass())
{
FeatureClassDefinition definition = featureClass?.GetDefinition();
string objectIdField = definition?.GetObjectIDField();
QueryFilter filter = new QueryFilter {
WhereClause = $"{objectIdField} = {uid}"
};
using (RowCursor existsResult = featureClass?.Search(filter, false))
{
while (existsResult?.MoveNext() ?? false)
{
using (Row row = existsResult.Current)
{
Feature feature = row as Feature;
feature?.SetShape(geometry);
feature?.Store();
}
}
}
}
});
}
private async void SelectCourse()
{
string fieldName = string.Empty;
var oidField = QueuedTask.Run(() =>
{
string name;
using (Geodatabase geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(GeoDataTool.DefaultProject.DefaultGeodatabasePath))))
{
FeatureClassDefinition fcd = geodatabase.GetDefinition <FeatureClassDefinition>(ConstDefintion.ConstFeatureClass_Course);
name = fcd.GetObjectIDField();
}
return(name);
}).Result;
string path = ConstDefintion.ConstFeatureClass_Course;
string whereClause = $"{oidField} = {CourseListSelectedItem}";
ProgressDialog progressDialogDomain = new ProgressDialog($"切换选择中", ConstDefintion.ConstStr_GeoprocessCancling, false);
var arg = Geoprocessing.MakeValueArray(path, "NEW_SELECTION", whereClause);
var task = await Geoprocessing.ExecuteToolAsync("SelectLayerByAttribute_management", arg, null, new CancelableProgressorSource(progressDialogDomain).Progressor);
if (!task.IsFailed)
{
if (!(MapView.Active == null))
{
await MapView.Active.ZoomToSelectedAsync();
}
}
}
private async Task <IGPResult> ExtraObstacle(double distance)
{
string fieldName = string.Empty;
var oidField = QueuedTask.Run(() =>
{
string name;
using (Geodatabase geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(GeoDataTool.DefaultProject.DefaultGeodatabasePath))))
{
FeatureClassDefinition fcd = geodatabase.GetDefinition <FeatureClassDefinition>(ConstDefintion.ConstFeatureClass_Course);
name = fcd.GetObjectIDField();
}
return(name);
}).Result;
string path = GeoDataTool.DefaultProject.DefaultGeodatabasePath + "\\" + ConstDefintion.ConstFeatureClass_Course;
string outpath = GeoDataTool.DefaultProject.DefaultGeodatabasePath + "\\" + ConstDefintion.ConstFeatureClass_SelectedCourse;
string whereClause = $"{oidField} = {CourseListSelectedItem}";
ProgressDialog progressDialogDomain = new ProgressDialog($"正在创建被选择航线图层", ConstDefintion.ConstStr_GeoprocessCancling, false);
var arg = Geoprocessing.MakeValueArray(path, outpath, whereClause);
var gp = await Geoprocessing.ExecuteToolAsync("Select_analysis", arg, null, new CancelableProgressorSource(progressDialogDomain).Progressor);
if (!gp.IsFailed)
{
ProgressDialog progressDialog1 = new ProgressDialog($"正在构造缓冲区", ConstDefintion.ConstStr_GeoprocessCancling, false);
string outBufferpath = GeoDataTool.DefaultProject.DefaultGeodatabasePath + "\\" + ConstDefintion.ConstFeatureClass_CourseBuffer;
string str_distance = $"{distance} NauticalMiles";
var arg1 = Geoprocessing.MakeValueArray(outpath, outBufferpath, str_distance);
var gp1 = await Geoprocessing.ExecuteToolAsync("Buffer_analysis", arg1, null, new CancelableProgressorSource(progressDialog1).Progressor);
if (!gp1.IsFailed)
{
ProgressDialog progressDialog2 = new ProgressDialog($"正在提取碍航物", ConstDefintion.ConstStr_GeoprocessCancling, false);
string insArgs = $"{ObstaclePath} 1;{outBufferpath} 2";
string outcourseObstacle = GeoDataTool.DefaultProject.DefaultGeodatabasePath + "\\" + ConstDefintion.ConstFeatureClass_CourseObstacle;
var arg2 = Geoprocessing.MakeValueArray(insArgs, outcourseObstacle);
var gp2 = await Geoprocessing.ExecuteToolAsync("Intersect_analysis", arg2, null, new CancelableProgressorSource(progressDialog2).Progressor);
if (!gp2.IsFailed)
{
ProgressDialog progressDialog3 = new ProgressDialog($"正在创建泰森多边形", ConstDefintion.ConstStr_GeoprocessCancling, false);
string outCourseObstacle_Thiessen = GeoDataTool.DefaultProject.DefaultGeodatabasePath + "\\" + ConstDefintion.ConstFeatureClass_CourseObstacleThiessen;
var arg3 = Geoprocessing.MakeValueArray(outcourseObstacle, outCourseObstacle_Thiessen);
var gp3 = await Geoprocessing.ExecuteToolAsync("CreateThiessenPolygons_analysis", arg3, null, new CancelableProgressorSource(progressDialog3).Progressor);
if (!gp3.IsFailed)
{
ProgressDialog progressDialog4 = new ProgressDialog($"正在裁剪", ConstDefintion.ConstStr_GeoprocessCancling, false);
string inCourseObstacle_Thiessen = outCourseObstacle_Thiessen;
string inBuffer = outBufferpath;
string outClipThiessen = GeoDataTool.DefaultProject.DefaultGeodatabasePath + "\\" + ConstDefintion.ConstFeatureClass_CourseObstacleThiessenClip;
var arg4 = Geoprocessing.MakeValueArray(inCourseObstacle_Thiessen, inBuffer, outClipThiessen);
var gp4 = await Geoprocessing.ExecuteToolAsync("Clip_analysis", arg4, null, new CancelableProgressorSource(progressDialog4).Progressor);
return(gp4);
}
}
}
}
return(null);
}
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 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);
});
}
