/// <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);
}
/// <summary>
/// 标准差
/// </summary>
/// <param name="dzxLayer"></param>
/// <param name="aue"></param>
/// <param name="bzc"></param>
public static void getBZC(OSGeo.OGR.Layer dzxLayer, out double aue, out double bzc)
{
//获取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);
values[i] = fileFeat.GetFieldAsDouble("EVE");
fileFeat.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);
}
/*************************************************************************************************/
/***************************读入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>
/// 获取原始坡度线
/// </summary>
/// <param name="Lev">提取级别，越高内容越丰富</param>
static OSGeo.OGR.Layer getPDX(int Lev)
{
//创建原始坡度线 polygon
shpDataSet.deleteLayerByName("slopeLine");
OSGeo.OGR.Layer slopePolyLayer = shpDataSet.CreateLayer("slopeLine", null, OSGeo.OGR.wkbGeometryType.wkbPolygon, null);
//获取分块数量
int Maxcnt = GetCutNumberOfImg("");
//开始计算
StaticTools.msgLine("createSlopeLine...");
for (int i = 0; i < Lev; i++)
{
//坡度阈值，每次变化得到的内容有所不同，最后合在一个polygon中
ImprotLevel = 85 - i * 5;
for (int ii = 0; ii < Maxcnt; ii++)
{
TKDataF(slopePolyLayer, ii);
StaticTools.progress((ii + 1) * (i + 1) * 100 / (Lev * Maxcnt),
string.Format("{0}/{1}on{2}/{3}", ii, Maxcnt, i, Lev));
}
}
slopeDataSet.Dispose();
//提线完成，删掉坡度图
if (IsDelete)
{
gdalDriver.Delete(slopePath);
}
return(slopePolyLayer);
}
public FeatureCursor(OSGeo.OGR.Layer layer, IQueryFilter filter)
{
if (layer == null)
{
return;
}
_layer = layer;
_layer.ResetReading();
if (filter is ISpatialFilter)
{
IEnvelope env = ((ISpatialFilter)filter).Geometry.Envelope;
_layer.SetSpatialFilterRect(env.minx, env.miny, env.maxx, env.maxy);
if (String.IsNullOrEmpty(filter.WhereClause))
{
_layer.SetAttributeFilter(null);
}
else
{
_layer.SetAttributeFilter(filter.WhereClause);
}
}
else
{
string where = filter.WhereClause;
if (String.IsNullOrEmpty(where))
{
where = null;
}
_layer.SetAttributeFilter(where);
_layer.SetSpatialFilter(null);
}
}
/// <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();
}
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());
//}
}
/// <summary>
/// Function to test if a the datasource contains the specified <paramref name="layerName"/>
/// </summary>
/// <param name="layerName">The name of the layer</param>
/// <returns><c>true</c> if the layer is present, otherwise <c>false</c></returns>
public Boolean ContainsLayer(string layerName)
{
using (OgrLayer layer = _ogrDataSource.GetLayerByName(layerName))
{
return(layer != null);
}
}
/// <summary>
/// This is GDAL's rasterization method. It's static becuase it makes a bit of a mess
/// </summary>
/// <param name="outputRaster"></param>
public static void Rasterize(Vector vectorinput, Raster outputRaster)
{
//http://www.gisremotesensing.com/2015/09/vector-to-raster-conversion-using-gdal-c.html
// Register GDal and get the driver objects
GdalConfiguration.ConfigureOgr();
outputRaster.Create();
outputRaster.SetNoData(-1.0);
Dataset _ds = Gdal.Open(outputRaster.GISFileInfo.FullName, Access.GA_Update);
vectorinput.Open();
int[] bandlist = new int[] { 1 };
OSGeo.OGR.Layer layer = vectorinput._ds.GetLayerByIndex(0);
double[] burnValues = new double[] { 1.0 };
string[] rasterizeOptions = new string[] { String.Format("ATTRIBUTE={0}", Vector.CGDMASKFIELD) }; // String.Format("ATTRIBUTE={0}", fieldname)
Gdal.RasterizeLayer(_ds, 1, bandlist, layer, IntPtr.Zero, IntPtr.Zero,
burnValues.Length, burnValues, rasterizeOptions,
new Gdal.GDALProgressFuncDelegate(ProgressFunc), "Raster conversion");
vectorinput.UnloadDS();
_ds.Dispose();
}
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);
}
public void AppendElement(string elementName)
{
if (_elements == null)
{
_elements = new List <IDatasetElement>();
}
foreach (IDatasetElement e in _elements)
{
if (e.Title == elementName)
{
return;
}
}
if (_dataSource != null)
{
for (int i = 0; i < _dataSource.GetLayerCount(); i++)
{
OSGeo.OGR.Layer ogrLayer = _dataSource.GetLayerByIndex(i);
if (ogrLayer == null)
{
continue;
}
if (ogrLayer.GetName() == elementName)
{
_elements.Add(new DatasetElement(new FeatureClass(this, ogrLayer)));
break;
}
}
}
}
//分块清理，提高效率
public static OSGeo.OGR.Layer cleanLayer_Cut(OSGeo.OGR.Layer pdLayer, double minArea, double maxArea, double maxCha = 1)
{
List <CutBox> Tree = buildTree(pdLayer);
shpDataSet.deleteLayerByName("pdClear");
OSGeo.OGR.Layer outLayer = shpDataSet.CreateLayer("pdClear", pdLayer.GetSpatialRef(), pdLayer.GetGeomType(), null);
OSGeo.OGR.Envelope oriEnve = new OSGeo.OGR.Envelope();
OSGeo.OGR.Envelope nextEnve = new OSGeo.OGR.Envelope();
StaticTools.msgLine("clean SlopeLine...");
for (int c = 0; c < Tree.Count; c++)
{
CutBox cb = Tree[c];
int featCount = cb.pdxIDs.Count;
for (int i = 0; i < featCount - 1; i++)
{
bool isOnly = true;
OSGeo.OGR.Feature ori = pdLayer.GetFeature(cb.pdxIDs[i]);
double oriArea = ori.GetGeometryRef().GetArea();
if (oriArea < minArea || oriArea > maxArea)
{
//判断当前要素的面积，过小或过大时，认为其有相同的图形，不加入新的Layer
isOnly = false;
}
else
{
//判断当前要素与其它要素的包围盒的对应边，差值都小于阈值时，认为是相同的图形，需要跳过
//没有相同的图型时，isOnly为true ，塞到新的layer里
ori.GetGeometryRef().GetEnvelope(oriEnve);
for (int j = i + 1; j < featCount; j++)
{
pdLayer.GetFeature(cb.pdxIDs[j]).GetGeometryRef().GetEnvelope(nextEnve);
if (Math.Abs(oriEnve.MaxX - nextEnve.MaxX) < maxCha &&
Math.Abs(oriEnve.MaxY - nextEnve.MaxY) < maxCha &&
Math.Abs(oriEnve.MinX - nextEnve.MinX) < maxCha &&
Math.Abs(oriEnve.MinY - nextEnve.MinY) < maxCha)
{
isOnly = false;
break;
}
}
}
if (isOnly)
{
outLayer.CreateFeature(ori);
}
StaticTools.progress((i + 2) * 100 / featCount, $"{i + 1} / {featCount}");
}
}
if (IsDelete)
{
shpDataSet.deleteLayerByName(pdLayer.GetName());
}
return(outLayer);
}
/************************************ 生成等值线 **********************************************/
public static string dzx(string filePath)
{
Console.WriteLine("开始创建等值线！");
OSGeo.OGR.Ogr.RegisterAll();
OSGeo.GDAL.Gdal.AllRegister();
//无效值
double noDataValue;
//0不使用无效值,1使用无效值
int hasDataValue;
//读入数据源
OSGeo.GDAL.Dataset inData = OSGeo.GDAL.Gdal.Open(filePath, OSGeo.GDAL.Access.GA_ReadOnly);
//分析数据源
inData.GetRasterBand(1).GetNoDataValue(out noDataValue, out hasDataValue);
double min, max, mean, std;
inData.GetRasterBand(1).GetStatistics(0, 1, out min, out max, out mean, out std);
int jianG = 2;
int count = Convert.ToInt32((max - min) / jianG + 0.5);
double[] shu = new double[count];
for (int i = 0; i < count; i++)
{
shu[i] = min + jianG * i;
}
//创建空的SHP
OSGeo.OGR.Ogr.RegisterAll();
OSGeo.OGR.Driver dr = OSGeo.OGR.Ogr.GetDriverByName("ESRI shapefile");
string a = StaticTools.tempFilePath("shp", "原始等值线");
OSGeo.OGR.DataSource ds = dr.CreateDataSource(a, null);
OSGeo.OGR.Layer dzxLayer = ds.CreateLayer("", null, OSGeo.OGR.wkbGeometryType.wkbMultiLineString, 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);
dzxLayer.CreateField(fieldDf0, 1); //ID
dzxLayer.CreateField(fieldDf1, 1); //Value
//Band(1), 间隔, 起始高度, 分段数量, 分段值数组, 是否有无效值, 无效值, 预置图层. ID字段, 高度值字段, null , null
OSGeo.GDAL.Gdal.ContourGenerate(inData.GetRasterBand(1), jianG, min, count, shu, hasDataValue, noDataValue, dzxLayer, 0, 1, null, null);
if (dzxLayer.GetFeatureCount(0) > 0)
{
Console.WriteLine("等值线创建完成！");
}
else
{
Console.WriteLine("等值线创建失败！");
}
ds.Dispose();
inData.Dispose();
return(a);
}
/// <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);
}
/// <summary>
/// Get Layer from Path
/// </summary>
/// <param name="path">Path of Layer</param>
/// <returns>Layer</returns>
public static OSGeo.OGR.Layer GetOgrLayer(string path)
{
OSGeo.OGR.Layer layer = null;
if (System.IO.File.Exists(path))
{
OSGeo.OGR.DataSource dsBaseLayer = OSGeo.OGR.Ogr.Open(path, 0);
layer = dsBaseLayer.GetLayerByIndex(0);
}
return(layer);
}
/// <summary>
/// 清理原文件
/// </summary>
/// <param name="jiaodu"></param>
/// <param name="cishu"></param>
private static void jianhua(OSGeo.OGR.Layer resLayer, double jiaodu, int cishu)
{
StaticTools.msgLine("huajian...");
StaticTools.progress(0);
for (int i = cishu; i > 0; i--)
{
resLayer.claenPoint(jiaodu, i);
StaticTools.progress((cishu - i + 1) * 100 / cishu);
}
}
public static int Polygonize(Band srcBand, Band maskBand, OSGeo.OGR.Layer outLayer, int iPixValField, string[] options, Gdal.GDALProgressFuncDelegate callback, string callback_data)
{
int ret = GdalPINVOKE.Polygonize(Band.getCPtr(srcBand), Band.getCPtr(maskBand), OSGeo.OGR.Layer.getCPtr(outLayer), iPixValField, (options != null)? new GdalPINVOKE.StringListMarshal(options)._ar : null, callback, callback_data);
if (GdalPINVOKE.SWIGPendingException.Pending)
{
throw GdalPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
//返回值是函数的系数
//例如：y=a0+a1*x 返回值则为a0 a1
//例如：y=a0+a1*x+a2*x*x 返回值则为a0 a1 a2
#endregion
/*************************************************************************************************/
/************************************ 生成等值线 **********************************************/
public static string dzxPath(string filePath)
{
OSGeo.OGR.Ogr.RegisterAll();
OSGeo.GDAL.Gdal.AllRegister();
//无效值
double noDataValue;
//0不使用无效值,1使用无效值
int hasDataValue;
//读入数据源
OSGeo.GDAL.Dataset inData = OSGeo.GDAL.Gdal.Open(filePath, OSGeo.GDAL.Access.GA_ReadOnly);
//分析数据源
inData.GetRasterBand(1).GetNoDataValue(out noDataValue, out hasDataValue);
double min, max, mean, std;
inData.GetRasterBand(1).GetStatistics(0, 1, out min, out max, out mean, out std);
int jianG = 2;
int count = Convert.ToInt32((max - min) / jianG + 0.5);
double[] shu = new double[count];
for (int i = 0; i < count; i++)
{
shu[i] = min + jianG * i;
}
//创建空的SHP
string dzSavePath = filePath.Substring(0, filePath.LastIndexOf(".")) + "_dzx.shp";
OSGeo.OGR.Driver dr = OSGeo.OGR.Ogr.GetDriverByName("ESRI shapefile");
if (System.IO.File.Exists(dzSavePath))
{
System.IO.File.Delete(dzSavePath);
}
OSGeo.OGR.DataSource ds = dr.CreateDataSource(dzSavePath, null);
OSGeo.OGR.Layer dzxLayer = ds.CreateLayer("等值线", null, OSGeo.OGR.wkbGeometryType.wkbMultiLineString, 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);
dzxLayer.CreateField(fieldDf0, 1); //ID
dzxLayer.CreateField(fieldDf1, 1); //Value
//Band(1), 间隔, 起始高度, 分段数量, 分段值数组, 是否有无效值, 无效值, 预置图层. ID字段, 高度值字段, null , null
OSGeo.GDAL.Gdal.ContourGenerate(inData.GetRasterBand(1), jianG, min, count, shu, hasDataValue, noDataValue, dzxLayer, 0, 1, null, null);
dzxLayer.Dispose();
ds.Dispose();
return(dzSavePath);
}
private static void getH(OSGeo.OGR.Layer oriLayer)
{
//创建一个BUFFER，BUFFER距离为1米
OSGeo.OGR.Layer bufLayer = bufferFile(oriLayer, 1);
//判断原文件中是否有以下字段，没有就创建
if (oriLayer.FindFieldIndex("MIN", 1) == -1)
{
OSGeo.OGR.FieldDefn min = new OSGeo.OGR.FieldDefn("MIN", OSGeo.OGR.FieldType.OFTReal);
oriLayer.CreateField(min, 1);
}
if (oriLayer.FindFieldIndex("MAX", 1) == -1)
{
OSGeo.OGR.FieldDefn max = new OSGeo.OGR.FieldDefn("MAX", OSGeo.OGR.FieldType.OFTReal);
oriLayer.CreateField(max, 1);
}
if (oriLayer.FindFieldIndex("HIGHT", 1) == -1)
{
OSGeo.OGR.FieldDefn hight = new OSGeo.OGR.FieldDefn("HIGHT", OSGeo.OGR.FieldType.OFTReal);
oriLayer.CreateField(hight, 1);
}
if (oriLayer.FindFieldIndex("TEMP", 1) == -1)
{
OSGeo.OGR.FieldDefn hight = new OSGeo.OGR.FieldDefn("TEMP", OSGeo.OGR.FieldType.OFTReal);
oriLayer.CreateField(hight, 1);
}
double[] transfrom = new double[6];
dsmDataset.GetGeoTransform(transfrom);
int allX = dsmDataset.RasterXSize;
int allY = dsmDataset.RasterYSize;
StaticTools.msgLine("getH...");
//开始计算每个Feature需要读取的栅格参数
int featCount = oriLayer.GetFeatureCount(0);
for (int i = 0; i < featCount; i++)
{
OSGeo.OGR.Feature oriFeat = oriLayer.GetFeature(i);
OSGeo.OGR.Feature bufFeat = bufLayer.GetFeature(i);
int[] subRasterOff_Size = subRasterInfo(transfrom, allX, allY, bufFeat);
// getMaxMinValue(dsmDataset, oriFeat, bufFeat, subRasterOff_Size);
oriLayer.SetFeature(oriFeat);
oriFeat.Dispose();
bufFeat.Dispose();
StaticTools.progress((i + 1) * 100 / featCount, $"{i} / {featCount}");
}
if (IsDelete)
{
shpDataSet.deleteLayerByName(bufLayer.GetName());
}
}
public void Dispose()
{
try
{
if (_layer == null)
{
return;
}
_layer.ResetReading();
_layer = null;
}
catch { }
}
///// <summary>
///// Loads a Ogr datasource with the specified layer
///// </summary>
///// <param name="filename">datasource</param>
///// <param name="layerName">name of layer</param>
/////If you want this functionality use
/////<example>
/////SharpMap.Data.Providers.Ogr prov = new SharpMap.Data.Providers.Ogr(datasource);
/////prov.LayerName = layerName;
/////</example>
//[Obsolete("This constructor does not work well with VB.NET. Use LayerName property instead")]
//public Ogr(string filename, string layerName)
//{
// Filename = filename;
// _ogrDataSource = OgrOgr.Open(filename, 1);
// _ogrLayer = _ogrDataSource.GetLayerByName(layerName);
// OsrSpatialReference spatialReference = _ogrLayer.GetSpatialRef();
// if (spatialReference != null)
// SRID = spatialReference.AutoIdentifyEPSG();
//}
/// <summary>
/// Loads a Ogr datasource with the specified layer
/// </summary>
/// <param name="filename">datasource</param>
/// <param name="layerNum">number of layer</param>
public Ogr(string filename, int layerNum)
{
Filename = filename;
_ogrDataSource = OgrOgr.Open(filename, 0);
_ogrLayer = _ogrDataSource.GetLayerByIndex(layerNum);
OsrSpatialReference spatialReference = _ogrLayer.GetSpatialRef();
if (spatialReference != null)
{
SRID = spatialReference.AutoIdentifyEPSG();
}
}
public Ogr(string filename, string layerName)
{
Filename = filename;
_ogrDataSource = OgrOgr.Open(filename, 1);
_ogrLayer = _ogrDataSource.GetLayerByName(layerName);
OsrSpatialReference spatialReference = _ogrLayer.GetSpatialRef();
if (spatialReference != null)
{
_srid = spatialReference.AutoIdentifyEPSG();
}
}
/// <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);
}
private static void TKDataF(OSGeo.OGR.Layer slopePolyLayer, int index)
{
double[] geoTansform = new double[6];
dsmDataset.GetGeoTransform(geoTansform);
int xTimes = (dsm_Xsize - 300) / 500;
int xRemainder = (dsm_Xsize - 300) % 500;
int yTimes = (dsm_Ysize - 300) / 500;
int yRemainder = (dsm_Ysize - 300) % 500;
int ax = xTimes, by = yTimes;
if (xRemainder > 10)
{
ax++;
}
int x = index % ax;
int y = index / ax;
int xsize = 800, ysize = 800;
if (x * 500 + 800 > dsm_Xsize)
{
xsize = dsm_Xsize - x * 500;
}
if (y * 500 + 800 > dsm_Ysize)
{
ysize = dsm_Ysize - y * 500;
}
double[] buffer = new double[xsize * ysize];
double[] slopebuffer = new double[xsize * ysize];
dsmDataset.GetRasterBand(1).ReadRaster(x * 500, y * 500, xsize, ysize, buffer, xsize, ysize, 0, 0);
slopeDataSet.GetRasterBand(1).ReadRaster(x * 500, y * 500, xsize, ysize, slopebuffer, xsize, ysize, 0, 0);
BasicUnit bUnit = new BasicUnit(x * 500, y * 500, xsize, ysize, ImprotLevel, buffer, slopebuffer, geoTansform, imgNodata);
List <OSGeo.OGR.Geometry> geolist = bUnit.Identify2();
lock (slopePolyLayer)
{
foreach (OSGeo.OGR.Geometry item in geolist)
{
if (item.GetGeometryType() == OSGeo.OGR.wkbGeometryType.wkbPolygon25D ||
item.GetGeometryType() == OSGeo.OGR.wkbGeometryType.wkbPolygon)
{
OSGeo.OGR.Feature oFea = new OSGeo.OGR.Feature(slopePolyLayer.GetLayerDefn());
oFea.SetGeometry(item);
slopePolyLayer.CreateFeature(oFea);
}
}
}
}
/// <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);
}
/// <summary>
/// DotSpatial to Ogr at layer level
/// </summary>
/// <param name="featureSet">DotSpatial IFeatureSet</param>
/// <returns>Ogr Layer</returns>
public static OSGeo.OGR.Layer DS2OrgLayer(DotSpatial.Data.IFeatureSet featureSet)
{
using (OSGeo.OGR.Driver driver = OSGeo.OGR.Ogr.GetDriverByName("Memory"))
{
OSGeo.OGR.DataSource dataSource = driver.CreateDataSource(featureSet.Name, null);
OSGeo.OGR.Layer layer = dataSource.CreateLayer("Result", DS2OgrProjection(featureSet.Projection), DS2OgrGeometryType(featureSet.FeatureType), new string[] { });
OSGeo.OGR.FeatureDefn featureDefn = DS2OgrDataTable(featureSet.DataTable);
for (int k = 0; k < featureDefn.GetFieldCount(); k++)
{
layer.CreateField(featureDefn.GetFieldDefn(k), 0);
}
for (int i = 0; i < featureSet.NumRows(); i++)
{
DotSpatial.Data.IFeature feature = featureSet.GetFeature(i);
OSGeo.OGR.Feature ogrFeature = new OSGeo.OGR.Feature(featureDefn);
ogrFeature.SetGeometry(DS2OgrGeometry(feature.Geometry, featureSet));
for (int j = 0; j < feature.DataRow.ItemArray.Length; j++)
{
#region Set Value to Feature
object value = feature.DataRow.ItemArray.GetValue(j);
if (value is int)
{
ogrFeature.SetField(j, (int)value);
}
else if (value is double)
{
ogrFeature.SetField(j, (double)value);
}
else if (value is string)
{
ogrFeature.SetField(j, (string)value);
}
else if (value is DateTime)
{
DateTime dateTime = (DateTime)value;
ogrFeature.SetField(j, dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour, dateTime.Minute, (float)dateTime.Second, 0);
}
#endregion
}
layer.CreateFeature(ogrFeature);
}
dataSource.FlushCache();
return(layer);
}
}
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);
}
/// <summary>
/// Reads the field types from the OgrFeatureDefinition -> OgrFieldDefinition
/// </summary>
/// <param name="oLayer">OgrLayer</param>
/// <returns>The feature data table</returns>
private static FeatureDataTable ReadColumnDefinition(OgrLayer oLayer)
{
var fdt = new FeatureDataTable
{
TableName = oLayer.GetName()
};
using (var ogrFeatureDefn = oLayer.GetLayerDefn())
{
int iField;
for (iField = 0; iField < ogrFeatureDefn.GetFieldCount(); iField++)
{
using (var ogrFldDef = ogrFeatureDefn.GetFieldDefn(iField))
{
var type= ogrFldDef.GetFieldType();
switch (type)
{
case OgrFieldType.OFTInteger:
fdt.Columns.Add(ogrFldDef.GetName(), typeof(Int32));
break;
case OgrFieldType.OFTIntegerList:
fdt.Columns.Add(ogrFldDef.GetName(), typeof(Int32[]));
break;
case OgrFieldType.OFTReal:
fdt.Columns.Add(ogrFldDef.GetName(), typeof(Double));
break;
case OgrFieldType.OFTRealList:
fdt.Columns.Add(ogrFldDef.GetName(), typeof(Double[]));
break;
case OgrFieldType.OFTWideString:
case OgrFieldType.OFTString:
fdt.Columns.Add(ogrFldDef.GetName(), typeof(String));
break;
case OgrFieldType.OFTStringList:
case OgrFieldType.OFTWideStringList:
fdt.Columns.Add(ogrFldDef.GetName(), typeof(String[]));
break;
case OgrFieldType.OFTDate:
case OgrFieldType.OFTTime:
case OgrFieldType.OFTDateTime:
fdt.Columns.Add(ogrFldDef.GetName(), typeof(DateTime));
break;
default:
{
//fdt.Columns.Add(_OgrFldDef.GetName(), System.Type.GetType("System.String"));
Debug.WriteLine("Not supported type: " + type + " [" + ogrFldDef.GetName() + "]");
break;
}
}
}
}
}
return fdt;
}
/// <summary>
/// Loads a Ogr datasource with the specified layer
/// </summary>
/// <param name="filename">datasource</param>
/// <param name="layerNum">number of layer</param>
public Ogr(string filename, int layerNum)
{
Filename = filename;
_ogrDataSource = OgrOgr.Open(filename, 0);
_ogrLayer = _ogrDataSource.GetLayerByIndex(layerNum);
OsrSpatialReference spatialReference = _ogrLayer.GetSpatialRef();
if (spatialReference != null)
SRID = spatialReference.AutoIdentifyEPSG();
}
/// <summary>
/// Reads the field types from the OgrFeatureDefinition -> OgrFieldDefinition
/// </summary>
/// <param name="fdt">FeatureDatatTable</param>
/// <param name="oLayer">OgrLayer</param>
private static void ReadColumnDefinition(FeatureDataTable fdt, OgrLayer oLayer)
{
using (OgrFeatureDefn ogrFeatureDefn = oLayer.GetLayerDefn())
{
int iField;
for (iField = 0; iField < ogrFeatureDefn.GetFieldCount(); iField++)
{
using (OgrFieldDefn ogrFldDef = ogrFeatureDefn.GetFieldDefn(iField))
{
OgrFieldType type= ogrFldDef.GetFieldType();
switch (type)
{
case OgrFieldType.OFTInteger:
fdt.Columns.Add(ogrFldDef.GetName(), Type.GetType("System.Int32"));
break;
case OgrFieldType.OFTReal:
fdt.Columns.Add(ogrFldDef.GetName(), Type.GetType("System.Double"));
break;
case OgrFieldType.OFTString:
fdt.Columns.Add(ogrFldDef.GetName(), Type.GetType("System.String"));
break;
case OgrFieldType.OFTWideString:
fdt.Columns.Add(ogrFldDef.GetName(), Type.GetType("System.String"));
break;
case OgrFieldType.OFTDate:
case OgrFieldType.OFTTime:
case OgrFieldType.OFTDateTime:
fdt.Columns.Add(ogrFldDef.GetName(), typeof(DateTime));
break;
default:
{
//fdt.Columns.Add(_OgrFldDef.GetName(), System.Type.GetType("System.String"));
Debug.WriteLine("Not supported type: " + type + " [" + ogrFldDef.GetName() + "]");
break;
}
}
}
}
}
}
public Ogr(string filename, string layerName)
{
Filename = filename;
_ogrDataSource = OgrOgr.Open(filename, 1);
_ogrLayer = _ogrDataSource.GetLayerByName(layerName);
OsrSpatialReference spatialReference = _ogrLayer.GetSpatialRef();
if (spatialReference != null)
_srid = spatialReference.AutoIdentifyEPSG();
}
