/// <summary>
/// 整合坡度多边形(Polygon),并清除重叠部份
/// </summary>
/// <param name="subPdx"></param>
/// <returns></returns>
public static string zhengHePdx(List <string> subPdx)
{
OSGeo.OGR.Ogr.RegisterAll();
OSGeo.OGR.Driver dr = OSGeo.OGR.Ogr.GetDriverByName("ESRI shapefile");
string res = StaticTools.tempFilePath("shp", "整合");
OSGeo.OGR.DataSource newDS = dr.CreateDataSource(res, null); //////////////待关闭1 has
Layer newLayer = newDS.CreateLayer("podu", null, OSGeo.OGR.wkbGeometryType.wkbPolygon, null); //////////////待关闭2
for (int i = 0; i < subPdx.Count; i++)
{
OSGeo.OGR.DataSource ds = dr.Open(subPdx[i], 0);//////////////待关闭3 has
Layer layer = ds.GetLayerByIndex(0);
for (int j = 0; j < layer.GetFeatureCount(0); j++)
{
OSGeo.OGR.Feature subFeat = layer.GetFeature(j);
OSGeo.OGR.Geometry subGeom = subFeat.GetGeometryRef();
double thisArea = subGeom.GetArea();
// 清理过小Featuer
if (thisArea > 200)
{
newLayer.CreateFeature(layer.GetFeature(j));
}
}
ds.Dispose();
Console.WriteLine("完成整合{0}/{1}", i + 1, subPdx.Count);
}
newDS.Dispose();
cleanPdx(res);
return(res);
}
/// <summary>
/// Creates a points shapefile
/// </summary>
/// <param name="FileName"></param>
private static void TestCreatePointsShapeFile(string FileName)
{
var points = new List <string>()
{
"P1", "P2", "P3", "P4"
};
OSGeo.OGR.Driver drv = Ogr.GetDriverByName("ESRI Shapefile");
using (var ds = drv.CreateDataSource(FileName, new string[] {})) {
var src = new OSGeo.OSR.SpatialReference("");
src.ImportFromEPSG(23030);
using (var layer = ds.CreateLayer("SENSORS", src, wkbGeometryType.wkbPoint, new string[] {})) {
FieldDefn fdefn = new FieldDefn("ID", FieldType.OFTString);
fdefn.SetWidth(32);
layer.CreateField(fdefn, 1);
fdefn = new FieldDefn("FIELD_2", FieldType.OFTReal);
layer.CreateField(fdefn, 1);
foreach (var s in points)
{
Feature feature = new Feature(layer.GetLayerDefn());
feature.SetField("ID", s);
feature.SetField("FIELD_2", 123.4d);
var geom = new Geometry(wkbGeometryType.wkbPoint);
double X = 123.4;
double Y = 123.4;
geom.AddPointZM(X, Y, 123.4d, 0d);
feature.SetGeometry(geom);
layer.CreateFeature(feature);
}
}
ds.FlushCache();
}
}
/// <summary>
/// 提取平角点到文件
/// </summary>
/// <param name="inFile"></param>
/// <param name="outFile"></param>
public static void newGeom(string inFile, string outFile, double jiao = 175, int times = 3)
{
Ogr.RegisterAll();
OSGeo.OGR.Driver dr = Ogr.GetDriverByName("ESRI shapefile");
DataSource ds = dr.Open(inFile, 0);
Layer layer = ds.GetLayerByIndex(0);
var pointDs = dr.CreateDataSource(outFile, null);
var pointLayer = pointDs.CreateLayer("PointLayer", null, wkbGeometryType.wkbPoint, null);
int featCount = layer.GetFeatureCount(0);
for (int i = 0; i < featCount; i++)
{
Feature afeat = layer.GetFeature(i);
List <int> a = _平角点ID集(afeat, jiao, times);
int straightCount = a.Count;
for (int j = 0; j < straightCount; j++)
{
Geometry geom = afeat.GetGeometryRef();
Geometry subGeom = geom.GetGeometryRef(0);
Feature pointFeat = new Feature(new FeatureDefn(""));
Geometry pointGeom = new Geometry(wkbGeometryType.wkbPoint);
pointGeom.AddPoint_2D(subGeom.GetX(j), subGeom.GetY(j));
pointFeat.SetGeometry(pointGeom);
pointLayer.CreateFeature(pointFeat);
pointFeat.Dispose();
}
afeat.Dispose();
}
ds.Dispose();
pointDs.Dispose();
}
/// <summary>
/// 在指定路径下构建shp数据源（此操作不会生成实际的shp文件）
/// </summary>
/// <param name="shpFilePath">shp文件路径</param>
/// <returns></returns>
public static DataSource CreateShapefileSource(string shpFilePath)
{
Driver driver = Ogr.GetDriverByName("ESRI Shapefile");
if (driver == null)
{
throw new Exception("ESRI Shapefile 驱动不可使用");
}
Gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "YES"); // 为了支持中文路径
DataSource dataSource = driver.CreateDataSource(shpFilePath, null);
if (dataSource == null)
{
throw new Exception("创建SHP文件" + shpFilePath + "失败");
}
DirectoryInfo directoryInfo = new DirectoryInfo(Path.GetDirectoryName(shpFilePath));
if (!directoryInfo.Exists)
{
directoryInfo.Create();
}
driver.Dispose();
return(dataSource);
}
public static void selectDZXFromPointM(string point, string dzx, string savePath)
{
OSGeo.OGR.Ogr.RegisterAll();
OSGeo.OGR.Driver dr = OSGeo.OGR.Ogr.GetDriverByName("ESRI shapefile");
OSGeo.OGR.DataSource poiDS = dr.Open(point, 0);
OSGeo.OGR.Layer poiLayer = poiDS.GetLayerByIndex(0);
if (File.Exists(savePath))
{
File.Delete(savePath);
}
OSGeo.OGR.DataSource newDS = dr.CreateDataSource(savePath, null);
OSGeo.OGR.Layer newLayer = newDS.CreateLayer("", null, OSGeo.OGR.wkbGeometryType.wkbPolygon, null);
tickTime = 0;
int poiCount = poiLayer.GetFeatureCount(0);
for (int i = 0; i < poiCount; i++)
{
subAdd(poiLayer.GetFeature(i), dzx, newLayer);
}
while (tickTime < poiCount)
{
Thread.Sleep(2222);
Console.WriteLine("getFeatureByPoint:{0}/{1}", tickTime, poiCount);
}
Console.WriteLine("【本次提取到{0}个要素】", newLayer.GetFeatureCount(0));
newDS.Dispose();
poiDS.Dispose();
}
/************************************* 清理点簇 （未完成）*****************************************/
public static void getCleanLins(string inFile, string outFile)
{
Ogr.RegisterAll();
OSGeo.OGR.Driver dr = Ogr.GetDriverByName("ESRI shapefile");
DataSource inds = dr.Open(inFile, 0);
Layer inLayer = inds.GetLayerByIndex(0);
if (File.Exists(outFile))
{
File.Delete(outFile);
}
DataSource outds = dr.CreateDataSource(outFile, null);
Layer outLayer = outds.CreateLayer("", null, wkbGeometryType.wkbPolygon, null);
int featCount = inLayer.GetFeatureCount(0);
for (int i = 0; i < featCount; i++)
{
Feature inFeat = inLayer.GetFeature(i);
Geometry inGeom = inFeat.GetGeometryRef();
Geometry inSubG = inGeom.GetGeometryRef(0);
Feature outFeat = new Feature(new FeatureDefn(""));
Geometry outGeom = new Geometry(wkbGeometryType.wkbPolygon);
outGeom.AddGeometry(getCleanGeom(inSubG));
outFeat.SetGeometry(outGeom);
outLayer.CreateFeature(outFeat);
Console.WriteLine("{0}/{1}", i, featCount);
}
inds.Dispose();
outds.Dispose();
}
/// <summary>
/// 创建一个Buffer file,用于获取最小高度,juli是buffer的距离
/// </summary>
/// <param name="infile"></param>
/// <param name="juli"></param>
/// <returns></returns>
private static string bufferFile(string infile, int juli)
{
Ogr.RegisterAll();
string bufferFile = StaticTools.tempFilePath("shp", "Buf");
OSGeo.OGR.Driver dr = Ogr.GetDriverByName("ESRI shapefile");
DataSource infileDs = dr.Open(infile, 0);
Layer inLayer = infileDs.GetLayerByIndex(0);
DataSource bufferDs = dr.CreateDataSource(bufferFile, null);
Layer bufferLayer = bufferDs.CreateLayer(inLayer.GetName(), inLayer.GetSpatialRef(), inLayer.GetGeomType(), null);
int featCount = inLayer.GetFeatureCount(0);
for (int i = 0; i < featCount; i++)
{
Feature inFeat = inLayer.GetFeature(i);
Geometry inGeom = inFeat.GetGeometryRef();
Geometry outGeom = inGeom.Buffer(juli, 0);
Feature outFeat = new Feature(new FeatureDefn(""));
outFeat.SetGeometry(outGeom);
bufferLayer.CreateFeature(outFeat);
inFeat.Dispose();
outFeat.Dispose();
}
infileDs.Dispose();
bufferDs.Dispose();
return(bufferFile);
}
/// <summary>
/// 整合坡度线（Line）
/// </summary>
/// <param name="subPdx"></param>
/// <returns></returns>
public static string zhengHePdLine(List <string> subPdx)
{
OSGeo.OGR.Ogr.RegisterAll();
OSGeo.OGR.Driver dr = OSGeo.OGR.Ogr.GetDriverByName("ESRI shapefile");
string newPath = StaticTools.tempFilePath("shp", "整合线");
OSGeo.OGR.DataSource newDs = dr.CreateDataSource(newPath, null);/////////////////
OSGeo.OGR.Layer newLayer = newDs.CreateLayer("Lines",
dr.Open(subPdx[0], 0).GetLayerByIndex(0).GetSpatialRef(),
dr.Open(subPdx[0], 0).GetLayerByIndex(0).GetGeomType(), null);
for (int i = 0; i < subPdx.Count; i++)
{
OSGeo.OGR.DataSource dsLine = dr.Open(subPdx[i], 0);///////////////////////
OSGeo.OGR.Layer lineLayer = dsLine.GetLayerByIndex(0);
for (int j = 0; j < lineLayer.GetFeatureCount(0); j++)
{
newLayer.CreateFeature(lineLayer.GetFeature(j));
}
dsLine.Dispose();
}
newDs.Dispose();
return(newPath);
}
/************************************ 对比并筛选 ***************************************************/
/// <summary>
/// 通过ID数组提取出所有要素,创建动作
/// </summary>
/// <param name="dzLine"></param>
/// <param name="pdLing"></param>
/// <param name="savePath"></param>
public static void selectFeat(string dzx, string pdx, string savePath)
{
Stopwatch ssww = new Stopwatch(); ssww.Start();
//获得数组
int[] a = getMinIdGroupM(dzx, pdx);
Console.WriteLine("ID to Feater...");
OSGeo.OGR.Ogr.RegisterAll();
OSGeo.OGR.Driver dr = OSGeo.OGR.Ogr.GetDriverByName("ESRI shapefile");
OSGeo.OGR.DataSource dzDS = dr.Open(dzx, 0);
OSGeo.OGR.Layer dzLayer = dzDS.GetLayerByIndex(0);
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++)
{
fileLayer.CreateFeature(dzLayer.GetFeature(a[i]));
dzLayer.GetFeature(a[i]).Dispose();
}
dzLayer.Dispose();
dzDS.Dispose();
fileLayer.Dispose();
ds.Dispose();
_2_坡度线.OutLine.CutImg.cleanPdxM(savePath);
ssww.Stop();
Console.WriteLine("提取轮廓线完成！用时：{0}", ssww.Elapsed.ToString());
}
public void testStaticPartition()
{
Gdal.AllRegister();
Gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "YES");
Gdal.SetConfigOption("SHAPE_ENCODING", "");
Ogr.RegisterAll();
//读取文件
DataSource ds = Ogr.Open(fromPath, 0);
Layer oLayer = ds.GetLayerByIndex(0);
// 写入文件
OSGeo.OGR.Driver oDriver = Ogr.GetDriverByName("ESRI Shapefile");
// 创建数据源
DataSource oDS;
if (Ogr.Open(toPath, 0) != null)
{
oDS = Ogr.Open(toPath, 1);
oDS.DeleteLayer(0);
}
else
{
oDS = oDriver.CreateDataSource(toPath, null);
}
Layer toLayer = oDS.CreateLayer("POINT", oLayer.GetSpatialRef(), wkbGeometryType.wkbPoint, null);
Random ran = new Random();
Feature oFeature = null;
Geometry lines = null;
FeatureDefn oDefn = oLayer.GetLayerDefn();
FieldDefn oFieldID = new FieldDefn("HEIGHT_G", FieldType.OFTReal);
toLayer.CreateField(oFieldID, 1);
FieldDefn oFieldName = new FieldDefn("PWLs", FieldType.OFTReal);
toLayer.CreateField(oFieldName, 1);
while ((oFeature = oLayer.GetNextFeature()) != null)
{
//read current feature
lines = oFeature.GetGeometryRef();
Feature feature = new Feature(oDefn);
feature.SetGeometry(Line.getPoint(lines, lines.Centroid()));
feature.SetField(0, 4.0);
feature.SetField(1, ran.Next(40, 120));
toLayer.CreateFeature(feature);
}
oDS.SyncToDisk();
}
/// <summary>
/// 线声源离散
/// </summary>
/// <param name="sourcePath">声源路径</param>
/// <param name="resultPath">离散后路径</param>
/// <param name="splitLength">分割长度</param>
/// <param name="timeType">时段</param>
/// <param name="frequency">频率</param>
/// <returns></returns>
private Layer getSource()
{
String sourceResultPath = m_resultPath + "\\SourceTemp.shp";//输出路径
// 写入文件
OSGeo.OGR.Driver resultDriver = Ogr.GetDriverByName("ESRI Shapefile");
// 创建数据源
DataSource resultDataSource;
if (Ogr.Open(sourceResultPath, 0) != null)
{
resultDataSource = Ogr.Open(sourceResultPath, 1);
resultDataSource.DeleteLayer(0);
}
else
{
resultDataSource = resultDriver.CreateDataSource(sourceResultPath, null);
}
//投影信息
OSGeo.OSR.SpatialReference projection = new OSGeo.OSR.SpatialReference("");
projection.ImportFromEPSG(3395);
//构建声源点图层
Layer resultLayer = resultDataSource.CreateLayer("POINT", projection, wkbGeometryType.wkbPoint, null);
//构建属性
resultLayer.CreateField(new FieldDefn("HEIGHT_G", FieldType.OFTReal), 1); //高度
resultLayer.CreateField(new FieldDefn("PWLs", FieldType.OFTReal), 1); //单一频率声功率级
resultLayer.CreateField(new FieldDefn("FREQUENCY", FieldType.OFTReal), 1); //频率
ISource sourceBean = null;
DataSource sourceDataSource;
foreach (KeyValuePair <String, String> item in m_sourcePath)
{
switch (item.Key)
{
case "road":
sourceBean = new RoadSourrce();
break;
case "rainway":
sourceBean = new RainwaySource();
break;
case "subway":
sourceBean = new RoadSourrce();
break;
}
//源文件
sourceDataSource = Ogr.Open(item.Value, 0);
resultLayer = sourceBean.getSource(sourceDataSource.GetLayerByIndex(0), resultLayer, m_splitLength, m_timeType, m_frequency);
}
return(resultLayer);
}
/************************************* 点角式 *****************************************/
/// <summary>
/// 清理等后生成新的文件
///
/// </summary>
public static void claenPoint(string filePath, string savefile, double jiaodu, int cishu)
{
OSGeo.OGR.Ogr.RegisterAll();
OSGeo.OGR.Driver dr = OSGeo.OGR.Ogr.GetDriverByName("ESRI shapefile");
//进来的Layer
OSGeo.OGR.DataSource oriDs = dr.Open(filePath, 0);
OSGeo.OGR.Layer oriLayer = oriDs.GetLayerByIndex(0);
//出去的Layer
if (System.IO.File.Exists(savefile))
{
savefile.deleteFiles();
}
OSGeo.OGR.DataSource targDs = dr.CreateDataSource(savefile, null);
OSGeo.OGR.Layer targLayer = targDs.CreateLayer("targ", null, OSGeo.OGR.wkbGeometryType.wkbPolygon, null);
int featCount = oriLayer.GetFeatureCount(0);
for (int i = 0; i < featCount; i++)
{
///进来的Featuer
OSGeo.OGR.Feature oriFeat = oriLayer.GetFeature(i);
///把一个Featuer转为点数组
OSGeo.OGR.Geometry oriGeom = oriFeat.GetGeometryRef();
OSGeo.OGR.Geometry subGeom = oriGeom.GetGeometryRef(0);
int pointCount = subGeom.GetPointCount();
Point[] aFeat = new Point[pointCount];
for (int c = 0; c < pointCount; c++)
{
aFeat[c].X = subGeom.GetX(c);
aFeat[c].Y = subGeom.GetY(c);
aFeat[c].Z = subGeom.GetZ(c);
}
///调选点方法,得到一个新的Featuer
Geometry newGeom = null;
if (aFeat.Length > cishu * 3)
{
newGeom = JID(aFeat, jiaodu, cishu);
}
else
{
oriFeat.Dispose();
continue;
}
if (newGeom != null)
{
Feature temp = new Feature(new FeatureDefn(""));
temp.SetGeometry(newGeom);
targLayer.CreateFeature(temp);
temp.Dispose();
}
oriFeat.Dispose();
Console.WriteLine("已完成{0}/{1}", i, featCount);
}
oriDs.Dispose();
targDs.Dispose();
}
/******************************* 算法一 *************************************/
///
/// 2 调用点矩法提出断点，标记在CUT字段中
///
/// 3 调用点角法提出平角点，标计在straight中
///
/// 4 通过cut字段提取分段点集，再通过straight提取选用点集
///
/// 5 用选出的点集拟合直线并保留参数
/// 6 用参数集进行求交
/// 7 主要参数：点距法中的最大点距、点角法中的最大角度和迭代次数
///
/******************************* 工作流 *************************************/
public static void getDLG(string inFile, string outFile)
{
//注册
Ogr.RegisterAll(); Gdal.AllRegister();
//驱动
OSGeo.OGR.Driver dr = Ogr.GetDriverByName("ESRI shapefile");
//原数据
DataSource inDS = dr.Open(inFile, 0);
Layer inLayer = inDS.GetLayerByIndex(0);
//out数据
if (File.Exists(outFile))
{
File.Delete(outFile);
}
DataSource outDS = dr.CreateDataSource(outFile, null);
Layer outLayer = outDS.CreateLayer("outLayer", null, wkbGeometryType.wkbPolygon, null);
int featCount = inLayer.GetFeatureCount(0);
for (int i = 0; i < featCount; i++)
{
Feature aFeatuer = inLayer.GetFeature(i);
Geometry subGeom = aFeatuer.GetGeometryRef().GetGeometryRef(0);
//工作流 2 ， 返回所有断点的ID，有重要参数！
List <int> cutIDS = _点距法提断点._提取断点(aFeatuer, 2);
//工作流 3， 返回所有平角点的ID，有重要参数！
List <int> straightIDS = _提取平角点._平角点ID集(aFeatuer, 175, 5);
//输出准备工作
Feature newFeat = new Feature(new FeatureDefn(""));
Geometry newGeom = new Geometry(wkbGeometryType.wkbPolygon);
//工作流 4 , 通过cut字段提取分段点集，再通过straight提取选用点集
newGeom.AddGeometry(ForDLG._提取断平拟合直线(aFeatuer, cutIDS, straightIDS));
//收！
newFeat.SetGeometry(newGeom);
outLayer.CreateFeature(newFeat);
newFeat.Dispose();
aFeatuer.Dispose();
}
inLayer.Dispose();
outLayer.Dispose();
inDS.Dispose();
outDS.Dispose();
}
private void DatasetCopy(string srcPath, string trgPath, string driverName)
{
var dataset = Ogr.OpenShared(srcPath, 0);
var layers = CommonUtils.GetDatasetLayers(dataset);
OSGeo.OGR.Driver driver = Ogr.GetDriverByName(driverName);
var trgDataset = driver.CreateDataSource(trgPath, null);
foreach (var srcLayer in layers)
{
trgDataset.CopyLayer(srcLayer, srcLayer.GetName(), null);
}
trgDataset.Dispose();
}
public static void selectDZXFromPoint(string point, string dzx, string savePath)
{
OSGeo.OGR.Ogr.RegisterAll();
OSGeo.OGR.Driver dr = OSGeo.OGR.Ogr.GetDriverByName("ESRI shapefile");
OSGeo.OGR.DataSource poiDS = dr.Open(point, 0);
OSGeo.OGR.DataSource dzxDS = dr.Open(dzx, 0);
if (File.Exists(savePath))
{
File.Delete(savePath);
}
OSGeo.OGR.DataSource newDS = dr.CreateDataSource(savePath, null);
OSGeo.OGR.Layer poiLayer = poiDS.GetLayerByIndex(0);
OSGeo.OGR.Layer dzxLayer = dzxDS.GetLayerByIndex(0);
OSGeo.OGR.Layer newLayer = newDS.CreateLayer("", dzxLayer.GetSpatialRef(), dzxLayer.GetGeomType(), null);
int poiCount = poiLayer.GetFeatureCount(0);
int dzxCount = dzxLayer.GetFeatureCount(0);
for (int i = 0; i < poiCount; i++)
{
OSGeo.OGR.Feature poiFeat = poiLayer.GetFeature(i);
OSGeo.OGR.Geometry poiGeom = poiFeat.GetGeometryRef();
for (int t = 0; t < dzxCount; t++)
{
OSGeo.OGR.Feature dzxFeat = dzxLayer.GetFeature(t);
OSGeo.OGR.Geometry dzxGeom = dzxFeat.GetGeometryRef();
if (poiGeom.Within(dzxGeom))
{
newLayer.CreateFeature(dzxFeat);
}
dzxFeat.Dispose();
Console.WriteLine("getFeatureByPoint:{0}/{1}", i, poiCount);
}
poiFeat.Dispose();
}
Console.WriteLine("【本次提取到{0}个要素】", newLayer.GetFeatureCount(0));
newDS.Dispose();
dzxDS.Dispose();
poiDS.Dispose();
}
private static void BufferLayer(string orShpPath, string destShpPath, double BufferDistance)
{
//destShpPath = Path.GetDirectoryName(orShpPath)+"\\"+Path.GetFileNameWithoutExtension(orShpPath) + "_buf.shp";
DataSource dataSource = Ogr.Open(orShpPath, 1);
Layer layer = dataSource.GetLayerByIndex(0);
OSGeo.OGR.Driver dr = Ogr.GetDriverByName("ESRI Shapefile");
DataSource destDs = dr.CreateDataSource(Path.GetDirectoryName(destShpPath), null);
Layer destLayer = destDs.CreateLayer(Path.GetFileNameWithoutExtension(destShpPath), layer.GetSpatialRef(), layer.GetGeomType(), null);
Feature fea;
while ((fea = layer.GetNextFeature()) != null)
{
Geometry geo = fea.GetGeometryRef();
geo = geo.Buffer(BufferDistance, 5);
fea.SetGeometry(geo);
destLayer.CreateFeature(fea);
}
destLayer.Dispose();
destDs.Dispose();
layer.Dispose();
dataSource.Dispose();
}
// 将给定shp转换为Web Mercator投影
public void TransformShp(DataSource ds, string FilePath)
{
Layer layer = ds.GetLayerByIndex(0);
SpatialReference sr = layer.GetSpatialRef();
SpatialReference Mercator = new SpatialReference("");
Mercator.ImportFromEPSG(3857); // Web Mercator
Mercator.SetMercator(0d, 0d, 1d, 0d, 0d);
string strDriver = "ESRI Shapefile";
OSGeo.OGR.Driver oDriver = Ogr.GetDriverByName(strDriver);
oDriver.Register();
//创造新矢量图层
DataSource ds1 = oDriver.CreateDataSource(FilePath, null);
Layer layer1 = ds1.CreateLayer(layer.GetName(), Mercator, layer.GetGeomType(), null);
//读取属性字段名
Feature feature = layer.GetFeature(0);
for (int i = 0; i < feature.GetFieldCount(); i++)
{
FieldDefn fieldDefn = feature.GetFieldDefnRef(i);
layer1.CreateField(fieldDefn, 1);
}
//遍历图层中每个要素
feature = layer.GetNextFeature();
while (feature != null)
{
Geometry geom = feature.GetGeometryRef();
geom.TransformTo(Mercator);
feature.SetGeometry(geom);
layer1.CreateFeature(feature);
feature = layer.GetNextFeature();
}
ds1.FlushCache();
ds1.Dispose();
}
public void testPolygonPartition()
{
Gdal.AllRegister();
Gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "YES");
Gdal.SetConfigOption("SHAPE_ENCODING", "");
Ogr.RegisterAll();
//读取文件
DataSource ds = Ogr.Open(fromPath, 0);
Layer oLayer = ds.GetLayerByIndex(0);
DataSource dsb = Ogr.Open(bPath, 0);
Layer bLayer = dsb.GetLayerByIndex(0);
// 写入文件
OSGeo.OGR.Driver oDriver = Ogr.GetDriverByName("ESRI Shapefile");
// 创建数据源
DataSource oDS = oDriver.CreateDataSource(toPath, null);
Layer toLayer = oDS.CreateLayer("POINT", oLayer.GetSpatialRef(), wkbGeometryType.wkbPoint, null);
// Layer toLayer = oDS.CreateLayer("POINT", oLayer.GetSpatialRef(), wkbGeometryType.wkbPolygon, null);
FieldDefn oFieldID = new FieldDefn("HEIGHT_G", FieldType.OFTReal);
toLayer.CreateField(oFieldID, 1);
FieldDefn oFieldName = new FieldDefn("PWLs", FieldType.OFTReal);
toLayer.CreateField(oFieldName, 1);
polygonPartition(oLayer, toLayer, bLayer);
oDS.SyncToDisk();
}
/// <summary>
/// 生成矢量切片
/// </summary>
/// <param name="srcLayer"></param>
/// <param name="rectExtent"></param>
/// <param name="format"></param>
/// <param name="saveFile"></param>
/// <param name="trgSrs">输出投影</param>
/// <param name="simplifyDiff">设置两个最小相似点的距离，越大点越容易合并。值类型与图层数据类型（经纬度或长度）保持一致</param>
/// <param name="createEmptyFile">设置两个最小相似点的距离，越大点越容易合并。值类型与图层数据类型（经纬度或长度）保持一致</param>
/// <returns></returns>
public static bool CreateTileFile(Layer srcLayer, RectExtent rectExtent,
string format, string saveFile, OSGeo.OSR.SpatialReference trgSrs, double simplifyDiff, bool createEmptyFile)
{
Geometry rectG = CommonUtils.RectExtentToGeometry(rectExtent);
srcLayer.SetSpatialFilter(rectG);
int featureCount = srcLayer.GetFeatureCount(1);
if (featureCount == 0 && !createEmptyFile)
{
return(true);
}
OSGeo.OGR.Driver driver = Ogr.GetDriverByName(format);
var trgDataset = driver.CreateDataSource(saveFile, null);
var trgLayerName = System.IO.Path.GetFileNameWithoutExtension(saveFile);
var trgLayer = trgDataset.CreateLayer(trgLayerName, trgSrs, srcLayer.GetGeomType(), null);
Feature feature = null;
int flag;
srcLayer.ResetReading();
while ((feature = srcLayer.GetNextFeature()) != null)
{
var geometry = feature.GetGeometryRef();
//Douglas - Peucker algorithm算法进行抽稀
if (simplifyDiff > 0)
{
var simGeo = geometry.SimplifyPreserveTopology(simplifyDiff);
feature.SetGeometry(simGeo);
}
flag = trgLayer.CreateFeature(feature);
}
return(true);
}
private void button4_Click(object sender, EventArgs e)
{
string dir_gdal_data = System.Environment.CurrentDirectory + "\\" + "gdal-data\\";
Environment.SetEnvironmentVariable("GDAL_DATA", dir_gdal_data, EnvironmentVariableTarget.Process);
DelegateCoordsTransform dele = null;
VectorAdjust.CoordinateAdjust ca = new CoordinateAdjust();
//------------WGS84--GCJ02--------------
if (comboBox1.SelectedIndex == 0 && comboBox2.SelectedIndex == 1)
{
dele = new DelegateCoordsTransform(ca.WGS84ToGCJ02);
}
//------------GCJ02--WGS84--------------
if (comboBox1.SelectedIndex == 1 && comboBox2.SelectedIndex == 0)
{
dele = new DelegateCoordsTransform(ca.GCJ02ToWGS84);
}
//------------WGS84--BD09--------------
if (comboBox1.SelectedIndex == 0 && comboBox2.SelectedIndex == 2)
{
dele = new DelegateCoordsTransform(ca.WGS84ToBD09);
}
//------------BD09---WGS84--------------
if (comboBox1.SelectedIndex == 2 && comboBox2.SelectedIndex == 0)
{
dele = new DelegateCoordsTransform(ca.BD09ToWGS84);
}
//------------BD09---GCJ02--------------
if (comboBox1.SelectedIndex == 2 && comboBox2.SelectedIndex == 1)
{
dele = new DelegateCoordsTransform(ca.BD09ToGCJ02);
}
//------------GCJ02--BD09--------------
if (comboBox1.SelectedIndex == 1 && comboBox2.SelectedIndex == 2)
{
dele = new DelegateCoordsTransform(ca.GCJ02ToBD09);
}
if (files == null || files.Length == 0)
{
MessageBox.Show("请选择要处理的数据");
this.button1.Focus();
return;
}
if (comboBox1.SelectedIndex == comboBox2.SelectedIndex)
{
MessageBox.Show("目标坐标系和原始坐标系相同，请重新选择");
return;
}
if (String.IsNullOrWhiteSpace(textBox2.Text))
{
MessageBox.Show("请先选择保存数据目录");
this.button2.Focus();
return;
}
//初始化驱动信息
//注册所有驱动
Ogr.RegisterAll();
OSGeo.GDAL.Gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "YES");
//为支持属性表字段支持中文
OSGeo.GDAL.Gdal.SetConfigOption("SHAPE_ENCODING", "");
//开启日志
Gdal.SetConfigOption("CPL_DEBUG", "ON");
Gdal.SetConfigOption("CPL_LOG", System.IO.Directory.GetCurrentDirectory() + "\\gdallog.txt");
//驱动名称
string strDriverName = "ESRI Shapefile";
OSGeo.OGR.Driver Tdriver = Ogr.GetDriverByName(strDriverName);
if (Tdriver == null)
{
MessageBox.Show("获得驱动失败！程序退出");
return;
}
//遍历某个图层
this.progressBar1.Maximum = files.Length;
this.progressBar1.Minimum = 0;
this.progressBar1.Value = 0;
for (int i = 0; i < files.Length; i++)//遍历每个图层
{
string shp_file = files[i];
string shp_dir = System.IO.Path.GetDirectoryName(shp_file);
string shp_fileSaveName = System.IO.Path.GetFileNameWithoutExtension(shp_file);
//打开源数据
DataSource dsS = Ogr.Open(shp_file, 0);
if (dsS == null)
{
MessageBox.Show("打开" + shp_file + "文件失败", "提示");
this.progressBar1.Value++;
continue;
}
//创建目标数据
string saveDir = this.textBox2.Text;
DataSource dsT = Tdriver.CreateDataSource(saveDir, null);
if (dsT == null)
{
MessageBox.Show("创建" + saveDir + "\\" + shp_fileSaveName + "文件失败");
this.progressBar1.Value++;
continue;
}
Layer layerS = dsS.GetLayerByIndex(0);
if (layerS == null)
{
MessageBox.Show("获得" + shp_file + "图层失败");
this.progressBar1.Value++;
continue;
}
//string shp_fileSaveName_utf8 = TransferEncoding(Encoding.BigEndianUnicode,Encoding.UTF8,shp_fileSaveName);
OSGeo.GDAL.Gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "YES");
Layer LayerT = dsT.CreateLayer(shp_fileSaveName, layerS.GetSpatialRef(), layerS.GetGeomType(), null);//layerS.GetSpatialRef()
if (LayerT == null)
{
MessageBox.Show("创建" + saveDir + "\\" + shp_fileSaveName + "图层失败！", "提示");
this.progressBar1.Value++;
continue;
}
Feature pFeatureS, pFeatureT;
Geometry geomS, geomT;
long countFeature = layerS.GetFeatureCount(0);
FeatureDefn fd = layerS.GetLayerDefn();
//对目标图层进行属性定义
for (int ii = 0; ii < fd.GetFieldCount(); ii++)
{
LayerT.CreateField(fd.GetFieldDefn(ii), 1);
}
fd.Dispose();
this.progressBar2.Minimum = 0;
this.progressBar2.Maximum = (int)countFeature;
this.progressBar2.Value = 0;
for (int k = 0; k < countFeature; k++)
{
pFeatureS = layerS.GetFeature(k);
if (pFeatureS != null)
{
geomS = pFeatureS.GetGeometryRef();
geomT = GeometryCoordTransfrom2D(geomS, dele);
pFeatureT = pFeatureS.Clone();
pFeatureT.SetFrom(pFeatureS, 1);
pFeatureT.SetGeometryDirectly(geomT);
LayerT.CreateFeature(pFeatureT);
geomS.Dispose();
geomT.Dispose();
pFeatureS.Dispose();
pFeatureT.Dispose();
}
this.progressBar2.Value++;
}
layerS.Dispose();
LayerT.Dispose();
dsS.Dispose();
dsT.Dispose();
this.progressBar1.Value++;
}
MessageBox.Show("处理完毕", "提示");
}
/// <summary>
/// 创建树木位置
/// </summary>
public List <Tree> createTreePosition(DEMOperate dem, int i)
{
Console.WriteLine("Create trees of feature " + i);
if (oLayer == null)
{
return(null);
}
string forestType = "人工林";
string distributeType = "";
double density = 0;
double standArea = 0;
double treeNum = 0;
double D = 0, Dg = 0;
List <Tree> trees = new List <Tree>();
Feature oFeature = oLayer.GetFeature(i);
// 获得森林类型
for (int iField = 0; iField < m_FeildList.Count; iField++)
{
if (m_FeildList[iField].ToUpper() == "F_QIYUAN" || m_FeildList[iField].ToUpper() == "TYPE" || m_FeildList[iField].ToUpper() == "FOREST_TYPE" || m_FeildList[iField].ToUpper() == "STAND_TYPE")
{
forestType = GetFeildContent(iField, oFeature);
}
if (m_FeildList[iField].ToUpper() == "F_DWZS" || m_FeildList[iField].ToUpper() == "DENSITY" || m_FeildList[iField].ToUpper() == "FOREST_DENSITY" || m_FeildList[iField].ToUpper() == "STAND_DENSITY")
{
density = Convert.ToDouble(GetFeildContent(iField, oFeature));
}
if (m_FeildList[iField].ToUpper() == "DISTRIBUTE" || m_FeildList[iField].ToUpper() == "F_FBLX")
{
distributeType = GetFeildContent(iField, oFeature);
}
if (m_FeildList[iField].ToUpper() == "MEAN_DBH")//算数平均胸径
{
D = Convert.ToDouble(GetFeildContent(iField, oFeature));
}
if (m_FeildList[iField].ToUpper() == "QUADRATIC_MEAN_DBH" || m_FeildList[iField].ToUpper() == "Q_MEAN_DBH")//平均胸径（二次平均胸径）
{
Dg = Convert.ToDouble(GetFeildContent(iField, oFeature));
}
if (m_FeildList[iField].ToUpper() == "F_ZHUSHU" || m_FeildList[iField].ToUpper() == "TREE_NUMBER" || m_FeildList[iField].ToUpper() == "TREENUMBER")//林木数量
{
treeNum = Convert.ToDouble(GetFeildContent(iField, oFeature));
}
}
if (density == 0)
{
if (treeNum != 0)
{
standArea = oFeature.GetGeometryRef().GetArea();
density = treeNum / standArea / 10000;
}
else
{
Console.WriteLine("DATA ERROR: The Stand density is lacked.");
return(null);
}
}
// 人工林
if (forestType == "人工林" || forestType == "Plantation")
{
Geometry geom = oFeature.GetGeometryRef();
Envelope env = new Envelope();
geom.GetEnvelope(env);
//分布范围
double xMax, xMin, yMax, yMin, xCen, yCen;
xMax = env.MaxX;
xMin = env.MinX;
yMax = env.MaxY;
yMin = env.MinY;
xCen = (xMax + xMin) / 2;
yCen = (yMax + yMin) / 2;
//将值放入泛型当中位置坐标
List <double> tempX = new List <double>();
List <double> tempY = new List <double>();
double sideLength = Math.Sqrt(density / 10000 * ((xMax - xMin) * (yMax - yMin)));//边长
double offsetX = (xMax - xMin) / sideLength;
double offsetY = (yMax - yMin) / sideLength;
double diagonal = Math.Sqrt((xMax - xMin) * (xMax - xMin) + (yMax - yMin) * (yMax - yMin)); //对角线
double xAdd = (diagonal - (xMax - xMin)) / 2;
double yAdd = (diagonal - (yMax - yMin)) / 2;
Random rand = new Random();
//菱形均匀分布
if (distributeType.Contains("Diamond") || distributeType.Contains("Interlaced"))
{
Console.WriteLine("Diamond distribution");
int row = 0;
for (double j = xMin - xAdd; j < xMax + xAdd; j += offsetX)
{
if (row % 2 == 0)
{
for (double k = yMin - yAdd; k < yMax + yAdd; k += offsetY)
{
tempX.Add(j + rand.Next(10) / 10.0 * offsetX / 4);
tempY.Add(k + rand.Next(10) / 10.0 * offsetY / 4);
}
}
else
{
for (double k = yMin - yAdd + offsetY / 2; k < yMax + yAdd; k += offsetY)
{
tempX.Add(j + rand.Next(10) / 10.0 * offsetX / 4);
tempY.Add(k + rand.Next(10) / 10.0 * offsetY / 4);
}
}
row++;
}
}
// 环形均匀分布
else if (distributeType.Contains("Circular"))
{
Console.WriteLine("Circular distribution");
//对角线做直径,计算面积，计算株数，计算环数，计算环距，计算极坐标，计算xy
double r = diagonal / 2;
double A = Math.PI * r * r;
double N = density / 10000 * A;
int roundNum = (int)((Math.Sqrt(1 + 4.0 / 3 * N) - 1) / 2);
double roundDistance = Math.Sqrt(A / Math.PI) / roundNum;
for (int j = 0; j < roundNum; j++)
{
double radius = j * roundDistance; //极矩
for (int k = 0; k < 6 * j; k++)
{
double angle = k * 2 * Math.PI / 6 / j; //极径
tempX.Add(radius * Math.Cos(angle) + rand.Next(10) / 10.0 * roundDistance / 4 + xCen + rand.Next(10) / 10.0 * roundDistance / 4);
tempY.Add(radius * Math.Sin(angle) + rand.Next(10) / 10.0 * roundDistance / 4 + yCen + rand.Next(10) / 10.0 * roundDistance / 4);
}
}
}
// 井型均匀分布
else if (distributeType.Contains("Rectangular"))
{
Console.WriteLine("Rectangular distribution");
for (double j = xMin - xAdd; j < xMax + xAdd; j += offsetX)
{
for (double k = yMin - yAdd; k < yMax + yAdd; k += offsetY)
{
tempX.Add(j + rand.Next(10) / 10.0 * offsetX / 4);
tempY.Add(k + rand.Next(10) / 10.0 * offsetY / 4);
}
}
}
else
{
Console.WriteLine("Rectangular distribution (default)");
// 默认井型
for (double j = xMin - xAdd; j < xMax + xAdd; j += offsetX)
{
for (double k = yMin - yAdd; k < yMax + yAdd; k += offsetY)
{
tempX.Add(j + rand.Next(10) / 10.0 * offsetX / 4);
tempY.Add(k + rand.Next(10) / 10.0 * offsetY / 4);
}
}
}
//计算林分坡度
dem.getColRow(xCen, yCen);
double aspect = dem.CalcuAspect();
//坐标系转换，林木沿山坡分布
for (int j = 0; j < tempX.Count; j++)
{
double x = (tempX[j] - xCen) * Math.Cos(aspect) + (tempY[j] - yCen) * Math.Sin(aspect);
double y = (tempY[j] - yCen) * Math.Cos(aspect) - (tempX[j] - xCen) * Math.Sin(aspect);
tempX[j] = x + xCen;
tempY[j] = y + yCen;
}
//用此Driver创建Shape文件
//创建DataSource
string temppath = "temp" + i + ".shp";
DataSource pDataSource = oDriver.CreateDataSource(temppath, null);
if (pDataSource == null)
{
Console.WriteLine("DataSource Creation Error");
}
//创建层Layer
string outname = "point_out" + i;
Layer tempLayer = pDataSource.CreateLayer(outname, null, wkbGeometryType.wkbPoint, null);
if (tempLayer == null)
{
Console.WriteLine("Layer Creation Failed");
}
//创建属性
FieldDefn oField1 = new FieldDefn("TREE_ID", FieldType.OFTInteger);
oField1.SetWidth(16);
tempLayer.CreateField(oField1, 1);
//创建一个Feature
Feature mFeature = new Feature(tempLayer.GetLayerDefn());
// 创建点
Geometry mPoint = new Geometry(wkbGeometryType.wkbPoint);
for (int j = 0; j < tempX.Count; j++)
{
//树木编号
mFeature.SetField(0, j);
//添加坐标点
mPoint.AddPoint(tempX[j], tempY[j], 0);
mFeature.SetGeometry(mPoint);
//将带有坐标及属性的Feature要素点写入Layer中
tempLayer.CreateFeature(mFeature);
}
//关闭文件读写
mFeature.Dispose();
mPoint.Dispose();
//创建裁切Layer
string clipLyrname = "ClipLayer" + i;
Layer clipLayer = pDataSource.CreateLayer(clipLyrname, null, wkbGeometryType.wkbPolygon, null);
clipLayer.CreateFeature(oFeature);
//裁剪
string treePosition = "treePosition" + i;
Layer result = pDataSource.CreateLayer(treePosition, null, wkbGeometryType.wkbPoint, null);
tempLayer.Clip(clipLayer, result, new string[] { "SKIP_FAILURES=YES" }, null, null);
// 删除临时temp.shp
tempLayer.Dispose();
pDataSource.DeleteLayer(0);
//以下读取数据并对trees赋值
int rFeatureCount = (int)result.GetFeatureCount(0);
Feature rFeature = null;
for (int k = 0; k < rFeatureCount; k++)
{
Tree tree = new Tree();
tree.ForestID = i; //标注所属树林
tree.ID = k; //树木编号
rFeature = result.GetFeature(k);
Geometry geometry = rFeature.GetGeometryRef();
tree.X = geometry.GetX(0);
tree.Y = geometry.GetY(0);
trees.Add(tree);//加入trees
}
Console.WriteLine("Get trees' locations");
//求算WVA,WVA表示采用加权Voronoi图得出每株数的多边形面积
List <double> boundX = new List <double>();
List <double> boundY = new List <double>();
boundX.Add(xMin - offsetX); boundX.Add(xMin - offsetX); boundX.Add(xMax + offsetX); boundX.Add(xMax + offsetX);
boundY.Add(yMin - offsetY); boundY.Add(yMax + offsetY); boundY.Add(yMax + offsetY); boundY.Add(yMin - offsetY);
Geometry oGeometry = new Geometry(wkbGeometryType.wkbPolygon);
List <double> treeX = new List <double>();
List <double> treeY = new List <double>();
List <double> Area = new List <double>();
for (int t = 0; t < trees.Count; t++)
{
//只在本树林范围计算WVA，此时tree_count为除本树林已加入trees的棵数
treeX.Add(trees[t].X);
treeY.Add(trees[t].Y);
Area.Add(0); //初始化
}
int t_num = trees.Count; //此树林树木棵数
double[] treex = treeX.ToArray(); double[] treey = treeY.ToArray();
double[] boundx = boundX.ToArray(); double[] boundy = boundY.ToArray();
double[] area = Area.ToArray();
CreateThiessen(treex, treey, t_num, boundx, boundy, 4, area);
for (int t = 0; t < trees.Count; t++)
{
trees[t].WVA = area[t];
}
//分配胸径
WeibullDistribute(trees, trees.Count, D, Dg);
// 删除临时
clipLayer.Dispose();
result.Dispose();
pDataSource.DeleteLayer(0);
pDataSource.DeleteLayer(0);
}
return(trees);
}
public bool VectorFileCoordTransfrom(string fileName, string saveFileName, DelegateCoordsTransform deleCoordsTransfrom)
{
//注册所有驱动
Ogr.RegisterAll();
OSGeo.GDAL.Gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "NO");
//为支持属性表字段支持中文
OSGeo.GDAL.Gdal.SetConfigOption("SHAPE_ENCODING", "");
//开启日志
Gdal.SetConfigOption("CPL_DEBUG", "ON");
Gdal.SetConfigOption("CPL_LOG", System.IO.Directory.GetCurrentDirectory() + "\\gdallog.txt");
/**
* 打开数据源
*/
//---------------------------------------
//目标
string strDriverName = null;
if (System.IO.Path.GetExtension(saveFileName).ToUpper().Equals(".TAB"))
{
strDriverName = "MapInfo File";
}
if (System.IO.Path.GetExtension(saveFileName).ToUpper().Equals(".SHP"))
{
strDriverName = "ESRI Shapefile";
}
OSGeo.OGR.Driver Tdriver = Ogr.GetDriverByName(strDriverName);
if (Tdriver == null)
{
return(false);
}
string dir = System.IO.Path.GetDirectoryName(saveFileName);
DataSource dsT = Tdriver.CreateDataSource(dir, null);
if (dsT == null)
{
return(false);
}
//---------------------------------------
//源
DataSource dsS = Ogr.Open(fileName, 0);
if (dsS == null)
{
return(false);
}
OSGeo.OGR.Driver Sdriver = dsS.GetDriver();
if (Sdriver == null)
{
return(false);
}
//-------------------------------------------------
try
{
for (int iLayer = 0; iLayer < dsS.GetLayerCount(); iLayer++)
{
//获得图层信息
Layer layerS = dsS.GetLayerByIndex(iLayer);
//创建图层
//图层名称
string saveName = System.IO.Path.GetFileNameWithoutExtension(saveFileName);
Layer layerT = dsT.CreateLayer(saveName, layerS.GetSpatialRef(), layerS.GetGeomType(), null);
if (layerS != null)
{
Feature pFeatureS;
Feature pFeatureT;
Geometry geomS, geomT;
//地理要素
long countFeature = layerS.GetFeatureCount(0);
FeatureDefn fd = layerS.GetLayerDefn();
//对目标图层进行属性定义
for (int i = 0; i < fd.GetFieldCount(); i++)
{
layerT.CreateField(fd.GetFieldDefn(i), 1);
}
fd.Dispose(); //释放资源
for (int i = 0; i < countFeature; i++)
{
pFeatureS = layerS.GetFeature(i);
if (pFeatureS != null)
{
geomS = pFeatureS.GetGeometryRef();
geomT = GeometryCoordTransfrom2D(geomS, deleCoordsTransfrom);
pFeatureT = pFeatureS.Clone();
pFeatureT.SetFrom(pFeatureS, 1);
pFeatureT.SetGeometryDirectly(geomT);
//newGeotry.Dispose();
layerT.CreateFeature(pFeatureT);
geomS.Dispose();
geomT.Dispose();
pFeatureS.Dispose();
pFeatureT.Dispose();
//layerT.SetFeature(pFeatureT);
//pFeature.Dispose();
}
} //endfor
} //endif
layerS.Dispose();
layerT.Dispose();
}//endfor
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
dsS.Dispose();
dsT.Dispose();
return(true);
}
/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param>
protected override void SolveInstance(IGH_DataAccess DA)
{
GH_Structure <IGH_GeometricGoo> gGoo = new GH_Structure <IGH_GeometricGoo>();
DA.GetDataTree <IGH_GeometricGoo>("Feature Geometry", out gGoo);
GH_Structure <GH_Number> bufferInt = new GH_Structure <GH_Number>();
DA.GetDataTree <GH_Number>("Buffer Distance", out bufferInt);
GH_Structure <IGH_GeometricGoo> gGooBuffered = new GH_Structure <IGH_GeometricGoo>();
///GDAL setup
RESTful.GdalConfiguration.ConfigureOgr();
///Use WGS84 spatial reference
OSGeo.OSR.SpatialReference dst = new OSGeo.OSR.SpatialReference("");
dst.SetWellKnownGeogCS("WGS84");
Transform transform = new Transform(1); // Heron.Convert.XYZToWGSTransform();
Transform revTransform = new Transform(1); //Heron.Convert.WGSToXYZTransform();
///Create virtual datasource to be converted later
///Using geojson as a flexiblle base file type which can be converted later with ogr2ogr
OSGeo.OGR.Driver drv = Ogr.GetDriverByName("GeoJSON");
DataSource ds = drv.CreateDataSource("/vsimem/out.geojson", null);
///Use OGR catch-all for geometry types
var gtype = wkbGeometryType.wkbGeometryCollection;
///Create layer
OSGeo.OGR.Layer layer = ds.CreateLayer("temp", dst, gtype, null);
FeatureDefn def = layer.GetLayerDefn();
var branchPaths = gGoo.Paths;
for (int a = 0; a < gGoo.Branches.Count; a++)
{
///create feature
OSGeo.OGR.Feature feature = new OSGeo.OGR.Feature(def);
///Get geometry type(s) in branch
var geomList = gGoo.Branches[a];
string geomType = string.Empty;
List <string> geomTypeList = geomList.Select(o => o.TypeName).ToList();
///Test if geometry in the branch is of the same type.
///If there is more than one element of a type, tag as multi, if there is more than one type, tag as mixed
if (geomTypeList.Count == 1)
{
geomType = geomTypeList.First();
}
else if (geomTypeList.Count > 1 && geomTypeList.All(gt => gt == geomTypeList.First()))
{
geomType = "Multi" + geomTypeList.First();
}
else
{
geomType = "Mixed";
}
//var buffList = bufferInt.Branches[a];
var buffList = new List <GH_Number>();
//var path = new GH_Path(a);
var path = branchPaths[a];
if (path.Valid)
{
buffList = (List <GH_Number>)bufferInt.get_Branch(path);
}
else
{
buffList = bufferInt.Branches[0];
}
int buffIndex = 0;
double buffDist = 0;
GH_Convert.ToDouble(buffList[buffIndex], out buffDist, GH_Conversion.Primary);
///For testing
//AddRuntimeMessage(GH_RuntimeMessageLevel.Remark, geomType);
///Add geomtery to feature
///Create containers for translating from GH Goo
Point3d pt = new Point3d();
List <Point3d> pts = new List <Point3d>();
Curve crv = null;
List <Curve> crvs = new List <Curve>();
Mesh mesh = new Mesh();
Mesh multiMesh = new Mesh();
int quadsecs = 10;
switch (geomType)
{
case "Point":
geomList.First().CastTo <Point3d>(out pt);
var bufferPt = Heron.Convert.Point3dToOgrPoint(pt, transform).Buffer(buffDist, quadsecs);
gGooBuffered.AppendRange(Heron.Convert.OgrGeomToGHGoo(bufferPt, revTransform), new GH_Path(a));
break;
case "MultiPoint":
foreach (var point in geomList)
{
point.CastTo <Point3d>(out pt);
pts.Add(pt);
}
var bufferPts = Heron.Convert.Point3dsToOgrMultiPoint(pts, transform).Buffer(buffDist, quadsecs);
gGooBuffered.AppendRange(Heron.Convert.OgrGeomToGHGoo(bufferPts, revTransform), new GH_Path(a));
break;
case "Curve":
geomList.First().CastTo <Curve>(out crv);
var bufferCrv = Heron.Convert.CurveToOgrLinestring(crv, transform).Buffer(buffDist, quadsecs);
gGooBuffered.AppendRange(Heron.Convert.OgrGeomToGHGoo(bufferCrv, revTransform), new GH_Path(a));
break;
case "MultiCurve":
bool allClosed = true;
foreach (var curve in geomList)
{
curve.CastTo <Curve>(out crv);
if (!crv.IsClosed)
{
allClosed = false;
}
crvs.Add(crv);
}
if (allClosed)
{
var bufferCrvs = Heron.Convert.CurvesToOgrPolygon(crvs, transform).Buffer(buffDist, quadsecs);
gGooBuffered.AppendRange(Heron.Convert.OgrGeomToGHGoo(bufferCrvs, revTransform), new GH_Path(a));
}
else
{
var bufferCrvs = Heron.Convert.CurvesToOgrMultiLinestring(crvs, transform).Buffer(buffDist, quadsecs);
gGooBuffered.AppendRange(Heron.Convert.OgrGeomToGHGoo(bufferCrvs, revTransform), new GH_Path(a));
}
break;
case "Mesh":
geomList.First().CastTo <Mesh>(out mesh);
mesh.Ngons.AddPlanarNgons(DocumentTolerance());
var bufferPoly = Ogr.ForceToMultiPolygon(Heron.Convert.MeshToMultiPolygon(mesh, transform)).Buffer(buffDist, quadsecs);
gGooBuffered.AppendRange(Heron.Convert.OgrGeomToGHGoo(bufferPoly, revTransform), new GH_Path(a));
break;
case "MultiMesh":
foreach (var m in geomList)
{
Mesh meshPart = new Mesh();
m.CastTo <Mesh>(out meshPart);
meshPart.Ngons.AddPlanarNgons(DocumentTolerance());
multiMesh.Append(meshPart);
}
var bufferPolys = Ogr.ForceToMultiPolygon(Heron.Convert.MeshToMultiPolygon(multiMesh, transform)).Buffer(buffDist, quadsecs);
gGooBuffered.AppendRange(Heron.Convert.OgrGeomToGHGoo(bufferPolys, revTransform), new GH_Path(a));
break;
case "Mixed":
OSGeo.OGR.Geometry geoCollection = new OSGeo.OGR.Geometry(wkbGeometryType.wkbGeometryCollection);
for (int gInt = 0; gInt < geomList.Count; gInt++)
{
string geomTypeMixed = geomTypeList[gInt];
switch (geomTypeMixed)
{
case "Point":
geomList[gInt].CastTo <Point3d>(out pt);
geoCollection.AddGeometry(Heron.Convert.Point3dToOgrPoint(pt, transform));
break;
case "Curve":
geomList[gInt].CastTo <Curve>(out crv);
geoCollection.AddGeometry(Heron.Convert.CurveToOgrLinestring(crv, transform));
break;
case "Mesh":
geomList[gInt].CastTo <Mesh>(out mesh);
geoCollection.AddGeometry(Ogr.ForceToMultiPolygon(Heron.Convert.MeshToMultiPolygon(mesh, transform)));
break;
default:
AddRuntimeMessage(GH_RuntimeMessageLevel.Remark, "Not able to export " + geomType + " geometry at branch " + gGoo.get_Path(a).ToString() +
". Geometry must be a Point, Curve or Mesh.");
break;
}
}
var bufferCol = geoCollection.Buffer(buffDist, quadsecs);
gGooBuffered.AppendRange(Heron.Convert.OgrGeomToGHGoo(bufferCol, revTransform), new GH_Path(a));
break;
default:
AddRuntimeMessage(GH_RuntimeMessageLevel.Remark, "Not able to export " + geomType + " geometry at branch " + gGoo.get_Path(a).ToString() +
". Geometry must be a Point, Curve or Mesh.");
break;
}
}
def.Dispose();
layer.Dispose();
ds.Dispose();
DA.SetDataTree(0, gGooBuffered);
}
public bool JsonToShapeFile(string jsonFilePath, string shapeFilePath)
{
OSGeo.OGR.Driver jsonFileDriver = Ogr.GetDriverByName("GeoJSON");
DataSource jsonFile = Ogr.Open(jsonFilePath, 0);
if (jsonFile == null)
{
return(false);
}
string filesPathName = shapeFilePath.Substring(0, shapeFilePath.Length - 4);
RemoveShapeFileIfExists(filesPathName);
Layer jsonLayer = jsonFile.GetLayerByIndex(0);
OSGeo.OGR.Driver esriShapeFileDriver = Ogr.GetDriverByName("ESRI Shapefile");
DataSource shapeFile = Ogr.Open(shapeFilePath, 0);
shapeFile = esriShapeFileDriver.CreateDataSource(shapeFilePath, new string[] { });
Layer shplayer = shapeFile.CreateLayer(jsonLayer.GetName(), GetSirgas2000CurrentUTMReferenceInCentimeters(), jsonLayer.GetGeomType(), new string[] { });
// cria os campos (propriedades) na layer
Feature feature = jsonLayer.GetNextFeature();
for (int i = 0; i < feature.GetFieldCount(); i++)
{
FieldDefn fieldDefn = new FieldDefn(getValidFieldName(feature.GetFieldDefnRef(i)), feature.GetFieldDefnRef(i).GetFieldType());
shplayer.CreateField(fieldDefn, 1);
}
while (feature != null)
{
Geometry geometry = feature.GetGeometryRef();
double[] point = convertWgs84ToSirgas2000UtmZone24(geometry.GetX(0), geometry.GetY(0));
Feature shpFeature = createPointInLayer(shplayer, point[0], point[1], GetSirgas2000CurrentUTMReferenceInCentimeters());
// copia os valores de cada campo
for (int i = 0; i < feature.GetFieldCount(); i++)
{
if (FieldType.OFTInteger == feature.GetFieldDefnRef(i).GetFieldType())
{
shpFeature.SetField(getValidFieldName(feature.GetFieldDefnRef(i)), feature.GetFieldAsInteger(i));
}
else if (FieldType.OFTReal == feature.GetFieldDefnRef(i).GetFieldType())
{
shpFeature.SetField(getValidFieldName(feature.GetFieldDefnRef(i)), feature.GetFieldAsDouble(i));
}
else
{
shpFeature.SetField(getValidFieldName(feature.GetFieldDefnRef(i)), feature.GetFieldAsString(i));
}
}
shplayer.SetFeature(shpFeature);
feature = jsonLayer.GetNextFeature();
}
shapeFile.Dispose();
// gerar zip dos arquivos gerados
string zipName = filesPathName + ".zip";
CompressToZipFile(new List <string>()
{
shapeFilePath, filesPathName + ".dbf", filesPathName + ".prj", filesPathName + ".shx"
}, zipName);
return(true);
}
public static void WriteVectorFile(string strVectorFile)
{
Gdal.AllRegister();
// 为了支持中文路径，请添加下面这句代码
OSGeo.GDAL.Gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "NO");
// 为了使属性表字段支持中文，请添加下面这句
OSGeo.GDAL.Gdal.SetConfigOption("SHAPE_ENCODING", "");
//string strVectorFile = @"C:\Users\Administrator\Desktop\shptest\TestPolygon.shp";
// 注册所有的驱动
Ogr.RegisterAll();
//创建数据，这里以创建ESRI的shp文件为例
string strDriverName = "ESRI Shapefile";
OSGeo.OGR.Driver oDriver = Ogr.GetDriverByName(strDriverName);
if (oDriver == null)
{
MessageBox.Show("%s 驱动不可用！\n", strVectorFile);
return;
}
// 创建数据源
DataSource oDS = oDriver.CreateDataSource(strVectorFile, null);
if (oDS == null)
{
MessageBox.Show("创建矢量文件【%s】失败！\n", strVectorFile);
return;
}
// 创建图层，创建一个多边形图层，这里没有指定空间参考，如果需要的话，需要在这里进行指定
Layer oLayer = oDS.CreateLayer("TestPolygon", null, wkbGeometryType.wkbPolygon, null);
if (oLayer == null)
{
MessageBox.Show("图层创建失败！\n");
return;
}
// 下面创建属性表
// 先创建一个叫FieldID的整型属性
FieldDefn oFieldID = new FieldDefn("FieldID", FieldType.OFTInteger);
oLayer.CreateField(oFieldID, 1);
// 再创建一个叫FeatureName的字符型属性，字符长度为50
FieldDefn oFieldName = new FieldDefn("FieldName", FieldType.OFTString);
oFieldName.SetWidth(100);
oLayer.CreateField(oFieldName, 1);
FeatureDefn oDefn = oLayer.GetLayerDefn();
// 创建三角形要素
Feature oFeatureTriangle = new Feature(oDefn);
oFeatureTriangle.SetField(0, 0);
oFeatureTriangle.SetField(1, "三角形");
Geometry geomTriangle = Geometry.CreateFromWkt("POLYGON ((0 0,20 0,10 15,0 0))");
oFeatureTriangle.SetGeometry(geomTriangle);
oLayer.CreateFeature(oFeatureTriangle);
// 创建矩形要素
Feature oFeatureRectangle = new Feature(oDefn);
oFeatureRectangle.SetField(0, 1);
oFeatureRectangle.SetField(1, "矩形");
Geometry geomRectangle = Geometry.CreateFromWkt("POLYGON ((30 0,60 0,60 30,30 30,30 0))");
oFeatureRectangle.SetGeometry(geomRectangle);
oLayer.CreateFeature(oFeatureRectangle);
// 创建岛要素
Feature oFeatureHole = new Feature(oDefn);
oFeatureHole.SetField(0, 1);
oFeatureHole.SetField(1, "环岛测试");
//Geometry geomWYX = Geometry.CreateFromWkt("POLYGON ((30 0,60 0,60 30,30 30,30 0))");
OSGeo.OGR.Geometry outGeo = new OSGeo.OGR.Geometry(OSGeo.OGR.wkbGeometryType.wkbLinearRing);
outGeo.AddPoint(40, -30, 0);
outGeo.AddPoint(60, -30, 0);
outGeo.AddPoint(60, -10, 0);
outGeo.AddPoint(40, -10, 0);
OSGeo.OGR.Geometry inGeo = new OSGeo.OGR.Geometry(OSGeo.OGR.wkbGeometryType.wkbLinearRing);
inGeo.AddPoint(45, -25, 0);
inGeo.AddPoint(55, -25, 0);
inGeo.AddPoint(55, -15, 0);
inGeo.AddPoint(45, -15, 0);
OSGeo.OGR.Geometry geo = new OSGeo.OGR.Geometry(OSGeo.OGR.wkbGeometryType.wkbPolygon);
geo.AddGeometryDirectly(outGeo);
geo.AddGeometryDirectly(inGeo);
oFeatureHole.SetGeometry(geo);
oLayer.CreateFeature(oFeatureHole);
// 创建Multi要素
Feature oFeatureMulty = new Feature(oDefn);
oFeatureMulty.SetField(0, 1);
oFeatureMulty.SetField(1, "MultyPart测试");
OSGeo.OGR.Geometry geo1 = new OSGeo.OGR.Geometry(OSGeo.OGR.wkbGeometryType.wkbLinearRing);
geo1.AddPoint(25, -10, 0);
geo1.AddPoint(5, -10, 0);
geo1.AddPoint(5, -30, 0);
geo1.AddPoint(25, -30, 0);
OSGeo.OGR.Geometry poly1 = new Geometry(wkbGeometryType.wkbPolygon);
poly1.AddGeometryDirectly(geo1);
OSGeo.OGR.Geometry geo2 = new OSGeo.OGR.Geometry(OSGeo.OGR.wkbGeometryType.wkbLinearRing);
geo2.AddPoint(0, -15, 0);
geo2.AddPoint(-5, -15, 0);
geo2.AddPoint(-5, -20, 0);
geo2.AddPoint(0, -20, 0);
OSGeo.OGR.Geometry poly2 = new Geometry(wkbGeometryType.wkbPolygon);
poly2.AddGeometryDirectly(geo2);
OSGeo.OGR.Geometry geoMulty = new OSGeo.OGR.Geometry(OSGeo.OGR.wkbGeometryType.wkbMultiPolygon);
geoMulty.AddGeometryDirectly(poly1);
geoMulty.AddGeometryDirectly(poly2);
oFeatureMulty.SetGeometry(geoMulty);
oLayer.CreateFeature(oFeatureMulty);
MessageBox.Show("\n数据集创建完成！\n");
}
public void getLayer()
{
Gdal.AllRegister();
Gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "YES");
Gdal.SetConfigOption("SHAPE_ENCODING", "");
Ogr.RegisterAll();
OSGeo.OGR.Driver oDriver = Ogr.GetDriverByName("ESRI Shapefile");
DataSource oDS;
if (Ogr.Open(toPath, 0) != null)
{
oDS = Ogr.Open(toPath, 1);
oDS.DeleteLayer(0);
}
else
{
oDS = oDriver.CreateDataSource(toPath, null);
}
List <Geometry> geos = new List <Geometry>();
Geometry plo = new Geometry(wkbGeometryType.wkbLinearRing);
plo.AddPoint(10, 10, 0);
plo.AddPoint(10, 20, 0);
plo.AddPoint(20, 20, 0);
plo.AddPoint(20, 10, 0);
plo.AddPoint(10, 10, 0);
Geometry plos = new Geometry(wkbGeometryType.wkbLinearRing);
plos.AddPoint(12, 12, 0);
plos.AddPoint(12, 18, 0);
plos.AddPoint(18, 18, 0);
plos.AddPoint(18, 12, 0);
plos.AddPoint(12, 12, 0);
Geometry ploy = new Geometry(wkbGeometryType.wkbPolygon);
ploy.AddGeometry(plo);
geos.Add(ploy);
// ploy.Segmentize(0.1);
ploy.AddGeometry(plos);
geos.Add(ploy);
Layer toLayer = oDS.CreateLayer("direct", null, wkbGeometryType.wkbPolygon, null);
FeatureDefn oDefn = toLayer.GetLayerDefn();
foreach (Geometry geom in geos)
{
Feature feature = new Feature(oDefn);
feature.SetGeometry(ploy);
toLayer.CreateFeature(feature);
}
oDS.SyncToDisk();
}
public void dxftest()
{
string frompath = "E:\\test\\fjz.dwg";
string toPath = path + "\\temp\\cov.shp";
Gdal.AllRegister();
Gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "YES");
Gdal.SetConfigOption("SHAPE_ENCODING", "");
Ogr.RegisterAll();
DataSource bs = Ogr.Open(frompath, 0);
int iLayerCount = bs.GetLayerCount();
Layer layer = bs.GetLayerByIndex(0);
String a = "";
Feature f = null;
for (int i = 0; i < iLayerCount; i++)
{
Console.WriteLine(iLayerCount);
Console.WriteLine(bs.GetLayerByIndex(i).GetName());
}
OSGeo.OGR.Driver oDriver = Ogr.GetDriverByName("ESRI Shapefile");
DataSource oDS;
if (Ogr.Open(toPath, 0) != null)
{
oDS = Ogr.Open(toPath, 1);
oDS.DeleteLayer(0);
}
else
{
oDS = oDriver.CreateDataSource(toPath, null);
}
Layer toLayer = oDS.CreateLayer("direct", null, wkbGeometryType.wkbLineString, null);
FeatureDefn oDefn = toLayer.GetLayerDefn();
FieldDefn oFieldName = new FieldDefn("area", FieldType.OFTReal);
toLayer.CreateField(oFieldName, 1);
try
{
while ((f = layer.GetNextFeature()) != null)
{
Geometry g = f.GetGeometryRef();
if (g.GetGeometryType() == wkbGeometryType.wkbLineString)
{
// Geometry lr=new Geometry(wkbGeometryType.wkbLinearRing);
// for (int i = 0; i < g.GetPointCount();i++ )
// {
// lr.AddPoint(g.GetX(i),g.GetY(i),g.GetZ(i));
// }
// lr.CloseRings();
// Geometry pr = new Geometry(wkbGeometryType.wkbPolygon);
// pr.AddGeometry(lr);
// if(pr.Area()>=10){
Feature feature = new Feature(oDefn);
// feature.SetField("area", pr.Area());
feature.SetGeometry(g);
toLayer.CreateFeature(feature);
// }
}
}
}
catch (Exception e)
{
}
oDS.SyncToDisk();
}
public void angleTest()
{
Gdal.AllRegister();
Gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "YES");
Gdal.SetConfigOption("SHAPE_ENCODING", "");
Ogr.RegisterAll();
string fromPath = path + "\\temp\\union.shp";
string toPath = path + "\\temp\\unionhell.shp";
DataSource bs = Ogr.Open(fromPath, 0);
Layer bLayer = bs.GetLayerByIndex(0);
OSGeo.OGR.Driver oDriver = Ogr.GetDriverByName("ESRI Shapefile");
// 创建数据源
DataSource oDS;
if (Ogr.Open(toPath, 0) != null)
{
oDS = Ogr.Open(toPath, 1);
oDS.DeleteLayer(0);
}
else
{
oDS = oDriver.CreateDataSource(toPath, null);
}
Layer toLayer = oDS.CreateLayer("direct", bLayer.GetSpatialRef(), wkbGeometryType.wkbPolygon, null);
FeatureDefn oDefn = toLayer.GetLayerDefn();
Feature fea = null;
while ((fea = bLayer.GetNextFeature()) != null)
{
Feature feature = new Feature(oDefn);
// Geometry geo = new Geometry(wkbGeometryType.wkbPolygon);
// geo.AddGeometry(fea.GetGeometryRef().ConvexHull());
feature.SetGeometry(fea.GetGeometryRef().ConvexHull());
toLayer.CreateFeature(feature);
}
oDS.SyncToDisk();
}
public void directTest()
{
Gdal.AllRegister();
Gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "YES");
Gdal.SetConfigOption("SHAPE_ENCODING", "");
Ogr.RegisterAll();
//读取文件
DataSource bs = Ogr.Open(bPath, 1);
Layer bLayer = bs.GetLayerByIndex(0);
FieldDefn oFieldName = new FieldDefn("idUnion", FieldType.OFTReal);
if (bLayer.GetLayerDefn().GetFieldIndex("idUnion") < 0)
{
bLayer.CreateField(oFieldName, 0);
}
Feature bfeature = null;
while ((bfeature = bLayer.GetNextFeature()) != null)
{
bfeature.SetField("idUnion", 0);
bLayer.SetFeature(bfeature);
}
bLayer.ResetReading();
Dictionary <double, geounion> geos = new Dictionary <double, geounion>();
geounion geo;
int count = bLayer.GetFeatureCount(0);
for (int i = 0; i < count; i++)
{
if (bLayer.GetFeature(i).GetFieldAsInteger("idUnion") != 1)
{
geo.geo = bLayer.GetFeature(i).GetGeometryRef();
geo.high = 0;
geo.key = bLayer.GetFeature(i).GetFID();
try
{
bLayer.SetSpatialFilter(geo.geo.Buffer(0.5, 30));
geo = getTouch(bLayer, geo);
if (geos.ContainsKey(geo.key))
{
geos.Remove(geo.key);
}
geos.Add(geo.key, geo);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
// Console.WriteLine(i + ":" + count + " " + DateTime.Now + ":" + DateTime.Now.Millisecond);
}
}
OSGeo.OGR.Driver oDriver = Ogr.GetDriverByName("ESRI Shapefile");
DataSource oDS;
if (Ogr.Open(toPath, 0) != null)
{
oDS = Ogr.Open(toPath, 1);
oDS.DeleteLayer(0);
}
else
{
oDS = oDriver.CreateDataSource(toPath, null);
}
// 创建数据源
Layer toLayer = oDS.CreateLayer("direct", bLayer.GetSpatialRef(), wkbGeometryType.wkbPolygon, null);
FieldDefn oFieldID = new FieldDefn("HEIGHT_G", FieldType.OFTReal);
toLayer.CreateField(oFieldID, 1);
FeatureDefn oDefn = toLayer.GetLayerDefn();
foreach (double key in geos.Keys)
{
//read current feature
Feature feature = new Feature(oDefn);
feature.SetField(0, geos[key].high);
feature.SetGeometry(geos[key].geo);
toLayer.CreateFeature(feature);
}
oDS.SyncToDisk();
}
public static bool CovertRegion2Line(string path, string savePath)
{
try
{
OSGeo.OGR.Ogr.RegisterAll();
OSGeo.OGR.Driver dr = OSGeo.OGR.Ogr.GetDriverByName("ESRI shapefile");
if (dr == null)
{
Console.WriteLine("启动驱动失败！\n");
}
OSGeo.OGR.DataSource ds = dr.Open(path, 0);
int layerCount = ds.GetLayerCount();
OSGeo.OGR.Layer layer = ds.GetLayerByIndex(0);
FeatureDefn fdf = layer.GetLayerDefn();
int fieldCount = fdf.GetFieldCount();
// 创建数据源
DataSource oDS = dr.CreateDataSource(savePath, null);
if (oDS == null)
{
Console.WriteLine("创建矢量文件【%s】失败！\n", savePath);
return(false);
}
OSGeo.OSR.SpatialReference srs = layer.GetSpatialRef();
// 创建图层，创建一个多边形图层，这里没有指定空间参考，如果需要的话，需要在这里进行指定
Layer oLayer = oDS.CreateLayer("line", srs, OSGeo.OGR.wkbGeometryType.wkbMultiLineString, null);
if (oLayer == null)
{
Console.WriteLine("图层创建失败！\n");
return(false);
}
for (int i = 0; i < fieldCount; i++)
{
FieldDefn fieldDefn = fdf.GetFieldDefn(i);
oLayer.CreateField(fieldDefn, 1);
}
FeatureDefn oDefn = oLayer.GetLayerDefn();
OSGeo.OGR.Feature feat;
while ((feat = layer.GetNextFeature()) != null)
{
Feature oFeatureMulty = new Feature(oDefn);
OSGeo.OGR.Geometry geometry = feat.GetGeometryRef();
for (int i = 0; i < fieldCount; i++)
{
string value = feat.GetFieldAsString(i);
oFeatureMulty.SetField(i, value);
}
OSGeo.OGR.wkbGeometryType goetype = geometry.GetGeometryType();
if (goetype == OSGeo.OGR.wkbGeometryType.wkbPolygon)
{
Geometry tempGeo = new Geometry(wkbGeometryType.wkbMultiLineString);
int count = geometry.GetGeometryCount();
for (int j = 0; j < count; j++)
{
Geometry line = new Geometry(wkbGeometryType.wkbLinearRing);
Geometry geo = geometry.GetGeometryRef(j);
for (int i = 0; i < geo.GetPointCount(); i++)
{
double x = geo.GetX(i);
double y = geo.GetY(i);
line.AddPoint(x, y, 0);
}
tempGeo.AddGeometryDirectly(line);
}
oFeatureMulty.SetGeometry(tempGeo);
}
oLayer.SetFeature(oFeatureMulty);
}
oLayer.Dispose();
layer.Dispose();
oDS.Dispose();
ds.Dispose();
dr.Dispose();
}
catch
{ }
return(false);
}
