//--------------------------------------------- FROM RHINO TYPES
public static GH_Curve CastFromPLine(Polyline crv)
{
GH_Curve outcv = new GH_Curve();
outcv.CastFrom(crv);
return(outcv);
}
public static Curve CastToCurve(GH_Curve c)
{
Curve crv;
c.CastTo <Curve>(out crv);
return(crv);
}
public override void DrawViewportWires(IGH_PreviewArgs args)
{
GH_Colour CurrentCrvColor;
base.DrawViewportMeshes(args);
int Thickness = CrvThickness.Value < 0 ? Math.Abs(CrvThickness.Value) : CrvThickness.Value == 0 ? 2 : CrvThickness.Value;
if (this.Hidden || this.Locked)
{
return;
}
if (this.Attributes.Selected)
{
CurrentCrvColor = new GH_Colour(Color.Green);
}
else
{
CurrentCrvColor = CrvColor;
}
for (int Index = 0; Index < CrvList.Count; Index++)
{
GH_Curve Crv = CrvList[Index];
args.Display.DrawCurve(Crv.Value, CurrentCrvColor.Value, Thickness);
}
}
/// <summary>
/// Constructor from a Grasshopper curve
/// </summary>
/// <param name="a">Grasshopper curve</param>
public RREdge(GH_Curve a)
{
this.or = false;
this.sn = new RRNode(0, a.Value.PointAtStart);
this.en = new RRNode(0, a.Value.PointAtEnd);
this.cs = null;
}
protected override void SolveInstance(IGH_DataAccess DA)
{
GH_Curve baseline = new GH_Curve();
GH_String layer = new GH_String("");
GH_Number height = new GH_Number();
GH_String style = new GH_String("");
List <Parameter> param = new List <Parameter>();
if (!DA.GetDataList <Parameter>("Parameters", param))
{
param = new List <Parameter>();
}
//DA.GetData<GH_String>("Family", ref family);
DA.GetData <GH_String>("Layer", ref layer);
DA.GetData <GH_String>("Style", ref style);
DA.GetData <GH_Number>("Height", ref height);
DA.GetData <GH_Curve>("Baseline", ref baseline);
Wall w = new Wall(style.Value, layer.Value, param, baseline.ToGrevitCurve(), "", height.Value, true, false);
SetGID(w);
Rhino.Geometry.Surface srf = Rhino.Geometry.Surface.CreateExtrusion(baseline.Value, new Rhino.Geometry.Vector3d(0, 0, height.Value));
SetPreview(w.GID, srf.ToBrep());
DA.SetData("GrevitComponent", w);
}
/// <summary>
/// Converts a polyline into a GH_Curve
/// </summary>
/// <param name="pline">The polyline to convert</param>
/// <returns>The GH_Curve</returns>
public static GH_Curve ConvertToGHCurve(Polyline pline)
{
GH_Curve ghl = new GH_Curve();
bool c = GH_Convert.ToGHCurve(pline, GH_Conversion.Both, ref ghl);
return(ghl);
}
internal static IEnumerable <IGH_Goo> PromptEdge(string prompt)
{
IGH_Goo goo = null;
try
{
var selectEdgeResult = theUI.SelectionManager.SelectTaggedObject(prompt, prompt, Selection.SelectionScope.WorkPart, Selection.SelectionAction.AllAndDisableSpecific, false, false, new Selection.MaskTriple[] { MaskTripleEx.Edge }, out var reference, out _);
if (selectEdgeResult == Selection.Response.Ok)
{
var edge = reference as Edge;
var extractedCurve = workPart.Features.CreateExtractGeometry(edge);
var nxCurve = extractedCurve.GetEntities()[0] as NXOpen.Curve;
nxCurve.RemoveParameters();
var curve = nxCurve.ToRhino();
goo = new GH_Curve(curve);
}
}
catch (Exception) { }
yield return(goo);
}
/// <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)
{
List <IGH_GeometricGoo> geometry = new List <IGH_GeometricGoo>();
Curve curve = null;
if (!DA.GetDataList(0, geometry) || !DA.GetData(1, ref curve))
{
return;
}
////////////////将于指定曲线线有关系的物件选出（Brep,Curve,Mesh）strict 选出完全重合，some 局部重合 ，all 相关联所有
List <IGH_GeometricGoo> collect = new List <IGH_GeometricGoo>();
List <int> indexes = new List <int>();
for (int i = 0; i < geometry.Count; i++)
{
IGH_GeometricGoo obj = geometry[i];
if (obj is GH_Curve)
{
GH_Curve ghcurve = (GH_Curve)obj;
if (CurveAndCurve(ghcurve.Value, curve, strict, some, all))
{
indexes.Add(i);
collect.Add(obj);
}
}
else if (obj is GH_Brep)
{
GH_Brep ghbrep = (GH_Brep)obj;
if (CurveAndBrep(ghbrep.Value, curve, strict, some, all))
{
indexes.Add(i);
collect.Add(obj);
}
}
else if (obj is GH_Surface)
{
GH_Surface ghsurface = (GH_Surface)obj;
if (CurveAndBrep(ghsurface.Value, curve, strict, some, all))
{
indexes.Add(i);
collect.Add(obj);
}
}
else if (obj is GH_Mesh)
{
GH_Mesh ghmesh = (GH_Mesh)obj;
if (CurveAndMesh(ghmesh.Value, curve, strict, some, all))
{
indexes.Add(i);
collect.Add(obj);
}
}
}
DA.SetDataList(0, collect);
DA.SetDataList(1, indexes);
}
public bool ConvertToGH_Curve <T>(ref T target)
{
var crv = ToCurve();
if (!(crv is null))
{
object obj = new GH_Curve(crv);
target = (T)obj;
return(true);
}
return(false);
}
public override bool CastTo <Q>(ref Q target)
{
if (typeof(Q).IsAssignableFrom(typeof(GH_Mesh)))
{
Mesh[] meshes = Value.GetMesh();
Mesh m = new Mesh();
for (int i = 0; i < meshes.Length; ++i)
{
m.Append(meshes[i]);
}
object mesh = new GH_Mesh(m);
target = (Q)mesh;
return(true);
}
if (typeof(Q).IsAssignableFrom(typeof(GlulamWorkpiece)))
{
object blank = Value;
target = (Q)blank;
return(true);
}
if (typeof(Q).IsAssignableFrom(typeof(GH_Brep)))
{
Brep[] breps = Value.GetBrep();
Brep b = new Brep();
for (int i = 0; i < breps.Length; ++i)
{
b.Append(breps[i]);
}
object brep = new GH_Brep(b);
target = (Q)brep;
return(true);
}
//if (typeof(Q).IsAssignableFrom(typeof(GH_)))
if (typeof(Q).IsAssignableFrom(typeof(GH_Curve)))
{
Curve[] crvs = Value.Blank.GetAllGlulams().Select(x => x.Centreline).ToArray();
//target = crvs.Select(x => new GH_Curve(x)).ToList() as Q;
object crv = new GH_Curve(crvs.FirstOrDefault());
target = (Q)(crv);
return(true);
}
if (typeof(Q).IsAssignableFrom(typeof(List <GH_Curve>)))
{
Curve[] crvs = Value.Blank.GetAllGlulams().Select(x => x.Centreline).ToArray();
//target = crvs.Select(x => new GH_Curve(x)).ToList() as Q;
object crv = crvs.Select(x => new GH_Curve(x)).ToList();
target = (Q)(crv);
return(true);
}
return(base.CastTo <Q>(ref target));
}
/// <summary>
/// Extract nodes from a tree structure with a flat hierarchy and returns grouped as nodes. NOTE: will have duplicate lines, as untrimmed.
/// </summary>
/// <param name="skeleton"></param>
/// <param name="trimLengthBase"></param>
/// <param name="trimLengthTop"></param>
/// <returns></returns>
private GH_Structure <GH_Curve> ExtractNodes(GH_Structure <GH_Curve> skeleton, double trimLengthBase, double trimLengthTop)
{
GH_Structure <GH_Curve> nodes = new GH_Structure <GH_Curve>(); //3dimensional list to preserve data structure internally
int nodeCount = 0;
for (int i = 0; i < skeleton.PathCount; i++)
{
List <GH_Curve> tempMembers = new List <GH_Curve>();
//add first member to tree
GH_Curve member0 = skeleton.get_DataItem(new GH_Path(i), 0);
tempMembers.Add(member0);
for (int j = 0; j < skeleton.PathCount; j++)
{
if (j != i) //if its not the same branch
{
//check whether last plane of branch i is the same as first plane of branch j
GH_Curve otherMember = skeleton.get_DataItem(new GH_Path(j), 0);
Vector3d distVector = member0.Value.PointAtEnd - otherMember.Value.PointAtStart;
double dist = distVector.Length;
if (dist < 0.01)
{
//if same plane, add branch
tempMembers.Add(otherMember);
}
}
}
if (tempMembers.Count > 1) //if node is actually a node that is more than just a base
{
//check if members have enough planes.
//e.g. if a member has only 1 plane, it is not enough to build a node.
bool isSufficient = true;
foreach (GH_Curve crv in tempMembers)
{
if (crv.Value.GetLength() < trimLengthTop)
{
isSufficient = false;
break;
}
}
if (isSufficient)
{
nodes.AppendRange(tempMembers, new GH_Path(nodeCount));
nodeCount++;
}
}
}
return(nodes);
}
/// <summary>
/// Solve method for ParVisCen
/// </summary>
public static GH_Point VisCen(GH_Curve ghcurve)
{
var c = ghcurve.Value;
var tt = DocumentTolerance();
Polyline plx;
if (!c.TryGetPolyline(out plx))
{
c.ToPolyline(100, 1, DocumentAngleTolerance(), tt, 0, tt, 0, 0, true).TryGetPolyline(out plx);
}
(Point3d, double)[] results = new (Point3d, double)[plx.Count];
protected override void SolveInstance(IGH_DataAccess DA)
{
GH_Curve curve = new GH_Curve();
DA.GetData <GH_Curve>("Curve", ref curve);
GH_String layer = new GH_String(string.Empty);
DA.GetData <GH_String>("Layer", ref layer);
Component c = curve.Value.ToNurbsCurve().ToGrevitCurve();
c.TypeOrLayer = layer.ToString();
SetGID(c);
DA.SetData("GrevitComponent", c);
}
/// <inheritdoc />
protected override void SolveInstance(IGH_DataAccess DA)
{
GH_Curve curve = null;
if (!DA.GetData(0, ref curve))
{
return;
}
if (!curve.Value.TryGetPolyline(out var poly))
{
throw new ArgumentException("The given curve is not a polyline.");
}
DA.SetData(0, new GH_Mesh(Mesh.CreateFromClosedPolyline(poly)));
}
protected override void SolveInstance(IGH_DataAccess DA)
{
object m_obj = null;
Mesh m_mesh = null;
bool m_faces = false;
DA.GetData("Mesh", ref m_mesh);
DA.GetData("Glulam", ref m_obj);
DA.GetData("Faces", ref m_faces);
Curve m_curve = null;
while (true)
{
GH_Glulam m_ghglulam = m_obj as GH_Glulam;
if (m_ghglulam != null)
{
m_curve = m_ghglulam.Value.Centreline;
break;
}
GH_Curve m_ghcurve = m_obj as GH_Curve;
if (m_ghcurve != null)
{
m_curve = m_ghcurve.Value;
break;
}
Glulam m_glulam = m_obj as Glulam;
if (m_glulam != null)
{
m_curve = m_glulam.Centreline;
break;
}
m_curve = m_obj as Curve;
if (m_curve != null)
{
break;
}
throw new Exception("Input must be either Glulam or Curve!");
}
List <Vector3d> deviations = m_mesh.CalculateTangentVector(m_curve, m_faces);
DA.SetDataList("Vectors", deviations);
}
protected override void SolveInstance(IGH_DataAccess DA)
{
object m_obj = null;
Mesh m_mesh = null;
double m_angle = Rhino.RhinoMath.ToRadians(5);
DA.GetData("Angle", ref m_angle);
DA.GetData("Mesh", ref m_mesh);
DA.GetData("Glulam", ref m_obj);
while (true)
{
GH_Glulam m_ghglulam = m_obj as GH_Glulam;
if (m_ghglulam != null)
{
m_mesh = m_ghglulam.Value.MapToCurveSpace(m_mesh);
break;
}
GH_Curve m_ghcurve = m_obj as GH_Curve;
if (m_ghcurve != null)
{
m_mesh = m_ghcurve.Value.MapToCurveSpace(m_mesh);
break;
}
Glulam m_glulam = m_obj as Glulam;
if (m_glulam != null)
{
m_mesh = m_glulam.MapToCurveSpace(m_mesh);
break;
}
Curve m_curve = m_obj as Curve;
if (m_curve != null)
{
m_mesh = m_curve.MapToCurveSpace(m_mesh);
break;
}
throw new Exception("Input must be either Glulam or Curve!");
}
var indices = m_mesh.CheckFibreCuttingAngle(m_angle);
DA.SetDataList("Face Indices", indices);
DA.SetData("debug", m_mesh);
}
protected override void BeforeSolveInstance()
{
ClearOutput();
curve = false;
line = false;
polyline = false;
arc = false;
circle = false;
ellipse = false;
IGH_Structure dd = Params.Input[0].VolatileData;
double tolerance = 0;
foreach (IGH_Goo number in Params.Input[1].VolatileData.AllData(true))
{
GH_Number num = (GH_Number)number;
tolerance = num.Value;
}
foreach (IGH_Goo geo in dd.AllData(true))
{
GH_Curve crv = (GH_Curve)geo;
if (crv.Value.IsLinear(tolerance))
{
line = true;
}
else if (crv.Value.IsPolyline())
{
polyline = true;
}
else if (crv.Value.IsCircle(tolerance))
{
circle = true;
}
else if (crv.Value.IsArc(tolerance))
{
arc = true;
}
else if (crv.Value.IsEllipse(tolerance))
{
ellipse = true;
}
else
{
curve = true;
}
}
AddOutput();
}
/// <summary>
/// Build curves representation with 1D tree structure. branch = one curve
/// </summary>
/// <param name="inputPlanes"></param>
/// <returns></returns>
private GH_Structure <GH_Curve> BuildStructureAsCurves(GH_Structure <GH_Plane> inputPlanes)
{
GH_Structure <GH_Curve> curves = new GH_Structure <GH_Curve>();
for (int i = 0; i < inputPlanes.PathCount; i++)
{
List <Point3d> cp = new List <Point3d>();
foreach (GH_Plane plane in inputPlanes.get_Branch(i))
{
cp.Add(plane.Value.Origin);
}
GH_Curve cv = new GH_Curve();
cv.CastFrom(Curve.CreateInterpolatedCurve(cp, 3));
curves.Append(cv, new GH_Path(i));
}
return(curves);
}
public override List <SpeckleObjectProperties> getObjectProperties(IEnumerable <object> objects)
{
var propertiesList = new List <SpeckleObjectProperties>();
var simpleProps = new List <ArchivableDictionary>();
int k = 0;
foreach (object o in objects)
{
CommonObject myObj = null;
GH_Brep brep = o as GH_Brep;
if (brep != null)
{
myObj = brep.Value;
}
GH_Surface srf = o as GH_Surface;
if (srf != null)
{
myObj = srf.Value;
}
GH_Mesh mesh = o as GH_Mesh;
if (mesh != null)
{
myObj = mesh.Value;
}
GH_Curve crv = o as GH_Curve;
if (crv != null)
{
myObj = crv.Value;
}
if (myObj != null)
{
if (myObj.UserDictionary.Keys.Length > 0)
{
propertiesList.Add(new SpeckleObjectProperties(k, myObj.UserDictionary));
}
}
k++;
}
return(propertiesList);
}
private GH_Structure <IGH_Goo> SingleDataStructrue(object value)
{
if (value is string path)
{
if (File.Exists(path) && Path.GetExtension(path) == ".noahdata")
{
byte[] array;
try
{
array = File.ReadAllBytes(path);
}
catch
{
return(null);
}
return(IO.DeserializeGrasshopperData(array));
}
}
GH_Structure <IGH_Goo> m_data = new GH_Structure <IGH_Goo>();
GH_Number castNumber = null;
GH_String castString = null;
GH_Curve castCurve = null;
if (GH_Convert.ToGHCurve(value, GH_Conversion.Both, ref castCurve))
{
m_data.Append(new GH_ObjectWrapper(castCurve));
}
else if (GH_Convert.ToGHNumber(value, GH_Conversion.Both, ref castNumber))
{
m_data.Append(new GH_ObjectWrapper(castNumber));
}
else if (GH_Convert.ToGHString(value, GH_Conversion.Both, ref castString))
{
m_data.Append(new GH_ObjectWrapper(castString));
}
else
{
m_data.Append((IGH_Goo)value);
}
return(m_data);
}
public static GH_Structure <GH_Curve> MakeTreeForWays(Dictionary <OSMTag, List <PolylineCurve> > foundWays)
{
var output = new GH_Structure <GH_Curve>();
var i = 0;
foreach (var entry in foundWays)
{
for (int j = 0; j < entry.Value.Count; j++)
{
GH_Path path = new GH_Path(i, j); // Need to ensure even an empty path exists to enable data matching
output.EnsurePath(path); // Need to ensure even an empty path exists to enable data matching
GH_Curve lineForPath = new GH_Curve(entry.Value[j]);
output.Append(lineForPath, path);
}
i++;
}
return(output);
}
public override void DrawViewportWires(IGH_PreviewArgs args)
{
if (Locked || args.Document.PreviewMode == GH_PreviewMode.Disabled)
{
return; //跳过锁定或非线框模式
}
List <GH_Colour> colour = ((GH_Structure <GH_Colour>)Params.Output[0].VolatileData).FlattenData();
List <GH_Curve> curve = ((GH_Structure <GH_Curve>)Params.Input[0].VolatileData).FlattenData();
for (int i = 0; i < colour.Count; i++)
{
GH_Curve cu = curve[i];
bool set = Attributes.GetTopLevel.Selected;
if (cu.IsValid)
{
args.Display.DrawCurve(cu.Value, set ? args.WireColour_Selected : colour[i].Value);
}
}
}
internal static IEnumerable <IGH_Goo> PromptEdge(UIDocument doc, string prompt)
{
IGH_Goo goo = null;
try
{
var reference = doc.Selection.PickObject(ObjectType.Edge, prompt);
if (reference != null)
{
var element = doc.Document.GetElement(reference);
var edge = element.GetGeometryObjectFromReference(reference) as Edge;
var curve = edge.AsCurve().ToCurve();
goo = new GH_Curve(curve);
}
}
catch (Autodesk.Revit.Exceptions.OperationCanceledException) { }
yield return(goo);
}
public override void BakeGeometry(RhinoDoc doc, ObjectAttributes att, List <Guid> obj_ids)
{
List <GH_Colour> colour = ((GH_Structure <GH_Colour>)Params.Output[0].VolatileData).FlattenData();
List <GH_Curve> curve = ((GH_Structure <GH_Curve>)Params.Input[0].VolatileData).FlattenData();
for (var i = 0; i < curve.Count; i++)
{
GH_Curve c = curve[i];
if (!c.IsValid)
{
continue;
}
ObjectAttributes oa = att.Duplicate();
oa.ColorSource = ObjectColorSource.ColorFromObject;
oa.ObjectColor = colour[i].Value;
Guid id = Guid.Empty;
c.BakeGeometry(doc, oa, ref id);
obj_ids.Add(id);
}
}
public static GH_Curve ProjectPolylineToTopo(Mesh topoMesh, Polyline pLine)
{
GH_Curve ghCurve = new GH_Curve();
List <Point3d> projectedPts = new List <Point3d>();
for (int j = 0; j < pLine.Count; j++)
{
Ray3d ray = new Ray3d(pLine[j], moveDir);
double t = Rhino.Geometry.Intersect.Intersection.MeshRay(topoMesh, ray);
if (t >= 0.0)
{
projectedPts.Add(ray.PointAt(t));
}
else
{
Ray3d rayOpp = new Ray3d(pLine[j], -moveDir);
double tOpp = Rhino.Geometry.Intersect.Intersection.MeshRay(topoMesh, rayOpp);
if (tOpp >= 0.0)
{
projectedPts.Add(rayOpp.PointAt(tOpp));
}
else
{
//return null;
}
}
}
Polyline pLineOut = new Polyline(projectedPts);
if (pLineOut.IsValid)
{
GH_Convert.ToGHCurve(pLineOut.ToNurbsCurve(), GH_Conversion.Primary, ref ghCurve);
return(ghCurve);
}
else
{
return(null);
}
}
public static bool CastCurveTo <Q>(Rhino.Geometry.Curve curve, out Q target)
{
if (curve != null)
{
// cast to GH_Curve (Caution: this loses all structural information)
if (typeof(Q).IsAssignableFrom(typeof(GH_Curve)))
{
var gc = new GH_Curve(curve);
target = (Q)(object)gc;
return(true);
}
// cast to GH_Line (Caution: this loses all structural information)
else if (typeof(Q).IsAssignableFrom(typeof(GH_Line)))
{
if (curve is Rhino.Geometry.LineCurve)
{
var gl = new GH_Line((curve as Rhino.Geometry.LineCurve).Line);
target = (Q)(object)gl;
return(true);
}
}
// cast to GH_Arc (Caution: this loses all structural information)
else if (typeof(Q).IsAssignableFrom(typeof(GH_Arc)))
{
if (curve is Rhino.Geometry.ArcCurve)
{
var ga = new GH_Arc((curve as Rhino.Geometry.ArcCurve).Arc);
target = (Q)(object)ga;
return(true);
}
}
else
{
throw new Exception("Unable to cast to type: " + typeof(Q).ToString());
}
}
target = default(Q);
return(false);
}
protected override void SolveInstance(IGH_DataAccess DA)
{
IGH_GeometricGoo g = null;
DA.GetData <IGH_GeometricGoo>(0, ref g);
string geoType = g.TypeName;
string name = null;
DA.GetData(1, ref name);
bool activate = false;
DA.GetData(2, ref activate);
Rhino.DocObjects.ObjectAttributes atts = new Rhino.DocObjects.ObjectAttributes();
string newID = null;
atts.Name = name;
if (activate)
{
GH_Point p = g as GH_Point;
if (p != null)
{
GeometryBase geo = GH_Convert.ToGeometryBase(p);
newID = RhinoDoc.ActiveDoc.Objects.Add(geo, atts).ToString();
}
GH_Curve c = g as GH_Curve;
if (c != null)
{
GeometryBase geo = GH_Convert.ToGeometryBase(c);
newID = RhinoDoc.ActiveDoc.Objects.Add(geo, atts).ToString();
}
}
DA.SetData(0, newID);
}
/// <summary>
/// Path[0] = joint; Path[1] = member
/// </summary>
/// <param name="inputPlanes"></param>
/// <returns></returns>
private GH_Structure <GH_Curve> BuildStructureAsCurves()
{
GH_Structure <GH_Curve> curves = new GH_Structure <GH_Curve>();
for (int i = 0; i < Utility.GetMainBranchCount(inputPlanes.Paths); i++)
{
int subBranchCount = Utility.GetSecondaryBranchCount(inputPlanes.Paths, i);
for (int j = 0; j < subBranchCount; j++)
{
GH_Path path = new GH_Path(i, j);
List <Point3d> cp = new List <Point3d>();
foreach (GH_Plane plane in inputPlanes.get_Branch(path))
{
cp.Add(plane.Value.Origin);
}
GH_Curve cv = new GH_Curve();
cv.CastFrom(Curve.CreateInterpolatedCurve(cp, 3));
curves.Append(cv, path);
}
}
return(curves);
}
public override bool CastTo <Q>(ref Q target)
{
if (typeof(Q).IsAssignableFrom(typeof(Feature)))
{
object blank = Value;
target = (Q)blank;
return(true);
}
else if (typeof(Q).IsAssignableFrom(typeof(GH_Brep)))
{
object blank = new GH_Brep(Value.ToBrep());
target = (Q)blank;
return(true);
}
if (typeof(Q).IsAssignableFrom(typeof(GH_Curve)))
{
object cl = new GH_Curve(Value.ToNurbsCurve());
target = (Q)cl;
return(true);
}
return(base.CastTo <Q>(ref target));
}
protected override void SolveInstance(IGH_DataAccess DA)
{
GH_Curve baseline = new GH_Curve();
GH_String layer = new GH_String("");
GH_Number height = new GH_Number();
GH_String style = new GH_String("");
List<Parameter> param = new List<Parameter>();
if (!DA.GetDataList<Parameter>("Parameters", param)) param = new List<Parameter>();
//DA.GetData<GH_String>("Family", ref family);
DA.GetData<GH_String>("Layer", ref layer);
DA.GetData<GH_String>("Style", ref style);
DA.GetData<GH_Number>("Height", ref height);
DA.GetData<GH_Curve>("Baseline", ref baseline);
Wall w = new Wall(style.Value,layer.Value,param, baseline.ToGrevitCurve(),"",height.Value,true,false);
SetGID(w);
Rhino.Geometry.Surface srf = Rhino.Geometry.Surface.CreateExtrusion(baseline.Value, new Rhino.Geometry.Vector3d(0, 0, height.Value));
SetPreview(w.GID, srf.ToBrep());
DA.SetData("GrevitComponent",w);
}
public static GH_Structure <GH_Curve> GetJoined(IList <Brep> inBreps)
{
GH_Structure <GH_Curve> joinedCurves = new GH_Structure <GH_Curve>();
for (int i = 0; i < inBreps.Count; i++)
{
GH_Path path = new GH_Path(i);
Brep brep = inBreps[i];
List <Curve> curvesToAdd = new List <Curve>();
curvesToAdd.AddRange(BrepBorderExtractor.GetJoined(brep));
foreach (Curve curve in curvesToAdd)
{
GH_Curve ghCurve = null;
if (GH_Convert.ToGHCurve(curve, GH_Conversion.Both, ref ghCurve))
{
joinedCurves.Append(ghCurve, path);
}
}
}
return(joinedCurves);
}
/// <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)
{
#region INPUTS
// import silkwormSettings file
List<string> silkwormSettings = new List<string>();
if (!DA.GetDataList(0, silkwormSettings)) return;
List<GH_ObjectWrapper> things = new List<GH_ObjectWrapper>();
if (!DA.GetDataList(1, things)) return;
// import Silkworm Movement
#endregion
SilkwormUtility sUtil = new SilkwormUtility();
Dictionary<string, string> Settings = sUtil.convertSettings(silkwormSettings);
#region Optional Variables
int shell = -999;
if (!DA.GetData(4, ref shell)) { }
double layerheight = -999;
if (!DA.GetData(3, ref layerheight)) { }
//bool detect = false;
//if (!DA.GetData(5, ref detect)) { }
List<Plane> sliceplanes = new List<Plane>();
if (!DA.GetDataList(2, sliceplanes)) { }
if (shell == -999)
{
shell = int.Parse(Settings["perimeters"]);
}
if (layerheight == -999)
{
layerheight = double.Parse(Settings["layer_height"]);
}
if (sliceplanes.Count<1)
{
sliceplanes.Add(Plane.WorldXY);
}
#endregion
List<Brep> Breps = new List<Brep>();
List<Mesh> Meshes = new List<Mesh>();
SilkwormSkein skein = new SilkwormSkein();
#region Sort Types
foreach (GH_ObjectWrapper obj in things)
{
if (obj.Value is GH_Brep)
{
Brep brep = null;
GH_Convert.ToBrep(obj.Value, ref brep, GH_Conversion.Both);
Breps.Add(brep);
continue;
}
if (obj.Value is GH_Mesh)
{
Mesh mesh = null;
GH_Convert.ToMesh(obj.Value, ref mesh, GH_Conversion.Both);
Meshes.Add(mesh);
continue;
}
}
#endregion
if (Breps.Count>0)
{
skein = new SilkwormSkein(Settings, Breps, sliceplanes, shell, layerheight);
skein.BrepSlice(false);
}
if (Meshes.Count > 0)
{
//TODO
}
//Reflect Errors and Warnings
foreach (string message in skein.ErrorMessages)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, message);
}
foreach (string message in skein.WarningMessages)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, message);
}
List<Curve>[] openregions = skein.openRegions;
List<Brep>[] rRegions = skein.Regions;
List<Brep>[] rPerimeterR = skein.regionPerimeter;
List<Brep>[] rInfillR = skein.regionInfill;
GH_Structure<GH_Brep> Regions = new GH_Structure<GH_Brep>();
GH_Structure<GH_Curve> openRegions = new GH_Structure<GH_Curve>();
#region Add Regions to GH_Structure
if (rRegions.GetUpperBound(0) > 1)
{
for (int i = 0; i < rRegions.Length; i++)
{
if (rRegions[i] != null)
{
for (int j = 0; j < rRegions[i].Count; j++)
{
GH_Brep gShapes = new GH_Brep(rRegions[i][j]);
Regions.Insert(gShapes, new GH_Path(i, 0), j);
}
}
}
}
if (rPerimeterR.GetUpperBound(0) > 1)
{
for (int i = 0; i < rPerimeterR.Length; i++)
{
if (rPerimeterR[i] != null)
{
for (int j = 0; j < rPerimeterR[i].Count; j++)
{
GH_Brep gShapes = new GH_Brep(rPerimeterR[i][j]);
Regions.Insert(gShapes, new GH_Path(i, 1), j);
}
}
}
}
if (rInfillR.GetUpperBound(0) > 1)
{
for (int i = 0; i < rInfillR.Length; i++)
{
if (rInfillR[i] != null)
{
for (int j = 0; j < rInfillR[i].Count; j++)
{
GH_Brep gShapes = new GH_Brep(rInfillR[i][j]);
Regions.Insert(gShapes, new GH_Path(i, 2), j);
}
}
}
}
if (openregions.GetUpperBound(0) > 1)
{
for (int i = 0; i < openregions.Length; i++)
{
if (openregions[i] != null)
{
for (int j = 0; j < openregions[i].Count; j++)
{
GH_Curve gShapes = new GH_Curve(openregions[i][j]);
openRegions.Insert(gShapes, new GH_Path(i), j);
}
}
}
}
//TODO
//Add Overhang and Bridges
#endregion
#region Add Open Regions to GH_Structure
if (openregions.GetUpperBound(0) > 1)
{
for (int i = 0; i < openregions.Length; i++)
{
for (int j = 0; j < openregions[i].Count; j++)
{
if (openregions[i][j] != null)
{
SilkwormSegment segment = new SilkwormSegment(openregions[i][j]);
Curve curve = segment.Pline.ToNurbsCurve();
GH_Curve gShapes = new GH_Curve(curve);
openRegions.Insert(gShapes, new GH_Path(i), j);
}
}
}
}
#endregion
#region OUTPUT
if (!DA.SetDataTree(0, Regions)) { return; }
if (!DA.SetDataTree(1, openRegions)) { return; }
#endregion
}
/// <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)
{
#region INPUTS
// import silkwormSettings file
List<string> silkwormSettings = new List<string>();
if (!DA.GetDataList(0, silkwormSettings)) return;
List<Brep> things = new List<Brep>();
if (!DA.GetDataList(1, things)) return;
// import Silkworm Movement
SilkwormUtility sUtil = new SilkwormUtility();
Dictionary<string, string> Settings = sUtil.convertSettings(silkwormSettings);
SilkwormCalculator calc = new SilkwormCalculator(Settings);
#region Optional Inputs
int infType = 0;
if (!DA.GetData(2, ref infType)) { }
List<double> spacing = new List<double>();
if (!DA.GetDataList(3, spacing)) { }
List<double> infDens = new List<double>();
if (!DA.GetDataList(4, infDens)) { }
List<double> infRot = new List<double>();
if (!DA.GetDataList(5, infRot)) { }
#endregion
if (spacing.Count<1)
{
spacing.Add(0.66);
//TODO Calculator
}
if (infDens.Count < 1)
{
infDens.Add(double.Parse(Settings["fill_density"]));
}
if (infRot.Count < 1)
{
infRot.Add(double.Parse(Settings["fill_angle"]));
}
#endregion
SilkwormSkein skein = new SilkwormSkein(Settings, things);
//Switch depending on which infill type is selected by input
if (infType == 0)
{
//Match length of data
if (spacing.Count != things.Count)
{
List<double> newspacing = new List<double>();
for (int e = 0; e < things.Count; e++)
{
newspacing.Add(spacing[0]);
}
spacing = newspacing;
}
skein.Skinner(spacing);
}
if (infType == 1)
{
//Match length of data
if (infDens.Count != things.Count)
{
List<double> newinfDens = new List<double>();
for (int e = 0; e < things.Count; e++)
{
newinfDens.Add(infDens[0]);
}
spacing = newinfDens;
}
if (infRot.Count != things.Count)
{
List<double> newinfRot = new List<double>();
for (int e = 0; e < things.Count; e++)
{
newinfRot.Add(infRot[0]);
}
spacing = newinfRot;
}
skein.Filler(infDens, infRot);
}
//Reflect Errors and Warnings
foreach (string message in skein.ErrorMessages)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, message);
}
foreach (string message in skein.WarningMessages)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, message);
}
//Output Holders
List<Curve>[] plPerimeter = skein.curvePerimeter;
List<Curve>[] plInfill = skein.curveInfill;
GH_Structure<GH_Curve> InfillRegion = new GH_Structure<GH_Curve>();
//Create GH_Structure
#region Create Structure from Curves
if (plPerimeter.Length > 0)
{
for (int i = 0; i < plPerimeter.Length; i++)
{
if (plPerimeter[i] != null)
{
for (int j = 0; j < plPerimeter[i].Count; j++)
{
Curve aShape = plPerimeter[i][j].ToNurbsCurve();
GH_Curve gShapes = new GH_Curve(aShape);
InfillRegion.Insert(gShapes, new GH_Path(i, 0), j);
//}
}
}
}
}
if (plInfill.Length > 0)
{
for (int i = 0; i < plInfill.Length; i++)
{
if (plInfill[i] != null)
{
for (int j = 0; j < plInfill[i].Count; j++)
{
Curve aShape = plInfill[i][j].ToNurbsCurve();
GH_Curve gShapes = new GH_Curve(aShape);
InfillRegion.Insert(gShapes, new GH_Path(i, 1), j);
}
}
}
}
#endregion
//Output
if (!DA.SetDataTree(0, InfillRegion)) { return; }
}
protected override void SolveInstance(IGH_DataAccess DA)
{
GH_Curve line = new GH_Curve();
DA.GetData<GH_Curve>("Curve", ref line);
GH_Boolean isModelLine = new GH_Boolean(false);
GH_Boolean isDetailLine = new GH_Boolean(false);
GH_Boolean isRoomBoundary = new GH_Boolean(false);
DA.GetData<GH_Boolean>("isModelLine", ref isModelLine);
DA.GetData<GH_Boolean>("isDetailLine", ref isDetailLine);
DA.GetData<GH_Boolean>("isRoomBoundary", ref isRoomBoundary);
RevitLine revitLine = new RevitLine();
revitLine.curve = line.Value.ToNurbsCurve().ToGrevitCurve();
SetGID(revitLine);
revitLine.isModelCurve = isModelLine.Value;
revitLine.isDetailCurve = isDetailLine.Value;
revitLine.isRoomBounding = isRoomBoundary.Value;
DA.SetData("GrevitComponent", revitLine);
}
protected override void SolveInstance(IGH_DataAccess DA)
{
GH_Curve baseline = new GH_Curve();
GH_Vector vector = new GH_Vector();
GH_String family = new GH_String("");
GH_String type = new GH_String("");
List<Parameter> parameters = new List<Parameter>();
if (!DA.GetDataList<Parameter>("Parameters", parameters)) parameters = new List<Parameter>();
DA.GetData<GH_Vector>("Vector", ref vector);
DA.GetData<GH_Curve>("Outline", ref baseline);
if (baseline.Value.IsPolyline() && baseline.Value.IsClosed)
{
Rhino.Geometry.Polyline pline;
if (baseline.Value.TryGetPolyline(out pline))
{
PLine plineToExtrude = new PLine();
plineToExtrude.points = new List<Grevit.Types.Point>();
foreach (Rhino.Geometry.Point3d pkt in pline)
{
plineToExtrude.points.Add(pkt.ToGrevitPoint());
}
plineToExtrude.closed = pline.IsClosed;
plineToExtrude.GID = baseline.ReferenceID.ToString();
Grevit.Types.Point extrusionVector = new Grevit.Types.Point()
{
x = vector.Value.X,
y = vector.Value.Y,
z = vector.Value.Z
};
SimpleExtrusion extrusion = new SimpleExtrusion(family.Value, type.Value, parameters, plineToExtrude, extrusionVector);
Rhino.Geometry.Surface srf = Rhino.Geometry.Surface.CreateExtrusion(baseline.Value, vector.Value);
SetGID(extrusion);
SetPreview(extrusion.GID, srf.ToBrep());
DA.SetData("GrevitComponent",extrusion);
}
}
}
protected override void SolveInstance(IGH_DataAccess DA)
{
GH_Curve baseline = new GH_Curve();
GH_String level = new GH_String("none");
GH_Number height = new GH_Number();
GH_Number offset = new GH_Number();
GH_Boolean join = new GH_Boolean(true);
GH_Boolean flip = new GH_Boolean(false);
GH_String family = new GH_String("");
GH_String type = new GH_String("none");
List<Parameter> parameters = new List<Parameter>();
if (!DA.GetDataList<Parameter>("Parameters", parameters)) parameters = new List<Parameter>();
DA.GetData<GH_Boolean>("Join", ref join);
DA.GetData<GH_String>("Type", ref type);
DA.GetData<GH_String>("Levelbottom", ref level);
DA.GetData<GH_Number>("Height", ref height);
DA.GetData<GH_Curve>("Baseline", ref baseline);
DA.GetData<GH_Boolean>("Flip", ref flip);
Wall wall = new Wall(family.Value, type.Value, parameters, baseline.ToGrevitCurve(), level.Value,height.Value,join.Value,flip.Value );
Rhino.Geometry.Surface srf = Rhino.Geometry.Surface.CreateExtrusion(baseline.Value, new Rhino.Geometry.Vector3d(0, 0, height.Value));
SetGID(wall);
SetPreview(wall.GID, srf.ToBrep());
DA.SetData("GrevitComponent", wall);
}
protected override void SolveInstance(IGH_DataAccess DA)
{
GH_Curve curve = new GH_Curve();
DA.GetData<GH_Curve>("Curve", ref curve);
GH_String layer = new GH_String(string.Empty);
DA.GetData<GH_String>("Layer", ref layer);
Component c = curve.Value.ToNurbsCurve().ToGrevitCurve();
c.TypeOrLayer = layer.ToString();
SetGID(c);
DA.SetData("GrevitComponent", c);
}
protected override void SolveInstance(IGH_DataAccess DA)
{
Types.Assembly assembly = new Types.Assembly();
DA.GetData<Types.Assembly>("Material", ref assembly);
GH_Curve curve = new GH_Curve();
GH_Number radius = new GH_Number(0);
GH_Number height = new GH_Number(0);
GH_Number width = new GH_Number(0);
Types.Profile profile = null;
if (!DA.GetData<GH_Number>("Radius", ref radius)) radius.Value = 0;
if (!DA.GetData<GH_Number>("Height", ref height)) height.Value = 0;
if (!DA.GetData<GH_Number>("Width", ref width)) width.Value = 0;
if (!DA.GetData<Types.Profile>("Profile", ref profile)) profile = null;
DA.GetData<GH_Curve>("Curve", ref curve);
double calculationVolume = 0;
if (profile != null)
{
calculationVolume = curve.Value.GetLength() * profile.Area;
drawColumn(curve.Value.PointAtStart, curve.Value.PointAtEnd, profile.Area);
}
else
{
if (radius.Value > 0)
{
drawColumn(curve.Value.PointAtStart, curve.Value.PointAtEnd, radius.Value);
calculationVolume = curve.Value.GetLength() * radius.Value * radius.Value * Math.PI;
}
else
{
drawColumn(curve.Value.PointAtStart, curve.Value.PointAtEnd, height.Value, width.Value);
calculationVolume = curve.Value.GetLength() * height.Value * width.Value;
}
}
Types.Result result = new Types.Result()
{
GlobalWarmingPotential = new Types.UnitDouble<Types.LCA.CO2e>(assembly.GlobalWarmingPotential.Value * calculationVolume),
Acidification = new Types.UnitDouble<Types.LCA.kgSO2>(assembly.Acidification.Value * calculationVolume),
DepletionOfNonrenewbles = new Types.UnitDouble<Types.LCA.MJ>(assembly.DepletionOfNonrenewbles.Value * calculationVolume),
DepletionOfOzoneLayer = new Types.UnitDouble<Types.LCA.kgCFC11>(assembly.DepletionOfOzoneLayer.Value * calculationVolume),
Eutrophication = new Types.UnitDouble<Types.LCA.kgPhostphate>(assembly.Eutrophication.Value * calculationVolume),
FormationTroposphericOzone = new Types.UnitDouble<Types.LCA.kgNOx>(assembly.FormationTroposphericOzone.Value * calculationVolume)
};
DA.SetData("LCA Result", result);
}
