/// <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)
{
///Gather GHA inputs
Curve boundary = null;
DA.GetData <Curve>(0, ref boundary);
string osmFilePath = string.Empty;
DA.GetData <string>("OSM Data Location", ref osmFilePath);
//string userSRStext = "WGS84";
//DA.GetData<string>(2, ref userSRStext);
List <string> filterWords = new List <string>();
DA.GetDataList <string>(2, filterWords);
List <string> filterKeyValue = new List <string>();
DA.GetDataList <string>(3, filterKeyValue);
Transform xformToMetric = new Transform(Rhino.RhinoMath.UnitScale(RhinoDoc.ActiveDoc.ModelUnitSystem, Rhino.UnitSystem.Meters));
Transform xformFromMetric = new Transform(Rhino.RhinoMath.UnitScale(Rhino.UnitSystem.Meters, RhinoDoc.ActiveDoc.ModelUnitSystem));
///Declare trees
Rectangle3d recs = new Rectangle3d();
GH_Structure <GH_String> fieldNames = new GH_Structure <GH_String>();
GH_Structure <GH_String> fieldValues = new GH_Structure <GH_String>();
GH_Structure <IGH_GeometricGoo> geometryGoo = new GH_Structure <IGH_GeometricGoo>();
GH_Structure <IGH_GeometricGoo> buildingGoo = new GH_Structure <IGH_GeometricGoo>();
Point3d max = new Point3d();
Point3d min = new Point3d();
if (boundary != null)
{
Point3d maxM = boundary.GetBoundingBox(true).Corner(true, false, true);
max = Heron.Convert.XYZToWGS(maxM);
Point3d minM = boundary.GetBoundingBox(true).Corner(false, true, true);
min = Heron.Convert.XYZToWGS(minM);
}
/// get extents (why is this not part of OsmSharp?)
System.Xml.Linq.XDocument xdoc = System.Xml.Linq.XDocument.Load(osmFilePath);
if (xdoc.Root.Element("bounds") != null)
{
double minlat = System.Convert.ToDouble(xdoc.Root.Element("bounds").Attribute("minlat").Value);
double minlon = System.Convert.ToDouble(xdoc.Root.Element("bounds").Attribute("minlon").Value);
double maxlat = System.Convert.ToDouble(xdoc.Root.Element("bounds").Attribute("maxlat").Value);
double maxlon = System.Convert.ToDouble(xdoc.Root.Element("bounds").Attribute("maxlon").Value);
Point3d boundsMin = Heron.Convert.WGSToXYZ(new Point3d(minlon, minlat, 0));
Point3d boundsMax = Heron.Convert.WGSToXYZ(new Point3d(maxlon, maxlat, 0));
recs = new Rectangle3d(Plane.WorldXY, boundsMin, boundsMax);
}
else
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Remark, "Cannot determine the extents of the OSM file. A 'bounds' element may not be present in the file.");
}
using (var fileStreamSource = File.OpenRead(osmFilePath))
{
/// create a source.
OsmSharp.Streams.XmlOsmStreamSource source = new OsmSharp.Streams.XmlOsmStreamSource(fileStreamSource);
/// filter by bounding box
OsmSharp.Streams.OsmStreamSource sourceClipped = source;
if (clipped)
{
sourceClipped = source.FilterBox((float)max.X, (float)max.Y, (float)min.X, (float)min.Y, true);
}
/// create a dictionary of elements
OsmSharp.Db.Impl.MemorySnapshotDb sourceMem = new OsmSharp.Db.Impl.MemorySnapshotDb(sourceClipped);
/// filter the source
var filtered = from osmGeos in sourceClipped
where osmGeos.Tags != null
select osmGeos;
if (filterWords.Any())
{
filtered = from osmGeos in filtered
where osmGeos.Tags.ContainsAnyKey(filterWords)
select osmGeos;
}
if (filterKeyValue.Any())
{
List <Tag> tags = new List <Tag>();
foreach (string term in filterKeyValue)
{
string[] kv = term.Split(',');
Tag tag = new Tag(kv[0], kv[1]);
tags.Add(tag);
}
filtered = from osmGeos in filtered
where osmGeos.Tags.Intersect(tags).Any()
select osmGeos;
}
source.Dispose();
/// loop over all objects and count them.
int nodes = 0, ways = 0, relations = 0;
foreach (OsmSharp.OsmGeo osmGeo in filtered)
{
//NODES
if (osmGeo.Type == OsmGeoType.Node)
{
OsmSharp.Node n = (OsmSharp.Node)osmGeo;
GH_Path nodesPath = new GH_Path(0, nodes);
//populate Fields and Values for each node
fieldNames.AppendRange(GetKeys(osmGeo), nodesPath);
fieldValues.AppendRange(GetValues(osmGeo), nodesPath);
//get geometry for node
Point3d nPoint = Heron.Convert.WGSToXYZ(new Point3d((double)n.Longitude, (double)n.Latitude, 0));
geometryGoo.Append(new GH_Point(nPoint), nodesPath);
//increment nodes
nodes++;
}
////////////////////////////////////////////////////////////
//WAYS
if (osmGeo.Type == OsmGeoType.Way)
{
OsmSharp.Way w = (OsmSharp.Way)osmGeo;
GH_Path waysPath = new GH_Path(1, ways);
//populate Fields and Values for each way
fieldNames.AppendRange(GetKeys(osmGeo), waysPath);
fieldValues.AppendRange(GetValues(osmGeo), waysPath);
//get polyline geometry for way
List <Point3d> wayNodes = new List <Point3d>();
foreach (long j in w.Nodes)
{
OsmSharp.Node n = (OsmSharp.Node)sourceMem.Get(OsmGeoType.Node, j);
wayNodes.Add(Heron.Convert.WGSToXYZ(new Point3d((double)n.Longitude, (double)n.Latitude, 0)));
}
PolylineCurve pL = new PolylineCurve(wayNodes);
if (pL.IsClosed)
{
//create base surface
Brep[] breps = Brep.CreatePlanarBreps(pL, DocumentTolerance());
geometryGoo.Append(new GH_Brep(breps[0]), waysPath);
}
else
{
geometryGoo.Append(new GH_Curve(pL), waysPath);
}
//building massing
if (w.Tags.ContainsKey("building") || w.Tags.ContainsKey("building:part"))
{
if (pL.IsClosed)
{
CurveOrientation orient = pL.ClosedCurveOrientation(Plane.WorldXY);
if (orient != CurveOrientation.CounterClockwise)
{
pL.Reverse();
}
Vector3d hVec = new Vector3d(0, 0, GetBldgHeight(osmGeo));
hVec.Transform(xformFromMetric);
Extrusion ex = Extrusion.Create(pL, hVec.Z, true);
IGH_GeometricGoo bldgGoo = GH_Convert.ToGeometricGoo(ex);
buildingGoo.Append(bldgGoo, waysPath);
}
}
//increment ways
ways++;
}
///////////////////////////////////////////////////////////
//RELATIONS
if (osmGeo.Type == OsmGeoType.Relation)
{
OsmSharp.Relation r = (OsmSharp.Relation)osmGeo;
GH_Path relationPath = new GH_Path(2, relations);
//populate Fields and Values for each relation
fieldNames.AppendRange(GetKeys(osmGeo), relationPath);
fieldValues.AppendRange(GetValues(osmGeo), relationPath);
List <Curve> pLines = new List <Curve>();
// start members loop
for (int mem = 0; mem < r.Members.Length; mem++)
{
GH_Path memberPath = new GH_Path(2, relations, mem);
OsmSharp.RelationMember rMem = r.Members[mem];
OsmSharp.OsmGeo rMemGeo = sourceMem.Get(rMem.Type, rMem.Id);
if (rMemGeo != null)
{
//get geometry for node
if (rMemGeo.Type == OsmGeoType.Node)
{
long memNodeId = rMem.Id;
OsmSharp.Node memN = (OsmSharp.Node)sourceMem.Get(rMem.Type, rMem.Id);
Point3d memPoint = Heron.Convert.WGSToXYZ(new Point3d((double)memN.Longitude, (double)memN.Latitude, 0));
geometryGoo.Append(new GH_Point(memPoint), memberPath);
}
//get geometry for way
if (rMem.Type == OsmGeoType.Way)
{
long memWayId = rMem.Id;
OsmSharp.Way memWay = (OsmSharp.Way)rMemGeo;
//get polyline geometry for way
List <Point3d> memNodes = new List <Point3d>();
foreach (long memNodeId in memWay.Nodes)
{
OsmSharp.Node memNode = (OsmSharp.Node)sourceMem.Get(OsmGeoType.Node, memNodeId);
memNodes.Add(Heron.Convert.WGSToXYZ(new Point3d((double)memNode.Longitude, (double)memNode.Latitude, 0)));
}
PolylineCurve memPolyline = new PolylineCurve(memNodes);
geometryGoo.Append(new GH_Curve(memPolyline.ToNurbsCurve()), memberPath);
CurveOrientation orient = memPolyline.ClosedCurveOrientation(Plane.WorldXY);
if (orient != CurveOrientation.CounterClockwise)
{
memPolyline.Reverse();
}
pLines.Add(memPolyline.ToNurbsCurve());
}
//get nested relations
if (rMem.Type == OsmGeoType.Relation)
{
///not sure if this is needed
}
}
}
//end members loop
bool allClosed = true;
foreach (Curve pc in pLines)
{
if (!pc.IsClosed)
{
allClosed = false;
}
}
if (pLines.Count > 0 && allClosed)
{
//create base surface
Brep[] breps = Brep.CreatePlanarBreps(pLines, DocumentTolerance());
geometryGoo.RemovePath(relationPath);
foreach (Brep b in breps)
{
geometryGoo.Append(new GH_Brep(b), relationPath);
//building massing
if (r.Tags.ContainsKey("building") || r.Tags.ContainsKey("building:part"))
{
Vector3d hVec = new Vector3d(0, 0, GetBldgHeight(osmGeo));
hVec.Transform(xformFromMetric);
//create extrusion from base surface
buildingGoo.Append(new GH_Brep(Brep.CreateFromOffsetFace(b.Faces[0], hVec.Z, DocumentTolerance(), false, true)), relationPath);
}
}
}
//increment relations
relations++;
} ///end relation loop
} ///end filtered loop
} ///end osm source loop
if (recs.IsValid)
{
DA.SetData(0, recs);
}
DA.SetDataTree(1, fieldNames);
DA.SetDataTree(2, fieldValues);
DA.SetDataTree(3, geometryGoo);
DA.SetDataTree(4, buildingGoo);
} ///end SolveInstance
//HATCH FILL REGION - infills a planar region with a hatching pattern
public void Filler(List <double> infDens, List <double> infRot)
{
double tolerance = 0.001;
//double overlaptol = 0.0;
double crossSecHyp = Math.Sqrt(Math.Pow(crossSec, 2) * 2);
curveInfill = new List <Curve> [planarBreps.Count];
//Create List of Infill Curves for each Planar Region
for (int u = 0; u < planarBreps.Count; u++)
{
//Rotate Plane for Filling
double rotationRad = infRot[u] * 0.0174532925;
Plane plane = Plane.WorldXY;
plane.Rotate(rotationRad, Plane.WorldXY.ZAxis);
//Create Bounding Box
Box bbox = new Box();
planarBreps[u].GetBoundingBox(plane, out bbox);
//Get Corners
Point3d[] cornerPts = bbox.GetCorners();
//Draw Parallel Lines
LineCurve baseLine = new LineCurve(cornerPts[0], cornerPts[1]);
LineCurve baseLine2 = new LineCurve(cornerPts[3], cornerPts[2]);
//int nPts = (int)Math.Round((baseLine.Line.Length/crossSec),0);
Point3d[] basePts = new Point3d[0];
Point3d[] basePts2 = new Point3d[0];
double length = baseLine.Line.Length;
double floatdivisions = length / crossSec;
double density = infDens[u];
int divisions = (int)Math.Round((floatdivisions * density));
//Divide Lines by Fill Density ratio
baseLine.DivideByCount(divisions, true, out basePts);
baseLine2.DivideByCount(divisions, true, out basePts2);
if (divisions == 0)
{
curveInfill[u] = new List <Curve>();
return;
}
Curve[][] intCurve = new Curve[basePts.Length][];
List <Curve> intCurves = new List <Curve>();
for (int i = 0; i < basePts.Length; i++)
{
LineCurve intLine = new LineCurve(basePts[i], basePts2[i]);
Point3d[] intPts = new Point3d[0];
BrepFace r_Infill = planarBreps[u].Faces[0];
Curve[] int_Curve = new Curve[0];
//Intersect Curves with Regions
Intersection.CurveBrepFace(intLine, r_Infill, tolerance, out int_Curve, out intPts);
intCurve[i] = int_Curve;
//Convert resulting Curves into LineCurves
for (int j = 0; j < int_Curve.Length; j++)
{
LineCurve line = new LineCurve(int_Curve[j].PointAtStart, int_Curve[j].PointAtEnd);
intCurve[i][j] = line;
//intCurves[j].Add(int_Curve[j]);
intCurves.Add(line);
}
}
//Rotate Array
List <Curve>[] int_Curves = RotatetoListArray(intCurve);
List <Curve> joinLines = new List <Curve>();
List <Curve> p_lines = new List <Curve>();
for (int l = 0; l < int_Curves.Length; l++)
{
for (int k = 1; k < int_Curves[l].Count; k += 2)
{
int_Curves[l][k].Reverse();
}
}
//Create a list of points for all connected lines in the infill. Do this for each seperate string of segments
for (int l = 0; l < int_Curves.Length; l++)
{
List <Point3d> plinePts = new List <Point3d>();
if (int_Curves[l].Count > 0)
{
plinePts.Add(int_Curves[l][0].PointAtStart);
for (int k = 1; k < int_Curves[l].Count; k++)
{
plinePts.Add(int_Curves[l][k - 1].PointAtEnd);
plinePts.Add(int_Curves[l][k].PointAtStart);
plinePts.Add(int_Curves[l][k].PointAtEnd);
}
PolylineCurve plCurve = new PolylineCurve(plinePts);
Curve curve = plCurve.ToNurbsCurve();
p_lines.Add(curve);
}
}
List <Curve> curve_s = p_lines;
curveInfill[u] = p_lines;
}
}
/// <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)
{
///Gather GHA inputs
Curve boundary = null;
DA.GetData <Curve>(0, ref boundary);
string osmFilePath = string.Empty;
DA.GetData <string>("OSM Data Location", ref osmFilePath);
//string userSRStext = "WGS84";
//DA.GetData<string>(2, ref userSRStext);
List <string> filterWords = new List <string>();
DA.GetDataList <string>(2, filterWords);
List <string> filterKeyValue = new List <string>();
DA.GetDataList <string>(3, filterKeyValue);
Transform xformToMetric = new Transform(scaleToMetric);
Transform xformFromMetric = new Transform(scaleFromMetric);
///Declare trees
Rectangle3d recs = new Rectangle3d();
GH_Structure <GH_String> fieldNames = new GH_Structure <GH_String>();
GH_Structure <GH_String> fieldValues = new GH_Structure <GH_String>();
GH_Structure <IGH_GeometricGoo> geometryGoo = new GH_Structure <IGH_GeometricGoo>();
GH_Structure <IGH_GeometricGoo> buildingGoo = new GH_Structure <IGH_GeometricGoo>();
Point3d max = new Point3d();
Point3d min = new Point3d();
if (boundary != null)
{
Point3d maxM = boundary.GetBoundingBox(true).Corner(true, false, true);
max = Heron.Convert.XYZToWGS(maxM);
Point3d minM = boundary.GetBoundingBox(true).Corner(false, true, true);
min = Heron.Convert.XYZToWGS(minM);
}
/// get extents (why is this not part of OsmSharp?)
System.Xml.Linq.XDocument xdoc = System.Xml.Linq.XDocument.Load(osmFilePath);
if (xdoc.Root.Element("bounds") != null)
{
double minlat = System.Convert.ToDouble(xdoc.Root.Element("bounds").Attribute("minlat").Value);
double minlon = System.Convert.ToDouble(xdoc.Root.Element("bounds").Attribute("minlon").Value);
double maxlat = System.Convert.ToDouble(xdoc.Root.Element("bounds").Attribute("maxlat").Value);
double maxlon = System.Convert.ToDouble(xdoc.Root.Element("bounds").Attribute("maxlon").Value);
Point3d boundsMin = Heron.Convert.WGSToXYZ(new Point3d(minlon, minlat, 0));
Point3d boundsMax = Heron.Convert.WGSToXYZ(new Point3d(maxlon, maxlat, 0));
recs = new Rectangle3d(Plane.WorldXY, boundsMin, boundsMax);
}
else
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Remark, "Cannot determine the extents of the OSM file. A 'bounds' element may not be present in the file. " +
"Try turning off clipping in this component's menu.");
}
using (var fileStreamSource = File.OpenRead(osmFilePath))
{
/// create a source.
OsmSharp.Streams.XmlOsmStreamSource source = new OsmSharp.Streams.XmlOsmStreamSource(fileStreamSource);
/// filter by bounding box
OsmSharp.Streams.OsmStreamSource sourceClipped = source;
if (clipped)
{
sourceClipped = source.FilterBox((float)max.X, (float)max.Y, (float)min.X, (float)min.Y, true);
}
/// create a dictionary of elements
OsmSharp.Db.Impl.MemorySnapshotDb sourceMem = new OsmSharp.Db.Impl.MemorySnapshotDb(sourceClipped);
/// filter the source
var filtered = from osmGeos in sourceClipped
where osmGeos.Tags != null
select osmGeos;
if (filterWords.Any())
{
filtered = from osmGeos in filtered
where osmGeos.Tags.ContainsAnyKey(filterWords)
select osmGeos;
}
if (filterKeyValue.Any())
{
List <Tag> tags = new List <Tag>();
foreach (string term in filterKeyValue)
{
string[] kv = term.Split(',');
Tag tag = new Tag(kv[0], kv[1]);
tags.Add(tag);
}
filtered = from osmGeos in filtered
where osmGeos.Tags.Intersect(tags).Any()
select osmGeos;
}
source.Dispose();
/// loop over all objects and count them.
int nodes = 0, ways = 0, relations = 0;
Dictionary <PolylineCurve, GH_Path> bldgOutlines = new Dictionary <PolylineCurve, GH_Path>();
List <BuildingPart> buildingParts = new List <BuildingPart>();
foreach (OsmSharp.OsmGeo osmGeo in filtered)
{
//NODES
if (osmGeo.Type == OsmGeoType.Node)
{
OsmSharp.Node n = (OsmSharp.Node)osmGeo;
GH_Path nodesPath = new GH_Path(0, nodes);
//populate Fields and Values for each node
fieldNames.AppendRange(GetKeys(osmGeo), nodesPath);
fieldValues.AppendRange(GetValues(osmGeo), nodesPath);
//get geometry for node
Point3d nPoint = Heron.Convert.WGSToXYZ(new Point3d((double)n.Longitude, (double)n.Latitude, 0));
geometryGoo.Append(new GH_Point(nPoint), nodesPath);
//increment nodes
nodes++;
}
////////////////////////////////////////////////////////////
//WAYS
if (osmGeo.Type == OsmGeoType.Way)
{
OsmSharp.Way w = (OsmSharp.Way)osmGeo;
GH_Path waysPath = new GH_Path(1, ways);
//populate Fields and Values for each way
fieldNames.AppendRange(GetKeys(osmGeo), waysPath);
fieldValues.AppendRange(GetValues(osmGeo), waysPath);
//get polyline geometry for way
List <Point3d> wayNodes = new List <Point3d>();
foreach (long j in w.Nodes)
{
OsmSharp.Node n = (OsmSharp.Node)sourceMem.Get(OsmGeoType.Node, j);
wayNodes.Add(Heron.Convert.WGSToXYZ(new Point3d((double)n.Longitude, (double)n.Latitude, 0)));
}
PolylineCurve pL = new PolylineCurve(wayNodes);
if (pL.IsClosed)
{
//create base surface
Brep[] breps = Brep.CreatePlanarBreps(pL, DocumentTolerance());
geometryGoo.Append(new GH_Brep(breps[0]), waysPath);
}
else
{
geometryGoo.Append(new GH_Curve(pL), waysPath);
}
//building massing
if ((w.Tags.ContainsKey("building") || w.Tags.ContainsKey("building:part")))// && !w.Tags.ContainsKey("construction"))
{
if (pL.IsClosed)
{
///Populate dictionary for sorting building parts later
if (w.Tags.ContainsKey("building"))
{
bldgOutlines.Add(pL, waysPath);
}
CurveOrientation orient = pL.ClosedCurveOrientation(Plane.WorldXY);
if (orient != CurveOrientation.CounterClockwise)
{
pL.Reverse();
}
///Move polylines to min height
double minHeightWay = GetMinBldgHeight(osmGeo);
Vector3d minVec = new Vector3d(0, 0, minHeightWay);
//minVec.Transform(xformFromMetric);
if (minHeightWay > 0.0)
{
var minHeightTranslate = Transform.Translation(minVec);
pL.Transform(minHeightTranslate);
}
Vector3d hVec = new Vector3d(0, 0, GetBldgHeight(osmGeo) - minHeightWay);
//hVec.Transform(xformFromMetric);
Extrusion ex = Extrusion.Create(pL, hVec.Z, true);
IGH_GeometricGoo bldgGoo = GH_Convert.ToGeometricGoo(ex);
///Save building parts for sorting later and remove part from geometry goo tree
if (w.Tags.ContainsKey("building:part"))
{
BuildingPart bldgPart = new BuildingPart(pL, bldgGoo, fieldNames[waysPath], fieldValues[waysPath], osmGeo);
buildingParts.Add(bldgPart);
fieldNames.RemovePath(waysPath);
fieldValues.RemovePath(waysPath);
geometryGoo.RemovePath(waysPath);
ways = ways - 1;
}
else
{
buildingGoo.Append(bldgGoo, waysPath);
}
}
}
//increment ways
ways++;
}
///////////////////////////////////////////////////////////
//RELATIONS
if (osmGeo.Type == OsmGeoType.Relation)
{
OsmSharp.Relation r = (OsmSharp.Relation)osmGeo;
GH_Path relationPath = new GH_Path(2, relations);
//populate Fields and Values for each relation
fieldNames.AppendRange(GetKeys(osmGeo), relationPath);
fieldValues.AppendRange(GetValues(osmGeo), relationPath);
List <Curve> pLines = new List <Curve>();
// start members loop
for (int mem = 0; mem < r.Members.Length; mem++)
{
GH_Path memberPath = new GH_Path(2, relations, mem);
OsmSharp.RelationMember rMem = r.Members[mem];
OsmSharp.OsmGeo rMemGeo = sourceMem.Get(rMem.Type, rMem.Id);
if (rMemGeo != null)
{
//get geometry for node
if (rMemGeo.Type == OsmGeoType.Node)
{
long memNodeId = rMem.Id;
OsmSharp.Node memN = (OsmSharp.Node)sourceMem.Get(rMem.Type, rMem.Id);
Point3d memPoint = Heron.Convert.WGSToXYZ(new Point3d((double)memN.Longitude, (double)memN.Latitude, 0));
geometryGoo.Append(new GH_Point(memPoint), memberPath);
}
//get geometry for way
if (rMem.Type == OsmGeoType.Way)
{
long memWayId = rMem.Id;
OsmSharp.Way memWay = (OsmSharp.Way)rMemGeo;
//get polyline geometry for way
List <Point3d> memNodes = new List <Point3d>();
foreach (long memNodeId in memWay.Nodes)
{
OsmSharp.Node memNode = (OsmSharp.Node)sourceMem.Get(OsmGeoType.Node, memNodeId);
memNodes.Add(Heron.Convert.WGSToXYZ(new Point3d((double)memNode.Longitude, (double)memNode.Latitude, 0)));
}
PolylineCurve memPolyline = new PolylineCurve(memNodes);
geometryGoo.Append(new GH_Curve(memPolyline.ToNurbsCurve()), memberPath);
CurveOrientation orient = memPolyline.ClosedCurveOrientation(Plane.WorldXY);
if (orient != CurveOrientation.CounterClockwise)
{
memPolyline.Reverse();
}
pLines.Add(memPolyline.ToNurbsCurve());
}
//get nested relations
if (rMem.Type == OsmGeoType.Relation)
{
///not sure if this is needed
}
}
}
//end members loop
bool allClosed = true;
foreach (Curve pc in pLines)
{
if (!pc.IsClosed)
{
allClosed = false;
}
}
if (pLines.Count > 0 && allClosed)
{
///Move polylines to min height
double minHeight = GetMinBldgHeight(osmGeo);
if (minHeight > 0.0)
{
Vector3d minVec = new Vector3d(0, 0, minHeight);
//minVec.Transform(xformFromMetric);
var minHeightTranslate = Transform.Translation(minVec);
for (int i = 0; i < pLines.Count; i++)
{
pLines[i].Transform(minHeightTranslate);
}
}
///Create base surface
Brep[] breps = Brep.CreatePlanarBreps(pLines, DocumentTolerance());
geometryGoo.RemovePath(relationPath);
foreach (Brep b in breps)
{
geometryGoo.Append(new GH_Brep(b), relationPath);
///Building massing
if (r.Tags.ContainsKey("building") || r.Tags.ContainsKey("building:part"))
{
Vector3d hVec = new Vector3d(0, 0, GetBldgHeight(osmGeo) - minHeight);
//hVec.Transform(xformFromMetric);
///Create extrusion from base surface
buildingGoo.Append(new GH_Brep(Brep.CreateFromOffsetFace(b.Faces[0], hVec.Z, DocumentTolerance(), false, true)), relationPath);
}
}
}
///Increment relations
relations++;
} ///End relation loop
} ///End filtered loop
///Add building parts to sub-branches under main building
for (int partIndex = 0; partIndex < buildingParts.Count; partIndex++)
{
BuildingPart bldgPart = buildingParts[partIndex];
Point3d partPoint = bldgPart.PartFootprint.PointAtStart;
partPoint.Z = 0;
bool replaceBuidingMass = false;
GH_Path mainBuildingMassPath = new GH_Path();
PolylineCurve massOutline = new PolylineCurve();
bool isRoof = bldgPart.PartOsmGeo.Tags.TryGetValue("roof:shape", out string isRoofString);
if (isRoof)
{
bldgPart.PartGoo = BldgPartToRoof(bldgPart);
}
foreach (KeyValuePair <PolylineCurve, GH_Path> pair in bldgOutlines)
{
PointContainment pc = pair.Key.Contains(partPoint, Plane.WorldXY, DocumentTolerance());
if (pc != PointContainment.Outside)
{
///Create new sub-branch
int numSubBranches = 0;
GH_Path partPath = pair.Value.AppendElement(numSubBranches);
while (buildingGoo.PathExists(partPath))
{
numSubBranches++;
partPath = pair.Value.AppendElement(numSubBranches);
}
///Add data to sub-branch
fieldNames.AppendRange(bldgPart.PartFieldNames, partPath);
fieldValues.AppendRange(bldgPart.PartFieldValues, partPath);
buildingGoo.Append(bldgPart.PartGoo, partPath);
///Remove the main building mass
replaceBuidingMass = true;
mainBuildingMassPath = pair.Value;
massOutline = pair.Key;
}
}
///Remove the main building mass
if (replaceBuidingMass)
{
buildingGoo.RemovePath(mainBuildingMassPath);
buildingGoo.Append(new GH_Curve(massOutline), mainBuildingMassPath);
}
else
{
GH_Path extrasPath = new GH_Path(3, partIndex);
buildingGoo.Append(bldgPart.PartGoo, extrasPath);
fieldNames.AppendRange(bldgPart.PartFieldNames, extrasPath);
fieldValues.AppendRange(bldgPart.PartFieldValues, extrasPath);
}
}
} ///end osm source loop
if (recs.IsValid)
{
DA.SetData(0, recs);
}
DA.SetDataTree(1, fieldNames);
DA.SetDataTree(2, fieldValues);
DA.SetDataTree(3, geometryGoo);
DA.SetDataTree(4, buildingGoo);
} ///end SolveInstance
/// <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)
{
Mesh topoMesh = new Mesh();
DA.GetData <Mesh>("Topography Mesh", ref topoMesh);
GH_Structure <IGH_GeometricGoo> featureGoo = new GH_Structure <IGH_GeometricGoo>();
DA.GetDataTree <IGH_GeometricGoo>("Feature Geometry", out featureGoo);
///Reserve one processor for GUI
totalMaxConcurrancy = System.Environment.ProcessorCount - 1;
///Tells us how many threads were using
//Message = totalMaxConcurrancy + " threads";
///Get Rtree of points and flat mesh for processing in detailed feature mesh projection
Mesh topoFlat = new Mesh();
Point3d[] topoFlatPoints = null;
RTree rTree = new RTree();
if (!fast)
{
topoFlat = topoMesh.DuplicateMesh();
for (int i = 0; i < topoFlat.Vertices.Count; i++)
{
Point3f v = topoFlat.Vertices[i];
v.Z = 0;
topoFlat.Vertices.SetVertex(i, v);
}
topoFlatPoints = topoFlat.Vertices.ToPoint3dArray();
rTree = RTree.CreateFromPointArray(topoFlatPoints);
}
///Create a dictionary that works in parallel
var gooTree = new System.Collections.Concurrent.ConcurrentDictionary <GH_Path, List <IGH_GeometricGoo> >();
///Multi-threading the loop
System.Threading.Tasks.Parallel.ForEach(featureGoo.Paths,
new System.Threading.Tasks.ParallelOptions {
MaxDegreeOfParallelism = totalMaxConcurrancy
},
pth =>
{
///Create containers for translating from GH Goo
Point3d pt = new Point3d();
Polyline pLine = null;
PolylineCurve pLineCurve = null;
Curve curve = null;
Mesh mesh = new Mesh();
Surface surface = null;
Brep brep = new Brep();
///Output container list
List <IGH_GeometricGoo> gGooList = new List <IGH_GeometricGoo>();
List <IGH_GeometricGoo> fGooList = new List <IGH_GeometricGoo>();
var branchFeatures = featureGoo.get_Branch(pth);
BoundingBox branchBox = new BoundingBox();
if (branchFeatures.Count > 0)
{
foreach (var bGoo in branchFeatures)
{
///Get geometry type(s) in branch
string geomType = string.Empty;
IGH_GeometricGoo fGoo = GH_Convert.ToGeometricGoo(bGoo);
if (fGoo != null && fGoo.IsValid)
{
if (grouped)
{
///Need to duplicate geometry or else move vector piles on similar to the following
///https://www.grasshopper3d.com/forum/topics/c-component-refresh-problem
fGooList.Add(fGoo.DuplicateGeometry());
branchBox.Union(fGoo.Boundingbox);
}
geomType = fGoo.TypeName;
switch (geomType)
{
case "Point":
fGoo.CastTo <Point3d>(out pt);
gGooList.Add(ProjectPointToTopo(topoMesh, pt));
break;
case "Line":
case "Polyline":
fGoo.CastTo <Polyline>(out pLine);
if (fast)
{
gGooList.Add(ProjectPolylineToTopo(topoMesh, pLine));
}
else
{
///Lock topoMesh so it's not accessed by mutliple threads at once in a "deadlock"
///https://docs.microsoft.com/en-us/dotnet/standard/threading/managed-threading-best-practices
lock (topoMesh)
{
gGooList.AddRange(ProjectCurveToTopo(topoMesh, pLine.ToNurbsCurve()));
}
}
break;
case "PolylineCurve":
fGoo.CastTo <PolylineCurve>(out pLineCurve);
if (fast)
{
gGooList.Add(ProjectPolylineToTopo(topoMesh, pLineCurve.ToPolyline()));
}
else
{
lock (topoMesh)
{
gGooList.AddRange(ProjectCurveToTopo(topoMesh, pLineCurve.ToNurbsCurve()));
}
}
break;
case "Curve":
fGoo.CastTo <Curve>(out curve);
if (fast)
{
if (curve.TryGetPolyline(out pLine))
{
gGooList.Add(ProjectPolylineToTopo(topoMesh, pLine));
}
else
{
gGooList.AddRange(ProjectCurveToTopo(topoMesh, curve));
}
}
else
{
lock (topoMesh)
{
gGooList.AddRange(ProjectCurveToTopo(topoMesh, curve));
}
}
break;
case "Mesh":
fGoo.CastTo <Mesh>(out mesh);
if (mesh.IsClosed)
{
gGooList.Add(ProjectSolidMeshToTopo(topoMesh, mesh));
}
else
{
if (fast)
{
gGooList.Add(ProjectMeshToTopoFast(topoMesh, mesh));
}
else
{
lock (topoMesh)
{
gGooList.Add(ProjectMeshToTopoSlow(topoMesh, topoFlat, topoFlatPoints, rTree, mesh));
}
}
}
break;
case "Surface":
fGoo.CastTo <Surface>(out surface);
gGooList.Add(ProjectSurfaceToTopoFast(topoMesh, surface));
break;
case "Brep":
fGoo.CastTo <Brep>(out brep);
gGooList.Add(ProjectBrepToTopo(topoMesh, brep));
break;
default:
AddRuntimeMessage(GH_RuntimeMessageLevel.Remark, "Not able to move " + geomType + " geometry to mesh" +
". Geometry must be a Point, Curve, Mesh, Surface or Brep.");
break;
}
}
else
{
}
}
///Move objects in branch a minimum distance if grouped selected
///If only one feature in a branch, not need to group
if (grouped && gGooList.Count > 1)
{
///Get the minimum move vector
Point3d lowestPoint = new Point3d();
double minDistance = double.MaxValue;
Vector3d minimumVec = new Vector3d();
foreach (var gi in gGooList)
{
if (gi != null)
{
Point3d gGooMin = gi.Boundingbox.Min;
Vector3d distVector = gGooMin - branchBox.Min;
if (distVector.Length < minDistance && distVector.Length > 0 && distVector.IsValid)
{
lowestPoint = gGooMin;
minDistance = distVector.Length;
minimumVec = new Vector3d(0, 0, distVector.Z);
}
}
}
///Move orignal feature geometry the minimum move vector
if (minDistance != double.MaxValue)
{
Transform transform = Transform.Translation(minimumVec);
for (int f = 0; f < fGooList.Count; f++)
{
fGooList[f].Transform(transform);
}
gooTree[pth] = fGooList;
}
}
else
{
gooTree[pth] = gGooList;
}
}
});
///End of multi-threaded loop
///Convert dictionary to regular old data tree
GH_Structure <IGH_GeometricGoo> gTree = new GH_Structure <IGH_GeometricGoo>();
foreach (KeyValuePair <GH_Path, List <IGH_GeometricGoo> > g in gooTree)
{
gTree.AppendRange(g.Value, g.Key);
}
topoFlat.Dispose();
topoMesh.Dispose();
DA.SetDataTree(0, gTree);
}
