public override bool Draw(RenderingParameters parameters)
{
if (parameters is RhinoRenderingParameters && RenderCurve != null)
{
RhinoRenderingParameters rParams = (RhinoRenderingParameters)parameters;
if (RenderCurve is RC.LineCurve && Dotted) //?
{
RC.Line line = ((RC.LineCurve)RenderCurve).Line;
if (Dotted)
{
rParams.Display.DrawDottedLine(line, Material.Diffuse);
}
else
{
rParams.Display.DrawLine(line, Material.Diffuse);
}
}
else
{
rParams.Display.DrawCurve(RenderCurve, Material.Diffuse, 3);
}
double arrS = ToRC.Convert(0.3);
if (ArrowStart)
{
rParams.Display.DrawArrowHead(RenderCurve.PointAtStart - arrS * RenderCurve.TangentAtStart, -RenderCurve.TangentAtStart, Material.Diffuse, 0, arrS);
}
if (ArrowEnd)
{
rParams.Display.DrawArrowHead(RenderCurve.PointAtEnd + arrS * RenderCurve.TangentAtEnd, RenderCurve.TangentAtEnd, Material.Diffuse, 0, arrS);
}
return(true);
}
return(false);
}
public bool MeshLineIntersect(Rhino.Geometry.Mesh x, Rhino.Geometry.Line L) //this is now for reading triangles from Rhino Mesh objects; can be eventually replaced with something, which reads OBJ mesh objects
{
//List<Point3d[]> TVs = new List<Point3d[]>();
//List of Triangle Vertices
Point3d[] TV = new Point3d[3];
//Triangle Vertices
Point3f av = default(Point3f);
Point3f bv = default(Point3f);
Point3f cv = default(Point3f);
Point3f dv = default(Point3f);
//Each face As MeshFace In x.Faces
bool does = false;
for (int k = 0; k <= x.Faces.Count - 1; k++)
{
x.Faces.GetFaceVertices(k, out av, out bv, out cv, out dv);
TV = new Point3d[] { new Point3d(av), new Point3d(bv), new Point3d(cv) };
//TVs.Add(TV);
if (TriangleLineIntersect(TV, x.FaceNormals[k], L))
{
does = true;
}
}
return(does);//TVs.Exists(Lambda => TriangleLineIntersect(Lambda, L));
}
/// <summary>
/// Returns a Windows Media Line from a Rhinocommon Line
/// </summary>
/// <param name="input">Rhinocommon Vector3d</param>
/// <returns>System Windows Vector</returns>
public static Sh.Path ToPath(this Rg.Line input)
{
Sh.Path path = new Sh.Path();
path.Data = input.ToGeometry();
return(path);
}
/// <summary>
/// Replace an existing object in the Rhino document with a line object
/// </summary>
/// <param name="obj"></param>
/// <param name="line"></param>
/// <returns></returns>
public static bool ReplaceLine(Guid obj, RC.Line line)
{
bool result = false;
Writing = true;
result = RhinoDoc.ActiveDoc.Objects.Replace(obj, line);
Writing = false;
return(result);
}
public static Rhino.Commands.Result ConstrainedCopy(Rhino.RhinoDoc doc)
{
// Get a single planar closed curve
var go = new Rhino.Input.Custom.GetObject();
go.SetCommandPrompt("Select curve");
go.GeometryFilter = Rhino.DocObjects.ObjectType.Curve;
go.GeometryAttributeFilter = Rhino.Input.Custom.GeometryAttributeFilter.ClosedCurve;
go.Get();
if (go.CommandResult() != Rhino.Commands.Result.Success)
{
return(go.CommandResult());
}
var objref = go.Object(0);
var base_curve = objref.Curve();
var first_point = objref.SelectionPoint();
if (base_curve == null || !first_point.IsValid)
{
return(Rhino.Commands.Result.Cancel);
}
Rhino.Geometry.Plane plane;
if (!base_curve.TryGetPlane(out plane))
{
return(Rhino.Commands.Result.Cancel);
}
// Get a point constrained to a line passing through the initial selection
// point and parallel to the plane's normal
var gp = new Rhino.Input.Custom.GetPoint();
gp.SetCommandPrompt("Offset point");
gp.DrawLineFromPoint(first_point, true);
var line = new Rhino.Geometry.Line(first_point, first_point + plane.Normal);
gp.Constrain(line);
gp.Get();
if (gp.CommandResult() != Rhino.Commands.Result.Success)
{
return(gp.CommandResult());
}
var second_point = gp.Point();
Rhino.Geometry.Vector3d vec = second_point - first_point;
if (vec.Length > 0.001)
{
var xf = Rhino.Geometry.Transform.Translation(vec);
Guid id = doc.Objects.Transform(objref, xf, false);
if (id != Guid.Empty)
{
doc.Views.Redraw();
return(Rhino.Commands.Result.Success);
}
}
return(Rhino.Commands.Result.Cancel);
}
//Gets all the members in the model and bakes them as breps to the rhino.
public static Tuple <Member[], Dlubal.RFEM5.CrossSection[]> GetMembers(string comment)
{
OpenConnection();
try
{
IModelData rData = RModel.GetModelData();
Dlubal.RFEM5.Line[] lines = rData.GetLines();
Dlubal.RFEM5.CrossSection[] crossSecs = rData.GetCrossSections();
Member[] members = rData.GetMembers();
members = members.Where(o => o.Comment == comment).ToArray();
List <Member> mList = new List <Member>();
Dictionary <int, Brep> rCrossSecs = new Dictionary <int, Brep>();
foreach (Dlubal.RFEM5.CrossSection crossSec in crossSecs)
{
rCrossSecs.Add(crossSec.No, GetCrscDBShape(crossSec.TextID));
}
foreach (Member member in members)
{
Dlubal.RFEM5.Line line = rData.GetLine(member.LineNo, ItemAt.AtNo).GetData();
Rhino.Geometry.Line rhLine = lineRfemToRhino(line, rData);
Vector3d direction = new Vector3d(rhLine.To - rhLine.From);
Plane plane = new Plane(rhLine.From, direction);
Brep tempCross = (Brep)rCrossSecs[member.StartCrossSectionNo].Duplicate();
Transform tr = Transform.PlaneToPlane(Plane.WorldXY, plane);
tempCross.Transform(tr);
Brep extruded = tempCross.Faces[0].CreateExtrusion(rhLine.ToNurbsCurve(), true);
ProjectPlugIn.Instance.beamBreps.Add(Tuple.Create(member.No, extruded));
}
foreach (Member m in members)
{
Dlubal.RFEM5.CrossSection c = Array.Find(crossSecs, o => o.No == m.StartCrossSectionNo);
if (c.TextID.Split(' ')[0] == "Rechteck" || c.TextID.Split(' ')[0] == "Kreis")
{
mList.Add(m);
}
}
CloseConnection();
return(Tuple.Create(mList.ToArray(), crossSecs));
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, ex.Source, MessageBoxButtons.OK, MessageBoxIcon.Error);
//Cleans Garbage collector for releasing all COM interfaces and objects
System.GC.Collect();
System.GC.WaitForPendingFinalizers();
CloseConnection();
}
return(Tuple.Create <Member[], Dlubal.RFEM5.CrossSection[]>(null, null));
}
public bool TriangleLineIntersect(Rhino.Geometry.Point3d[] Vx, Rhino.Geometry.Line L)
{
if (Vx.Length != 3)
{
throw new Exception("Triangle is not valid!");
}
Point3d O = Vx[0];
Vector3d U = Vx[1] - O;
Vector3d V = Vx[2] - O;
Vector3d N = Vector3d.CrossProduct(U, V);
//plane normal
Point3d PS = L.From; //start point of the line
Point3d PE = L.To; //end point of the line
double Nomin = ((O - PS) * N);
//operator * for dot product
double Denom = N * (PE - PS);
// only if the line is not paralell to the plane containing triangle T
if (Denom != 0)
{
double alpha = Nomin / Denom;
// parameter along the line where it intersects the plane in question, only if not paralell to the plane
Point3d P = PS + alpha * (PE - PS);
//L.PointAt(alpha) '
Vector3d W = P - O;
double UU = U * U;
double VV = V * V;
double UV = U * V;
double WU = W * U;
double WV = W * V;
double STDenom = Math.Pow(UV, 2) - UU * VV;
double s = (UV * WV - VV * WU) / STDenom;
double t = (UV * WU - UU * WV) / STDenom;
Point3d Point = O + s * U + t * V;
if (s >= 0 & t >= 0 & s + t <= 1)
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
private static Rhino.Geometry.Line lineRfemToRhino(Dlubal.RFEM5.Line line, IModelData rData)
{
Point3D point1 = line.ControlPoints[0];
Point3D point2 = line.ControlPoints[line.ControlPoints.Length - 1];
Rhino.Geometry.Line rhLine = new Rhino.Geometry.Line(new Point3d(point1.X, point1.Y, point1.Z),
new Point3d(point2.X, point2.Y, point2.Z));
return(rhLine);
}
/***************************************************/
public static bool IsEqual(this BHG.Line bhLine, RHG.Line rhLine, double tolerance = BHG.Tolerance.Distance)
{
if (bhLine == null & rhLine == default(RHG.Line))
{
return(true);
}
return(bhLine.Start.IsEqual(rhLine.PointAt(0), tolerance) &&
bhLine.End.IsEqual(rhLine.PointAt(1), tolerance));
}
/// <summary>
/// Convert a Rhino line to a Nucleus one
/// </summary>
/// <param name="line">The line to be converted</param>
/// <returns>A new line if the input is valid, else null</returns>
public static Line Convert(RC.Line line)
{
if (line.IsValid)
{
return(new Line(Convert(line.From), Convert(line.To)));
}
else
{
return(null);
}
}
// Casting to GH Data Types
public bool ConvertToGH_Line <T>(ref T target)
{
if ((NodeCount == 2) && (Type == LineType.PolylineType))
{
Rhino.Geometry.Line pline = new Rhino.Geometry.Line(ControlPoints[0], ControlPoints[1]);
object obj = new GH_Line(pline);
target = (T)obj;
return(true);
}
return(false);
}
//Create Bottom and Top Chord Pts
public static List <List <Point3d> > TrussPtsFromLines(Curve PCCurve, Curve SCCurve, int Segments, int ForceVert)
{
List <List <Point3d> > ChordPts = new List <List <Point3d> >();
//Check if truss is planar
//define Primary and Secondary cord points
List <Point3d> PCPts = new List <Point3d>();
List <Point3d> SCPts = new List <Point3d>();
//Create PC Points
Point3d[] PCPtArray = new Point3d[] { };
var t = PCCurve.DivideByCount(Segments, true, out PCPtArray);
PCPts = PCPtArray.ToList();
//splits boths curves evenly and joins lines
if (ForceVert == 0)
{
Point3d[] SCPtArray = new Point3d[] { };
var breaks = SCCurve.DivideByCount(Segments, true, out SCPtArray);
SCPts = SCPtArray.ToList();
}
//Creates points on SC curve based on verticals to a directions z,x,y defualt to y for now.
else if (ForceVert == 1)
{
foreach (Point3d pt in PCPts)
{
//create temp line for intersection. <<<This needs improvement>>>!!!
Point3d tempPT = pt;
tempPT.Y = pt.Y + 5;
Line tempLine = new Rhino.Geometry.Line(pt, tempPT);
//intersection event
var tempevent = Rhino.Geometry.Intersect.Intersection.CurveCurve(SCCurve, tempLine.ToNurbsCurve(), 0.001, 0.001);
SCPts.Add(tempevent[0].PointA);
}
}
//splits PC curves evenly and produces verticals perpendicular to the line
//else if(ForceVert == 2)
//{}
ChordPts.Add(PCPts);
ChordPts.Add(SCPts);
return(ChordPts);
}
public static string ToSVG(this Hp.Geometry input)
{
string path = string.Empty;
switch (input.CurveType)
{
case Geometry.CurveTypes.Arc:
Rg.Arc arc = new Rg.Arc();
input.Curve.TryGetArc(out arc);
path = arc.ToSVG();
break;
case Geometry.CurveTypes.Circle:
Rg.Circle circle = new Rg.Circle();
input.Curve.TryGetCircle(out circle);
path = circle.ToSVG();
break;
case Geometry.CurveTypes.Ellipse:
Rg.Ellipse ellipse = new Rg.Ellipse();
input.Curve.TryGetEllipse(out ellipse);
path = ellipse.ToSVG();
break;
case Geometry.CurveTypes.Line:
Rg.Line line = new Rg.Line(input.Curve.PointAtStart, input.Curve.PointAtEnd);
path = line.ToSVG();
break;
case Geometry.CurveTypes.Polyline:
Rg.Polyline polyline = new Rg.Polyline();
input.Curve.TryGetPolyline(out polyline);
path = polyline.ToSVG();
break;
case Geometry.CurveTypes.Rectangle:
Rg.Polyline pline = new Rg.Polyline();
input.Curve.TryGetPolyline(out pline);
path = pline.ToSVG();
break;
default:
path = input.Curve.ToSVG();
break;
}
return(path);
}
public static Sm.Geometry ToGeometry(this Geometry input)
{
Sm.Geometry geometry = null;
switch (input.CurveType)
{
case Geometry.CurveTypes.Arc:
Rg.Arc arc = new Rg.Arc();
input.Curve.TryGetArc(out arc);
geometry = arc.ToGeometry();
break;
case Geometry.CurveTypes.Circle:
Rg.Circle circle = new Rg.Circle();
input.Curve.TryGetCircle(out circle);
geometry = circle.ToGeometry();
break;
case Geometry.CurveTypes.Ellipse:
Rg.Ellipse ellipse = new Rg.Ellipse();
input.Curve.TryGetEllipse(out ellipse);
geometry = ellipse.ToGeometry();
break;
case Geometry.CurveTypes.Line:
Rg.Line line = new Rg.Line(input.Curve.PointAtStart, input.Curve.PointAtEnd);
geometry = line.ToGeometry();
break;
case Geometry.CurveTypes.Polyline:
Rg.Polyline polyline = new Rg.Polyline();
input.Curve.TryGetPolyline(out polyline);
geometry = polyline.ToGeometry();
break;
case Geometry.CurveTypes.Rectangle:
Rg.Polyline pline = new Rg.Polyline();
input.Curve.TryGetPolyline(out pline);
Rg.Rectangle3d rectangle = new Rg.Rectangle3d(Rg.Plane.WorldXY, pline[0], pline[2]);
geometry = rectangle.ToGeometry();
break;
default:
geometry = input.Curve.ToGeometry();
break;
}
return(geometry);
}
public static Rhino.Commands.Result LineBetweenCurves(Rhino.RhinoDoc doc)
{
Rhino.Input.Custom.GetObject go = new Rhino.Input.Custom.GetObject();
go.SetCommandPrompt("Select two curves");
go.GeometryFilter = Rhino.DocObjects.ObjectType.Curve;
go.GetMultiple(2, 2);
if (go.CommandResult() != Rhino.Commands.Result.Success)
{
return(go.CommandResult());
}
Rhino.DocObjects.ObjRef objRef0 = go.Object(0);
Rhino.DocObjects.ObjRef objRef1 = go.Object(1);
double t0 = Rhino.RhinoMath.UnsetValue;
double t1 = Rhino.RhinoMath.UnsetValue;
Rhino.Geometry.Curve curve0 = objRef0.CurveParameter(out t0);
Rhino.Geometry.Curve curve1 = objRef1.CurveParameter(out t1);
if (null == curve0 || !Rhino.RhinoMath.IsValidDouble(t0) ||
null == curve1 || !Rhino.RhinoMath.IsValidDouble(t1))
{
return(Rhino.Commands.Result.Failure);
}
Rhino.Geometry.Line line = Rhino.Geometry.Line.Unset;
bool rc = Rhino.Geometry.Line.TryCreateBetweenCurves(curve0, curve1, ref t0, ref t1, false, false, out line);
if (rc)
{
if (Guid.Empty != doc.Objects.AddLine(line))
{
doc.Views.Redraw();
return(Rhino.Commands.Result.Success);
}
}
return(Rhino.Commands.Result.Failure);
}
public static Edge ToTopologic(this Rhino.Geometry.Line line)
{
if (line == null)
{
return(null);
}
Vertex vertex_1 = line.From.ToTopologic();
if (vertex_1 == null)
{
return(null);
}
Vertex vertex_2 = line.To.ToTopologic();
if (vertex_2 == null)
{
return(null);
}
return(Edge.ByStartVertexEndVertex(vertex_1, vertex_2));
}
private void SunSliderController(DrawEventArgs e)
{
Rectangle bounds = e.Viewport.Bounds;
if (this._dateParam != 0.0)
{
Point3d[] point3dArray = new Point3d[3];
for (int index = 0; index < 3; ++index)
{
double num1 = (double)(bounds.Width / 2) + Math.Sin(Math.PI - Math.PI / 2.0 * (double)index) * (double)this._dateSlideRadius;
double num2 = (double)(bounds.Height / 2) + Math.Cos(Math.PI - Math.PI / 2.0 * (double)index) * (double)this._dateSlideRadius;
Point3d local = point3dArray[index];
Rhino.Geometry.Line world = e.Viewport.ClientToWorld(new System.Drawing.Point((int)num1, (int)num2));
Point3d from = world.From;
local = from;
}
e.Display.DrawArc(new Arc(new Circle(point3dArray[0], point3dArray[1], point3dArray[2]), 2.0 * Math.PI * this._dateParam), this._dateArcColor, 10);
}
if (this._timeParam != 0.0)
{
Point3d[] point3dArray = new Point3d[3];
for (int index = 0; index < 3; ++index)
{
double num1 = (double)(bounds.Width / 2) + Math.Sin(Math.PI - Math.PI / 2.0 * (double)index) * (double)this._timeSlideRadious;
double num2 = (double)(bounds.Height / 2) + Math.Cos(Math.PI - Math.PI / 2.0 * (double)index) * (double)this._timeSlideRadious;
Point3d local = point3dArray[index];
Line world = e.Viewport.ClientToWorld(new System.Drawing.Point((int)num1, (int)num2));
Point3d from = world.From;
local = from;
}
e.Display.DrawArc(new Arc(new Circle(point3dArray[0], point3dArray[1], point3dArray[2]), 2.0 * Math.PI * this._timeParam), this._timeArcColor, 10);
}
e.Display.Draw2dText(this._datetime.ToString("m"), Color.White, new Point2d((double)(bounds.Width / 2), (double)(bounds.Height / 2 - 13)), true, 20);
e.Display.Draw2dText(this._datetime.ToString("t"), Color.White, new Point2d((double)(bounds.Width / 2), (double)(bounds.Height / 2 + 13)), true, 20);
e.Display.Draw2dText("Date", this._dateArcColor, new Point2d((double)(bounds.Width / 2), (double)(bounds.Height / 2 - this._dateSlideRadius + 20)), true, 10);
e.Display.Draw2dText("Time", this._timeArcColor, new Point2d((double)(bounds.Width / 2), (double)(bounds.Height / 2 - this._timeSlideRadious - 20)), true, 10);
}
/// <summary>
/// Gets the world coordinate line in the view frustum
/// that projects to a point on the screen.
/// </summary>
/// <param name="screenX">(screenx,screeny) = screen location.</param>
/// <param name="screenY">(screenx,screeny) = screen location.</param>
/// <returns>3d world coordinate line segment starting on the near clipping plane and ending on the far clipping plane.</returns>
public Rhino.Geometry.Line GetFrustumLine( double screenX, double screenY)
{
Rhino.Geometry.Line line = new Rhino.Geometry.Line();
IntPtr pConstThis = ConstPointer();
if (!UnsafeNativeMethods.ON_Viewport_GetFrustumLine(pConstThis, screenX, screenY, ref line))
line = Rhino.Geometry.Line.Unset;
return line;
}
public void SetInputs(List <DataTree <ResthopperObject> > values)
{
foreach (var tree in values)
{
if (!_input.TryGetValue(tree.ParamName, out var inputGroup))
{
continue;
}
if (inputGroup.AlreadySet(tree))
{
Console.WriteLine("Skipping input tree... same input");
continue;
}
inputGroup.CacheTree(tree);
inputGroup.Param.VolatileData.Clear();
inputGroup.Param.ExpireSolution(true);
if (inputGroup.Param is Param_Point)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
Rhino.Geometry.Point3d rPt = JsonConvert.DeserializeObject <Rhino.Geometry.Point3d>(restobj.Data);
GH_Point data = new GH_Point(rPt);
inputGroup.Param.AddVolatileData(path, i, data);
}
}
continue;
}
if (inputGroup.Param is Param_Vector)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
Rhino.Geometry.Vector3d rhVector = JsonConvert.DeserializeObject <Rhino.Geometry.Vector3d>(restobj.Data);
GH_Vector data = new GH_Vector(rhVector);
inputGroup.Param.AddVolatileData(path, i, data);
}
}
continue;
}
if (inputGroup.Param is Param_Integer)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
int rhinoInt = JsonConvert.DeserializeObject <int>(restobj.Data);
GH_Integer data = new GH_Integer(rhinoInt);
inputGroup.Param.AddVolatileData(path, i, data);
}
}
continue;
}
if (inputGroup.Param is Param_Number)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
double rhNumber = JsonConvert.DeserializeObject <double>(restobj.Data);
GH_Number data = new GH_Number(rhNumber);
inputGroup.Param.AddVolatileData(path, i, data);
}
}
continue;
}
if (inputGroup.Param is Param_String)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
string rhString = restobj.Data;
GH_String data = new GH_String(rhString);
inputGroup.Param.AddVolatileData(path, i, data);
}
}
continue;
}
if (inputGroup.Param is Param_Line)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
Rhino.Geometry.Line rhLine = JsonConvert.DeserializeObject <Rhino.Geometry.Line>(restobj.Data);
GH_Line data = new GH_Line(rhLine);
inputGroup.Param.AddVolatileData(path, i, data);
}
}
continue;
}
if (inputGroup.Param is Param_Curve)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
GH_Curve ghCurve;
try
{
Rhino.Geometry.Polyline data = JsonConvert.DeserializeObject <Rhino.Geometry.Polyline>(restobj.Data);
Rhino.Geometry.Curve c = new Rhino.Geometry.PolylineCurve(data);
ghCurve = new GH_Curve(c);
}
catch
{
var dict = JsonConvert.DeserializeObject <Dictionary <string, string> >(restobj.Data);
var c = (Rhino.Geometry.Curve)Rhino.Runtime.CommonObject.FromJSON(dict);
ghCurve = new GH_Curve(c);
}
inputGroup.Param.AddVolatileData(path, i, ghCurve);
}
}
continue;
}
if (inputGroup.Param is Param_Circle)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
Rhino.Geometry.Circle rhCircle = JsonConvert.DeserializeObject <Rhino.Geometry.Circle>(restobj.Data);
GH_Circle data = new GH_Circle(rhCircle);
inputGroup.Param.AddVolatileData(path, i, data);
}
}
continue;
}
if (inputGroup.Param is Param_Plane)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
Rhino.Geometry.Plane rhPlane = JsonConvert.DeserializeObject <Rhino.Geometry.Plane>(restobj.Data);
GH_Plane data = new GH_Plane(rhPlane);
inputGroup.Param.AddVolatileData(path, i, data);
}
}
continue;
}
if (inputGroup.Param is Param_Rectangle)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
Rhino.Geometry.Rectangle3d rhRectangle = JsonConvert.DeserializeObject <Rhino.Geometry.Rectangle3d>(restobj.Data);
GH_Rectangle data = new GH_Rectangle(rhRectangle);
inputGroup.Param.AddVolatileData(path, i, data);
}
}
continue;
}
if (inputGroup.Param is Param_Box)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
Rhino.Geometry.Box rhBox = JsonConvert.DeserializeObject <Rhino.Geometry.Box>(restobj.Data);
GH_Box data = new GH_Box(rhBox);
inputGroup.Param.AddVolatileData(path, i, data);
}
}
continue;
}
if (inputGroup.Param is Param_Surface)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
Rhino.Geometry.Surface rhSurface = JsonConvert.DeserializeObject <Rhino.Geometry.Surface>(restobj.Data);
GH_Surface data = new GH_Surface(rhSurface);
inputGroup.Param.AddVolatileData(path, i, data);
}
}
continue;
}
if (inputGroup.Param is Param_Brep)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
Rhino.Geometry.Brep rhBrep = JsonConvert.DeserializeObject <Rhino.Geometry.Brep>(restobj.Data);
GH_Brep data = new GH_Brep(rhBrep);
inputGroup.Param.AddVolatileData(path, i, data);
}
}
continue;
}
if (inputGroup.Param is Param_Mesh)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
Rhino.Geometry.Mesh rhMesh = JsonConvert.DeserializeObject <Rhino.Geometry.Mesh>(restobj.Data);
GH_Mesh data = new GH_Mesh(rhMesh);
inputGroup.Param.AddVolatileData(path, i, data);
}
}
continue;
}
if (inputGroup.Param is GH_NumberSlider)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
double rhNumber = JsonConvert.DeserializeObject <double>(restobj.Data);
GH_Number data = new GH_Number(rhNumber);
inputGroup.Param.AddVolatileData(path, i, data);
}
}
continue;
}
if (inputGroup.Param is Param_Boolean || inputGroup.Param is GH_BooleanToggle)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
bool boolean = JsonConvert.DeserializeObject <bool>(restobj.Data);
GH_Boolean data = new GH_Boolean(boolean);
inputGroup.Param.AddVolatileData(path, i, data);
}
}
continue;
}
if (inputGroup.Param is GH_Panel)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
string rhString = JsonConvert.DeserializeObject <string>(restobj.Data);
GH_String data = new GH_String(rhString);
inputGroup.Param.AddVolatileData(path, i, data);
}
}
continue;
}
}
}
public static string ToSVG(this Rg.Line input)
{
return("M " + input.From.ToSVG() + input.To.ToSVG() + " ");
}
public static Line ToLine(this rg.Line line)
{
return(new Line(line.From.ToVector3(), line.To.ToVector3()));
}
/***************************************************/
public static void RenderRhinoWires(RHG.Line line, Rhino.Display.DisplayPipeline pipeline, Color bhColour, int thickness)
{
pipeline.DrawLine(line, bhColour, thickness);
}
private Topologic.Edge ByLine(Rhino.Geometry.Line ghLine)
{
Topologic.Vertex vertex1 = ByPoint(ghLine.From);
Topologic.Vertex vertex2 = ByPoint(ghLine.To);
return(Topologic.Edge.ByStartVertexEndVertex(vertex1, vertex2));
}
//RHINO TO REVIT
public Line RhinoToRevitLine(rg.Line line)
{
return(Line.CreateBound(RhinoToRevitPoint(line.From), RhinoToRevitPoint(line.To)));
}
public Result Execute(
ExternalCommandData commandData,
ref string message,
ElementSet elements)
{
UIApplication uiapp = commandData.Application;
UIDocument uidoc = uiapp.ActiveUIDocument;
Application app = uiapp.Application;
Document doc = uidoc.Document;
double scale = 304.8;
#region TEST
////cut line endpoints
//XYZ v1 = new XYZ(0, 2000, 0)/scale;
//XYZ v2 = new XYZ(6018, 2000, 0) / scale;
////rhino cut line endpoints
// rg.Point3d rv0 = new rg.Point3d(0, 2000, 0);
// rg.Point3d rv1 = new rg.Point3d(6018, 2000, 0);
//rg.Point3d rv2 = new rg.Point3d(0, 2000, 1);
////rhino cut plane
//rg.Plane cutPlane = new rg.Plane(rv0, rv1, rv2);
////wip points
//rg.Point3d rv3 = new rg.Point3d(857, 203, 4597);
//rg.Point3d rv4 = new rg.Point3d(857, 6221, 4597);
//rg.Point3d rv5 = new rg.Point3d(9818, 6221, 4597);
// //wip plane
// rg.Plane rhinoPlane = new rg.Plane(rv3, rv4, rv5);
// rg.Line intLine;
// var result = rg.Intersect.Intersection.PlanePlane(cutPlane, rhinoPlane, out intLine);
// using (Transaction t = new Transaction(doc, "Project Line"))
// {
// t.Start();
// SketchPlane sp = SketchPlane.Create(doc, RhinoToRevitPlane(cutPlane));
// doc.Create.NewModelCurve(RhinoToRevitLine(intLine), sp);
// t.Commit();
// }
// TaskDialog.Show("r", "Done");
#endregion
#region Revit
// SELECT THE LINE TO PROJECT AND CONSTRUCT THE PLANE TO INTERSECT THE MESH
Reference lineToProject = uidoc.Selection.PickObject(ObjectType.Element, "Select cut Line");
Element lineElement = doc.GetElement(lineToProject);
CurveElement curveLine = lineElement as CurveElement;
LocationCurve lineLocation = lineElement.Location as LocationCurve;
Line line = lineLocation.Curve as Line;
rg.Line rhinoCutLine = new rg.Line(RevitToRhinoPoint(line.GetEndPoint(0)), RevitToRhinoPoint(line.GetEndPoint(1)));
XYZ perpDir = line.Direction.CrossProduct(XYZ.BasisZ).Normalize();
Plane cutPlane = Plane.CreateByNormalAndOrigin(perpDir, line.GetEndPoint(0));
// GET THE MESH GEOMETRY
Reference meshRef = uidoc.Selection.PickObject(ObjectType.Element, "Select Mesh");
Element e = doc.GetElement(meshRef);
Options opt = new Options();
opt.ComputeReferences = true;
opt.IncludeNonVisibleObjects = false;
opt.View = doc.ActiveView;
GeometryElement geomElem = e.get_Geometry(opt);
Mesh geomMesh = null;
foreach (GeometryObject geomObj in geomElem)
{
GeometryInstance gi = geomObj as GeometryInstance;
if (gi != null)
{
foreach (GeometryObject element in gi.GetInstanceGeometry())
{
geomMesh = element as Mesh;
}
}
else
{
geomMesh = geomObj as Mesh;
}
}
int counter = 0;
using (Transaction t = new Transaction(doc, "Project Line"))
{
t.Start();
SketchPlane sp = SketchPlane.Create(doc, cutPlane);
XYZ spOrigin = sp.GetPlane().Origin;
Debug.Write($"Sketch plane origin: {spOrigin}\n");
XYZ spNormal = sp.GetPlane().Normal;
Debug.Write($"Sketch plane normal: {spNormal}\n");
Line spX = Line.CreateBound(spOrigin, spOrigin + XYZ.BasisZ * 100);
Debug.Write($"line start: {spX.GetEndParameter(0)}\n");
Debug.Write($"line end: {spX.GetEndParameter(1)}\n");
ModelCurve mc = doc.Create.NewModelCurve(spX, sp);
Debug.Write($"mc: {mc.Id}\n");
List <XYZ> intersectionPoints = new List <XYZ>();
for (int i = 0; i < geomMesh.NumTriangles; i++)
{
MeshTriangle triangle = geomMesh.get_Triangle(i);
XYZ vertex1 = triangle.get_Vertex(0);
XYZ vertex2 = triangle.get_Vertex(1);
XYZ vertex3 = triangle.get_Vertex(2);
rg.Point3d rhinoVertex1 = RevitToRhinoPoint(vertex1);
rg.Point3d rhinoVertex2 = RevitToRhinoPoint(vertex2);
rg.Point3d rhinoVertex3 = RevitToRhinoPoint(vertex3);
List <rg.Line> rhinoEdges = new List <rg.Line> {
new rg.Line(rhinoVertex1, rhinoVertex2), new rg.Line(rhinoVertex1, rhinoVertex2), new rg.Line(rhinoVertex1, rhinoVertex2)
};
XYZ[] pts = new XYZ[2];
int ptscount = 0;
foreach (rg.Line edge in rhinoEdges)
{
double a = 0;
double b = 0;
bool result = rg.Intersect.Intersection.LineLine(edge, rhinoCutLine, out a, out b);
if (result)
{
intersectionPoints.Add(RhinoToRevitPoint(edge.PointAt(a)));
pts[ptscount] = RhinoToRevitPoint(edge.PointAt(a));
ptscount = 1;
counter++;
}
}
if (pts[0] != null)
{
try
{
Line temp = Line.CreateBound(pts[0], pts[0] + XYZ.BasisZ * 100);
//Line li = Line.CreateBound(pts[0], new XYZ(pts[0].X, pts[0].Y, pts[0].Z +100));
doc.Create.NewModelCurve(temp, sp);
}
catch { }
}
}
t.Commit();
}
TaskDialog.Show("Intersections found", counter.ToString());
#endregion
return(Result.Succeeded);
}
static public Autodesk.Revit.DB.Line ToHost(this Rhino.Geometry.Line line)
{
return(Autodesk.Revit.DB.Line.CreateBound(line.From.ToHost(), line.To.ToHost()));
}
static internal Rhino.Geometry.Line Scale(this Rhino.Geometry.Line l, double factor)
{
return(new Rhino.Geometry.Line(l.From.Scale(factor), l.To.Scale(factor)));
}
public void SetInputs(List <DataTree <ResthopperObject> > values)
{
foreach (var tree in values)
{
if (!_input.TryGetValue(tree.ParamName, out var inputGroup))
{
continue;
}
if (inputGroup.AlreadySet(tree))
{
LogDebug("Skipping input tree... same input");
continue;
}
inputGroup.CacheTree(tree);
IGH_ContextualParameter contextualParameter = inputGroup.Param as IGH_ContextualParameter;
if (contextualParameter != null)
{
switch (ParamTypeName(inputGroup.Param))
{
case "Number":
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
double[] doubles = new double[entree.Value.Count];
for (int i = 0; i < doubles.Length; i++)
{
ResthopperObject restobj = entree.Value[i];
doubles[i] = JsonConvert.DeserializeObject <double>(restobj.Data);
}
contextualParameter.AssignContextualData(doubles);
break;
}
}
break;
case "Integer":
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
int[] integers = new int[entree.Value.Count];
for (int i = 0; i < integers.Length; i++)
{
ResthopperObject restobj = entree.Value[i];
integers[i] = JsonConvert.DeserializeObject <int>(restobj.Data);
}
contextualParameter.AssignContextualData(integers);
break;
}
}
break;
case "Point":
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
Point3d[] points = new Point3d[entree.Value.Count];
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
points[i] = JsonConvert.DeserializeObject <Rhino.Geometry.Point3d>(restobj.Data);
}
contextualParameter.AssignContextualData(points);
break;
}
}
break;
case "Line":
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
Line[] lines = new Line[entree.Value.Count];
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
lines[i] = JsonConvert.DeserializeObject <Rhino.Geometry.Line>(restobj.Data);
}
contextualParameter.AssignContextualData(lines);
break;
}
}
break;
case "Text":
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
string[] strings = new string[entree.Value.Count];
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
strings[i] = restobj.Data.Trim(new char[] { '"' });
}
contextualParameter.AssignContextualData(strings);
break;
}
}
break;
case "Geometry":
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GeometryBase[] geometries = new GeometryBase[entree.Value.Count];
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
var dict = JsonConvert.DeserializeObject <Dictionary <string, string> >(restobj.Data);
geometries[i] = Rhino.Runtime.CommonObject.FromJSON(dict) as GeometryBase;
}
contextualParameter.AssignContextualData(geometries);
break;
}
}
break;
}
continue;
}
inputGroup.Param.VolatileData.Clear();
inputGroup.Param.ExpireSolution(false); // mark param as expired but don't recompute just yet!
if (inputGroup.Param is Param_Point)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
Rhino.Geometry.Point3d rPt = JsonConvert.DeserializeObject <Rhino.Geometry.Point3d>(restobj.Data);
GH_Point data = new GH_Point(rPt);
inputGroup.Param.AddVolatileData(path, i, data);
}
}
continue;
}
if (inputGroup.Param is Param_Vector)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
Rhino.Geometry.Vector3d rhVector = JsonConvert.DeserializeObject <Rhino.Geometry.Vector3d>(restobj.Data);
GH_Vector data = new GH_Vector(rhVector);
inputGroup.Param.AddVolatileData(path, i, data);
}
}
continue;
}
if (inputGroup.Param is Param_Integer)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
int rhinoInt = JsonConvert.DeserializeObject <int>(restobj.Data);
GH_Integer data = new GH_Integer(rhinoInt);
inputGroup.Param.AddVolatileData(path, i, data);
}
}
continue;
}
if (inputGroup.Param is Param_Number)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
double rhNumber = JsonConvert.DeserializeObject <double>(restobj.Data);
GH_Number data = new GH_Number(rhNumber);
inputGroup.Param.AddVolatileData(path, i, data);
}
}
continue;
}
if (inputGroup.Param is Param_String)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
string rhString = restobj.Data;
GH_String data = new GH_String(rhString);
inputGroup.Param.AddVolatileData(path, i, data);
}
}
continue;
}
if (inputGroup.Param is Param_Line)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
Rhino.Geometry.Line rhLine = JsonConvert.DeserializeObject <Rhino.Geometry.Line>(restobj.Data);
GH_Line data = new GH_Line(rhLine);
inputGroup.Param.AddVolatileData(path, i, data);
}
}
continue;
}
if (inputGroup.Param is Param_Curve)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
GH_Curve ghCurve;
try
{
Rhino.Geometry.Polyline data = JsonConvert.DeserializeObject <Rhino.Geometry.Polyline>(restobj.Data);
Rhino.Geometry.Curve c = new Rhino.Geometry.PolylineCurve(data);
ghCurve = new GH_Curve(c);
}
catch
{
var dict = JsonConvert.DeserializeObject <Dictionary <string, string> >(restobj.Data);
var c = (Rhino.Geometry.Curve)Rhino.Runtime.CommonObject.FromJSON(dict);
ghCurve = new GH_Curve(c);
}
inputGroup.Param.AddVolatileData(path, i, ghCurve);
}
}
continue;
}
if (inputGroup.Param is Param_Circle)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
Rhino.Geometry.Circle rhCircle = JsonConvert.DeserializeObject <Rhino.Geometry.Circle>(restobj.Data);
GH_Circle data = new GH_Circle(rhCircle);
inputGroup.Param.AddVolatileData(path, i, data);
}
}
continue;
}
if (inputGroup.Param is Param_Plane)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
Rhino.Geometry.Plane rhPlane = JsonConvert.DeserializeObject <Rhino.Geometry.Plane>(restobj.Data);
GH_Plane data = new GH_Plane(rhPlane);
inputGroup.Param.AddVolatileData(path, i, data);
}
}
continue;
}
if (inputGroup.Param is Param_Rectangle)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
Rhino.Geometry.Rectangle3d rhRectangle = JsonConvert.DeserializeObject <Rhino.Geometry.Rectangle3d>(restobj.Data);
GH_Rectangle data = new GH_Rectangle(rhRectangle);
inputGroup.Param.AddVolatileData(path, i, data);
}
}
continue;
}
if (inputGroup.Param is Param_Box)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
Rhino.Geometry.Box rhBox = JsonConvert.DeserializeObject <Rhino.Geometry.Box>(restobj.Data);
GH_Box data = new GH_Box(rhBox);
inputGroup.Param.AddVolatileData(path, i, data);
}
}
continue;
}
if (inputGroup.Param is Param_Surface)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
Rhino.Geometry.Surface rhSurface = JsonConvert.DeserializeObject <Rhino.Geometry.Surface>(restobj.Data);
GH_Surface data = new GH_Surface(rhSurface);
inputGroup.Param.AddVolatileData(path, i, data);
}
}
continue;
}
if (inputGroup.Param is Param_Brep)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
Rhino.Geometry.Brep rhBrep = JsonConvert.DeserializeObject <Rhino.Geometry.Brep>(restobj.Data);
GH_Brep data = new GH_Brep(rhBrep);
inputGroup.Param.AddVolatileData(path, i, data);
}
}
continue;
}
if (inputGroup.Param is Param_Mesh)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
Rhino.Geometry.Mesh rhMesh = JsonConvert.DeserializeObject <Rhino.Geometry.Mesh>(restobj.Data);
GH_Mesh data = new GH_Mesh(rhMesh);
inputGroup.Param.AddVolatileData(path, i, data);
}
}
continue;
}
if (inputGroup.Param is GH_NumberSlider)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
double rhNumber = JsonConvert.DeserializeObject <double>(restobj.Data);
GH_Number data = new GH_Number(rhNumber);
inputGroup.Param.AddVolatileData(path, i, data);
}
}
continue;
}
if (inputGroup.Param is Param_Boolean || inputGroup.Param is GH_BooleanToggle)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
bool boolean = JsonConvert.DeserializeObject <bool>(restobj.Data);
GH_Boolean data = new GH_Boolean(boolean);
inputGroup.Param.AddVolatileData(path, i, data);
}
}
continue;
}
if (inputGroup.Param is GH_Panel)
{
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
string rhString = JsonConvert.DeserializeObject <string>(restobj.Data);
GH_String data = new GH_String(rhString);
inputGroup.Param.AddVolatileData(path, i, data);
}
}
continue;
}
}
}
private UI.FrixelReferenceData Regenerate()
{
MassingStructure massing = GenerateMassingStructure();
if (massing == null)
{
return(null);
}
var Nodes = massing.Nodes;
// Crawl across the point array and crete pixels
var nodeList = Nodes.Values.ToList();
List <Pixel> pixelList = new List <Pixel>();
for (int x = 0; x < massing.xBayCount; x++)
{
for (int y = 0; y < massing.yBayCount; y++)
{
if (!Nodes.ContainsKey(new Tuple <int, int>(x, y)))
{
continue;
}
var currentPoint = Nodes[new Tuple <int, int>(x, y)];
var topLeft = new Tuple <int, int>(x, y + 1);
var topRight = new Tuple <int, int>(x + 1, y + 1);
var botLeft = new Tuple <int, int>(x, y);
var botRight = new Tuple <int, int>(x + 1, y);
Core.Geometry.Point2d topLeftPt;
Core.Geometry.Point2d topRightPt;
Core.Geometry.Point2d botLeftPt;
Core.Geometry.Point2d botRightPt;
if (
Nodes.TryGetValue(botLeft, out botLeftPt) &&
Nodes.TryGetValue(topLeft, out topLeftPt) &&
Nodes.TryGetValue(topRight, out topRightPt) &&
Nodes.TryGetValue(botRight, out botRightPt) &&
Utilities.AtLeastXInside(topLeftPt.IsInside, topRightPt.IsInside, botLeftPt.IsInside, botRightPt.IsInside, 2)
)
{
pixelList.Add(new Pixel(
nodeList.IndexOf(topLeftPt),
nodeList.IndexOf(topRightPt),
nodeList.IndexOf(botLeftPt),
nodeList.IndexOf(botRightPt),
PixelState.None
));
topLeftPt.IsPixeled = true;
topRightPt.IsPixeled = true;
botLeftPt.IsPixeled = true;
botRightPt.IsPixeled = true;
}
}
}
// Remove unpixeled nodes and update nodeList
var nodeListCopy = nodeList.Where(n => n.IsPixeled).ToList();
foreach (var p in pixelList)
{
p.UpdateTopology(
nodeListCopy.IndexOf(nodeList[p.TopLeft]),
nodeListCopy.IndexOf(nodeList[p.TopRight]),
nodeListCopy.IndexOf(nodeList[p.BottomLeft]),
nodeListCopy.IndexOf(nodeList[p.BottomRight])
);
}
nodeList = nodeListCopy;
// Find the closest node to the spine line
Tuple <double, int> closestPoint = null;
var crv = new Rhino.Geometry.Line(_spine.Item1, _spine.Item2).ToNurbsCurve();
int spi = 0;
foreach (var p in nodeList.Select(n => new Point3d(n.X, n.Y, 0)))
{
double dist = double.PositiveInfinity;
double t = 0;
crv.ClosestPoint(p, out t, 100);
var crvPt = crv.PointAt(t);
dist = crvPt.DistanceTo(p);
// First cycle
if (closestPoint == null)
{
closestPoint = new Tuple <double, int>(dist, spi); spi++; continue;
}
// If its closer
if (!double.IsInfinity(dist) && dist < closestPoint.Item1)
{
closestPoint = new Tuple <double, int>(dist, spi);
}
spi++;
}
var closestNode = nodeList[closestPoint.Item2];
var coord = Nodes.Where(x => x.Value == closestNode).First().Key;
// Find orientation of spine curve, vert or horz, to create spine
bool xDir = Math.Abs(_spine.Item1.X - _spine.Item2.X) > Math.Abs(_spine.Item1.Y - _spine.Item2.Y);
if (xDir)
{
var horzPts = Nodes.Where(x => x.Key.Item2 == coord.Item2).ToList().Select(x => x.Value).ToList();
List <Core.Geometry.Point2d> newPts = new List <Core.Geometry.Point2d>();
foreach (var pt in horzPts)
{
var myCoord = nodeList.IndexOf(pt);
foreach (var p in pixelList.Where(p => p.ContainsNode(myCoord, true)).ToList())
{
p.ChangeStateTo(PixelState.Moment);
p.LockedBrace = true;
newPts.Add(nodeList[p.BottomLeft]);
newPts.Add(nodeList[p.TopLeft]);
}
}
horzPts.AddRange(newPts);
// Lock support points (LEFT)
var horzPtsMin = horzPts.Select(p => p.X).Min();
nodeList.Where(p => p.X.IsCloseTo(horzPtsMin)).ToList().ForEach(p => p.IsLocked = true);
}
else
{
var vertPts = Nodes.Where(x => x.Key.Item1 == coord.Item1).ToList().Select(x => x.Value).ToList();
List <Core.Geometry.Point2d> newPts = new List <Core.Geometry.Point2d>();
foreach (var pt in vertPts)
{
var myCoord = nodeList.IndexOf(pt);
foreach (var p in pixelList.Where(p => p.ContainsNode(myCoord, true)).ToList())
{
p.ChangeStateTo(PixelState.Moment);
newPts.Add(nodeList[p.BottomLeft]);
newPts.Add(nodeList[p.BottomRight]);
}
}
vertPts.AddRange(newPts);
// Lock support points (BOTTOM)
var vertPtsMin = vertPts.Select(p => p.Y).Min();
vertPts.Where(p => p.Y.IsCloseTo(vertPtsMin)).ToList().ForEach(p => p.IsLocked = true);
pixelList.ForEach(p =>
{
if (nodeList[p.BottomLeft].Y.IsCloseTo(vertPtsMin))
{
nodeList[p.BottomLeft].IsLocked = true;
}
if (nodeList[p.BottomRight].Y.IsCloseTo(vertPtsMin))
{
nodeList[p.BottomRight].IsLocked = true;
}
});
}
foreach (var p in pixelList.Where(p => p.ContainsNode(spi)).ToList())
{
p.ChangeStateTo(PixelState.Moment);
}
// Create the pixel structure
var pixelStruct = new Core.PixelStructure(nodeList, pixelList);
// Return the data
return(new UI.FrixelReferenceData(pixelStruct, massing));
}
public static Response Grasshopper(NancyContext ctx)
{
// load grasshopper file
var archive = new GH_Archive();
// TODO: stream to string
var body = ctx.Request.Body.ToString();
string json = string.Empty;
using (var reader = new StreamReader(ctx.Request.Body))
{
json = reader.ReadToEnd();
}
//GrasshopperInput input = Newtonsoft.Json.JsonConvert.DeserializeObject<GrasshopperInput>(json);
//JsonSerializerSettings settings = new JsonSerializerSettings();
//settings.ContractResolver = new DictionaryAsArrayResolver();
Schema input = JsonConvert.DeserializeObject <Schema>(json);
string grasshopperXml = string.Empty;
if (input.Algo != null)
{
// If request contains markup
byte[] byteArray = Convert.FromBase64String(input.Algo);
grasshopperXml = System.Text.Encoding.UTF8.GetString(byteArray);
}
else
{
// If request contains pointer
string pointer = input.Pointer;
grasshopperXml = GetGhxFromPointer(pointer);
}
if (!archive.Deserialize_Xml(grasshopperXml))
{
throw new Exception();
}
var definition = new GH_Document();
if (!archive.ExtractObject(definition, "Definition"))
{
throw new Exception();
}
// Set input params
foreach (var obj in definition.Objects)
{
var group = obj as GH_Group;
if (group == null)
{
continue;
}
if (group.NickName.Contains("RH_IN"))
{
// It is a RestHopper input group!
GHTypeCodes code = (GHTypeCodes)Int32.Parse(group.NickName.Split(':')[1]);
var param = group.Objects()[0];
//GH_Param<IGH_Goo> goo = obj as GH_Param<IGH_Goo>;
// SetData
foreach (Resthopper.IO.DataTree <ResthopperObject> tree in input.Values)
{
string paramname = tree.ParamName;
if (group.NickName == paramname)
{
switch (code)
{
case GHTypeCodes.Boolean:
//PopulateParam<GH_Boolean>(goo, tree);
Param_Boolean boolParam = param as Param_Boolean;
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
List <GH_Boolean> objectList = new List <GH_Boolean>();
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
bool boolean = JsonConvert.DeserializeObject <bool>(restobj.Data);
GH_Boolean data = new GH_Boolean(boolean);
boolParam.AddVolatileData(path, i, data);
}
}
break;
case GHTypeCodes.Point:
//PopulateParam<GH_Point>(goo, tree);
Param_Point ptParam = param as Param_Point;
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
List <GH_Point> objectList = new List <GH_Point>();
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
Rhino.Geometry.Point3d rPt = JsonConvert.DeserializeObject <Rhino.Geometry.Point3d>(restobj.Data);
GH_Point data = new GH_Point(rPt);
ptParam.AddVolatileData(path, i, data);
}
}
break;
case GHTypeCodes.Vector:
//PopulateParam<GH_Vector>(goo, tree);
Param_Vector vectorParam = param as Param_Vector;
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
List <GH_Vector> objectList = new List <GH_Vector>();
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
Rhino.Geometry.Vector3d rhVector = JsonConvert.DeserializeObject <Rhino.Geometry.Vector3d>(restobj.Data);
GH_Vector data = new GH_Vector(rhVector);
vectorParam.AddVolatileData(path, i, data);
}
}
break;
case GHTypeCodes.Integer:
//PopulateParam<GH_Integer>(goo, tree);
Param_Integer integerParam = param as Param_Integer;
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
List <GH_Integer> objectList = new List <GH_Integer>();
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
int rhinoInt = JsonConvert.DeserializeObject <int>(restobj.Data);
GH_Integer data = new GH_Integer(rhinoInt);
integerParam.AddVolatileData(path, i, data);
}
}
break;
case GHTypeCodes.Number:
//PopulateParam<GH_Number>(goo, tree);
Param_Number numberParam = param as Param_Number;
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
List <GH_Number> objectList = new List <GH_Number>();
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
double rhNumber = JsonConvert.DeserializeObject <double>(restobj.Data);
GH_Number data = new GH_Number(rhNumber);
numberParam.AddVolatileData(path, i, data);
}
}
break;
case GHTypeCodes.Text:
//PopulateParam<GH_String>(goo, tree);
Param_String stringParam = param as Param_String;
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
List <GH_String> objectList = new List <GH_String>();
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
string rhString = JsonConvert.DeserializeObject <string>(restobj.Data);
GH_String data = new GH_String(rhString);
stringParam.AddVolatileData(path, i, data);
}
}
break;
case GHTypeCodes.Line:
//PopulateParam<GH_Line>(goo, tree);
Param_Line lineParam = param as Param_Line;
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
List <GH_Line> objectList = new List <GH_Line>();
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
Rhino.Geometry.Line rhLine = JsonConvert.DeserializeObject <Rhino.Geometry.Line>(restobj.Data);
GH_Line data = new GH_Line(rhLine);
lineParam.AddVolatileData(path, i, data);
}
}
break;
case GHTypeCodes.Curve:
//PopulateParam<GH_Curve>(goo, tree);
Param_Curve curveParam = param as Param_Curve;
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
List <GH_Curve> objectList = new List <GH_Curve>();
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
GH_Curve ghCurve;
try
{
Rhino.Geometry.Polyline data = JsonConvert.DeserializeObject <Rhino.Geometry.Polyline>(restobj.Data);
Rhino.Geometry.Curve c = new Rhino.Geometry.PolylineCurve(data);
ghCurve = new GH_Curve(c);
}
catch
{
Rhino.Geometry.NurbsCurve data = JsonConvert.DeserializeObject <Rhino.Geometry.NurbsCurve>(restobj.Data);
Rhino.Geometry.Curve c = new Rhino.Geometry.NurbsCurve(data);
ghCurve = new GH_Curve(c);
}
curveParam.AddVolatileData(path, i, ghCurve);
}
}
break;
case GHTypeCodes.Circle:
//PopulateParam<GH_Circle>(goo, tree);
Param_Circle circleParam = param as Param_Circle;
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
List <GH_Circle> objectList = new List <GH_Circle>();
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
Rhino.Geometry.Circle rhCircle = JsonConvert.DeserializeObject <Rhino.Geometry.Circle>(restobj.Data);
GH_Circle data = new GH_Circle(rhCircle);
circleParam.AddVolatileData(path, i, data);
}
}
break;
case GHTypeCodes.PLane:
//PopulateParam<GH_Plane>(goo, tree);
Param_Plane planeParam = param as Param_Plane;
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
List <GH_Plane> objectList = new List <GH_Plane>();
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
Rhino.Geometry.Plane rhPlane = JsonConvert.DeserializeObject <Rhino.Geometry.Plane>(restobj.Data);
GH_Plane data = new GH_Plane(rhPlane);
planeParam.AddVolatileData(path, i, data);
}
}
break;
case GHTypeCodes.Rectangle:
//PopulateParam<GH_Rectangle>(goo, tree);
Param_Rectangle rectangleParam = param as Param_Rectangle;
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
List <GH_Rectangle> objectList = new List <GH_Rectangle>();
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
Rhino.Geometry.Rectangle3d rhRectangle = JsonConvert.DeserializeObject <Rhino.Geometry.Rectangle3d>(restobj.Data);
GH_Rectangle data = new GH_Rectangle(rhRectangle);
rectangleParam.AddVolatileData(path, i, data);
}
}
break;
case GHTypeCodes.Box:
//PopulateParam<GH_Box>(goo, tree);
Param_Box boxParam = param as Param_Box;
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
List <GH_Box> objectList = new List <GH_Box>();
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
Rhino.Geometry.Box rhBox = JsonConvert.DeserializeObject <Rhino.Geometry.Box>(restobj.Data);
GH_Box data = new GH_Box(rhBox);
boxParam.AddVolatileData(path, i, data);
}
}
break;
case GHTypeCodes.Surface:
//PopulateParam<GH_Surface>(goo, tree);
Param_Surface surfaceParam = param as Param_Surface;
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
List <GH_Surface> objectList = new List <GH_Surface>();
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
Rhino.Geometry.Surface rhSurface = JsonConvert.DeserializeObject <Rhino.Geometry.Surface>(restobj.Data);
GH_Surface data = new GH_Surface(rhSurface);
surfaceParam.AddVolatileData(path, i, data);
}
}
break;
case GHTypeCodes.Brep:
//PopulateParam<GH_Brep>(goo, tree);
Param_Brep brepParam = param as Param_Brep;
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
List <GH_Brep> objectList = new List <GH_Brep>();
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
Rhino.Geometry.Brep rhBrep = JsonConvert.DeserializeObject <Rhino.Geometry.Brep>(restobj.Data);
GH_Brep data = new GH_Brep(rhBrep);
brepParam.AddVolatileData(path, i, data);
}
}
break;
case GHTypeCodes.Mesh:
//PopulateParam<GH_Mesh>(goo, tree);
Param_Mesh meshParam = param as Param_Mesh;
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
List <GH_Mesh> objectList = new List <GH_Mesh>();
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
Rhino.Geometry.Mesh rhMesh = JsonConvert.DeserializeObject <Rhino.Geometry.Mesh>(restobj.Data);
GH_Mesh data = new GH_Mesh(rhMesh);
meshParam.AddVolatileData(path, i, data);
}
}
break;
case GHTypeCodes.Slider:
//PopulateParam<GH_Number>(goo, tree);
GH_NumberSlider sliderParam = param as GH_NumberSlider;
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
List <GH_Number> objectList = new List <GH_Number>();
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
double rhNumber = JsonConvert.DeserializeObject <double>(restobj.Data);
GH_Number data = new GH_Number(rhNumber);
sliderParam.AddVolatileData(path, i, data);
}
}
break;
case GHTypeCodes.BooleanToggle:
//PopulateParam<GH_Boolean>(goo, tree);
GH_BooleanToggle toggleParam = param as GH_BooleanToggle;
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
List <GH_Boolean> objectList = new List <GH_Boolean>();
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
bool rhBoolean = JsonConvert.DeserializeObject <bool>(restobj.Data);
GH_Boolean data = new GH_Boolean(rhBoolean);
toggleParam.AddVolatileData(path, i, data);
}
}
break;
case GHTypeCodes.Panel:
//PopulateParam<GH_String>(goo, tree);
GH_Panel panelParam = param as GH_Panel;
foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree)
{
GH_Path path = new GH_Path(GhPath.FromString(entree.Key));
List <GH_Panel> objectList = new List <GH_Panel>();
for (int i = 0; i < entree.Value.Count; i++)
{
ResthopperObject restobj = entree.Value[i];
string rhString = JsonConvert.DeserializeObject <string>(restobj.Data);
GH_String data = new GH_String(rhString);
panelParam.AddVolatileData(path, i, data);
}
}
break;
}
}
}
}
}
Schema OutputSchema = new Schema();
OutputSchema.Algo = Utils.Base64Encode(string.Empty);
// Parse output params
foreach (var obj in definition.Objects)
{
var group = obj as GH_Group;
if (group == null)
{
continue;
}
if (group.NickName.Contains("RH_OUT"))
{
// It is a RestHopper output group!
GHTypeCodes code = (GHTypeCodes)Int32.Parse(group.NickName.Split(':')[1]);
var param = group.Objects()[0] as IGH_Param;
if (param == null)
{
continue;
}
try
{
param.CollectData();
param.ComputeData();
}
catch (Exception)
{
param.Phase = GH_SolutionPhase.Failed;
// TODO: throw something better
throw;
}
// Get data
Resthopper.IO.DataTree <ResthopperObject> OutputTree = new Resthopper.IO.DataTree <ResthopperObject>();
OutputTree.ParamName = group.NickName;
var volatileData = param.VolatileData;
for (int p = 0; p < volatileData.PathCount; p++)
{
List <ResthopperObject> ResthopperObjectList = new List <ResthopperObject>();
foreach (var goo in volatileData.get_Branch(p))
{
if (goo == null)
{
continue;
}
else if (goo.GetType() == typeof(GH_Boolean))
{
GH_Boolean ghValue = goo as GH_Boolean;
bool rhValue = ghValue.Value;
ResthopperObjectList.Add(GetResthopperObject <bool>(rhValue));
}
else if (goo.GetType() == typeof(GH_Point))
{
GH_Point ghValue = goo as GH_Point;
Point3d rhValue = ghValue.Value;
ResthopperObjectList.Add(GetResthopperObject <Point3d>(rhValue));
}
else if (goo.GetType() == typeof(GH_Vector))
{
GH_Vector ghValue = goo as GH_Vector;
Vector3d rhValue = ghValue.Value;
ResthopperObjectList.Add(GetResthopperObject <Vector3d>(rhValue));
}
else if (goo.GetType() == typeof(GH_Integer))
{
GH_Integer ghValue = goo as GH_Integer;
int rhValue = ghValue.Value;
ResthopperObjectList.Add(GetResthopperObject <int>(rhValue));
}
else if (goo.GetType() == typeof(GH_Number))
{
GH_Number ghValue = goo as GH_Number;
double rhValue = ghValue.Value;
ResthopperObjectList.Add(GetResthopperObject <double>(rhValue));
}
else if (goo.GetType() == typeof(GH_String))
{
GH_String ghValue = goo as GH_String;
string rhValue = ghValue.Value;
ResthopperObjectList.Add(GetResthopperObject <string>(rhValue));
}
else if (goo.GetType() == typeof(GH_Line))
{
GH_Line ghValue = goo as GH_Line;
Line rhValue = ghValue.Value;
ResthopperObjectList.Add(GetResthopperObject <Line>(rhValue));
}
else if (goo.GetType() == typeof(GH_Curve))
{
GH_Curve ghValue = goo as GH_Curve;
Curve rhValue = ghValue.Value;
ResthopperObjectList.Add(GetResthopperObject <Curve>(rhValue));
}
else if (goo.GetType() == typeof(GH_Circle))
{
GH_Circle ghValue = goo as GH_Circle;
Circle rhValue = ghValue.Value;
ResthopperObjectList.Add(GetResthopperObject <Circle>(rhValue));
}
else if (goo.GetType() == typeof(GH_Plane))
{
GH_Plane ghValue = goo as GH_Plane;
Plane rhValue = ghValue.Value;
ResthopperObjectList.Add(GetResthopperObject <Plane>(rhValue));
}
else if (goo.GetType() == typeof(GH_Rectangle))
{
GH_Rectangle ghValue = goo as GH_Rectangle;
Rectangle3d rhValue = ghValue.Value;
ResthopperObjectList.Add(GetResthopperObject <Rectangle3d>(rhValue));
}
else if (goo.GetType() == typeof(GH_Box))
{
GH_Box ghValue = goo as GH_Box;
Box rhValue = ghValue.Value;
ResthopperObjectList.Add(GetResthopperObject <Box>(rhValue));
}
else if (goo.GetType() == typeof(GH_Surface))
{
GH_Surface ghValue = goo as GH_Surface;
Brep rhValue = ghValue.Value;
ResthopperObjectList.Add(GetResthopperObject <Brep>(rhValue));
}
else if (goo.GetType() == typeof(GH_Brep))
{
GH_Brep ghValue = goo as GH_Brep;
Brep rhValue = ghValue.Value;
ResthopperObjectList.Add(GetResthopperObject <Brep>(rhValue));
}
else if (goo.GetType() == typeof(GH_Mesh))
{
GH_Mesh ghValue = goo as GH_Mesh;
Mesh rhValue = ghValue.Value;
ResthopperObjectList.Add(GetResthopperObject <Mesh>(rhValue));
}
}
GhPath path = new GhPath(new int[] { p });
OutputTree.Add(path.ToString(), ResthopperObjectList);
}
OutputSchema.Values.Add(OutputTree);
}
}
if (OutputSchema.Values.Count < 1)
{
throw new System.Exceptions.PayAttentionException("Looks like you've missed something..."); // TODO
}
string returnJson = JsonConvert.SerializeObject(OutputSchema);
return(returnJson);
}
/// <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)
{
// Declare variables
Point3d position = new Point3d(0, 10, 0);
Color color = Color.White;
double intensity = 1;
double angle = 0.35;
double distance = 0;
double decay = 1;
Boolean castShadow = false;
string name = "";
// Reference the inputs
DA.GetData(0, ref position);
DA.GetData(1, ref color);
DA.GetData(2, ref intensity);
DA.GetData(3, ref angle);
DA.GetData(4, ref distance);
DA.GetData(5, ref decay);
DA.GetData(6, ref castShadow);
DA.GetData(7, ref name);
// Build the light object
dynamic lightObject = new ExpandoObject();
lightObject.Uuid = Guid.NewGuid();
lightObject.Type = "SpotLight";
if (name.Length > 0)
{
lightObject.Name = name;
}
lightObject.Color = Convert.ToInt32(color.R.ToString("X2") + color.G.ToString("X2") + color.B.ToString("X2"), 16);;
lightObject.Intensity = intensity;
lightObject.Angle = (Math.PI / 180) * angle;
lightObject.CastShadow = castShadow;
lightObject.Distance = distance;
lightObject.Decay = decay;
lightObject.Matrix = new Matrix(position).Array;
// Create a helper to aid in visualizing the light's behavior
List <Curve> helper = new List <Curve>();
var line = new Rhino.Geometry.Line(position, new Point3d(0, 0, 0));
helper.Add(line.ToNurbsCurve());
Vector3d vector = new Vector3d(new Point3d(0, 0, 0) - position);
Plane plane = new Plane(position, vector);
double radius = vector.Length * Math.Tan((Math.PI / 180) * angle);
Cone cone = new Cone(plane, vector.Length, radius);
Brep brep = cone.ToBrep(false);
for (int i = 0; i < brep.Edges.Count; i++)
{
helper.Add(brep.Edges[i].EdgeCurve);
}
// Create object3d
Object3d object3d = new Object3d(lightObject);
// Set outputs
DA.SetDataList(0, helper);
DA.SetData(1, object3d);
}
