/************************************ 对比并筛选 ***************************************************/
/// <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());
}
async static void getDoubFeat(string filePath, int s, int ss)
{
await Task.Run(() =>
{
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 layer = ds.GetLayerByIndex(0);
OSGeo.OGR.Feature oriFeat = layer.GetFeature(s);
for (int i = s + 1; i < ss; i++)
{
OSGeo.OGR.Feature nextFeat = layer.GetFeature(i);
if (StaticTools.isSame(oriFeat, nextFeat, 1))
{
ids.Add(s);
break;
}
nextFeat.Dispose();
}
oriFeat.Dispose();
layer.Dispose();
ds.Dispose();
tickTime++;
}
);
}
/// <summary>
/// 通过是否相交和面积差,获得最小面积差相交要素的ID数组--------多线OK
/// </summary>
/// <param name="dzx"></param>
/// <param name="pdx"></param>
/// <returns></returns>
private static int[] getMinIdGroupM(string dzx, string pdx)
{
Console.WriteLine("起用多线程提取轮廓线ID....");
OSGeo.OGR.Ogr.RegisterAll();
OSGeo.OGR.Driver dr = OSGeo.OGR.Ogr.GetDriverByName("ESRI shapefile");
OSGeo.OGR.DataSource pdDS = dr.Open(pdx, 0);
OSGeo.OGR.Layer pdLayer = pdDS.GetLayerByIndex(0);
int pdCount = pdLayer.GetFeatureCount(0);
for (int pdi = 0; pdi < pdCount; pdi++)
{
OSGeo.OGR.Feature pdFeat = pdLayer.GetFeature(pdi);
select(pdFeat, dzx);
}
while (tickTime < pdCount)
{
Console.WriteLine("第{0}个完成，共{1}个", tickTime, pdCount);
Thread.Sleep(2000);
}
pdLayer.Dispose();
pdDS.Dispose();
Console.WriteLine("多线程提取ID完成.....");
return(minIdG.ToArray());
}
/// <summary>
/// 关闭ShpReader
/// </summary>
public void Close()
{
if (_ogrLayer != null)
{
_ogrLayer.Dispose();
_ogrDataSource.Dispose();
}
}
/// <summary>
/// 子线程提取轮廓线ID
/// </summary>
/// <param name="pdFeat"></param>
/// <param name="dzx"></param>
async static void select(Feature pdFeat, string dzx)
{
await Task.Run(() =>
{
double afterCha = -1;
int yesID = -1;
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 dzxLayer = dzDS.GetLayerByIndex(0);
OSGeo.OGR.Geometry pdGeom = pdFeat.GetGeometryRef();
int dzCount = dzxLayer.GetFeatureCount(0);
for (int dzi = 0; dzi < dzCount; dzi++)
{
OSGeo.OGR.Feature dzFeat = dzxLayer.GetFeature(dzi);
OSGeo.OGR.Geometry dzGeom = dzFeat.GetGeometryRef();
if (pdGeom.Intersect(dzGeom))
{
double cha = Math.Abs(dzGeom.GetArea() - pdGeom.GetArea());
if (afterCha == -1)
{
afterCha = cha;
yesID = dzi;
}
else if (cha < afterCha)
{
afterCha = cha;
yesID = dzi;
}
}
dzGeom.Dispose();
dzFeat.Dispose();
}
if (yesID != -1)
{
minIdG.Add(yesID);
}
dzDS.Dispose();
dzxLayer.Dispose();
pdGeom.Dispose();
pdFeat.Dispose();
tickTime++;
});
}
public void Dispose()
{
_ogrLayer?.Dispose();
}
protected override void SolveInstance(IGH_DataAccess DA)
{
///Gather GHA inputs
List <Curve> boundary = new List <Curve>();
DA.GetDataList <Curve>("Boundary", boundary);
string shpFilePath = string.Empty;
DA.GetData <string>("Vector Data Location", ref shpFilePath);
bool cropIt = true;
DA.GetData <Boolean>("Crop file", ref cropIt);
string userSRStext = "WGS84";
DA.GetData <string>(2, ref userSRStext);
///GDAL setup
///Some preliminary testing has been done to read SHP, GeoJSON, OSM, KML, MVT, GML and GDB
///It can be spotty with KML, MVT and GML and doesn't throw informative errors. Likely has to do with getting a valid CRS and
///TODO: resolve errors with reading KML, MVT, GML.
DataSource dataSource = CreateDataSource(shpFilePath);
List <Layer> layerSet = GetLayers(dataSource);
///Declare trees
GH_Structure <GH_Rectangle> recs = new GH_Structure <GH_Rectangle>();
GH_Structure <GH_String> spatialReferences = new GH_Structure <GH_String>();
GH_Structure <GH_String> fnames = new GH_Structure <GH_String>();
GH_Structure <GH_String> fset = new GH_Structure <GH_String>();
GH_Structure <GH_Point> gset = new GH_Structure <GH_Point>();
GH_Structure <GH_Point> gsetUser = new GH_Structure <GH_Point>();
GH_Structure <GH_Rectangle> recsUser = new GH_Structure <GH_Rectangle>();
GH_Structure <GH_String> gtype = new GH_Structure <GH_String>();
GH_Structure <IGH_GeometricGoo> gGoo = new GH_Structure <IGH_GeometricGoo>();
///Loop through each layer. Layers usually occur in Geodatabase GDB format. SHP usually has only one layer.
for (int iLayer = 0; iLayer < dataSource.GetLayerCount(); iLayer++)
{
OSGeo.OGR.Layer layer = dataSource.GetLayerByIndex(iLayer);
if (layer == null)
{
Console.WriteLine($"Couldn't fetch advertised layer {iLayer}");
System.Environment.Exit(-1);
}
long count = layer.GetFeatureCount(1);
int featureCount = System.Convert.ToInt32(count);
AddRuntimeMessage(GH_RuntimeMessageLevel.Remark, $"Layer #{iLayer} {layer.GetName()} has {featureCount} features");
///Get the spatial reference of the input vector file and set to WGS84 if not known
///
OSGeo.OSR.SpatialReference sourceSRS = new SpatialReference(Osr.SRS_WKT_WGS84);
string spatialReference = GetSpatialReference(layer, iLayer, dataSource, sourceSRS);
spatialReferences.Append(new GH_String(spatialReference), new GH_Path(iLayer));
///Set transform from input spatial reference to Rhino spatial reference
///TODO: look into adding a step for transforming to CRS set in SetCRS
OSGeo.OSR.SpatialReference rhinoSRS = new OSGeo.OSR.SpatialReference("");
rhinoSRS.SetWellKnownGeogCS("WGS84");
///TODO: verify the userSRS is valid
///TODO: use this as override of global SetSRS
OSGeo.OSR.SpatialReference userSRS = new OSGeo.OSR.SpatialReference("");
userSRS.SetFromUserInput(userSRStext);
///These transforms move and scale in order to go from userSRS to XYZ and vice versa
Transform userSRSToModelTransform = Heron.Convert.GetUserSRSToModelTransform(userSRS);
Transform modelToUserSRSTransform = Heron.Convert.GetModelToUserSRSTransform(userSRS);
Transform sourceToModelSRSTransform = Heron.Convert.GetUserSRSToModelTransform(sourceSRS);
Transform modelToSourceSRSTransform = Heron.Convert.GetModelToUserSRSTransform(sourceSRS);
///Get OGR envelope of the data in the layer in the sourceSRS
OSGeo.OGR.Envelope ext = new OSGeo.OGR.Envelope();
layer.GetExtent(ext, 1);
OSGeo.OGR.Geometry extMinSourceOgr = new OSGeo.OGR.Geometry(wkbGeometryType.wkbPoint);
extMinSourceOgr.AddPoint(ext.MinX, ext.MinY, 0.0);
extMinSourceOgr.AssignSpatialReference(sourceSRS);
OSGeo.OGR.Geometry extMaxSourceOgr = new OSGeo.OGR.Geometry(wkbGeometryType.wkbPoint);
extMaxSourceOgr.AddPoint(ext.MaxX, ext.MaxY, 0.0);
extMaxSourceOgr.AssignSpatialReference(sourceSRS);
///Get extents in Rhino SRS
Point3d extPTmin = Heron.Convert.OgrPointToPoint3d(extMinSourceOgr, sourceToModelSRSTransform);
Point3d extPTmax = Heron.Convert.OgrPointToPoint3d(extMaxSourceOgr, sourceToModelSRSTransform);
Rectangle3d rec = new Rectangle3d(Plane.WorldXY, extPTmin, extPTmax);
recs.Append(new GH_Rectangle(rec), new GH_Path(iLayer));
///Get extents in userSRS
///Can give odd results if crosses 180 longitude
extMinSourceOgr.TransformTo(userSRS);
extMaxSourceOgr.TransformTo(userSRS);
Point3d extPTminUser = Heron.Convert.OgrPointToPoint3d(extMinSourceOgr, userSRSToModelTransform);
Point3d extPTmaxUser = Heron.Convert.OgrPointToPoint3d(extMaxSourceOgr, userSRSToModelTransform);
Rectangle3d recUser = new Rectangle3d(Plane.WorldXY, extPTminUser, extPTmaxUser);
recsUser.Append(new GH_Rectangle(recUser), new GH_Path(iLayer));
if (boundary.Count == 0 && cropIt == true)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Define a boundary or set cropIt to False");
}
else if (boundary.Count == 0 && cropIt == false)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Remark, "Clipping boundary has not been defined. File extents will be used instead");
boundary.Add(rec.ToNurbsCurve());
}
///Loop through input boundaries
for (int i = 0; i < boundary.Count; i++)
{
OSGeo.OGR.FeatureDefn def = layer.GetLayerDefn();
///Get the field names
List <string> fieldnames = new List <string>();
for (int iAttr = 0; iAttr < def.GetFieldCount(); iAttr++)
{
OSGeo.OGR.FieldDefn fdef = def.GetFieldDefn(iAttr);
fnames.Append(new GH_String(fdef.GetNameRef()), new GH_Path(i, iLayer));
}
///Check if boundary is contained in extent
if (!rec.IsValid || ((rec.Height == 0) && (rec.Width == 0)))
{
///Get field data if even if no geometry is present in the layer
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "One or more vector datasource bounds are not valid.");
OSGeo.OGR.Feature feat;
int m = 0;
while ((feat = layer.GetNextFeature()) != null)
{
///Loop through field values
for (int iField = 0; iField < feat.GetFieldCount(); iField++)
{
OSGeo.OGR.FieldDefn fdef = def.GetFieldDefn(iField);
fset.Append(new GH_String(feat.GetFieldAsString(iField)), new GH_Path(i, iLayer, m));
fdef.Dispose();
}
m++;
feat.Dispose();
}
}
else if (boundary[i] == null)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Clipping boundary " + i + " not set.");
}
else if (!boundary[i].IsValid)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Clipping boundary " + i + " is not valid.");
}
else if (rec.IsValid && Curve.PlanarClosedCurveRelationship(rec.ToNurbsCurve(), boundary[i], Plane.WorldXY, Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance) == RegionContainment.Disjoint)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "One or more clipping boundaries may be outside the bounds of the vector datasource.");
}
else
{
///Create bounding box for clipping geometry
Point3d min = boundary[i].GetBoundingBox(true).Min;
Point3d max = boundary[i].GetBoundingBox(true).Max;
min.Transform(modelToSourceSRSTransform);
max.Transform(modelToSourceSRSTransform);
double[] minpT = new double[3];
double[] maxpT = new double[3];
minpT[0] = min.X;
minpT[1] = min.Y;
minpT[2] = min.Z;
maxpT[0] = max.X;
maxpT[1] = max.Y;
maxpT[2] = max.Z;
OSGeo.OGR.Geometry ebbox = OSGeo.OGR.Geometry.CreateFromWkt("POLYGON((" + minpT[0] + " " + minpT[1] + ", " + minpT[0] + " " + maxpT[1] + ", " + maxpT[0] + " " + maxpT[1] + ", " + maxpT[0] + " " + minpT[1] + ", " + minpT[0] + " " + minpT[1] + "))");
///Create bounding box for clipping geometry
///Not working on MVT type files
//boundary[i].Transform(modelToSourceSRSTransform);
//OSGeo.OGR.Geometry ebbox = Heron.Convert.CurveToOgrPolygon(boundary[i]);
///Clip Shapefile
///http://pcjericks.github.io/py-gdalogr-cookbook/vector_layers.html
OSGeo.OGR.Layer clipped_layer = layer;
if (cropIt)
{
clipped_layer.SetSpatialFilter(ebbox);
}
///Loop through geometry
OSGeo.OGR.Feature feat;
def = clipped_layer.GetLayerDefn();
int m = 0;
while ((feat = clipped_layer.GetNextFeature()) != null)
{
OSGeo.OGR.Geometry geom = feat.GetGeometryRef();
OSGeo.OGR.Geometry sub_geom;
OSGeo.OGR.Geometry geomUser = feat.GetGeometryRef().Clone();
OSGeo.OGR.Geometry sub_geomUser;
///reproject geometry to WGS84 and userSRS
///TODO: look into using the SetCRS global variable here
if (geom.GetSpatialReference() == null)
{
geom.AssignSpatialReference(sourceSRS);
}
if (geomUser.GetSpatialReference() == null)
{
geomUser.AssignSpatialReference(sourceSRS);
}
geom.TransformTo(rhinoSRS);
geomUser.TransformTo(userSRS);
gtype.Append(new GH_String(geom.GetGeometryName()), new GH_Path(i, iLayer, m));
if (feat.GetGeometryRef() != null)
{
///Convert GDAL geometries to IGH_GeometricGoo
gGoo.AppendRange(Heron.Convert.OgrGeomToGHGoo(geomUser, userSRSToModelTransform), new GH_Path(i, iLayer, m));
/// Get Feature Values
if (fset.PathExists(new GH_Path(i, iLayer, m)))
{
fset.get_Branch(new GH_Path(i, iLayer, m)).Clear();
}
for (int iField = 0; iField < feat.GetFieldCount(); iField++)
{
OSGeo.OGR.FieldDefn fdef = def.GetFieldDefn(iField);
if (feat.IsFieldSet(iField))
{
fset.Append(new GH_String(feat.GetFieldAsString(iField)), new GH_Path(i, iLayer, m));
}
else
{
fset.Append(new GH_String("null"), new GH_Path(i, iLayer, m));
}
}
///End get Feature Values
///Start get points if open polylines and points
for (int gpc = 0; gpc < geom.GetPointCount(); gpc++)
{
///Loop through geometry points for Rhino SRS
double[] ogrPt = new double[3];
geom.GetPoint(gpc, ogrPt);
Point3d pt3D = new Point3d(ogrPt[0], ogrPt[1], ogrPt[2]);
pt3D.Transform(Heron.Convert.WGSToXYZTransform());
gset.Append(new GH_Point(pt3D), new GH_Path(i, iLayer, m));
///Loop through geometry points for User SRS
double[] ogrPtUser = new double[3];
geomUser.GetPoint(gpc, ogrPtUser);
Point3d pt3DUser = new Point3d(ogrPtUser[0], ogrPtUser[1], ogrPtUser[2]);
pt3DUser.Transform(userSRSToModelTransform);
gsetUser.Append(new GH_Point(pt3DUser), new GH_Path(i, iLayer, m));
///End loop through geometry points
/// Get Feature Values
if (fset.PathExists(new GH_Path(i, iLayer, m)))
{
fset.get_Branch(new GH_Path(i, iLayer, m)).Clear();
}
for (int iField = 0; iField < feat.GetFieldCount(); iField++)
{
OSGeo.OGR.FieldDefn fdef = def.GetFieldDefn(iField);
if (feat.IsFieldSet(iField))
{
fset.Append(new GH_String(feat.GetFieldAsString(iField)), new GH_Path(i, iLayer, m));
}
else
{
fset.Append(new GH_String("null"), new GH_Path(i, iLayer, m));
}
}
///End Get Feature Values
}
///End getting points if open polylines or points
///Start getting points if closed polylines and multipolygons
for (int gi = 0; gi < geom.GetGeometryCount(); gi++)
{
sub_geom = geom.GetGeometryRef(gi);
OSGeo.OGR.Geometry subsub_geom;
sub_geomUser = geomUser.GetGeometryRef(gi);
OSGeo.OGR.Geometry subsub_geomUser;
if (sub_geom.GetGeometryCount() > 0)
{
for (int n = 0; n < sub_geom.GetGeometryCount(); n++)
{
subsub_geom = sub_geom.GetGeometryRef(n);
subsub_geomUser = sub_geomUser.GetGeometryRef(n);
for (int ptnum = 0; ptnum < subsub_geom.GetPointCount(); ptnum++)
{
///Loop through geometry points
double[] ogrPt = new double[3];
subsub_geom.GetPoint(ptnum, ogrPt);
Point3d pt3D = new Point3d(ogrPt[0], ogrPt[1], ogrPt[2]);
pt3D.Transform(Heron.Convert.WGSToXYZTransform());
gset.Append(new GH_Point(pt3D), new GH_Path(i, iLayer, m, gi, n));
///Loop through geometry points for User SRS
double[] ogrPtUser = new double[3];
subsub_geomUser.GetPoint(ptnum, ogrPtUser);
Point3d pt3DUser = new Point3d(ogrPtUser[0], ogrPtUser[1], ogrPtUser[2]);
pt3DUser.Transform(userSRSToModelTransform);
gsetUser.Append(new GH_Point(pt3DUser), new GH_Path(i, iLayer, m, gi, n));
///End loop through geometry points
}
subsub_geom.Dispose();
subsub_geomUser.Dispose();
}
}
else
{
for (int ptnum = 0; ptnum < sub_geom.GetPointCount(); ptnum++)
{
///Loop through geometry points
double[] ogrPt = new double[3];
sub_geom.GetPoint(ptnum, ogrPt);
Point3d pt3D = new Point3d(ogrPt[0], ogrPt[1], ogrPt[2]);
pt3D.Transform(Heron.Convert.WGSToXYZTransform());
gset.Append(new GH_Point(pt3D), new GH_Path(i, iLayer, m, gi));
///Loop through geometry points for User SRS
double[] ogrPtUser = new double[3];
sub_geomUser.GetPoint(ptnum, ogrPtUser);
Point3d pt3DUser = new Point3d(ogrPtUser[0], ogrPtUser[1], ogrPtUser[2]);
pt3DUser.Transform(userSRSToModelTransform);
gsetUser.Append(new GH_Point(pt3DUser), new GH_Path(i, iLayer, m, gi));
///End loop through geometry points
}
}
sub_geom.Dispose();
sub_geomUser.Dispose();
/// Get Feature Values
if (fset.PathExists(new GH_Path(i, iLayer, m)))
{
fset.get_Branch(new GH_Path(i, iLayer, m)).Clear();
}
for (int iField = 0; iField < feat.GetFieldCount(); iField++)
{
OSGeo.OGR.FieldDefn fdef = def.GetFieldDefn(iField);
if (feat.IsFieldSet(iField))
{
fset.Append(new GH_String(feat.GetFieldAsString(iField)), new GH_Path(i, iLayer, m));
}
else
{
fset.Append(new GH_String("null"), new GH_Path(i, iLayer, m));
}
}
///End Get Feature Values
}
//m++;
}
m++;
geom.Dispose();
geomUser.Dispose();
feat.Dispose();
} ///end while loop through features
} ///end clipped layer else statement
} ///end loop through boundaries
layer.Dispose();
}///end loop through layers
dataSource.Dispose();
DA.SetDataTree(0, recs);
DA.SetDataTree(1, spatialReferences);
DA.SetDataTree(2, fnames);
DA.SetDataTree(3, fset);
DA.SetDataTree(4, gset);
DA.SetDataTree(5, gsetUser);
DA.SetDataTree(6, recsUser);
DA.SetDataTree(7, gGoo);
DA.SetDataTree(8, gtype);
}
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);
}
/// <summary>
/// 转换并纠偏，只使用与火星坐标纠偏
/// </summary>
/// <param name="dataTable">数据表，如果是点表中含X,Y字段，如果是线和面，表中含有PATH字段</param>
/// <param name="filePath">存储路径</param>
/// <param name="geoType">数据类型，暂时支持简单的点线面</param>
//public static void saveShpFile(DataTable dataTable,string filePath,wkbGeometryType geoType)
//{
// saveShpFile(dataTable, filePath, geoType, ProjectConvert.GCJ_WGS);
//}
/// <summary>
/// 导出shp数据到表格
/// </summary>
/// <param name="path">文件路径</param>
/// <returns>DataTable</returns>
public static DataTable GetData(string path)
{
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);
DataTable dataTable = new DataTable();
FeatureDefn fdf = layer.GetLayerDefn();
int fieldCount = fdf.GetFieldCount();
for (int i = 0; i < fieldCount; i++)
{
dataTable.Columns.Add(fdf.GetFieldDefn(i).GetName(), Type.GetType("System.String"));
}
if (fdf.GetGeomType() == OSGeo.OGR.wkbGeometryType.wkbPoint)
{
if (!dataTable.Columns.Contains("X"))
{
dataTable.Columns.Add("X", Type.GetType("System.String"));
}
if (!dataTable.Columns.Contains("Y"))
{
dataTable.Columns.Add("Y", Type.GetType("System.String"));
}
}
else if (fdf.GetGeomType() == OSGeo.OGR.wkbGeometryType.wkbPolygon || fdf.GetGeomType() == OSGeo.OGR.wkbGeometryType.wkbLineString)
{
if (!dataTable.Columns.Contains("PATH"))
{
dataTable.Columns.Add("PATH", Type.GetType("System.String"));
}
}
OSGeo.OGR.Feature feat;
while ((feat = layer.GetNextFeature()) != null)
{
DataRow row = dataTable.NewRow();
OSGeo.OGR.Geometry geometry = feat.GetGeometryRef();
for (int i = 0; i < fieldCount; i++)
{
string value = feat.GetFieldAsString(i);
row[i] = value.Replace(",", "");
}
OSGeo.OGR.wkbGeometryType goetype = geometry.GetGeometryType();
if (goetype == OSGeo.OGR.wkbGeometryType.wkbPoint)
{
double x = geometry.GetX(0);
double y = geometry.GetY(0);
row["X"] = x.ToString();
row["Y"] = y.ToString();
}
else if (goetype == OSGeo.OGR.wkbGeometryType.wkbLineString)
{
string points = "";
for (int i = 0; i < geometry.GetPointCount(); i++)
{
double x = geometry.GetX(i);
double y = geometry.GetY(i);
points += x.ToString() + "|" + y.ToString() + ";";
}
if (points != "")
{
points.Substring(0, points.Length - 1);
}
row["PATH"] = points;
}
else if (goetype == OSGeo.OGR.wkbGeometryType.wkbPolygon)
{
int count = geometry.GetGeometryCount();
string points = "";
for (int j = 0; j < count; j++)
{
Geometry geo = geometry.GetGeometryRef(j);
for (int i = 0; i < geo.GetPointCount(); i++)
{
double x = geo.GetX(i);
double y = geo.GetY(i);
points += x.ToString() + "|" + y.ToString() + ";";
}
if (points != "")
{
points.Substring(0, points.Length - 1);
}
points += "|";
}
if (points != "")
{
points.Substring(0, points.Length - 1);
}
row["PATH"] = points;
}
}
layer.Dispose();
ds.Dispose();
dr.Dispose();
return(dataTable);
}
catch
{
return(null);
}
}
/// <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)
{
Curve boundary = null;
DA.GetData <Curve>(0, ref boundary);
int zoom = -1;
DA.GetData <int>(1, ref zoom);
string filePath = string.Empty;
DA.GetData <string>(2, ref filePath);
if (!filePath.EndsWith(@"\"))
{
filePath = filePath + @"\";
}
string prefix = string.Empty;
DA.GetData <string>(3, ref prefix);
if (prefix == "")
{
prefix = mbSource;
}
string URL = mbURL;
string mbToken = string.Empty;
DA.GetData <string>(4, ref mbToken);
if (mbToken == "")
{
string hmbToken = System.Environment.GetEnvironmentVariable("HERONMAPBOXTOKEN");
if (hmbToken != null)
{
mbToken = hmbToken;
AddRuntimeMessage(GH_RuntimeMessageLevel.Remark, "Using Mapbox token stored in Environment Variable HERONMAPBOXTOKEN.");
}
else
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "No Mapbox token is specified. Please get a valid token from mapbox.com");
return;
}
}
bool run = false;
DA.GetData <bool>("Run", ref run);
///GDAL setup
RESTful.GdalConfiguration.ConfigureOgr();
OSGeo.OGR.Ogr.RegisterAll();
RESTful.GdalConfiguration.ConfigureGdal();
GH_Curve imgFrame;
GH_String tCount;
GH_Structure <GH_String> fnames = new GH_Structure <GH_String>();
GH_Structure <GH_String> fvalues = new GH_Structure <GH_String>();
GH_Structure <IGH_GeometricGoo> gGoo = new GH_Structure <IGH_GeometricGoo>();
GH_Structure <GH_String> gtype = new GH_Structure <GH_String>();
GH_Structure <IGH_GeometricGoo> gGooBuildings = new GH_Structure <IGH_GeometricGoo>();
int tileTotalCount = 0;
int tileDownloadedCount = 0;
///Get image frame for given boundary
if (!boundary.GetBoundingBox(true).IsValid)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Boundary is not valid.");
return;
}
BoundingBox boundaryBox = boundary.GetBoundingBox(true);
//create cache folder for vector tiles
string cacheLoc = filePath + @"HeronCache\";
List <string> cachefilePaths = new List <string>();
if (!Directory.Exists(cacheLoc))
{
Directory.CreateDirectory(cacheLoc);
}
//tile bounding box array
List <Point3d> boxPtList = new List <Point3d>();
//get the tile coordinates for all tiles within boundary
var ranges = Convert.GetTileRange(boundaryBox, zoom);
var x_range = ranges.XRange;
var y_range = ranges.YRange;
if (x_range.Length > 100 || y_range.Length > 100)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "This tile range is too big (more than 100 tiles in the x or y direction). Check your units.");
return;
}
///cycle through tiles to get bounding box
List <Polyline> tileExtents = new List <Polyline>();
List <double> tileHeight = new List <double>();
List <double> tileWidth = new List <double>();
for (int y = (int)y_range.Min; y <= y_range.Max; y++)
{
for (int x = (int)x_range.Min; x <= x_range.Max; x++)
{
//add bounding box of tile to list for translation
Polyline tileExtent = Heron.Convert.GetTileAsPolygon(zoom, y, x);
tileExtents.Add(tileExtent);
tileWidth.Add(tileExtent[0].DistanceTo(tileExtent[1]));
tileHeight.Add(tileExtent[1].DistanceTo(tileExtent[2]));
boxPtList.AddRange(tileExtent.ToList());
cachefilePaths.Add(cacheLoc + mbSource.Replace(" ", "") + zoom + "-" + x + "-" + y + ".mvt");
tileTotalCount = tileTotalCount + 1;
}
}
tCount = new GH_String(tileTotalCount + " tiles (" + tileDownloadedCount + " downloaded / " + (tileTotalCount - tileDownloadedCount) + " cached)");
///bounding box of tile boundaries
BoundingBox bboxPts = new BoundingBox(boxPtList);
///convert bounding box to polyline
List <Point3d> imageCorners = bboxPts.GetCorners().ToList();
imageCorners.Add(imageCorners[0]);
imgFrame = new GH_Curve(new Rhino.Geometry.Polyline(imageCorners).ToNurbsCurve());
///tile range as string for (de)serialization of TileCacheMeta
string tileRangeString = "Tile range for zoom " + zoom.ToString() + ": "
+ x_range[0].ToString() + "-"
+ y_range[0].ToString() + " to "
+ x_range[1].ToString() + "-"
+ y_range[1].ToString();
AddRuntimeMessage(GH_RuntimeMessageLevel.Remark, tileRangeString);
///Query Mapbox URL
///download all tiles within boundary
///API to query
string mbURLauth = mbURL + mbToken;
if (run == true)
{
for (int y = (int)y_range.Min; y <= (int)y_range.Max; y++)
{
for (int x = (int)x_range.Min; x <= (int)x_range.Max; x++)
{
//create tileCache name
string tileCache = mbSource.Replace(" ", "") + zoom + "-" + x + "-" + y + ".mvt";
string tileCacheLoc = cacheLoc + tileCache;
//check cache folder to see if tile image exists locally
if (File.Exists(tileCacheLoc))
{
}
else
{
string urlAuth = Heron.Convert.GetZoomURL(x, y, zoom, mbURLauth);
System.Net.WebClient client = new System.Net.WebClient();
client.DownloadFile(urlAuth, tileCacheLoc);
client.Dispose();
///https://gdal.org/development/rfc/rfc59.1_utilities_as_a_library.html
///http://osgeo-org.1560.x6.nabble.com/gdal-dev-How-to-convert-shapefile-to-geojson-using-c-bindings-td5390953.html#a5391028
///ogr2ogr is slow
//OSGeo.GDAL.Dataset httpDS = OSGeo.GDAL.Gdal.OpenEx("MVT:"+urlAuth,4,null,null,null);
//var transOptions = new OSGeo.GDAL.GDALVectorTranslateOptions(new[] { "-s_srs","EPSG:3857", "-t_srs", "EPSG:4326","-skipfailures" });
//var transDS = OSGeo.GDAL.Gdal.wrapper_GDALVectorTranslateDestName(mvtLoc + zoom + "-" + x + "-" + y , httpDS, transOptions, null, null);
//httpDS.Dispose();
//transDS.Dispose();
tileDownloadedCount = tileDownloadedCount + 1;
}
}
}
}
//add to tile count total
tCount = new GH_String(tileTotalCount + " tiles (" + tileDownloadedCount + " downloaded / " + (tileTotalCount - tileDownloadedCount) + " cached)");
AddRuntimeMessage(GH_RuntimeMessageLevel.Remark, tCount.ToString());
///Build a VRT file
///https://stackoverflow.com/questions/55386597/gdal-c-sharp-wrapper-for-vrt-doesnt-write-a-vrt-file
//string vrtFile = cacheLoc + "mapboxvector.vrt";
//AddRuntimeMessage(GH_RuntimeMessageLevel.Remark, vrtFile);
//var vrtOptions = new OSGeo.GDAL.GDALBuildVRTOptions(new[] { "-overwrite" });
//var vrtDataset = OSGeo.GDAL.Gdal.wrapper_GDALBuildVRT_names(vrtFile, cachefilePaths.ToArray(), vrtOptions, null, null);
//vrtDataset.Dispose();
///Set transform from input spatial reference to Rhino spatial reference
///TODO: look into adding a step for transforming to CRS set in SetCRS
OSGeo.OSR.SpatialReference rhinoSRS = new OSGeo.OSR.SpatialReference("");
rhinoSRS.SetWellKnownGeogCS("WGS84");
///TODO: verify the userSRS is valid
///TODO: use this as override of global SetSRS
OSGeo.OSR.SpatialReference userSRS = new OSGeo.OSR.SpatialReference("");
//userSRS.SetFromUserInput(userSRStext);
userSRS.SetFromUserInput("WGS84");
OSGeo.OSR.SpatialReference sourceSRS = new SpatialReference("");
sourceSRS.SetFromUserInput("EPSG:3857");
///These transforms move and scale in order to go from userSRS to XYZ and vice versa
Transform userSRSToModelTransform = Heron.Convert.GetUserSRSToModelTransform(userSRS);
Transform modelToUserSRSTransform = Heron.Convert.GetModelToUserSRSTransform(userSRS);
Transform sourceToModelSRSTransform = Heron.Convert.GetUserSRSToModelTransform(sourceSRS);
Transform modelToSourceSRSTransform = Heron.Convert.GetModelToUserSRSTransform(sourceSRS);
//OSGeo.GDAL.Driver gdalOGR = OSGeo.GDAL.Gdal.GetDriverByName("VRT");
//var ds = OSGeo.GDAL.Gdal.OpenEx(vrtFile, 4, ["VRT","MVT"], null, null);
int t = 0;
foreach (string mvtTile in cachefilePaths)// cachefilePaths)
{
OSGeo.OGR.Driver drv = OSGeo.OGR.Ogr.GetDriverByName("MVT");
OSGeo.OGR.DataSource ds = OSGeo.OGR.Ogr.Open("MVT:" + mvtTile, 0);
string[] mvtOptions = new[] { "CLIP", "NO" };
//OSGeo.OGR.DataSource ds = drv.Open(mvtTile, 0);
if (ds == null)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "The vector datasource was unreadable by this component. It may not a valid file type for this component or otherwise null/empty.");
return;
}
///Morph raw mapbox tile points to geolocated tile
Vector3d moveDir = tileExtents[t].ElementAt(0) - new Point3d(0, 0, 0);
Transform move = Transform.Translation(moveDir);
Transform scale = Transform.Scale(Plane.WorldXY, tileWidth[t] / 4096, tileHeight[t] / 4096, 1);
Transform scaleMove = Transform.Multiply(move, scale);
for (int iLayer = 0; iLayer < ds.GetLayerCount(); iLayer++)
{
OSGeo.OGR.Layer layer = ds.GetLayerByIndex(iLayer);
long count = layer.GetFeatureCount(1);
int featureCount = System.Convert.ToInt32(count);
AddRuntimeMessage(GH_RuntimeMessageLevel.Remark, "Layer #" + iLayer + " " + layer.GetName() + " has " + featureCount + " features");
//if (layer.GetName() == "admin" || layer.GetName() == "building")
//{
OSGeo.OGR.FeatureDefn def = layer.GetLayerDefn();
///Get the field names
List <string> fieldnames = new List <string>();
for (int iAttr = 0; iAttr < def.GetFieldCount(); iAttr++)
{
OSGeo.OGR.FieldDefn fdef = def.GetFieldDefn(iAttr);
fnames.Append(new GH_String(fdef.GetNameRef()), new GH_Path(iLayer, t));
}
///Loop through geometry
OSGeo.OGR.Feature feat;
int m = 0;
///error "Self-intersection at or near point..." when zoom gets below 12 for water
///this is an issue with the way mvt simplifies geometries at lower zoom levels and is a known problem
///TODO: look into how to fix invalid geom and return to the typical while loop iterating method
//while ((feat = layer.GetNextFeature()) != null)
while (true)
{
try
{
feat = layer.GetNextFeature();
}
catch
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Some features had invalid geometry and were skipped.");
continue;
}
if (feat == null)
{
break;
}
OSGeo.OGR.Geometry geom = feat.GetGeometryRef();
///reproject geometry to WGS84 and userSRS
///TODO: look into using the SetCRS global variable here
gtype.Append(new GH_String(geom.GetGeometryName()), new GH_Path(iLayer, t, m));
Transform tr = scaleMove; // new Transform(1);
if (feat.GetGeometryRef() != null)
{
///Convert GDAL geometries to IGH_GeometricGoo
foreach (IGH_GeometricGoo gMorphed in Heron.Convert.OgrGeomToGHGoo(geom, tr))
{
//gMorphed.Morph(morph);
gGoo.Append(gMorphed, new GH_Path(iLayer, t, m));
}
if (layer.GetName() == "building")
{
if (feat.GetFieldAsString(def.GetFieldIndex("extrude")) == "true")
{
double unitsConversion = Rhino.RhinoMath.UnitScale(Rhino.RhinoDoc.ActiveDoc.ModelUnitSystem, Rhino.UnitSystem.Meters);
double height = System.Convert.ToDouble(feat.GetFieldAsString(def.GetFieldIndex("height"))) / unitsConversion;
double min_height = System.Convert.ToDouble(feat.GetFieldAsString(def.GetFieldIndex("min_height"))) / unitsConversion;
bool underground = System.Convert.ToBoolean(feat.GetFieldAsString(def.GetFieldIndex("underground")));
if (geom.GetGeometryType() == wkbGeometryType.wkbPolygon)
{
Extrusion bldg = Heron.Convert.OgrPolygonToExtrusion(geom, tr, height, min_height, underground);
IGH_GeometricGoo bldgGoo = GH_Convert.ToGeometricGoo(bldg);
gGooBuildings.Append(bldgGoo, new GH_Path(iLayer, t, m));
}
if (geom.GetGeometryType() == wkbGeometryType.wkbMultiPolygon)
{
List <Extrusion> bldgs = Heron.Convert.OgrMultiPolyToExtrusions(geom, tr, height, min_height, underground);
foreach (Extrusion bldg in bldgs)
{
IGH_GeometricGoo bldgGoo = GH_Convert.ToGeometricGoo(bldg);
gGooBuildings.Append(bldgGoo, new GH_Path(iLayer, t, m));
}
}
}
}
/// Get Feature Values
if (fvalues.PathExists(new GH_Path(iLayer, t, m)))
{
//fvalues.get_Branch(new GH_Path(iLayer, t, m)).Clear();
}
for (int iField = 0; iField < feat.GetFieldCount(); iField++)
{
OSGeo.OGR.FieldDefn fdef = def.GetFieldDefn(iField);
if (feat.IsFieldSet(iField))
{
fvalues.Append(new GH_String(feat.GetFieldAsString(iField)), new GH_Path(iLayer, t, m));
}
else
{
fvalues.Append(new GH_String("null"), new GH_Path(iLayer, t, m));
}
}
}
m++;
geom.Dispose();
feat.Dispose();
}///end while loop through features
//}///end layer by name
layer.Dispose();
}///end loop through layers
ds.Dispose();
t++;
}///end loop through mvt tiles
//write out new tile range metadata for serialization
TileCacheMeta = tileRangeString;
DA.SetData(0, imgFrame);
DA.SetDataTree(1, fnames);
DA.SetDataTree(2, fvalues);
DA.SetDataTree(3, gGoo);
DA.SetDataList(4, "copyright Mapbox");
DA.SetDataTree(5, gtype);
DA.SetDataTree(6, gGooBuildings);
DA.SetDataList(7, tileExtents);
}
/// <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 static Boolean CleanFileGDBNames(frmMain pFrm, string pTgtFileGDB, string pSrcPGeoMDB, string pTgtFeatClass)
{
try
{
// Connect to database
var mOdbcConn = new OdbcConnection("Driver={Microsoft Access Driver (*.mdb, *.accdb)};Dbq=" + pSrcPGeoMDB + ";Uid=Admin;Pwd=;");
// Load road names
pFrm.Log("Start loading names");
var mRoadNames = new Dictionary <int, DataRow>();
var mDataAdapter = new OdbcDataAdapter(sqlStatements.selectRoadNamesSQL, mOdbcConn);
var mDataTable = new DataTable();
mDataAdapter.Fill(mDataTable);
int ctr1 = 0;
int total1 = mDataTable.Rows.Count;
foreach (DataRow mRow in mDataTable.Rows)
{
int mRoadId;
if (int.TryParse(mRow["ADRROADID"].ToString(), out mRoadId))
{
mRoadNames.Add(mRoadId, mRow);
}
ctr1++;
if (ctr1 % 50 == 0)
{
Application.DoEvents();
}
}
pFrm.Log("Done loading road names");
mOdbcConn.Close();
mDataAdapter.Dispose();
mDataAdapter = null;
mOdbcConn.Dispose();
mOdbcConn = null;
// Load district names
Gdal.SetConfigOption("SHAPE_ENCODING", "UTF-8");
DataSource districtDataSource = Ogr.Open(DistrictImport.GetShapefileName(), 0);
OSGeo.OGR.Layer districtLayer = districtDataSource.GetLayerByIndex(0);
if (districtLayer == null)
{
pFrm.Log("Could not load district names layer");
goto CleanUpDistricts;
}
pFrm.Log("Done loading district names");
var mFileGDBDrv = OSGeo.OGR.Ogr.GetDriverByName("FileGDB");
var mTgtDSrc = mFileGDBDrv.Open(pTgtFileGDB, 1);
var mTgtLyr = mTgtDSrc.GetLayerByName(pTgtFeatClass);
if (mTgtLyr == null)
{
pFrm.Log("Could not open layer " + pTgtFeatClass + " for update");
goto CleanUp;
}
pFrm.Log("Opened target FileGDB for update");
Feature mFeat = null;
int mNumTgtFeats = mTgtLyr.GetFeatureCount(1);
// Clean all existing district and street names
pFrm.Log("Processing");
for (int idxFeature = 0; idxFeature < mNumTgtFeats; idxFeature++)
{
if (null != (mFeat = mTgtLyr.GetFeature(idxFeature)))
{
Geometry mGeometry = mFeat.GetGeometryRef();
double[] p = new double[2];
mGeometry.GetPoint(0, p);
if (pTgtFeatClass == "Address_unit_signs")
{
int mRoadID = mFeat.GetFieldAsInteger("ROADID");
mFeat.SetField("ROADNAME_EN", mRoadNames.GetStringOrNull(mRoadID, "NAMEENGLISH"));
mFeat.SetField("ROADNAME_AR", mRoadNames.GetStringOrNull(mRoadID, "NAMEARABIC"));
mFeat.SetField("ROADNAME_POP_EN", null);
mFeat.SetField("ROADNAME_POP_AR", null);
mFeat.SetField("DESCRIPTION_EN", mRoadNames.GetStringOrNull(mRoadID, "DESCRIPTIONENGLISH"));
mFeat.SetField("DESCRIPTION_AR", mRoadNames.GetStringOrNull(mRoadID, "DESCRIPTIONARABIC"));
}
else if (pTgtFeatClass == "Street_name_signs")
{
int mRoadID1 = mFeat.GetFieldAsInteger("ROADID_P1");
int mRoadID2 = mFeat.GetFieldAsInteger("ROADID_P2");
mFeat.SetField("ROADNAME_EN_P1", mRoadNames.GetStringOrNull(mRoadID1, "NAMEENGLISH"));
mFeat.SetField("ROADNAME_AR_P1", mRoadNames.GetStringOrNull(mRoadID1, "NAMEARABIC"));
mFeat.SetField("ROADNAME_EN_P2", mRoadNames.GetStringOrNull(mRoadID2, "NAMEENGLISH"));
mFeat.SetField("ROADNAME_AR_P2", mRoadNames.GetStringOrNull(mRoadID2, "NAMEARABIC"));
}
else if (pTgtFeatClass == "Address_guide_sign")
{
int mRoadID = mFeat.GetFieldAsInteger("ROADID");
string tmpRoadEn = mRoadNames.GetStringOrNull(mRoadID, "NAMEENGLISH");
string tmpRoadAr = mRoadNames.GetStringOrNull(mRoadID, "NAMEARABIC");
mFeat.SetField("ROADNAME_EN", tmpRoadEn);
mFeat.SetField("ROADNAME_AR", tmpRoadAr);
}
districtLayer.SetSpatialFilter(mGeometry);
using (Feature matchDistrict = districtLayer.GetFeature(0))
{
if (matchDistrict != null &&
matchDistrict.IsFieldSet("NAMELATIN") &&
matchDistrict.IsFieldSet("NAMEARABIC"))
{
string tmpDistEn = matchDistrict.GetFieldAsString("NAMELATIN");
string tmpDistAr = matchDistrict.GetFieldAsString("NAMEARABIC");
mFeat.SetField("DISTRICT_EN", tmpDistEn);
mFeat.SetField("DISTRICT_AR", tmpDistAr);
}
else
{
mFeat.SetField("DISTRICT_EN", null);
mFeat.SetField("DISTRICT_AR", null);
pFrm.Log("No district name match for " + pTgtFeatClass + " with coordinates: " + p[0].ToString() + ", " + p[1].ToString());
}
}
Application.DoEvents();
mTgtLyr.SetFeature(mFeat);
DoEventsOnBatchSize:
if (idxFeature % 250 == 0 || idxFeature == mNumTgtFeats)
{
pFrm.Log("Processed " + idxFeature + " out of" + mNumTgtFeats + " features");
//Thread.Sleep(250);
mTgtLyr.SyncToDisk();
}
if (mGeometry != null)
{
mGeometry.Dispose();
}
if (mFeat != null)
{
mFeat.Dispose();
}
}
}
CleanUp:
if (mTgtLyr != null)
{
mTgtLyr.Dispose();
}
if (mTgtDSrc != null)
{
mTgtDSrc.Dispose();
}
if (mFileGDBDrv != null)
{
mFileGDBDrv.Dispose();
}
CleanUpDistricts:
if (districtLayer != null)
{
districtLayer.Dispose();
}
if (districtDataSource != null)
{
districtDataSource.Dispose();
}
}
catch (Exception ex)
{
pFrm.Log(ex.Message);
pFrm.Log(ex.StackTrace);
return(false);
}
return(true);
}
public static bool ExportSelectedDatabaseToGML(Action <string, bool> aLog, string pOutputFilename)
{
// Get database, return if no database selected
if (frmMain.dbx == null)
{
aLog("Please select a database first...", true);
return(false);
}
// Setup driver
OSGeo.OGR.Driver drv = Ogr.GetDriverByName("GML");
if (drv == null)
{
aLog("Could not load driver", true);
return(false);
}
// Create fieldAttributes datasource
DataSource ds = drv.CreateDataSource(pOutputFilename, null);
if (ds == null)
{
aLog("Could not create datasource", true);
return(false);
}
// Create fieldAttributes layer
OSGeo.OGR.Layer l = ds.CreateLayer("AddressUnits", null, wkbGeometryType.wkbPoint, null);
if (l == null)
{
aLog("Failed to create GML file: AddressUnits", true);
return(false);
}
// Create fieldAttributes class to hold address unit data
AddressUnit mAddressUnits = new AddressUnit();
// Add fields to shapefile
foreach (System.Reflection.FieldInfo mFld in mAddressUnits.GetType().GetFields())
{
var val = (DatFld)mFld.GetValue(mAddressUnits);
var mNewField = new FieldDefn(mFld.Name, val.type);
if (val.type == FieldType.OFTString)
{
mNewField.SetWidth(val.length);
}
if (Ogr.OGRERR_NONE != l.CreateField(mNewField, 1))
{
aLog("Failed to add field: " + mFld.Name, true);
}
}
int ctr = 0;
double mX, mY;
var mAdmAdrFeature = new AddressUnitFeature(frmMain.dbx);
DataTable mTable = mAdmAdrFeature.GetTable(sqlStatements.selectAddressUnitsSQL);
// Add features
foreach (DataRow mRow in mTable.Rows)
{
if (Double.TryParse(mRow["loc_x"].ToString(), out mX) && Double.TryParse(mRow["loc_y"].ToString(), out mY))
{
var mFeature = new OSGeo.OGR.Feature(l.GetLayerDefn());
var mPoint = new OSGeo.OGR.Geometry(wkbGeometryType.wkbPoint);
mPoint.SetPoint(0, mX, mY, 0);
mFeature.SetFID(ctr);
mFeature.SetGeometry(mPoint);
mFeature.SetField("ADDRESSUNITID", int.Parse(mRow["id"].ToString()));
mFeature.SetField("ROADID", int.Parse(mRow["road_id"].ToString()));
mFeature.SetField("ADDRESSUNITNR", int.Parse(mRow["addressUnitNumber"].ToString()));
mFeature.SetField("ROADNAME_EN", Utilities.GetANSI(mRow["NAMEENGLISH"].ToString()));
mFeature.SetField("ROADNAME_AR", Utilities.GetANSI(mRow["NAMEARABIC"].ToString()));
mFeature.SetField("DISTRICT_EN", Utilities.GetANSI(mRow["DISTRICT_EN"].ToString()));
mFeature.SetField("DISTRICT_AR", Utilities.GetANSI(mRow["DISTRICT_AR"].ToString()));
mFeature.SetField("MUNICIPALITY_EN", Utilities.GetANSI(Utilities.LABEL_ABUDHABI_EN));
mFeature.SetField("MUNICIPALITY_AR", Utilities.GetANSI(Utilities.LABEL_ABUDHABI_AR));
mFeature.SetField("QR_CODE", Utilities.GetANSI(mAdmAdrFeature.GetQRCode(mRow, mTable)));
l.CreateFeature(mFeature);
}
else
{
Utilities.LogDebug("Error");
}
ctr++;
}
l.Dispose();
ds.Dispose();
drv.Dispose();
return(true);
}
public static void getH(string DSMfile, string oriShp)
{
Console.WriteLine("开始提取建筑高度！");
Gdal.AllRegister();
Ogr.RegisterAll();
Stopwatch aTime = new Stopwatch(); aTime.Start();
//创建一个BUFFER，BUFFER距离为1米
string bufShp = bufferFile(oriShp, 1);
//打开原文件和Buffer文件
OSGeo.OGR.Driver dr = Ogr.GetDriverByName("ESRI shapefile");
DataSource oriDs = dr.Open(oriShp, 1);
DataSource bufDs = dr.Open(bufShp, 0);
OSGeo.OGR.Layer bufLayer = bufDs.GetLayerByIndex(0);
OSGeo.OGR.Layer oriLayer = oriDs.GetLayerByIndex(0);
//判断原文件中是否有以下字段，没有就创建
if (oriLayer.FindFieldIndex("MIN", 1) == -1)
{
FieldDefn min = new FieldDefn("MIN", FieldType.OFTReal);
oriLayer.CreateField(min, 1);
}
if (oriLayer.FindFieldIndex("MAX", 1) == -1)
{
FieldDefn max = new FieldDefn("MAX", FieldType.OFTReal);
oriLayer.CreateField(max, 1);
}
if (oriLayer.FindFieldIndex("HIGHT", 1) == -1)
{
FieldDefn hight = new FieldDefn("HIGHT", FieldType.OFTReal);
oriLayer.CreateField(hight, 1);
}
//打开栅格
Dataset dsmDs = Gdal.Open(DSMfile, Access.GA_ReadOnly);
double[] transfrom = new double[6];
dsmDs.GetGeoTransform(transfrom);
int allX = dsmDs.RasterXSize;
int allY = dsmDs.RasterYSize;
//开始计算每个Feature需要读取的栅格参数
int featCount = oriLayer.GetFeatureCount(0);
for (int i = 0; i < featCount; i++)
{
int[] subRasterOff_Size = subRasterInfo(transfrom, allX, allY, bufLayer.GetFeature(i));
Feature oriFeat = oriLayer.GetFeature(i);
Feature bufFeat = bufLayer.GetFeature(i);
getMaxMinValue(dsmDs, oriFeat, bufFeat, subRasterOff_Size);
oriLayer.SetFeature(oriFeat);
oriFeat.Dispose();
Console.WriteLine("当前处理：{0}/{1}", i, featCount);
}
oriLayer.Dispose();
bufLayer.Dispose();
oriDs.Dispose();
bufDs.Dispose();
dsmDs.Dispose();
aTime.Stop();
Console.WriteLine("建筑高度值提取完成！用时：{0}", aTime.Elapsed.ToString());
}
/// <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)
{
///TODO: fix crash with "multi" types in a branch for shapefiles, can't create lines in a points layer
/// fix mesh/polygon face creation issue on sphere, dropping faces or flipped faces
/// fix swtich case for shapfiles so that points and multipoints (eg) are written to the same file. don't use switch anymore, us ifs
/// fix sql statements, they don't seem to have an effect. Need these to work for pulling apart geometry collections.
///Gather GHA inputs
string filename = string.Empty;
DA.GetData <string>("Vector Data Filename", ref filename);
string folder = string.Empty;
DA.GetData <string>("Vector Data Folder", ref folder);
folder = Path.GetFullPath(folder);
if (!folder.EndsWith(Path.DirectorySeparatorChar.ToString()))
{
folder += Path.DirectorySeparatorChar;
}
string shpPath = folder + filename + drvExtension;
///for more than one geometry type, a list of files for shapefile output needs to be established
List <string> shpPathList = new List <string>();
List <string> shpTypeList = new List <string>();
List <string> fields = new List <string>();
DA.GetDataList <string>("Fields", fields);
GH_Structure <GH_String> values = new GH_Structure <GH_String>();
DA.GetDataTree <GH_String>("Values", out values);
GH_Structure <IGH_GeometricGoo> gGoo = new GH_Structure <IGH_GeometricGoo>();
DA.GetDataTree <IGH_GeometricGoo>("Feature Geometry", out gGoo);
bool export = false;
DA.GetData <bool>("Export", ref export);
///GDAL setup
RESTful.GdalConfiguration.ConfigureOgr();
OSGeo.GDAL.Gdal.SetConfigOption("OGR_SKIP", "KML");
string driverType = drvType;
//OSGeo.OGR.Driver drv = Ogr.GetDriverByName("LIBKML");// driverType);
OSGeo.OGR.Driver drv = Ogr.GetDriverByName("GeoJSON");
if (export == true)
{
///File setup for save
FileInfo file = new FileInfo(folder);
file.Directory.Create();
if (File.Exists(shpPath))
{
drv.DeleteDataSource(shpPath);
}
///Create virtual datasource to be converted later
///Using geojson as a flexiblle base file type which can be converted later with ogr2ogr
DataSource ds = drv.CreateDataSource("/vsimem/out.geojson", null);
///Use WGS84 spatial reference
OSGeo.OSR.SpatialReference dst = new OSGeo.OSR.SpatialReference("");
dst.SetWellKnownGeogCS("WGS84");
Transform transform = Heron.Convert.XYZToWGSTransform();
///Use OGR catch-all for geometry types
var gtype = wkbGeometryType.wkbGeometryCollection;
///Create layer
//string[] layerOptions = new string[] { "LIBKML_USE_SCHEMADATA=NO", "LIBKML_USE_SIMPLEFIELD=NO", "LIBKML_ALTITUDEMODE_FIELD=relativeToGround" };
//string[] layerOptions = new string[] { "LIBKML_STRICT_COMPLIANCE=FALSE" };
OSGeo.OGR.Layer layer = ds.CreateLayer(filename, dst, gtype, null);
FeatureDefn def = layer.GetLayerDefn();
///Add fields to layer
for (int f = 0; f < fields.Count; f++)
{
OSGeo.OGR.FieldDefn fname = new OSGeo.OGR.FieldDefn(fields[f], OSGeo.OGR.FieldType.OFTString);
layer.CreateField(fname, f);
}
///Specific fields for LIBKML for use in Google Earth
///See LIBMKL driver for more info https://gdal.org/drivers/vector/libkml.html
if (drvType == "LIBKML")
{
OSGeo.OGR.FieldDefn kmlFieldAltitudeMode = new OSGeo.OGR.FieldDefn("altitudeMode", OSGeo.OGR.FieldType.OFTString);
layer.CreateField(kmlFieldAltitudeMode, fields.Count());
//OSGeo.OGR.FieldDefn kmlFieldExtrude = new OSGeo.OGR.FieldDefn("tessellate", OSGeo.OGR.FieldType.OFTInteger);
//layer.CreateField(kmlFieldExtrude, fields.Count()+1);
}
for (int a = 0; a < gGoo.Branches.Count; a++)
{
///create feature
OSGeo.OGR.Feature feature = new OSGeo.OGR.Feature(def);
///Set LIBKML specific fields for use in Google Earth, defaulting to 'relativeToGround'. Consider setting to 'absolute'.
if (drvType == "LIBKML")
{
feature.SetField("altitudeMode", "relativeToGround");
//feature.SetField("altitudeMode", "absolute");
//feature.SetField("tessellate", 0);
}
///TODO: Build style table
OSGeo.OGR.StyleTable styleTable = new StyleTable();
//feature.SetStyleString("BRUSH(fc:#0000FF);PEN(c:#000000)");
///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";
}
///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();
switch (geomType)
{
case "Point":
geomList.First().CastTo <Point3d>(out pt);
feature.SetGeometry(Heron.Convert.Point3dToOgrPoint(pt, transform));
if (!shpTypeList.Contains("POINT"))
{
shpTypeList.Add("POINT");
}
break;
case "MultiPoint":
foreach (var point in geomList)
{
point.CastTo <Point3d>(out pt);
pts.Add(pt);
}
feature.SetGeometry(Heron.Convert.Point3dsToOgrMultiPoint(pts, transform));
if (!shpTypeList.Contains("MULTIPOINT"))
{
shpTypeList.Add("MULTIPOINT");
}
break;
case "Curve":
geomList.First().CastTo <Curve>(out crv);
feature.SetGeometry(Heron.Convert.CurveToOgrLinestring(crv, transform));
if (!shpTypeList.Contains("LINESTRING"))
{
shpTypeList.Add("LINESTRING");
}
break;
case "MultiCurve":
foreach (var curve in geomList)
{
curve.CastTo <Curve>(out crv);
crvs.Add(crv);
}
feature.SetGeometry(Heron.Convert.CurvesToOgrMultiLinestring(crvs, transform));
if (!shpTypeList.Contains("MULTILINESTRING"))
{
shpTypeList.Add("MULTILINESTRING");
}
break;
case "Mesh":
geomList.First().CastTo <Mesh>(out mesh);
feature.SetGeometry(Heron.Convert.MeshToMultiPolygon(mesh, transform));
if (!shpTypeList.Contains("MULTIPOLYGON"))
{
shpTypeList.Add("MULTIPOLYGON");
}
break;
case "MultiMesh":
foreach (var m in geomList)
{
Mesh meshPart = new Mesh();
m.CastTo <Mesh>(out meshPart);
multiMesh.Append(meshPart);
}
feature.SetGeometry(Heron.Convert.MeshToMultiPolygon(multiMesh, transform));
if (!shpTypeList.Contains("MULTIPOLYGON"))
{
shpTypeList.Add("MULTIPOLYGON");
}
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;
}
}
feature.SetGeometry(geoCollection);
if (!shpTypeList.Contains("GEOMETRYCOLLECTION"))
{
shpTypeList.Add("GEOMETRYCOLLECTION");
}
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;
}
///Give the feature a unique ID
feature.SetFID(a);
///Add values to fields
GH_Path path = gGoo.get_Path(a);
for (int vInt = 0; vInt < fields.Count; vInt++)
{
string val = string.Empty;
if (values.get_Branch(path) != null)
{
val = values.get_DataItem(path, vInt).ToString();
}
feature.SetField(fields[vInt], val);
}
///Save feature to layer
layer.CreateFeature(feature);
///Cleanup
feature.Dispose();
}
layer.Dispose();
ds.Dispose();
drv.Dispose();
///Convert in memory dataset to file using ogr2ogr
///For KML set 'altitudeMode' to 'relativeToGround' or 'absolute'
///Set base options for all export types
if (drvType == "KML")
{
drvType = "LIBKML";
}
List <string> ogr2ogrOptions = new List <string> {
"-overwrite",
"-f", drvType,
"-dim", "XYZ",
"-skipfailures",
//"-lco", "LIBKML_STRICT_COMPLIANCE=FALSE",
//"-lco", "AltitudeMode=absolute",
//"-dsco", "SHAPE_REWIND_ON_WRITE=YES"
};
Dataset src = Gdal.OpenEx("/vsimem/out.geojson", 0, null, null, null);
if (drvType != "ESRI Shapefile")
{
Dataset destDataset = Gdal.wrapper_GDALVectorTranslateDestName(shpPath, src, new GDALVectorTranslateOptions(ogr2ogrOptions.ToArray()), null, null);
destDataset.Dispose();
shpPathList.Add(shpPath);
}
///Export multiple layers for shapefile
///https://trac.osgeo.org/gdal/wiki/FAQVector#HowdoItranslateamixedgeometryfiletoshapefileformat
else
{
///
if (shpTypeList.Count <= 1 && shpTypeList.First() != "GEOMETRYCOLLECTION")
{
if (shpTypeList.First() == "POLYGON" || shpTypeList.First() == "MULTIPOLYGON")
{
ogr2ogrOptions.AddRange(new List <string> {
"-lco", "SHPT=MULTIPATCH"
});
}
Dataset destDataset = Gdal.wrapper_GDALVectorTranslateDestName(shpPath, src, new GDALVectorTranslateOptions(ogr2ogrOptions.ToArray()), null, null);
destDataset.Dispose();
shpPathList.Add(shpPath);
}
else
{
///Add -explodecollections for mixed geometries in a branch
///"-where" statement is not necessary, but could speed up big datasets
string shpFileName = string.Empty;
List <string> ogr2ogrShpOptions = new List <string>();
if (shpTypeList.Contains("POINT") || shpTypeList.Contains("MULTIPOINT"))
{
shpFileName = folder + filename + "_points.shp";
shpPathList.Add(shpFileName);
List <string> ogr2ogrShpOptionsPts = new List <string> {
"-overwrite",
"-f", drvType,
"-dim", "XYZ",
"-skipfailures"
};
//ogr2ogrShpOptionsPts.AddRange(new List<string> { "-where", "ogr_geometry=POINT", "-where", "ogr_geometry=MULTIPOINT", "-lco", "SHPT=MULTIPOINTZ", "-nlt", "PROMOTE_TO_MULTI"});
ogr2ogrShpOptionsPts.AddRange(new List <string> {
"-sql", "SELECT * FROM " + filename + " WHERE OGR_GEOMETRY='MULTIPOINT' OR OGR_GEOMETRY='POINT'", "-lco", "SHPT=MULTIPOINTZ", "-nlt", "PROMOTE_TO_MULTI"
});
//ogr2ogrShpOptionsPts.AddRange(new List<string> { "-dialect", "sqlite", "-sql", "select * from " + filename + " where GeometryType(geometry) in ('POINT','MULTIPOINT')", "-lco", "SHPT=MULTIPOINTZ", "-nlt", "PROMOTE_TO_MULTI" });
Dataset destDatasetPoint = Gdal.wrapper_GDALVectorTranslateDestName(shpFileName, src, new GDALVectorTranslateOptions(ogr2ogrShpOptionsPts.ToArray()), null, null);
destDatasetPoint.Dispose();
}
if (shpTypeList.Contains("LINESTRING") || shpTypeList.Contains("MULTILINESTRING"))
{
shpFileName = folder + filename + "_lines.shp";
shpPathList.Add(shpFileName);
List <string> ogr2ogrShpOptionsLines = new List <string> {
"-overwrite",
"-f", drvType,
"-dim", "XYZ",
"-skipfailures"
};
//ogr2ogrShpOptionsLines.AddRange(new List<string> { "-where", "ogr_geometry=LINESTRING25D", "-where", "ogr_geometry=MULTILINESTRING25D", "-lco", "SHPT=ARCZ", "-nlt", "PROMOTE_TO_MULTI" });
ogr2ogrShpOptionsLines.AddRange(new List <string> {
"-sql", "SELECT * FROM " + filename + " WHERE OGR_GEOMETRY='LINESTRING' OR OGR_GEOMETRY='MULTILINESTRING'", "-lco", "SHPT=ARCZ", "-nlt", "PROMOTE_TO_MULTI"
});
//ogr2ogrShpOptionsLines.AddRange(new List<string> { "-dialect", "sqlite", "-sql", "select * from " + filename + " where GeometryType(geometry) in ('LINESTRING','MULTILINESTRING')", "-lco", "SHPT=ARCZ", "-nlt", "PROMOTE_TO_MULTI" });
Dataset destDatasetLinestring = Gdal.wrapper_GDALVectorTranslateDestName(shpFileName, src, new GDALVectorTranslateOptions(ogr2ogrShpOptionsLines.ToArray()), null, null);
destDatasetLinestring.Dispose();
}
if (shpTypeList.Contains("POLYGON") || shpTypeList.Contains("MULTIPOLYGON"))
{
shpFileName = folder + filename + "_polygons.shp";
shpPathList.Add(shpFileName);
List <string> ogr2ogrShpOptionsPolygons = new List <string> {
"-overwrite",
"-f", drvType,
"-dim", "XYZ",
"-skipfailures",
"-dsco", "SHAPE_REWIND_ON_WRITE=NO"
};
//ogr2ogrShpOptionsPolygons.AddRange(new List<string> { "-where", "ogr_geometry=POLYGON", "-where", "ogr_geometry=MULTIPOLYGON", "-lco", "SHPT=POLYGONZ", "-nlt", "PROMOTE_TO_MULTI" });
ogr2ogrShpOptionsPolygons.AddRange(new List <string> {
"-sql", "SELECT * FROM " + filename + " WHERE OGR_GEOMETRY='MULTIPOLYGON25D' OR OGR_GEOMETRY='POLYGON25D'", "-lco", "SHPT=POLYGONZ", "-nlt", "PROMOTE_TO_MULTI"
});
Dataset destDatasetPolygon = Gdal.wrapper_GDALVectorTranslateDestName(shpFileName, src, new GDALVectorTranslateOptions(ogr2ogrShpOptionsPolygons.ToArray()), null, null);
destDatasetPolygon.Dispose();
}
///Not working properly when multiple geometry types are part of the same branch for SHP export.
if (shpTypeList.Contains("GEOMETRYCOLLECTION"))
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Remark, "One or more branches contain a mix of geometry types.");
///export points
shpFileName = folder + filename + "_gc-points.shp";
shpPathList.Add(shpFileName);
List <string> ogr2ogrShpOptionsGCPts = new List <string> {
"-overwrite",
"-f", drvType,
"-dim", "XYZ",
"-skipfailures"
};
ogr2ogrShpOptionsGCPts.AddRange(new List <string> {
"-explodecollections", "-where", "ogr_geometry=GEOMETRYCOLLECTION", "-lco", "SHPT=MULTIPOINTZ", "-nlt", "PROMOTE_TO_MULTI"
});
//ogr2ogrShpOptionsGCPts.AddRange(new List<string> { "-explodecollections", "-sql", "SELECT * FROM " + filename + " WHERE OGR_GEOMETRY='MULTIPOINT' OR OGR_GEOMETRY='POINT'", "-lco", "SHPT=MULTIPOINTZ", "-nlt", "PROMOTE_TO_MULTI" });
Dataset destDatasetGCPoints = Gdal.wrapper_GDALVectorTranslateDestName(shpFileName, src, new GDALVectorTranslateOptions(ogr2ogrShpOptionsGCPts.ToArray()), null, null);
destDatasetGCPoints.Dispose();
///export lines
shpFileName = folder + filename + "_gc-lines.shp";
shpPathList.Add(shpFileName);
List <string> ogr2ogrShpOptionsGCLines = new List <string> {
"-overwrite",
"-f", drvType,
"-dim", "XYZ",
"-skipfailures"
};
ogr2ogrShpOptionsGCLines.AddRange(new List <string> {
"-explodecollections", "-where", "ogr_geometry=GEOMETRYCOLLECTION", "-lco", "SHPT=ARCZ", "-nlt", "PROMOTE_TO_MULTI"
});
//ogr2ogrShpOptionsGCLines.AddRange(new List<string> { "-explodecollections", "-sql", "SELECT * FROM " + filename + " WHERE OGR_GEOMETRY='MULTILINESTRING25D' OR OGR_GEOMETRY='LINESTRING25D'", "-lco", "SHPT=ARCZ", "-nlt", "PROMOTE_TO_MULTI" });
Dataset destDatasetGCLines = Gdal.wrapper_GDALVectorTranslateDestName(shpFileName, src, new GDALVectorTranslateOptions(ogr2ogrShpOptionsGCLines.ToArray()), null, null);
destDatasetGCLines.Dispose();
///export meshes
shpFileName = folder + filename + "_gc-polygons.shp";
shpPathList.Add(shpFileName);
List <string> ogr2ogrShpOptionsGCPolygons = new List <string> {
"-overwrite",
"-f", drvType,
"-dim", "XYZ",
"-skipfailures",
"-dsco", "SHAPE_REWIND_ON_WRITE=NO"
};
ogr2ogrShpOptionsGCPolygons.AddRange(new List <string> {
"-explodecollections", "-where", "ogr_geometry=GEOMETRYCOLLECTION", "-lco", "SHPT=POLYGONZ", "-nlt", "PROMOTE_TO_MULTI"
});
//ogr2ogrShpOptionsGCPolygons.AddRange(new List<string> { "-explodecollections", "-sql", "SELECT * FROM " + filename + " WHERE OGR_GEOMETRY='MULTIPOLYGON' OR OGR_GEOMETRY='POLYGON'", "-lco", "SHPT=POLYGONZ", "-nlt", "PROMOTE_TO_MULTI" });
Dataset destDatasetGCPolygons = Gdal.wrapper_GDALVectorTranslateDestName(shpFileName, src, new GDALVectorTranslateOptions(ogr2ogrShpOptionsGCPolygons.ToArray()), null, null);
destDatasetGCPolygons.Dispose();
}
}
}
///Clean up
Gdal.Unlink("/vsimem/out.geojson");
}
DA.SetDataList(0, shpPathList);
}
protected override void SolveInstance(IGH_DataAccess DA)
{
List <Curve> boundary = new List <Curve>();
DA.GetDataList <Curve>(0, boundary);
string shpFileLoc = "";
DA.GetData <string>("Vector Data Location", ref shpFileLoc);
///GDAL setup
///Some preliminary testing has been done to read SHP, GeoJSON, OSM, KML, MVT, GML and GDB
///It can be spotty with KML, MVT and GML and doesn't throw informative errors. Likely has to do with getting a valid CRS and
///TODO: resolve errors with reading KML, MVT, GML.
RESTful.GdalConfiguration.ConfigureOgr();
OSGeo.OGR.Ogr.RegisterAll();
OSGeo.OGR.Driver drv = OSGeo.OGR.Ogr.GetDriverByName("ESRI Shapefile");
OSGeo.OGR.DataSource ds = OSGeo.OGR.Ogr.Open(shpFileLoc, 0);
if (ds == null)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "The vector datasource was unreadable by this component. It may not a valid file type for this component or otherwise null/empty.");
return;
}
List <OSGeo.OGR.Layer> layerset = new List <OSGeo.OGR.Layer>();
List <int> fc = new List <int>();
for (int iLayer = 0; iLayer < ds.GetLayerCount(); iLayer++)
{
OSGeo.OGR.Layer layer = ds.GetLayerByIndex(iLayer);
if (layer == null)
{
Console.WriteLine("Couldn't fetch advertised layer " + iLayer);
System.Environment.Exit(-1);
}
else
{
layerset.Add(layer);
}
}
///Declare trees
GH_Structure <GH_String> layname = new GH_Structure <GH_String>();
GH_Structure <GH_Integer> fcs = new GH_Structure <GH_Integer>();
GH_Structure <GH_Rectangle> recs = new GH_Structure <GH_Rectangle>();
GH_Structure <GH_String> sRefs = new GH_Structure <GH_String>();
GH_Structure <GH_String> fnames = new GH_Structure <GH_String>();
GH_Structure <GH_String> fset = new GH_Structure <GH_String>();
GH_Structure <GH_Point> gset = new GH_Structure <GH_Point>();
///Loop through each layer. Layers usually occur in Geodatabase GDB format. SHP usually has only one layer.
for (int iLayer = 0; iLayer < ds.GetLayerCount(); iLayer++)
{
OSGeo.OGR.Layer layer = ds.GetLayerByIndex(iLayer);
if (layer == null)
{
Console.WriteLine("Couldn't fetch advertised layer " + iLayer);
System.Environment.Exit(-1);
}
long count = layer.GetFeatureCount(1);
int featureCount = System.Convert.ToInt32(count);
fcs.Append(new GH_Integer(featureCount), new GH_Path(iLayer));
layname.Append(new GH_String(layer.GetName()), new GH_Path(iLayer));
///Get OGR envelope of the data in the layer
OSGeo.OGR.Envelope ext = new OSGeo.OGR.Envelope();
layer.GetExtent(ext, 1);
Point3d extMin = new Point3d();
Point3d extMax = new Point3d();
extMin.X = ext.MinX;
extMin.Y = ext.MinY;
extMax.X = ext.MaxX;
extMax.Y = ext.MaxY;
///Get the spatial reference of the input vector file and set to WGS84 if not known
OSGeo.OSR.SpatialReference sr = new SpatialReference(Osr.SRS_WKT_WGS84);
string sRef = "";
if (layer.GetSpatialRef() == null)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Remark, "Coordinate Reference System (CRS) is missing. CRS set automatically set to WGS84.");
sr.ImportFromXML(shpFileLoc);
string pretty = "";
sr.ExportToPrettyWkt(out pretty, 0);
AddRuntimeMessage(GH_RuntimeMessageLevel.Remark, pretty);
sr.SetWellKnownGeogCS("WGS84");
sRef = "Coordinate Reference System (CRS) is missing. CRS set automatically set to WGS84.";
//sr.ImportFromEPSG(2263);
}
else
{
if (layer.GetSpatialRef().Validate() != 0)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Remark, "Coordinate Reference System (CRS) is unknown or unsupported. CRS set automatically set to WGS84.");
sr.SetWellKnownGeogCS("WGS84");
sRef = "Coordinate Reference System (CRS) is unknown or unsupported. SRS set automatically set to WGS84.";
}
else
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Remark, "Coordinate Reference System (CRS) set from layer" + iLayer + ".");
sr = layer.GetSpatialRef();
sr.ExportToWkt(out sRef);
}
}
sRefs.Append(new GH_String(sRef), new GH_Path(iLayer));
///Set transform from input spatial reference to Rhino spatial reference
///TODO: look into adding a step for transforming to CRS set in SetCRS
OSGeo.OSR.SpatialReference dst = new OSGeo.OSR.SpatialReference("");
dst.SetWellKnownGeogCS("WGS84");
OSGeo.OSR.CoordinateTransformation coordTransform = new OSGeo.OSR.CoordinateTransformation(sr, dst);
OSGeo.OSR.CoordinateTransformation revTransform = new OSGeo.OSR.CoordinateTransformation(dst, sr);
///Get bounding box of data in layer
double[] extMinPT = new double[3] {
extMin.X, extMin.Y, extMin.Z
};
double[] extMaxPT = new double[3] {
extMax.X, extMax.Y, extMax.Z
};
coordTransform.TransformPoint(extMinPT);
coordTransform.TransformPoint(extMaxPT);
Point3d extPTmin = new Point3d(extMinPT[0], extMinPT[1], extMinPT[2]);
Point3d extPTmax = new Point3d(extMaxPT[0], extMaxPT[1], extMaxPT[2]);
Rectangle3d rec = new Rectangle3d(Plane.WorldXY, Heron.Convert.ToXYZ(extPTmin), Heron.Convert.ToXYZ(extPTmax));
recs.Append(new GH_Rectangle(rec), new GH_Path(iLayer));
///Loop through input boundaries
for (int i = 0; i < boundary.Count; i++)
{
OSGeo.OGR.FeatureDefn def = layer.GetLayerDefn();
///Get the field names
List <string> fieldnames = new List <string>();
for (int iAttr = 0; iAttr < def.GetFieldCount(); iAttr++)
{
OSGeo.OGR.FieldDefn fdef = def.GetFieldDefn(iAttr);
fnames.Append(new GH_String(fdef.GetNameRef()), new GH_Path(i, iLayer));
}
///Check if boundary is contained in extent
if (!rec.IsValid || ((rec.Height == 0) && (rec.Width == 0)))
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "One or more vector datasource bounds are not valid.");
OSGeo.OGR.Feature feat;
int m = 0;
while ((feat = layer.GetNextFeature()) != null)
{
///Loop through field values
for (int iField = 0; iField < feat.GetFieldCount(); iField++)
{
OSGeo.OGR.FieldDefn fdef = def.GetFieldDefn(iField);
fset.Append(new GH_String(feat.GetFieldAsString(iField)), new GH_Path(i, iLayer, m));
fdef.Dispose();
}
m++;
feat.Dispose();
}
}
else if (boundary[i] == null)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Clipping boundary " + i + " not set.");
}
else if (!boundary[i].IsValid)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Clipping boundary " + i + " is not valid.");
}
else if (rec.IsValid && Curve.PlanarClosedCurveRelationship(rec.ToNurbsCurve(), boundary[i], Plane.WorldXY, Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance) == RegionContainment.Disjoint)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "One or more boundaries may be outside the bounds of the vector datasource.");
}
else
{
///Create bounding box for clipping geometry
Point3d min = Heron.Convert.ToWGS(boundary[i].GetBoundingBox(true).Min);
Point3d max = Heron.Convert.ToWGS(boundary[i].GetBoundingBox(true).Max);
double[] minpT = new double[3];
double[] maxpT = new double[3];
minpT[0] = min.X;
minpT[1] = min.Y;
minpT[2] = min.Z;
maxpT[0] = max.X;
maxpT[1] = max.Y;
maxpT[2] = max.Z;
revTransform.TransformPoint(minpT);
revTransform.TransformPoint(maxpT);
///Convert to OGR geometry
///TODO: add conversion from GH geometry to OGR to Convert class
OSGeo.OGR.Geometry ebbox = OSGeo.OGR.Geometry.CreateFromWkt("POLYGON((" + minpT[0] + " " + minpT[1] + ", " + minpT[0] + " " + maxpT[1] + ", " + maxpT[0] + " " + maxpT[1] + ", " + maxpT[0] + " " + minpT[1] + ", " + minpT[0] + " " + minpT[1] + "))");
///Clip Shapefile
///http://pcjericks.github.io/py-gdalogr-cookbook/vector_layers.html
///TODO: allow for polyline/curve as clipper, not just bounding box
OSGeo.OGR.Layer clipped_layer = layer;
clipped_layer.SetSpatialFilter(ebbox);
///Loop through geometry
OSGeo.OGR.Feature feat;
def = clipped_layer.GetLayerDefn();
int m = 0;
while ((feat = clipped_layer.GetNextFeature()) != null)
{
OSGeo.OGR.Geometry geom = feat.GetGeometryRef();
OSGeo.OGR.Geometry sub_geom;
///reproject geometry to WGS84
///TODO: look into using the SetCRS global variable here
geom.Transform(coordTransform);
if (feat.GetGeometryRef() != null)
{
///Start get points if open polylines and points
for (int gpc = 0; gpc < geom.GetPointCount(); gpc++)
{
///Loop through geometry points
double[] pT = new double[3];
pT[0] = geom.GetX(gpc);
pT[1] = geom.GetY(gpc);
pT[2] = geom.GetZ(gpc);
if (Double.IsNaN(geom.GetZ(gpc)))
{
pT[2] = 0;
}
//coordTransform.TransformPoint(pT);
Point3d pt3D = new Point3d();
pt3D.X = pT[0];
pt3D.Y = pT[1];
pt3D.Z = pT[2];
gset.Append(new GH_Point(Heron.Convert.ToXYZ(pt3D)), new GH_Path(i, iLayer, m));
///End loop through geometry points
/// Get Feature Values
if (fset.PathExists(new GH_Path(i, iLayer, m)))
{
fset.get_Branch(new GH_Path(i, iLayer, m)).Clear();
}
for (int iField = 0; iField < feat.GetFieldCount(); iField++)
{
OSGeo.OGR.FieldDefn fdef = def.GetFieldDefn(iField);
if (feat.IsFieldSet(iField))
{
fset.Append(new GH_String(feat.GetFieldAsString(iField)), new GH_Path(i, iLayer, m));
}
else
{
fset.Append(new GH_String("null"), new GH_Path(i, iLayer, m));
}
}
///End Get Feature Values
}
///End getting points if open polylines or points
///Start getting points if closed polylines and multipolygons
for (int gi = 0; gi < geom.GetGeometryCount(); gi++)
{
sub_geom = geom.GetGeometryRef(gi);
OSGeo.OGR.Geometry subsub_geom;
List <Point3d> geom_list = new List <Point3d>();
///trouble getting all points. this is a troubleshoot
///gset.Append(new GH_Point(new Point3d(0, 0, sub_geom.GetGeometryCount())), new GH_Path(i, iLayer, m, gi));
if (sub_geom.GetGeometryCount() > 0)
{
for (int n = 0; n < sub_geom.GetGeometryCount(); n++)
{
subsub_geom = sub_geom.GetGeometryRef(n);
for (int ptnum = 0; ptnum < subsub_geom.GetPointCount(); ptnum++)
{
///Loop through geometry points
double[] pT = new double[3];
pT[0] = subsub_geom.GetX(ptnum);
pT[1] = subsub_geom.GetY(ptnum);
pT[2] = subsub_geom.GetZ(ptnum);
Point3d pt3D = new Point3d();
pt3D.X = pT[0];
pt3D.Y = pT[1];
pt3D.Z = pT[2];
gset.Append(new GH_Point(Heron.Convert.ToXYZ(pt3D)), new GH_Path(i, iLayer, m, gi, n));
///End loop through geometry points
}
subsub_geom.Dispose();
}
}
else
{
for (int ptnum = 0; ptnum < sub_geom.GetPointCount(); ptnum++)
{
///Loop through geometry points
double[] pT = new double[3];
pT[0] = sub_geom.GetX(ptnum);
pT[1] = sub_geom.GetY(ptnum);
pT[2] = sub_geom.GetZ(ptnum);
Point3d pt3D = new Point3d();
pt3D.X = pT[0];
pt3D.Y = pT[1];
pt3D.Z = pT[2];
gset.Append(new GH_Point(Heron.Convert.ToXYZ(pt3D)), new GH_Path(i, iLayer, m, gi));
///End loop through geometry points
}
}
sub_geom.Dispose();
/// Get Feature Values
if (fset.PathExists(new GH_Path(i, iLayer, m)))
{
fset.get_Branch(new GH_Path(i, iLayer, m)).Clear();
}
for (int iField = 0; iField < feat.GetFieldCount(); iField++)
{
OSGeo.OGR.FieldDefn fdef = def.GetFieldDefn(iField);
if (feat.IsFieldSet(iField))
{
fset.Append(new GH_String(feat.GetFieldAsString(iField)), new GH_Path(i, iLayer, m));
}
else
{
fset.Append(new GH_String("null"), new GH_Path(i, iLayer, m));
}
}
///End Get Feature Values
}
//m++;
}
m++;
feat.Dispose();
} ///end while loop through features
}
} //end loop through boundaries
layer.Dispose();
}///end loop through layers
ds.Dispose();
DA.SetDataTree(0, layname);
DA.SetDataTree(1, fcs);
DA.SetDataTree(2, recs);
DA.SetDataTree(3, sRefs);
DA.SetDataTree(4, fnames);
DA.SetDataTree(5, fset);
DA.SetDataTree(6, gset);
}