/// <summary>
/// DotSpatial to Ogr at geometry level
/// </summary>
/// <param name="geometry">GeoAPI/DotSpatial IGeometry</param>
/// <param name="featureSet">DotSpatial IFeatureSet</param>
/// <returns>Ogr Geometry</returns>
public static OSGeo.OGR.Geometry DS2OgrGeometry(GeoAPI.Geometries.IGeometry geometry, DotSpatial.Data.IFeatureSet featureSet)
{
string wkbGeometry = geometry.AsText();
OSGeo.OGR.Geometry result = OSGeo.OGR.Ogr.CreateGeometryFromWkt(ref wkbGeometry, DS2OgrProjection(featureSet.Projection));
return(result);
}
public IGeometry GetGeometry(string wkt)
{
OSGeo.OGR.Geometry geometry = OSGeo.OGR.Geometry.CreateFromWkt(wkt);
IGeometry destGeometry = geometry?.ToGeometry();
return(destGeometry);
}
/// <summary>
/// Returns the data associated with all the geometries that are intersected by 'geom'
/// </summary>
/// <param name="geom">Geometry to intersect with</param>
/// <param name="ds">FeatureDataSet to fill data into</param>
protected override void OnExecuteIntersectionQuery(Geometry geom, FeatureDataSet ds)
{
OgrGeometry ogrGeometry = OgrGeometry.CreateFromWkb(GeometryToWKB.Write(geom));
_ogrLayer.SetSpatialFilter(ogrGeometry);
ExecuteIntersectionQuery(ds);
}
/// <summary>
/// Ogr to DotSpatial at layer level
/// </summary>
/// <param name="layer">Ogr Layer</param>
/// <returns>DotSpatial IFeatureSet</returns>
public static DotSpatial.Data.IFeatureSet Ogr2DSLayer(OSGeo.OGR.Layer layer)
{
DotSpatial.Data.IFeatureSet featureSet = new DotSpatial.Data.FeatureSet();
featureSet.FeatureType = Ogr2DSGeometryType(layer.GetGeomType());
featureSet.DataTable = Ogr2DSDataTable(layer.GetLayerDefn());
featureSet.Projection = Ogr2DSProjection(layer.GetSpatialRef());
for (int i = 0; i < layer.GetFeatureCount(0); i++)
{
OSGeo.OGR.Geometry geometry = layer.GetFeature(i).GetGeometryRef();
DotSpatial.Data.IFeature feature = new DotSpatial.Data.Feature(Ogr2DSGeometry(geometry));
OSGeo.OGR.Feature ogrFeature = layer.GetFeature(i);
feature.DataRow = featureSet.DataTable.NewRow();
for (int j = 0; j < layer.GetLayerDefn().GetFieldCount(); j++)
{
object value = GetOgrValue(ogrFeature, j);
if (value == null)
{
value = DBNull.Value;
}
feature.DataRow[j] = value;
}
featureSet.Features.Add(feature);
}
return(featureSet);
}
private IGeometry ReadWkb(OgrGeometryType type, OgrGeometry geom)
{
var b = new byte[geom.WkbSize()];
geom.ExportToWkb(b);
return(Reader.Read(b));
}
public void QueryShape(IGeometry pGeometry)
{
if (pGeometry == null)
{
return;
}
try
{
OSGeo.OGR.Geometry ogrGeometry = m_currentOGRFeature.GetGeometryRef();
//export geometry from OGR to WKB
int wkbSize = ogrGeometry.WkbSize();
byte[] wkbBuffer = new byte[wkbSize];
ogrGeometry.ExportToWkb(wkbBuffer);
//import geometry from WKB to ESRI Shape
IWkb pWKB = pGeometry as IWkb;
pWKB.ImportFromWkb(wkbSize, ref wkbBuffer[0]);
pGeometry.SpatialReference = m_pDataset.SpatialReference;
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(" Error: " + ex.Message);
pGeometry.SetEmpty();
}
}
private static void _标准差(string dzx, out double aue, out double bzc)
{
OSGeo.OGR.Ogr.RegisterAll();
OSGeo.OGR.Driver dr = OSGeo.OGR.Ogr.GetDriverByName("ESRI shapefile");
OSGeo.OGR.DataSource dzxDS = dr.Open(dzx, 0);
OSGeo.OGR.Layer dzxLayer = dzxDS.GetLayerByIndex(0);
//获取Featuer数
int featCount = dzxLayer.GetFeatureCount(0);
// 1 拿到每个Featuer的Value
double[] values = new double[featCount];
for (int i = 0; i < featCount; i++)
{
OSGeo.OGR.Feature fileFeat = dzxLayer.GetFeature(i);
OSGeo.OGR.Geometry fileGeom = fileFeat.GetGeometryRef();
values[i] = fileFeat.GetFieldAsDouble("EVE");
fileGeom.Dispose();
fileFeat.Dispose();
}
dzxDS.Dispose();
// 2 求Values的平均值
aue = values.Average();
// 3 求values与平均值差的平方和
double pingFangHe = 0;
for (int i = 0; i < featCount; i++)
{
pingFangHe += (values[i] - aue) * (values[i] - aue);
}
// 4 每个值与平均值的差相加,除Featuer数.再开方,得到标准差
bzc = Math.Sqrt(pingFangHe / featCount);
}
private IGeometry ReadLineString(OgrGeometryType type, OgrGeometry geom)
{
var count = geom.GetPointCount();
var dimension = geom.GetCoordinateDimension();
var cs = _factory.CoordinateSequenceFactory.Create(count, dimension);
if (dimension > 2)
{
for (var i = 0; i < cs.Count; i++)
{
cs.SetOrdinate(i, Ordinate.X, geom.GetX(i));
cs.SetOrdinate(i, Ordinate.Y, geom.GetY(i));
cs.SetOrdinate(i, Ordinate.Z, geom.GetZ(i));
}
}
else
{
for (var i = 0; i < cs.Count; i++)
{
cs.SetOrdinate(i, Ordinate.X, geom.GetX(i));
cs.SetOrdinate(i, Ordinate.Y, geom.GetY(i));
}
}
return(_factory.CreateLineString(cs));
}
static void getMinOutLineFromLayerToLayer(OSGeo.OGR.Layer inLayer)
{
shpDataSet.deleteLayerByName("minOutLine");
OSGeo.OGR.Layer minoutline = shpDataSet.CreateLayer("minOutLine", inLayer.GetSpatialRef(), inLayer.GetGeomType(), null);
OSGeo.OGR.Feature aFeat = null;
StaticTools.msgLine("getMinOutline...");
int featCount = inLayer.GetFeatureCount(0);
for (int i = 0; i < featCount; i++)
{
aFeat = inLayer.GetFeature(i);
OSGeo.OGR.Geometry oGeometry = aFeat.GetGeometryRef();
OSGeo.OGR.Geometry ogeo = oGeometry.GetGeometryRef(0);
QTGeometry qtGeo = new QTGeometry(ogeo);
minoutline.CreateFeature(qtGeo.GetSMBR());
StaticTools.progress((i + 1) * 100 / featCount, $"{i} / {featCount}");
}
minoutline.Dispose();
//inLayer.ResetReading();
//while ((aFeat = inLayer.GetNextFeature()) != null)
//{
// OSGeo.OGR.Geometry oGeometry = aFeat.GetGeometryRef();
// OSGeo.OGR.Geometry ogeo = oGeometry.GetGeometryRef(0);
// QTGeometry qtGeo = new QTGeometry(ogeo);
// minoutline.CreateFeature(qtGeo.GetSMBR());
//}
}
public FeatureDataSet ExecuteQuery(string query, OgrGeometry filter)
{
try
{
var results = _ogrDataSource.ExecuteSQL(query, filter, "");
results.ResetReading();
//reads the column definition of the layer/feature
var ds = new FeatureDataSet();
var myDt = ReadColumnDefinition(results);
myDt.BeginLoadData();
var reader = new OgrGeometryReader(Factory);
OgrFeature ogrFeature;
while ((ogrFeature = results.GetNextFeature()) != null)
{
//LoadOgrFeatureToFeatureDataRow(myDt, ogrFeature, Factory);
LoadOgrFeatureToFeatureDataRow(myDt, ogrFeature, reader);
ogrFeature.Dispose();
}
myDt.EndLoadData();
ds.Tables.Add(myDt);
_ogrDataSource.ReleaseResultSet(results);
return(ds);
}
catch (Exception exc)
{
_log.Debug(t => t(exc.ToString()));
return(new FeatureDataSet());
}
}
/*************************************************************************************************/
/***************************读入SHP文件***************************/
/// <summary>
/// shpPolygon To List<Point[]>
/// </summary>
/// <param name="filePath"></param>
/// <returns></returns>
public static List <Point[]> shpPolygonToPointGL(string filePath)
{
List <Point[]> allFeature = new List <Point[]>();
OSGeo.OGR.Ogr.RegisterAll();
OSGeo.OGR.Driver dr = OSGeo.OGR.Ogr.GetDriverByName("ESRI shapefile");
OSGeo.OGR.DataSource ds = dr.Open(filePath, 0);
OSGeo.OGR.Layer fileLayer = ds.GetLayerByIndex(0);
int FeatCount = fileLayer.GetFeatureCount(0);
for (int u = 0; u < FeatCount; u++)
{
OSGeo.OGR.Feature fileFeature = fileLayer.GetFeature(u);
OSGeo.OGR.Geometry fileGeom = fileFeature.GetGeometryRef();
OSGeo.OGR.Geometry subGeom = fileGeom.GetGeometryRef(0);
int k = subGeom.GetPointCount();
Point[] aFeat = new Point[k];
for (int i = 0; i < k; i++)
{
aFeat[i].X = subGeom.GetX(i);
aFeat[i].Y = subGeom.GetY(i);
aFeat[i].Z = subGeom.GetZ(i);
}
allFeature.Add(aFeat);
}
return(allFeature);
}
/// <summary>
/// 通过ID数组提取出所有要素
/// </summary>
/// <param name="dzLine"></param>
/// <param name="pdLing"></param>
/// <param name="savePath"></param>
public static void selectFeat(string dzLine, string pdLing, string savePath)
{
//获得数组
int[] a = getMinIdGroup(dzLine, pdLing);
OSGeo.OGR.Ogr.RegisterAll();
OSGeo.OGR.Driver dr = OSGeo.OGR.Ogr.GetDriverByName("ESRI shapefile");
//读取原Layer
OSGeo.OGR.DataSource dzDS = dr.Open(dzLine, 0);
OSGeo.OGR.Layer dzLayer = dzDS.GetLayerByIndex(0);
//新建Layer
if (System.IO.File.Exists(savePath))
{
System.IO.File.Delete(savePath);
}
OSGeo.OGR.DataSource ds = dr.CreateDataSource(savePath, null);
OSGeo.OGR.Layer fileLayer = ds.CreateLayer("", null, OSGeo.OGR.wkbGeometryType.wkbPolygon, null);
//get featuer by ID
for (int i = 0; i < a.Length; i++)
{
OSGeo.OGR.Feature dzFeat = dzLayer.GetFeature(a[i]);
OSGeo.OGR.Geometry dzGeom = dzFeat.GetGeometryRef();
OSGeo.OGR.Geometry fileGeom = dzGeom;
OSGeo.OGR.Feature fileFeat = new OSGeo.OGR.Feature(dzFeat.GetDefnRef());
fileFeat.SetGeometry(fileGeom);
fileLayer.CreateFeature(dzFeat);
}
fileLayer.Dispose();
ds.Dispose();
dzDS.Dispose();
}
/// <summary>
/// Ogr to DotSpatial at geometry level
/// </summary>
/// <param name="geometry">Ogr Geometry</param>
/// <returns>GeoAPI/DotSpatial IGeometry</returns>
public static GeoAPI.Geometries.IGeometry Ogr2DSGeometry(OSGeo.OGR.Geometry geometry)
{
geometry.FlattenTo2D();
Byte[] wkbGeometry = new Byte[geometry.WkbSize()];
geometry.ExportToWkb(wkbGeometry, OSGeo.OGR.wkbByteOrder.wkbXDR);
NetTopologySuite.IO.WKBReader wkbReader = new NetTopologySuite.IO.WKBReader();
return(wkbReader.Read(wkbGeometry));
}
/// <summary>
/// 根据区块范围，获取对应的pdx,dzx
/// </summary>
/// <param name="pdLayer"></param>
/// <param name="dzxlayer"></param>
/// <returns></returns>
static List <CutBox> buildTree(OSGeo.OGR.Layer pdLayer, OSGeo.OGR.Layer dzxlayer = null)
{
StaticTools.msgLine("buildTree...");
OSGeo.OGR.Layer cutLayer = createCutLayer(3000);
//用 cutLayer 中的 Featuers 创建一个容器,容器中是对应 Featuer 的 cutBox
List <CutBox> allBoxes = new List <CutBox>();
int cutFeatCount = cutLayer.GetFeatureCount(0);
int pdFeatCount = pdLayer.GetFeatureCount(0);
if (dzxlayer != null)
{
int dzFeatCount = dzxlayer.GetFeatureCount(0);
for (int cuti = 0; cuti < cutFeatCount; cuti++)
{
CutBox cb = new CutBox();
//把与盒子相交的等值线塞入盒子,向外Buffer一定距离，避免尴尬
OSGeo.OGR.Geometry cutGeom = cutLayer.GetFeature(cuti).GetGeometryRef().Buffer(5, 0);
for (int dzi = 0; dzi < dzFeatCount; dzi++)
{
if (cutGeom.Intersect(dzxlayer.GetFeature(dzi).GetGeometryRef()))
{
cb.dzxIDs.Add(dzi);
}
}
allBoxes.Add(cb);
StaticTools.progress((cuti + 1) * 100 / cutFeatCount, $"{cuti}/{cutFeatCount}");
}
}
//遍历坡度线，放入对应的cutBox
//不会重复，要素只会放入第一个匹配上的盒子里
for (int pdi = 0; pdi < pdFeatCount; pdi++)
{
//拿出一个坡度要素
OSGeo.OGR.Geometry aGeom = pdLayer.GetFeature(pdi).GetGeometryRef();
for (int cuti = 0; cuti < cutFeatCount; cuti++)
{
//拿出一个盒子，与要素求交
OSGeo.OGR.Geometry cutGeom = cutLayer.GetFeature(cuti).GetGeometryRef();
if (aGeom.Intersects(cutGeom))
{
//塞入盒子,盒子ID ，坡度线ID
allBoxes[cuti].pdxIDs.Add(pdi);
break;
}
}
StaticTools.progress((pdi + 1) * 100 / pdFeatCount, $"{pdi}/{pdFeatCount}");
}
if (IsDelete)
{
shpDataSet.deleteLayerByName(cutLayer.GetName());
}
return(allBoxes);
}
public Geometry(OSGeo.OGR.Geometry geometry)
{
if (geometry == null)
{
throw new Exception("geometry不能为空");
}
OgrGeometry = geometry;
Geometries.CollectionChanged += Geometries_CollectionChanged;
Coordinates.CollectionChanged += Coordinates_CollectionChanged;
}
public IGeometry GetLineString(IEnumerable <ICoordinate> coordinates)
{
Geometry geometry = null;
OSGeo.OGR.Geometry ogrGeometry = coordinates?.ToOgrLineString();
if (ogrGeometry != null)
{
geometry = new Geometry(ogrGeometry);
}
return(geometry);
}
private IGeometry ReadPoint(OgrGeometryType type, OgrGeometry geom)
{
var c = new Coordinate(geom.GetX(0), geom.GetY(0));
if ((int)type > 0x1000000)
{
c.Z = geom.GetZ(0);
}
return(_factory.CreatePoint(c));
}
public IGeometry GetPolygon(IEnumerable <IEnumerable <ICoordinate> > ringList)
{
Geometry geometry = null;
OSGeo.OGR.Geometry ogrGeometry = ringList?.ToOgrPolygon();
if (ogrGeometry != null)
{
geometry = new Geometry(ogrGeometry);
}
return(geometry);
}
public IGeometry GetPoint(ICoordinate coordinate)
{
Geometry geometry = null;
OSGeo.OGR.Geometry ogrGeometry = coordinate?.ToOgrPoint();
if (ogrGeometry != null)
{
geometry = new Geometry(ogrGeometry);
}
return(geometry);
}
/// <summary>
/// Returns the data associated with all the geometries that are intersected by 'geom'
/// </summary>
/// <param name="geom">Geometry to intersect with</param>
/// <param name="ds">FeatureDataSet to fill data into</param>
protected override void OnExecuteIntersectionQuery(Geometry geom, IFeatureCollectionSet fcs, CancellationToken?ct = null)
{
using (var ogrGeometry = OgrGeometry.CreateFromWkb(GeometryToWKB.Write(geom)))
{
_ogrLayer.SetSpatialFilter(ogrGeometry);
var fds = new FeatureDataSet();
ExecuteIntersectionQuery(fds);
foreach (var fd in fds)
{
fcs.Add(fd);
}
}
}
static OSGeo.OGR.Feature polyFeat(OSGeo.OGR.Geometry lineGeom)
{
OSGeo.OGR.Feature polyFeat = new OSGeo.OGR.Feature(new OSGeo.OGR.FeatureDefn(""));
OSGeo.OGR.Geometry polyGeom = new OSGeo.OGR.Geometry(OSGeo.OGR.wkbGeometryType.wkbPolygon);
OSGeo.OGR.Geometry subGeom = new OSGeo.OGR.Geometry(OSGeo.OGR.wkbGeometryType.wkbLinearRing);
for (int s = 0; s < lineGeom.GetPointCount(); s++)
{
subGeom.AddPoint(lineGeom.GetX(s), lineGeom.GetY(s), lineGeom.GetZ(s));
}
polyGeom.AddGeometry(subGeom);
polyFeat.SetGeometry(polyGeom);
return(polyFeat);
}
public Geometry GetGeometry()
{
OSGeo.OGR.Geometry geo2 = new OSGeo.OGR.Geometry(OSGeo.OGR.wkbGeometryType.wkbLinearRing);
// 2 1
// 3 4
geo2.AddPoint(MaxX, MaxY, 0);
geo2.AddPoint(MinX, MaxY, 0);
geo2.AddPoint(MinX, MinY, 0);
geo2.AddPoint(MaxX, MinY, 0);
OSGeo.OGR.Geometry poly2 = new Geometry(wkbGeometryType.wkbPolygon);
poly2.AddGeometryDirectly(geo2);
return(poly2);
}
/// <summary>
/// Returns the data associated with all the geometries that are intersected by 'geom'
/// </summary>
/// <param name="geom">Geometry to intersect with</param>
/// <param name="ds">FeatureDataSet to fill data into</param>
protected override void OnExecuteIntersectionQuery(Geometry geom, FeatureDataSet ds)
{
using (var ogrGeometry = OgrGeometry.CreateFromWkb(GeometryToWKB.Write(geom)))
{
OgrDataSource ogrDataSource;
using (var ogrLayer = GetLayer(_layerIndex, out ogrDataSource))
{
ogrLayer.SetSpatialFilter(ogrGeometry);
ExecuteIntersectionQuery(ds, ogrLayer);
ogrDataSource.Dispose();
}
}
}
/// <summary>
/// 根据dsm的坐标划分区域
/// </summary>
/// <param name="tileSize">区块尺寸</param>
/// <returns></returns>
static OSGeo.OGR.Layer createCutLayer(double tileSize)
{
shpDataSet.deleteLayerByName("cutLayer");
OSGeo.OGR.Layer cutLayer = shpDataSet.CreateLayer("cutLayer", srs, OSGeo.OGR.wkbGeometryType.wkbPolygon, null);
double[] trans = new double[6];
dsmDataset.GetGeoTransform(trans);
//四边坐标
double top = trans[3];
double left = trans[0];
double right = trans[0] + dsmDataset.RasterXSize * trans[1];
double bottom = trans[3] + dsmDataset.RasterYSize * trans[5];
//子块角点
Point LB, LT, RT, RB;
//横竖块数
int hCount = (int)((top - bottom) / tileSize) + 1;
int wCount = (int)((right - left) / tileSize) + 1;
for (int h = 0; h < hCount; h++)
{
for (int w = 0; w < wCount; w++)
{
OSGeo.OGR.Geometry subCutGeom = new OSGeo.OGR.Geometry(OSGeo.OGR.wkbGeometryType.wkbLinearRing);
LB.X = left + tileSize * w;
LB.Y = bottom + tileSize * h;
subCutGeom.AddPoint(LB.X, LB.Y, 0);
LT.X = LB.X;
LT.Y = LB.Y + tileSize;
subCutGeom.AddPoint(LT.X, LT.Y, 0);
RT.X = LB.X + tileSize;
RT.Y = LT.Y;
subCutGeom.AddPoint(RT.X, RT.Y, 0);
RB.X = RT.X;
RB.Y = LB.Y;
subCutGeom.AddPoint(RB.X, RB.Y, 0);
//封闭poly
subCutGeom.AddPoint(LB.X, LB.Y, 0);
OSGeo.OGR.Geometry cutGeom = new OSGeo.OGR.Geometry(OSGeo.OGR.wkbGeometryType.wkbPolygon);
cutGeom.AddGeometry(subCutGeom);
OSGeo.OGR.Feature cutFeat = new OSGeo.OGR.Feature(new OSGeo.OGR.FeatureDefn(""));
cutFeat.SetGeometry(cutGeom);
cutLayer.CreateFeature(cutFeat);
}
}
return(cutLayer);
}
/// <summary>
/// 三点夹角的判定条件,输出为满足条件的成员的ID所组成的ID数组
/// </summary>
/// <param name="aFeat"></param>
/// <returns></returns>
private static OSGeo.OGR.Geometry JID(Point[] aFeat, double userSet, int seleTime)
{
List <Point[]> pjGroupL = new List <Point[]>();
List <Point[]> zjGroupL = new List <Point[]>();
List <Point> pjGroup = new List <Point>();
List <Point> zjGroup = new List <Point>();
for (int i = 0; i < aFeat.Length; i++)
{
int frontId, thisId, backId;
bool[] yon = new bool[seleTime];
for (int t = 1; t <= seleTime; t++)
{
frontId = i < t ? aFeat.Length - 1 + i - t : i - t;
thisId = i;
backId = i > aFeat.Length - 1 - t ? i - (aFeat.Length - 1) + t : backId = i + t;
double jiaodu = cosCalculator(aFeat[frontId], aFeat[thisId], aFeat[backId]);
yon[t - 1] = jiaodu > userSet;
}
if (yon.Contains(true))
{
pjGroup.Add(aFeat[i]);
}
else
{
zjGroup.Add(aFeat[i]);
}
}
OSGeo.OGR.Geometry outGeom = new OSGeo.OGR.Geometry(OSGeo.OGR.wkbGeometryType.wkbPolygon);
OSGeo.OGR.Geometry subGeom = new OSGeo.OGR.Geometry(OSGeo.OGR.wkbGeometryType.wkbLinearRing);
for (int g = 0; g < zjGroup.Count(); g++)
{
Point a = zjGroup[g];
subGeom.AddPoint(a.X, a.Y, a.Z);
}
if (subGeom.GetPointCount() < 4)
{
return(null);
}
subGeom.CloseRings();
outGeom.AddGeometry(subGeom);
return(outGeom);
}
/// <summary>
/// 通过slope的位置和面积筛选dzxPoly
/// </summary>
/// <param name="slopePolyLayer"></param>
/// <param name="dzxPolyLayer"></param>
/// <returns></returns>
static OSGeo.OGR.Layer selectionFeatuers(OSGeo.OGR.Layer slopePolyLayer, OSGeo.OGR.Layer dzxPolyLayer)
{
shpDataSet.deleteLayerByName("resLayer");
OSGeo.OGR.Layer resLayer = shpDataSet.CreateLayer("resLayer", srs, dzxPolyLayer.GetGeomType(), null);
List <CutBox> selectTree = buildTree(slopePolyLayer, dzxPolyLayer);
StaticTools.msgLine("selection...");
for (int i = 0; i < selectTree.Count; i++)
{
CutBox abox = selectTree[i];
for (int pdi = 0; pdi < abox.pdxIDs.Count; pdi++)
{
int ff = abox.pdxIDs[pdi];
OSGeo.OGR.Geometry pdGeom = slopePolyLayer.GetFeature(ff).GetGeometryRef();
double pdArea = pdGeom.GetArea();
double afterCha = double.MaxValue;
int yesID = -1;
for (int dzi = 0; dzi < abox.dzxIDs.Count; dzi++)
{
int tt = abox.dzxIDs[dzi];
OSGeo.OGR.Geometry dzGeom = dzxPolyLayer.GetFeature(tt).GetGeometryRef();
if (pdGeom.Intersect(dzGeom))
{
double cha = Math.Abs(dzGeom.GetArea() - pdArea);
if (cha < afterCha)
{
afterCha = cha;
yesID = tt;
}
}
}
if (yesID != -1)
{
resLayer.CreateFeature(dzxPolyLayer.GetFeature(yesID));
}
StaticTools.progress((pdi + 1) * 100 / abox.pdxIDs.Count, $"{pdi}/{abox.pdxIDs.Count} @ {i + 1} / {selectTree.Count}");
}
}
if (IsDelete)
{
shpDataSet.deleteLayerByName(slopePolyLayer.GetName());
shpDataSet.deleteLayerByName(dzxPolyLayer.GetName());
}
return(resLayer);
}
/******************************** 等值线转换为多边形 ***********************************************/
/// <summary>
/// 等值线转为POLYGON
/// </summary>
/// <param name="filePath"></param>
/// <returns></returns>
public static string dzPoly(string filePath)
{
OSGeo.OGR.Ogr.RegisterAll();
OSGeo.OGR.Driver dr = OSGeo.OGR.Ogr.GetDriverByName("ESRI shapefile");
string a = StaticTools.tempFilePath("shp", "等值线POLY");
OSGeo.OGR.DataSource newDS = dr.CreateDataSource(a, null);
OSGeo.OGR.Layer polyLayer = newDS.CreateLayer("", null, OSGeo.OGR.wkbGeometryType.wkbPolygon, null);
OSGeo.OGR.FieldDefn fieldDf0 = new OSGeo.OGR.FieldDefn("LID", OSGeo.OGR.FieldType.OFTInteger);
OSGeo.OGR.FieldDefn fieldDf1 = new OSGeo.OGR.FieldDefn("EVE", OSGeo.OGR.FieldType.OFTReal);
polyLayer.CreateField(fieldDf0, 1); //ID
polyLayer.CreateField(fieldDf1, 1); //Value
OSGeo.OGR.FeatureDefn featDF = new OSGeo.OGR.FeatureDefn("");
Console.WriteLine("开始等值线转POLY！");
OSGeo.OGR.DataSource cleanDS = dr.Open(filePath, 0);
OSGeo.OGR.Layer cleanLayer = cleanDS.GetLayerByIndex(0);
for (int i = 0; i < cleanLayer.GetFeatureCount(0); i++)
{
OSGeo.OGR.Feature lineFeat = cleanLayer.GetFeature(i);
OSGeo.OGR.Geometry lineGeom = lineFeat.GetGeometryRef();
OSGeo.OGR.Feature polyFeat = new OSGeo.OGR.Feature(featDF);
OSGeo.OGR.Geometry polyGeom = new OSGeo.OGR.Geometry(OSGeo.OGR.wkbGeometryType.wkbPolygon);
OSGeo.OGR.Geometry subGeom = new OSGeo.OGR.Geometry(OSGeo.OGR.wkbGeometryType.wkbLinearRing);
int u = lineGeom.GetPointCount();
for (int s = 0; s < u; s++)
{
double x = lineGeom.GetX(s);
double y = lineGeom.GetY(s);
double z = lineGeom.GetZ(s);
subGeom.AddPoint(x, y, z);
}
polyGeom.AddGeometry(subGeom);
polyFeat.SetGeometry(polyGeom);
polyLayer.CreateFeature(polyFeat);
lineGeom.Dispose();
polyGeom.Dispose();
subGeom.Dispose();
lineFeat.Dispose();
polyFeat.Dispose();
}
cleanLayer.Dispose();
polyLayer.Dispose();
cleanDS.Dispose();
newDS.Dispose();
Console.WriteLine("等值线转POLY完成！");
return(a);
}
public FeatureDataSet ExecuteQuery(string query, OgrGeometry filter)
{
try
{
FeatureDataSet ds = new FeatureDataSet();
FeatureDataTable myDt = new FeatureDataTable();
OgrLayer results = _ogrDataSource.ExecuteSQL(query, filter, "");
//reads the column definition of the layer/feature
ReadColumnDefinition(myDt, results);
OgrFeature ogrFeature;
results.ResetReading();
while ((ogrFeature = results.GetNextFeature()) != null)
{
FeatureDataRow dr = OgrFeatureToFeatureDataRow(myDt, ogrFeature, Factory);
myDt.AddRow(dr);
/*
* myDt.NewRow();
* for (int iField = 0; iField < ogrFeature.GetFieldCount(); iField++)
* {
* if (myDt.Columns[iField].DataType == Type.GetType("System.String"))
* dr[iField] = ogrFeature.GetFieldAsString(iField);
* else if (myDt.Columns[iField].GetType() == Type.GetType("System.Int32"))
* dr[iField] = ogrFeature.GetFieldAsInteger(iField);
* else if (myDt.Columns[iField].GetType() == Type.GetType("System.Double"))
* dr[iField] = ogrFeature.GetFieldAsDouble(iField);
* else
* dr[iField] = ogrFeature.GetFieldAsString(iField);
* }
*
* dr.Geometry = ParseOgrGeometry(ogrFeature.GetGeometryRef());
* myDt.AddRow(dr);
*/
}
ds.Tables.Add(myDt);
_ogrDataSource.ReleaseResultSet(results);
return(ds);
}
catch (Exception exc)
{
Debug.WriteLine(exc.ToString());
return(new FeatureDataSet());
}
}
/// <summary>
/// LineD to shpLine
/// </summary>
/// <param name="savePath"></param>
/// <param name="aLine"></param>
public static void LineDtoshpLine(string savePath, LineD aLine)
{
OSGeo.OGR.Ogr.RegisterAll();
OSGeo.OGR.Driver dr = OSGeo.OGR.Ogr.GetDriverByName("ESRI shapefile");
OSGeo.OGR.DataSource ds = dr.CreateDataSource(savePath, null);
OSGeo.OGR.Layer fileLayer = ds.CreateLayer("", null, OSGeo.OGR.wkbGeometryType.wkbLineString, null);
OSGeo.OGR.FeatureDefn FeatDf = new OSGeo.OGR.FeatureDefn("");
OSGeo.OGR.Feature fileFeat = new OSGeo.OGR.Feature(FeatDf);
OSGeo.OGR.Geometry fileGeom = new OSGeo.OGR.Geometry(OSGeo.OGR.wkbGeometryType.wkbLineString);
fileGeom.AddPoint(aLine.Start.X, aLine.Start.Y, aLine.Start.Z);
fileGeom.AddPoint(aLine.End.X, aLine.End.Y, aLine.End.Z);
fileFeat.SetGeometry(fileGeom);
fileLayer.CreateFeature(fileFeat);
fileLayer.Dispose();
ds.Dispose();
}
/// <summary>
/// Spatial filter using OGR
/// </summary>
/// <param name="featureSet">FeatureSet</param>
/// <param name="geometry">Spatial geometry</param>
/// <returns>Indexs of selected features</returns>
public static List <int> OgrSpatialFilter(IFeatureSet featureSet, IGeometry geometry)
{
List <int> result = new List <int>();
OSGeo.OGR.Layer layer = GIS.GDAL.VectorConverter.DS2OrgLayer(featureSet);
OSGeo.OGR.Geometry geo = GIS.GDAL.VectorConverter.DS2OgrGeometry(geometry, featureSet);
layer.SetSpatialFilter(geo);
OSGeo.OGR.Feature feature = layer.GetNextFeature();
while (feature != null)
{
result.Add(Convert.ToInt32(feature.GetFID()));
feature = layer.GetNextFeature();
}
return(result);
}
public FeatureDataSet ExecuteQuery(string query, OgrGeometry filter)
{
try
{
var results = _ogrDataSource.ExecuteSQL(query, filter, "");
results.ResetReading();
//reads the column definition of the layer/feature
var ds = new FeatureDataSet();
var myDt = ReadColumnDefinition(results);
myDt.BeginLoadData();
OgrFeature ogrFeature;
while ((ogrFeature = results.GetNextFeature()) != null)
{
LoadOgrFeatureToFeatureDataRow(myDt, ogrFeature, Factory);
ogrFeature.Dispose();
}
myDt.EndLoadData();
ds.Tables.Add(myDt);
_ogrDataSource.ReleaseResultSet(results);
return ds;
}
catch (Exception exc)
{
Debug.WriteLine(exc.ToString());
return new FeatureDataSet();
}
}
private static Geometry ParseOgrGeometry(OgrGeometry ogrGeometry, GeoAPI.Geometries.IGeometryFactory factory)
{
if (ogrGeometry != null)
{
//Just in case it isn't 2D
ogrGeometry.FlattenTo2D();
var wkbBuffer = new byte[ogrGeometry.WkbSize()];
ogrGeometry.ExportToWkb(wkbBuffer);
var geom = GeometryFromWKB.Parse(wkbBuffer, factory);
if (geom == null)
Debug.WriteLine("Failed to parse '{0}'", ogrGeometry.GetGeometryType());
return geom;
}
return null;
}
private static Geometry ParseOgrGeometry(OgrGeometry ogrGeometry)
{
if (ogrGeometry != null)
{
//Just in case it isn't 2D
ogrGeometry.FlattenTo2D();
byte[] wkbBuffer = new byte[ogrGeometry.WkbSize()];
ogrGeometry.ExportToWkb(wkbBuffer);
Geometry geom = GeometryFromWKB.Parse(wkbBuffer);
if (geom == null)
Debug.WriteLine(string.Format("Failed to parse '{0}'", ogrGeometry.GetGeometryType()));
return geom;
}
return null;
}
public FeatureDataSet ExecuteQuery(string query, OgrGeometry filter)
{
try
{
FeatureDataSet ds = new FeatureDataSet();
FeatureDataTable myDt = new FeatureDataTable();
OgrLayer results = _ogrDataSource.ExecuteSQL(query, filter, "");
//reads the column definition of the layer/feature
ReadColumnDefinition(myDt, results);
OgrFeature ogrFeature;
results.ResetReading();
while ((ogrFeature = results.GetNextFeature()) != null)
{
FeatureDataRow dr = OgrFeatureToFeatureDataRow(myDt, ogrFeature);
myDt.AddRow(dr);
/*
myDt.NewRow();
for (int iField = 0; iField < ogrFeature.GetFieldCount(); iField++)
{
if (myDt.Columns[iField].DataType == Type.GetType("System.String"))
dr[iField] = ogrFeature.GetFieldAsString(iField);
else if (myDt.Columns[iField].GetType() == Type.GetType("System.Int32"))
dr[iField] = ogrFeature.GetFieldAsInteger(iField);
else if (myDt.Columns[iField].GetType() == Type.GetType("System.Double"))
dr[iField] = ogrFeature.GetFieldAsDouble(iField);
else
dr[iField] = ogrFeature.GetFieldAsString(iField);
}
dr.Geometry = ParseOgrGeometry(ogrFeature.GetGeometryRef());
myDt.AddRow(dr);
*/
}
ds.Tables.Add(myDt);
_ogrDataSource.ReleaseResultSet(results);
return ds;
}
catch (Exception exc)
{
Debug.WriteLine(exc.ToString());
return new FeatureDataSet();
}
}
