private void SetCurveType(Rg.Curve curve)
{
Rg.Circle R = new Rg.Circle();
Rg.Arc A = new Rg.Arc();
Rg.Ellipse S = new Rg.Ellipse();
Rg.Polyline P = new Rg.Polyline();
if (curve.TryGetCircle(out R))
{
curveType = CurveTypes.Circle;
}
else if (curve.TryGetArc(out A))
{
curveType = CurveTypes.Arc;
}
else if (curve.TryGetEllipse(out S))
{
curveType = CurveTypes.Ellipse;
}
else if (curve.IsLinear())
{
curveType = CurveTypes.Line;
}
else if (curve.TryGetPolyline(out P))
{
curveType = CurveTypes.Polyline;
}
else
{
curveType = CurveTypes.Spline;
}
}
public List <Brep> ComputeAnchorGeometry()
{
Vector3d NormNormalVec = NormalVec / NormalVec.Length;
Point3d A = Origin + NormNormalVec * Height1 / 2;
Point3d B = Origin - NormNormalVec * Height1 / 2;
Point3d C = Origin - NormNormalVec * (Height1 / 2 + Height2);
List <Brep> displayGeometry = new List <Brep>();
Rhino.Geometry.Plane planea = new Rhino.Geometry.Plane(A, NormNormalVec);
Rhino.Geometry.Plane planeb = new Rhino.Geometry.Plane(B, NormNormalVec);
Rhino.Geometry.Plane planec = new Rhino.Geometry.Plane(C, NormNormalVec);
Rhino.Geometry.Circle circlea = new Rhino.Geometry.Circle(planea, Radius2);
Rhino.Geometry.Circle circleb = new Rhino.Geometry.Circle(planeb, Radius1);
Rhino.Geometry.Circle circlec = new Rhino.Geometry.Circle(planec, Radius2);
Rhino.Geometry.Cylinder cylindera = new Rhino.Geometry.Cylinder(circlea, Height2);
Rhino.Geometry.Brep brepa = cylindera.ToBrep(true, true);
displayGeometry.Add(brepa);
Rhino.Geometry.Cylinder cylinderb = new Rhino.Geometry.Cylinder(circleb, Height1);
Rhino.Geometry.Brep brepb = cylinderb.ToBrep(true, true);
displayGeometry.Add(brepb);
Rhino.Geometry.Cylinder cylinderc = new Rhino.Geometry.Cylinder(circlec, Height2);
Rhino.Geometry.Brep brepc = cylinderc.ToBrep(true, true);
displayGeometry.Add(brepc);
return(displayGeometry);
}
public static string ToSVG(this Rg.Circle input)
{
Rg.Vector3d axisX = input.Plane.XAxis;
axisX.Unitize();
axisX = axisX * input.Radius;
Rg.Vector3d axisY = input.Plane.YAxis;
axisY.Unitize();
axisY = axisY * input.Radius;
Rg.Point3d A = input.Plane.Origin + axisX;
Rg.Point3d B = input.Plane.Origin + axisY;
axisX.Reverse();
axisY.Reverse();
Rg.Point3d C = input.Plane.Origin + axisX;
Rg.Point3d D = input.Plane.Origin + axisY;
double radians = Rg.Vector3d.VectorAngle(input.Plane.YAxis, Rg.Vector3d.YAxis, Rg.Plane.WorldXY);
double degrees = 180.0 - (radians / Math.PI) * 180.0;
int flip = Convert.ToInt32(!(Rg.Vector3d.VectorAngle(input.Plane.ZAxis, Rg.Vector3d.ZAxis) > 1));
return("M " + A.ToSVG()
+ " A " + input.Radius + ", " + input.Radius + " " + degrees + " 0," + flip + " " + B.ToSVG()
+ " A " + input.Radius + ", " + input.Radius + " " + degrees + " 0," + flip + " " + C.ToSVG()
+ " A " + input.Radius + ", " + input.Radius + " " + degrees + " 0," + flip + " " + D.ToSVG()
+ " A " + input.Radius + ", " + input.Radius + " " + degrees + " 0," + flip + " " + A.ToSVG());
}
protected override void OnDynamicDraw(GetPointDrawEventArgs e)
{
base.OnDynamicDraw(e);
var cplane = e.RhinoDoc.Views.ActiveView.ActiveViewport.ConstructionPlane();
var radius = m_center_point.DistanceTo(e.CurrentPoint);
var circle = new Circle(cplane, m_center_point, radius);
e.Display.DrawCircle(circle, System.Drawing.Color.Black);
}
/// <summary>
/// Returns a Windows Shapes Path from a Rhinocommon Circle
/// </summary>
/// <param name="input">Rhinocommon Circle</param>
/// <returns>System Windows Shapes Path</returns>
public static Sh.Path ToPath(this Rg.Circle input)
{
Sh.Path path = new Sh.Path();
path.Data = input.ToGeometry();
return(path);
}
private string ShootScene(Point3d loc, int res, double lens)
{
// Generate list of point targets in circle around basepoint
var circ = new Rhino.Geometry.Circle(loc, 1);
var circCast = circ.ToNurbsCurve();
var ptParams = circCast.DivideByCount(res, false);
// Get the active vpt
var av = Rhino.RhinoDoc.ActiveDoc.Views.ActiveView;
// Set viewport props
av.ActiveViewport.Camera35mmLensLength = lens;
// Create temp directory
var appdpath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
var myPath = appdpath + @"\aviary\";
System.IO.Directory.CreateDirectory(myPath);
// Clear existing in temp directory
System.IO.DirectoryInfo di = new DirectoryInfo(myPath);
foreach (FileInfo file in di.GetFiles())
{
file.Delete();
}
int nameIterator = 0;
foreach (var par in ptParams)
{
// Convert par to target point
var tar = circCast.PointAt(par);
// Set the camera
av.ActiveViewport.SetCameraLocations(tar, loc);
// Capture the active viewport
using (Bitmap map = av.CaptureToBitmap(new Size(800, 600)))
{
string outputFileName = myPath + "_" + nameIterator.ToString() + ".jpg";
using (MemoryStream memory = new MemoryStream())
{
using (FileStream fs = new FileStream(outputFileName, FileMode.Create, FileAccess.ReadWrite))
{
map.Save(memory, System.Drawing.Imaging.ImageFormat.Jpeg);
byte[] bytes = memory.ToArray();
fs.Write(bytes, 0, bytes.Length);
}
}
}
nameIterator++;
}
return(myPath);
}
/***************************************************/
public static bool IsEqual(this BHG.Circle bhCircle, RHG.Circle rhCircle, double tolerance = BHG.Tolerance.Distance)
{
if (bhCircle == null & rhCircle.Equals(default(RHG.Circle)))
{
return(true);
}
return(bhCircle.Centre.IsEqual(rhCircle.Center, tolerance) &&
bhCircle.Normal.IsEqual(rhCircle.Normal, tolerance) &&
Math.Abs(bhCircle.Radius - rhCircle.Radius) < tolerance);
}
public static Rhino.Commands.Result AddCircle(Rhino.RhinoDoc doc)
{
Rhino.Geometry.Point3d center = new Rhino.Geometry.Point3d(0, 0, 0);
const double radius = 10.0;
Rhino.Geometry.Circle c = new Rhino.Geometry.Circle(center, radius);
if (doc.Objects.AddCircle(c) != Guid.Empty)
{
doc.Views.Redraw();
return Rhino.Commands.Result.Success;
}
return Rhino.Commands.Result.Failure;
}
/***************************************************/
public static RHG.Cylinder ToRhino(this BHG.Cylinder cylinder)
{
if (cylinder == null)
{
return(default(RHG.Cylinder));
}
RHG.Plane plane = new RHG.Plane(cylinder.Centre.ToRhino(), cylinder.Axis.ToRhino());
RHG.Circle circle = new RHG.Circle(plane, cylinder.Radius);
return(new RHG.Cylinder(circle, cylinder.Height));
}
/***************************************************/
public static BHG.ICurve FromRhino(this RHG.Curve rCurve)
{
if (rCurve == null)
{
return(null);
}
Type curveType = rCurve.GetType();
if (rCurve.IsLinear() && rCurve.SpanCount < 2)
{
return(new BHG.Line {
Start = rCurve.PointAtStart.FromRhino(), End = rCurve.PointAtEnd.FromRhino(), Infinite = false
});
}
if (rCurve.IsCircle())
{
RHG.Circle circle = new RHG.Circle();
rCurve.TryGetCircle(out circle);
return(circle.FromRhino());
}
else if (rCurve.IsArc() || typeof(RHG.ArcCurve).IsAssignableFrom(curveType))
{
RHG.Arc arc = new RHG.Arc();
rCurve.TryGetArc(out arc);
return(arc.FromRhino());
}
else if (rCurve.IsPolyline() || typeof(RHG.PolylineCurve).IsAssignableFrom(curveType))
{
RHG.Polyline polyline = new RHG.Polyline();
rCurve.TryGetPolyline(out polyline);
return(polyline.FromRhino());
}
else if (rCurve.IsClosed && rCurve.IsEllipse())
{
RHG.Ellipse ellipse = new RHG.Ellipse();
rCurve.TryGetEllipse(out ellipse);
return(ellipse.FromRhino());
}
else if (rCurve is RHG.NurbsCurve)
{
return(((RHG.NurbsCurve)rCurve).FromRhino());
}
else if (rCurve is RHG.PolyCurve)
{
return(((RHG.PolyCurve)rCurve).FromRhino()); //The test of IsPolyline above is very important to make sure we can cast to PolyCurve here
}
else
{
return((rCurve.ToNurbsCurve()).FromRhino());
}
}
public static Rhino.Commands.Result AddCircle(Rhino.RhinoDoc doc)
{
Rhino.Geometry.Point3d center = new Rhino.Geometry.Point3d(0, 0, 0);
const double radius = 10.0;
Rhino.Geometry.Circle c = new Rhino.Geometry.Circle(center, radius);
if (doc.Objects.AddCircle(c) != Guid.Empty)
{
doc.Views.Redraw();
return(Rhino.Commands.Result.Success);
}
return(Rhino.Commands.Result.Failure);
}
/// <summary>
/// Constructs a new cylinder with a finite height.
/// </summary>
/// <param name="baseCircle">Base circle for cylinder.</param>
/// <param name="height">Height of cylinder (zero for infinite cylinder).</param>
/// <example>
/// <code source='examples\vbnet\ex_addcylinder.vb' lang='vbnet'/>
/// <code source='examples\cs\ex_addcylinder.cs' lang='cs'/>
/// <code source='examples\py\ex_addcylinder.py' lang='py'/>
/// </example>
public Cylinder(Circle baseCircle, double height)
{
m_basecircle = baseCircle;
if (height > 0.0)
{
m_height1 = 0.0;
m_height2 = height;
}
else
{
m_height1 = height;
m_height2 = 0.0;
}
}
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 AddCylinder(Rhino.RhinoDoc doc)
{
Rhino.Geometry.Point3d center_point = new Rhino.Geometry.Point3d(0, 0, 0);
Rhino.Geometry.Point3d height_point = new Rhino.Geometry.Point3d(0, 0, 10);
Rhino.Geometry.Vector3d zaxis = height_point - center_point;
Rhino.Geometry.Plane plane = new Rhino.Geometry.Plane(center_point, zaxis);
double radius = 5;
Rhino.Geometry.Circle circle = new Rhino.Geometry.Circle(plane, radius);
Rhino.Geometry.Cylinder cylinder = new Rhino.Geometry.Cylinder(circle, zaxis.Length);
Rhino.Geometry.Brep brep = cylinder.ToBrep(true, true);
if (brep != null)
{
doc.Objects.AddBrep(brep);
doc.Views.Redraw();
}
return Rhino.Commands.Result.Success;
}
public override void InitializeControls(RhinoObject rhObj)
{
var rc = false;
m_control.ClearRadius();
var circle = new Circle();
if (null != rhObj)
{
rc = GetCircle(rhObj, ref circle);
if (rc)
m_control.Radius = circle.Radius;
}
else
{
var radius = Rhino.RhinoMath.UnsetValue;
var varies = false;
foreach (var rh_obj in SelectedObjects)
{
if (GetCircle(rh_obj, ref circle))
{
if (Rhino.RhinoMath.IsValidDouble(radius))
{
if (System.Math.Abs(radius - circle.Radius) > Rhino.RhinoMath.SqrtEpsilon)
{
radius = Rhino.RhinoMath.UnsetValue;
varies = true;
break;
}
}
else
{
radius = circle.Radius;
}
}
}
if (!varies && Rhino.RhinoMath.IsValidDouble(radius))
{
m_control.Radius = radius;
}
}
}
static System.Xml.XmlElement SvgCircle(Rhino.Geometry.Circle c, System.Xml.XmlDocument doc)
{
var elem = doc.CreateElement("circle");
var attrib = doc.CreateAttribute("cx");
attrib.Value = $"{c.Center.X}";
elem.Attributes.Append(attrib);
attrib = doc.CreateAttribute("cy");
attrib.Value = $"{c.Center.Y}";
elem.Attributes.Append(attrib);
attrib = doc.CreateAttribute("r");
attrib.Value = $"{c.Radius}";
elem.Attributes.Append(attrib);
attrib = doc.CreateAttribute("fill-opacity");
attrib.Value = "0";
elem.Attributes.Append(attrib);
attrib = doc.CreateAttribute("stroke");
attrib.Value = "#000000";
elem.Attributes.Append(attrib);
return(elem);
}
static internal Rhino.Geometry.Curve ToRhino(this Autodesk.Revit.DB.Curve curve)
{
switch (curve)
{
case Autodesk.Revit.DB.Line line:
return(line.IsBound ? new Rhino.Geometry.LineCurve(line.GetEndPoint(0).ToRhino(), line.GetEndPoint(1).ToRhino()) : null);
case Autodesk.Revit.DB.Arc arc:
var plane = new Rhino.Geometry.Plane(arc.Center.ToRhino(), new Vector3d(arc.XDirection.ToRhino()), new Vector3d(arc.YDirection.ToRhino()));
var c = new Rhino.Geometry.Circle(plane, arc.Radius);
if (arc.IsBound)
{
var a = new Rhino.Geometry.Arc(c, new Interval(arc.GetEndParameter(0), arc.GetEndParameter(1)));
return(new Rhino.Geometry.ArcCurve(a));
}
else
{
return(new Rhino.Geometry.ArcCurve(c));
}
}
return(null);
}
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;
}
}
}
/// <summary>Constrains the picked point to lie on a circle.</summary>
/// <param name="circle">A circle to use as constraint.</param>
/// <returns>true if constraint could be applied.</returns>
public bool Constrain(Circle circle)
{
IntPtr ptr = NonConstPointer();
return UnsafeNativeMethods.CRhinoGetPoint_Constrain3(ptr, ref circle);
}
/// <summary>
/// Initializes a circle from two 3d points and a tangent at the first point.
/// The start/end of the circle is at point "startPoint".
/// </summary>
/// <param name="startPoint">Start point of circle.</param>
/// <param name="tangentAtP">Tangent vector at start.</param>
/// <param name="pointOnCircle">Point coincident with desired circle.</param>
/// <remarks>May create an Invalid circle</remarks>
public Circle(Point3d startPoint, Vector3d tangentAtP, Point3d pointOnCircle)
: this()
{
if (!UnsafeNativeMethods.ON_Circle_CreatePtVecPt(ref this, startPoint, tangentAtP, pointOnCircle))
{
this = new Circle();
}
}
protected override void SolveInstance(IGH_DataAccess DA)
{
List<DHr> hours = new List<DHr>();
string alt_key = "solar_altitude";
Interval alt_ival = new Interval(0, Math.PI / 2);
string azm_key = "solar_azimuth";
Interval azm_ival = new Interval(0, Math.PI * 2);
bool cull_night = true;
if (DA.GetDataList(0, hours)) {
this.plot_type = PType.Invalid;
String p_type_string = "";
DA.GetData(4, ref p_type_string);
p_type_string = p_type_string.ToLowerInvariant().Trim();
if (p_type_string.Contains("stereo")) { this.plot_type = PType.Stereo; }
if (p_type_string.Contains("ortho")) { this.plot_type = PType.Ortho; }
if (this.plot_type == PType.Invalid) {
this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Plot type not recognized. Choose 'Ortho' or 'Stereo'.");
return;
}
Plane plane = new Plane(new Point3d(0, 0, 0), new Vector3d(0, 0, 1));
DA.GetData(1, ref plane);
Grasshopper.Kernel.Types.UVInterval ival2d = new Grasshopper.Kernel.Types.UVInterval();
if (!DA.GetData(2, ref ival2d)) {
ival2d.U0 = 0.0;
ival2d.U1 = 1.0;
ival2d.V0 = 0.0;
ival2d.V1 = 1.0;
}
double radius_gr = 3.0;
DA.GetData(3, ref radius_gr);
DA.GetData(5, ref alt_key);
DA.GetData(6, ref azm_key);
DA.GetData(7, ref cull_night);
List<Point3d> points = new List<Point3d>();
Plane drawPlane = new Plane(plane);
if (this.plot_type == PType.Ortho) DA.SetData(5, new Rectangle3d(drawPlane, ival2d.U, ival2d.V)); // set the trimming boundary
if (this.plot_type == PType.Stereo)
{
drawPlane.Origin = new Point3d(plane.Origin.X, plane.Origin.Y + ival2d.V.Mid, plane.Origin.Z);
drawPlane.Rotate(-Math.PI / 2, drawPlane.ZAxis);
ival2d.V0 = radius_gr; // sets the radius of stereographic plots
ival2d.V1 = 0.0;
Circle circ = new Circle(drawPlane, Math.Abs(ival2d.V.Length));
DA.SetData(5, circ); // set the trimming boundary
}
for (int h = 0; h < hours.Count; h++) {
double x = 0;
double y = 0;
switch (this.plot_type) {
case PType.Ortho:
x = ival2d.U.ParameterAt(azm_ival.NormalizedParameterAt(hours[h].val(azm_key)));
y = ival2d.V.ParameterAt(alt_ival.NormalizedParameterAt(hours[h].val(alt_key)));
break;
case PType.Stereo:
double radius = ival2d.V.ParameterAt(alt_ival.NormalizedParameterAt(hours[h].val(alt_key)));
double theta = -hours[h].val(azm_key); // reversed theta to ensure clockwise direction
x = radius * Math.Cos(theta);
y = radius * Math.Sin(theta);
break;
}
Point3d pt = drawPlane.PointAt(x, y);
points.Add(pt);
hours[h].pos = pt; // TODO: solar plots currently record the point in world space, switch to graph space
}
List<Polyline> plines = new List<Polyline>();
List<Color> colors = new List<Color>();
for (int h = 0; h < points.Count; h++)
{
List<Point3d> pts = new List<Point3d>();
DHr prev_hr; if (h > 0) prev_hr = hours[h - 1]; else prev_hr = hours[hours.Count - 1];
DHr this_hr = hours[h];
DHr next_hr; if (h < hours.Count - 1) next_hr = hours[h + 1]; else next_hr = hours[0];
switch (this.plot_type) {
case PType.Ortho:
if ((this_hr.hr - 1 == prev_hr.hr) && (this_hr.pos_x > prev_hr.pos_x)) pts.Add(interp(this_hr.pos, prev_hr.pos, 0.5));
pts.Add(this_hr.pos);
if ((this_hr.hr + 1 == next_hr.hr) && (this_hr.pos_x < next_hr.pos_x)) pts.Add(interp(this_hr.pos, next_hr.pos, 0.5));
break;
case PType.Stereo:
pts.Add(interp(this_hr.pos, prev_hr.pos, 0.5));
pts.Add(this_hr.pos);
pts.Add(interp(this_hr.pos, next_hr.pos, 0.5));
break;
}
plines.Add(new Polyline(pts));
colors.Add(hours[h].color);
}
Mesh mesh = CreateColoredMesh(hours, points, plines, cull_night, alt_key);
mesh.Compact();
mesh.Weld(0.1);
if (cull_night) {
List<DHr> day_hours = new List<DHr>();
List<Point3d> day_points = new List<Point3d>();
List<Polyline> day_plines = new List<Polyline>();
List<Color> day_colors = new List<Color>();
for (int h = 1; h < hours.Count - 1; h++)
{
if (hour_contains_day(hours, h, alt_key))
{
day_hours.Add(hours[h]);
day_points.Add(points[h]);
day_plines.Add(plines[h]);
day_colors.Add(colors[h]);
}
}
hours = day_hours;
points = day_points;
plines = day_plines;
colors = day_colors;
#region failed attempt to trim mesh
//trim mesh
/*
Plane trimPlane = new Plane(plane);
trimPlane.Rotate(Math.PI/2,plane.XAxis);
Mesh trimMesh = Mesh.CreateFromPlane(trimPlane, ival2d.U, new Interval(-0.1, 0.1), 10, 10);
//Mesh[] result = Mesh.CreateBooleanSplit(new Mesh[] { mesh }, new Mesh[] { trimMesh });
Mesh[] result = mesh.Split(trimPlane);
if (result.Length == 1) mesh = result[0];
else if (result.Length == 2) {
Point3d pt = plane.PointAt(0, 1);
Point3d p0 = result[0].ClosestPoint(pt);
Point3d p1 = result[1].ClosestPoint(pt);
if (p0.DistanceTo(pt) < p1.DistanceTo(pt)) mesh = result[0];
else mesh = result[1];
}
*/
#endregion
}
DA.SetDataList(0, new List<DHr>(hours));
DA.SetDataList(1, points);
DA.SetDataList(2, plines);
DA.SetDataList(3, colors);
DA.SetData(4, mesh);
}
}
public PackingCircle(Point3d center, double radius)
{
m_circle = new Circle(center, radius);
}
/// <summary>
/// Draw a single circle object.
/// </summary>
/// <param name="circle">Circle to draw.</param>
/// <param name="color">Color to draw with.</param>
/// <param name="thickness">Thickness (in pixels) of circle.</param>
public void DrawCircle(Circle circle, System.Drawing.Color color, int thickness)
{
int argb = color.ToArgb();
UnsafeNativeMethods.CRhinoDisplayPipeline_DrawCircle(m_ptr, ref circle, argb, thickness);
}
/// <summary>
/// Convert a Rhino circle to a Nucleus one
/// </summary>
/// <param name="circle"></param>
/// <returns></returns>
public static Circle Convert(RC.Circle circle)
{
return(new Circle(circle.Radius, Convert(circle.Plane)));
}
public Geometry(Rg.Circle circle)
{
curveType = CurveTypes.Circle;
curve = circle.ToNurbsCurve();
}
/// <summary>
/// Initializes a new <see cref="ArcCurve"/> instance,
/// copying values from a <see cref="Circle"/> and specifying the
/// needed parametrization of the arc.
/// <para>Circle will not be newly cut at these parameterizations.</para>
/// </summary>
/// <param name="circle">A circle.</param>
/// <param name="t0">A new Domain.T0 value.</param>
/// <param name="t1">A new Domain.T1 value.</param>
public ArcCurve(Circle circle, double t0, double t1)
{
IntPtr ptr = UnsafeNativeMethods.ON_ArcCurve_New5(ref circle, t0, t1);
ConstructNonConstObject(ptr);
}
private void GenerateGeo()
{
model = new Rhino.FileIO.File3dm();
int num = 10;
float outerRad = 2f;
var curves = new List <Rhino.Geometry.NurbsCurve>();
for (int i = 0; i < num; i++)
{
var pt = new Rhino.Geometry.Point3d(0, 0, height / (num - 1) * i);
var circle = new Rhino.Geometry.Circle(pt, pipeRad);
var polygon = Rhino.Geometry.Polyline.CreateInscribedPolygon(circle, segments);
var curve = polygon.ToNurbsCurve();
curve.Rotate(i * Mathf.Deg2Rad * angle, new Rhino.Geometry.Vector3d(0, 0, 1), new Rhino.Geometry.Point3d(0, 0, 0));
curve.Translate(new Rhino.Geometry.Vector3d(Mathf.Cos(Mathf.Deg2Rad * angle * i), Mathf.Sin(Mathf.Deg2Rad * angle * i), 0) * outerRad);
curves.Add(curve);
}
var breps = BrepCompute.CreateFromLoft(curves, Rhino.Geometry.Point3d.Unset, Rhino.Geometry.Point3d.Unset, Rhino.Geometry.LoftType.Normal, false);
var meshList = new List <Rhino.Geometry.Mesh>();
foreach (var brep in breps)
{
var brep2 = brep.CapPlanarHoles(0.001);
// generates two additional breps
var meshes = MeshCompute.CreateFromBrep(brep2);
meshList.AddRange(meshes.ToList());
model.Objects.AddBrep(brep2);
}
foreach (var mesh in meshList)
{
Mesh meshObj = new Mesh();
var vertices = new List <Vector3>();
foreach (var meshVertex in mesh.Vertices)
{
var vertex = new Vector3(meshVertex.X, meshVertex.Z, meshVertex.Y);
vertices.Add(vertex);
}
var triangles = new List <int>();
foreach (var meshFace in mesh.Faces)
{
if (meshFace.IsTriangle)
{
triangles.Add(meshFace.C);
triangles.Add(meshFace.B);
triangles.Add(meshFace.A);
}
else if (meshFace.IsQuad)
{
triangles.Add(meshFace.C);
triangles.Add(meshFace.B);
triangles.Add(meshFace.A);
triangles.Add(meshFace.D);
triangles.Add(meshFace.C);
triangles.Add(meshFace.A);
}
}
var normals = new List <Vector3>();
foreach (var normal in mesh.Normals)
{
normals.Add(new Vector3(normal.X, normal.Z, normal.Y));
}
meshObj.vertices = vertices.ToArray();
meshObj.triangles = triangles.ToArray();
meshObj.normals = normals.ToArray();
GameObject gb = new GameObject();
gb.AddComponent <MeshFilter>().mesh = meshObj;
gb.AddComponent <MeshRenderer>().material = mat;
}
}
private void createModel()
{
/*
* Rhino.Geometry.Point3d origin = Util.openTkToRhinoPoint(Util.vrToPlatformPoint(ref mScene, new OpenTK.Vector3(0, 0, 0)));
* Rhino.Geometry.Point3d normalP1 = Util.openTkToRhinoPoint(Util.vrToPlatformPoint(ref mScene, new OpenTK.Vector3(0, 0, -0.05f)));
* Rhino.Geometry.Point3d normalP2 = Util.openTkToRhinoPoint(Util.vrToPlatformPoint(ref mScene, new OpenTK.Vector3(0, 0, -1)));
* Rhino.Geometry.Vector3d normal = new Rhino.Geometry.Vector3d(normalP2.X - normalP1.X, normalP2.Y - normalP1.Y, normalP2.Z - normalP1.Z);
* Plane plane = new Plane(origin, normal);
* float radius = 20;
* Rhino.Geometry.Circle circle = new Rhino.Geometry.Circle(plane, origin, radius);
* NurbsCurve circleCurve = circle.ToNurbsCurve();
*
* //compute transform to follow controllers
* OpenTK.Matrix4 tansform = mScene.robotToPlatform * mScene.vrToRobot * Util.getControllerTipPosition(ref mScene, primaryControllerIdx == mScene.leftControllerIdx);
* Transform t = Util.OpenTKToRhinoTransform(tansform);
* circleCurve.Transform(t);
* Brep[] shapes = Brep.CreatePlanarBreps(circleCurve);
* Brep circle_s = shapes[0];
* Brep circleBrep = circle_s;
*
* Guid renderObjId = Util.addSceneNode(ref mScene, circleBrep, ref mesh_m, "circle");
*/
//offset the point a little bit to make the plane better
OpenTK.Vector4 controller_p = UtilOld.getControllerTipPosition(ref mScene, primaryControllerIdx == mScene.leftControllerIdx) * new OpenTK.Vector4(0, 0, -0.05f, 1);
OpenTK.Vector4 controller_pZ = UtilOld.getControllerTipPosition(ref mScene, primaryControllerIdx == mScene.leftControllerIdx) * new OpenTK.Vector4(0, 0, -1, 1);
Point3d controller_pRhino = UtilOld.openTkToRhinoPoint(UtilOld.vrToPlatformPoint(ref mScene, new OpenTK.Vector3(controller_p.X, controller_p.Y, controller_p.Z)));
Point3d controller_pZRhin = UtilOld.openTkToRhinoPoint(UtilOld.vrToPlatformPoint(ref mScene, new OpenTK.Vector3(controller_pZ.X, controller_pZ.Y, controller_pZ.Z)));
//fix the x and y axis of the model Plane
OpenTK.Vector4 controller_x1 = UtilOld.getControllerTipPosition(ref mScene, primaryControllerIdx == mScene.leftControllerIdx) * new OpenTK.Vector4(1, 0, 0, 1);
OpenTK.Vector4 controller_y1 = UtilOld.getControllerTipPosition(ref mScene, primaryControllerIdx == mScene.leftControllerIdx) * new OpenTK.Vector4(0, 1, 0, 1);
Point3d controller_x1Rhino = UtilOld.openTkToRhinoPoint(UtilOld.vrToPlatformPoint(ref mScene, new OpenTK.Vector3(controller_x1.X, controller_x1.Y, controller_x1.Z)));
Point3d controller_y1Rhino = UtilOld.openTkToRhinoPoint(UtilOld.vrToPlatformPoint(ref mScene, new OpenTK.Vector3(controller_y1.X, controller_y1.Y, controller_y1.Z)));
OpenTK.Vector4 controller_o = UtilOld.getControllerTipPosition(ref mScene, primaryControllerIdx == mScene.leftControllerIdx) * new OpenTK.Vector4(0, 0, 0, 1);
Point3d controller_oRhino = UtilOld.openTkToRhinoPoint(UtilOld.vrToPlatformPoint(ref mScene, new OpenTK.Vector3(controller_o.X, controller_o.Y, controller_o.Z)));
Rhino.Geometry.Vector3d normal = new Rhino.Geometry.Vector3d(controller_pZRhin.X - controller_oRhino.X, controller_pZRhin.Y - controller_oRhino.Y, controller_pZRhin.Z - controller_oRhino.Z);
normal.Unitize();
modelPlane = new Plane(controller_oRhino, normal);
if (shapeType == ShapeType.Circle)
{
Rhino.Geometry.Circle circle = new Rhino.Geometry.Circle(modelPlane, controller_oRhino, radius);
modelcurve = circle.ToNurbsCurve();
}
else if (shapeType == ShapeType.Rect)
{
Rhino.Geometry.Vector3d xAxis = new Rhino.Geometry.Vector3d(controller_x1Rhino.X - controller_oRhino.X, controller_x1Rhino.Y - controller_oRhino.Y, controller_x1Rhino.Z - controller_oRhino.Z);
xAxis.Unitize();
Rhino.Geometry.Vector3d yAxis = new Rhino.Geometry.Vector3d(controller_y1Rhino.X - controller_oRhino.X, controller_y1Rhino.Y - controller_oRhino.Y, controller_y1Rhino.Z - controller_oRhino.Z);
yAxis.Unitize();
modelPlane.XAxis = xAxis;
modelPlane.YAxis = yAxis;
//Rectangle3d rect = new Rectangle3d(modelPlane, width, height);
Rectangle3d rect = new Rectangle3d(modelPlane, new Interval(-width / 2, width / 2), new Interval(-height / 2, height / 2));
modelcurve = rect.ToNurbsCurve();
}
if (modelcurve != null)
{
Brep[] shapes = Brep.CreatePlanarBreps(modelcurve);
modelBrep = shapes[0];
UtilOld.updateSceneNode(ref mScene, modelBrep, ref mesh_m, "3D-" + shapeType.ToString(), ref previewObjSN);
}
}
protected override void SolveInstance(IGH_DataAccess DA)
{
Curve c = null;
if (!DA.GetData(0, ref c))
{
return;
}
double t = c.GetLength() / 300;
double check = t;
bool fg = false;
switch (flag)
{
case 1:
Rhino.Geometry.Arc arcs = new Arc();
for (int i = 0; i < 301; i++) //循环300次
{
fg = c.TryGetArc(out arcs, check);
if (fg)
{
DA.SetData(0, arcs);
return;
}
check += t;
}
return;
case 2:
Rhino.Geometry.Circle circles = new Rhino.Geometry.Circle();
for (int i = 0; i < 301; i++) //循环300次
{
fg = c.TryGetCircle(out circles, check);
if (fg)
{
DA.SetData(0, circles);
return;
}
check += t;
}
return;
case 3:
Rhino.Geometry.Ellipse ellipse = new Ellipse();
for (int i = 0; i < 301; i++) //循环300次
{
fg = c.TryGetEllipse(out ellipse, check);
if (fg)
{
DA.SetData(0, ellipse);
return;
}
check += t;
}
return;
case 4:
double minseg = c.GetLength() / 400;
double maxseg = c.GetLength() / 10;
PolylineCurve pl = c.ToPolyline(0, 0, Math.PI, 1, 1, 1, minseg, maxseg, true);
DA.SetData(0, pl);
return;
}
}
public static Commands.Result GetCircle(out Rhino.Geometry.Circle circle)
{
circle = new Circle();
uint rc = UnsafeNativeMethods.RHC_RhinoGetCircle(ref circle);
Rhino.Commands.Result cmdRc = (Rhino.Commands.Result)rc;
if (cmdRc != Rhino.Commands.Result.Success)
circle = new Circle();
return cmdRc;
}
/// <summary>
/// Transforms this sphere. Note that non-similarity preserving transformations
/// cannot be applied to a sphere as that would result in an ellipsoid.
/// </summary>
/// <param name="xform">Transformation matrix to apply.</param>
/// <returns>true on success, false on failure.</returns>
public bool Transform(Transform xform)
{
Circle xc = new Circle(m_plane, m_radius);
bool rc = xc.Transform(xform);
if (rc)
{
m_plane = xc.m_plane;
m_radius = xc.m_radius;
}
return rc;
}
protected override void onClickOculusTrigger(ref VREvent_t vrEvent)
{
primaryDeviceIndex = vrEvent.trackedDeviceIndex;
if (currentState != State.READY || targetPRhObjID == Guid.Empty)
{
return;
}
pointOnObjRef = new ObjRef(targetPRhObjID);
//chage to only raycasting to the obj where we draw, if not snap to the origin
if (!(projectP.X == 0 && projectP.Y == 0 && projectP.Z == 0))
{
rayCastingObjs.Clear();
rayCastingObjs.Add(pointOnObjRef);
}
//testing
Vector3 projectPVR = UtilOld.platformToVRPoint(ref mScene, UtilOld.RhinoToOpenTKPoint(projectP));
mScene.iPointList.Add(UtilOld.platformToVRPoint(ref mScene, projectPVR)); //not use at the current version, point is VR coordinate
pointsList.Add(projectP);
//render edit points in VR
Geometry.Geometry geo = new Geometry.DrawPointMarker(new Vector3(0, 0, 0));
Material.Material m = new Material.SingleColorMaterial(0, 1, 0, 1);
SceneNode editPointSN;
UtilOld.MarkPointVR(ref mScene, projectPVR, ref geo, ref m, out editPointSN);
pointMarkers.Add(editPointSN);
//TODO-hide two other design plane
if (pointMarkers.Count == 1)
{
if (pointOnObjRef != null && drawnType == DrawnType.Plane)
{
if (!(projectP.X == 0 && projectP.Y == 0 && projectP.Z == 0))
{
UtilOld.hideOtherPlanes(ref mScene, pointOnObjRef.Object().Attributes.Name);
}
computeContourCurve();
}
//TODO- how to find the curvePlane on the surface like teapot body, using the normal of first point?
//do we need to use different ways for patch surface and other generated surface
else if (pointOnObjRef != null && drawnType == DrawnType.Surface)
{
computeContourCurve();
}
}
if (maxNumPoint == pointMarkers.Count)
{
//Assume we always can find a curvePlane sicnce we use a huge tolerance
NurbsCurve modelcurve = null;
Brep modelBrep;
string modelName = "";
if (shapeType == ShapeType.Circle)
{
float radius = (float)Math.Sqrt(Math.Pow(pointsList[1].X - pointsList[0].X, 2) + Math.Pow(pointsList[1].Y - pointsList[0].Y, 2) + Math.Pow(pointsList[1].Z - pointsList[0].Z, 2));
Circle circle = new Rhino.Geometry.Circle(curvePlane, pointsList[0], radius);
modelcurve = circle.ToNurbsCurve();
modelName = "Circle";
}
else if (shapeType == ShapeType.Rect)
{
Vector3 rectDiagonalV = new Vector3((float)(pointsList[0].X - pointsList[1].X), (float)(pointsList[0].Y - pointsList[1].Y), (float)(pointsList[0].Z - pointsList[1].Z));
float lenDiagonal = rectDiagonalV.Length;
Vector3 rectLeftTop = new Vector3((float)pointsList[0].X, (float)pointsList[0].Y, (float)pointsList[0].Z) + lenDiagonal * rectDiagonalV.Normalized();
Point3d topLeftP = new Point3d(rectLeftTop.X, rectLeftTop.Y, rectLeftTop.Z);
Rectangle3d rect = new Rectangle3d(curvePlane, topLeftP, pointsList[1]);
//using top-left cornel and bottom right
//Rectangle3d rect = new Rectangle3d(curvePlane, pointsList[0], pointsList[1]);
modelcurve = rect.ToNurbsCurve();
modelName = "Rect";
}
/*
* Brep[] shapes = Brep.CreatePlanarBreps(modelcurve);
* modelBrep = shapes[0];
* Guid guid = Util.addRhinoObjectSceneNode(ref mScene, ref modelBrep, ref profile_m, modelName, out renderObjSN);
*/
//generate new curveOnObj for mvoingPlane cases sicne and move the XYZPlanes to origial positons
if (drawnType == DrawnType.Plane)
{
Rhino.Geometry.Vector3d newNormal = new Rhino.Geometry.Vector3d();;
Point3d newOrigin = new Point3d();
String planeName = pointOnObjRef.Object().Attributes.Name;
Point3d planeOrigin = pointOnObjRef.Object().Geometry.GetBoundingBox(true).Center;
if (planeName.Contains("planeXY"))
{
newNormal = new Rhino.Geometry.Vector3d(0, 0, 1);
newOrigin = new Point3d(0, 0, planeOrigin.Z);
}
else if (planeName.Contains("planeYZ"))
{
newNormal = new Rhino.Geometry.Vector3d(1, 0, 0);
newOrigin = new Point3d(planeOrigin.X, 0, 0);
}
else if (planeName.Contains("planeXZ"))
{
newNormal = new Rhino.Geometry.Vector3d(0, 1, 0);
newOrigin = new Point3d(0, planeOrigin.Y, 0);
}
Plane newPlane = new Plane(newOrigin, newNormal);
int size = 240;
PlaneSurface plane_surface = new PlaneSurface(newPlane, new Interval(-size, size), new Interval(-size, size));
Brep newPlaneBrep = Brep.CreateFromSurface(plane_surface);
Guid newPlaneID = UtilOld.addRhinoObject(ref mScene, ref newPlaneBrep, "MoveP");
//might be better to use Replace(), just need to be careful about the referece count
pointOnObjRef = null;
pointOnObjRef = new ObjRef(newPlaneID);
modelcurve.SetUserString(CurveData.CurveOnObj.ToString(), newPlaneID.ToString());
modelcurve.SetUserString(CurveData.PlaneOrigin.ToString(), newPlane.Origin.ToString());
modelcurve.SetUserString(CurveData.PlaneNormal.ToString(), newPlane.Normal.ToString());
}
else if (drawnType == DrawnType.Surface)
{
modelcurve.SetUserString(CurveData.CurveOnObj.ToString(), pointOnObjRef.ObjectId.ToString());
modelcurve.SetUserString(CurveData.PlaneOrigin.ToString(), curvePlane.Origin.ToString());
modelcurve.SetUserString(CurveData.PlaneNormal.ToString(), curvePlane.Normal.ToString());
}
mScene.iCurveList.Add(modelcurve);
//call next interaction in the chain
afterCurveCount = mScene.iCurveList.Count;
mScene.pushInteractionFromChain();
currentState = State.READY;
}
}
// Start is called before the first frame update
void Start()
{
ComputeServer.AuthToken = authToken;
var model = new Rhino.FileIO.File3dm();
var curves = new List <Rhino.Geometry.NurbsCurve>();
for (int i = 0; i < 20; i++)
{
var s = 10f;
var pt = new Rhino.Geometry.Point3d(Random.Range(-s, s), Random.Range(-s, s), 0);
// model.Objects.AddPoint(pt);
var r = Random.Range(1f, 3f);
var circle = new Rhino.Geometry.Circle(pt, r);
var curve = circle.ToNurbsCurve();
curves.Add(curve);
}
var unionCrvsC = CurveCompute.CreateBooleanUnion(curves);
var height = Random.Range(1f, 5f);
var extrusions = new List <Rhino.Geometry.Extrusion>();
foreach (var unionCrvC in unionCrvsC)
{
var extrusion = Rhino.Geometry.Extrusion.Create(unionCrvC, height, true);
model.Objects.AddExtrusion(extrusion);
extrusions.Add(extrusion);
}
var meshList = new List <Rhino.Geometry.Mesh>();
foreach (var extrusion in extrusions)
{
var brep = extrusion.ToBrep();
var meshes = MeshCompute.CreateFromBrep(brep);
meshList.AddRange(meshes.ToList());
}
foreach (var mesh in meshList)
{
Mesh meshObj = new Mesh();
var vertices = new List <Vector3>();
// mesh.RebuildNormals();
foreach (var meshVertex in mesh.Vertices)
{
var vertex = new Vector3(meshVertex.X, meshVertex.Z, meshVertex.Y);
vertices.Add(vertex);
}
var triangles = new List <int>();
foreach (var meshFace in mesh.Faces)
{
if (meshFace.IsTriangle)
{
triangles.Add(meshFace.C);
triangles.Add(meshFace.B);
triangles.Add(meshFace.A);
}
else if (meshFace.IsQuad)
{
triangles.Add(meshFace.C);
triangles.Add(meshFace.B);
triangles.Add(meshFace.A);
triangles.Add(meshFace.D);
triangles.Add(meshFace.C);
triangles.Add(meshFace.A);
}
}
meshObj.vertices = vertices.ToArray();
meshObj.triangles = triangles.ToArray();
meshObj.RecalculateNormals();
GameObject gb = new GameObject();
gb.AddComponent <MeshFilter>().mesh = meshObj;
gb.AddComponent <MeshRenderer>().material = mat;
}
var path = Application.dataPath + "/../Outputs/model.3dm";
model.Write(path, 5);
}
// compute plate and output polyline
public void ComputePlates()
{
// set up second type of plate
for (int i = 0; i < oSpringMesh.Vertices.Count; i++)
{
Point3d vertexPosition = oSpringMesh.Vertices[i].Position;
Point3d closeVertice = Point3dList.ClosestPointInList(iClosedPanelPts, vertexPosition);
if (ICD.Utils.Distance(closeVertice, vertexPosition) < iClosePanelDist)
oVertexPanel2[i] = true;
}
// attractor thickness
for (int i = 0; i < oSpringMesh.Vertices.Count; i++)
{
Point3d vertexPosition = oSpringMesh.Vertices[i].Position;
// different thickness
Point3d closestPt = Point3dList.ClosestPointInList(iAttrThicknessPts, vertexPosition);
double distValue = ICD.Utils.Distance(vertexPosition, closestPt);
if (iHeightThickness) // adding z coordinate as account
{
double k = vertexPosition.Z * 0.125;
distValue *= k * iMinThickness + (0.5 - k) * iMaxThickness;
}
othickness.Add(distValue);
}
// fix the second type plate area thickness
for (int i = 0; i < oSpringMesh.Vertices.Count; i++)
{
Vertex vt = oSpringMesh.Vertices[i];
//List<int> Neighbours = v.NeighborVertexIndices;
oInfo += "i = " + i.ToString() + ", value = " + oVertexPanel2[i] + "\n";
foreach (int n in vt.NeighborVertexIndices)
{
if (oVertexPanel2[n] == true)
{
oInfo += "n = " + n.ToString() + ", value = " + oVertexPanel2[n] + "\n";
oInfo += n.ToString() + " get it \n";
double temp = othickness[n];
othickness[i] = temp;
}
}
oInfo += "==============================\n";
}
// remap
double max = othickness.Max();
double min = othickness.Min();
// map(value, low1, high1, low2, high2) = > low2 + (value - low1) * (high2 - low2) / (high1 - low1)
for (int i = 0; i < othickness.Count; i++)
othickness[i] = iMinThickness + (othickness[i] - min) * (iMaxThickness - iMinThickness) / (max - min);
// ------------------------- end attractors --------------------------------------------------------------------------
// test
foreach (int id in iID)
{
Circle c = new Circle(oSpringMesh.Vertices[id].Position, 0.2);
oDebugList.Add(NurbsCurve.CreateFromCircle(c));
}
// create plate using TPI
DualTPI(false);
DualTPI(true);
}
/// <summary>
/// Try to convert this curve into a circle using RhinoMath.ZeroTolerance.
/// </summary>
/// <param name="circle">On success, the Circle will be filled in.</param>
/// <returns>true if the curve could be converted into a Circle.</returns>
public bool TryGetCircle(out Circle circle)
{
return TryGetCircle(out circle, RhinoMath.ZeroTolerance);
}
private bool GetCircle(RhinoObject rhObj, ref Circle circle)
{
var rc = false;
if (null != rhObj)
{
var curve_obj = rhObj as CurveObject;
if (null != curve_obj)
{
var arc_curve = curve_obj.CurveGeometry as ArcCurve;
if (null != arc_curve && arc_curve.IsCompleteCircle)
{
circle = new Circle(arc_curve.Arc);
rc = true;
}
}
}
return rc;
}
/// <summary>
/// Construct a radial dimension from 3d input
/// </summary>
/// <param name="circle"></param>
/// <param name="arrowTip">3d point on the circle at the dimension arrow tip</param>
/// <param name="offsetDistance">distance from arrow tip to knee point</param>
public RadialDimension(Circle circle, Point3d arrowTip, double offsetDistance)
{
IntPtr pThis = UnsafeNativeMethods.ON_RadialDimension2_New();
ConstructNonConstObject(pThis);
Point3d center = circle.Center;
Vector3d xAxis = circle.Plane.XAxis;
Vector3d normal = circle.Normal;
UnsafeNativeMethods.ON_RadialDimension2_CreateFromPoints(pThis, center, arrowTip, xAxis, normal, offsetDistance);
}
public bool SetFromCircle(Circle circle)
{
IntPtr pThis = NonConstPointer();
return UnsafeNativeMethods.CRhinoGumball_SetFromCircle(pThis, ref circle);
}
/// <summary>
/// Returns a Windows Media Ellipse from a Rhinocommon Circle
/// </summary>
/// <param name="input">Rhinocommon Circle</param>
/// <returns>System Windows Media Circle</returns>
public static Sm.EllipseGeometry ToGeometry(this Rg.Circle input)
{
return(new Sm.EllipseGeometry(input.Center.ToWindowsPoint(), input.Radius, input.Radius));
}
public void CaculateAm()
{
for (int i = 0; i < mesh.Faces.Count; i++)
{
int[] f = vs.IndicesFromFace(i);
Point3d p1 = vs[f[0]];
Point3d p2 = vs[f[1]];
Point3d p3 = vs[f[2]];
Circle circle = new Circle(p1, p2, p3);
double a = p1.DistanceTo(p2);
double b = p1.DistanceTo(p3);
double c = p2.DistanceTo(p3);
// Print(f.Length.ToString());
// Print(a.ToString() + "/" + b.ToString() + "/" + c.ToString());
Point3d ci = new Point3d();
int sign = 0;
if (c >= a && c >= b)
{
if ((c * c) < (a * a + b * b))
{
ci = circle.Center;
}
else { ci = (p2 + p3) / 2; sign = 1; }
}
else if (a >= c && a >= b)
{
if ((a * a) < (c * c + b * b))
{
ci = circle.Center;
}
else { ci = (p2 + p1) / 2; sign = 2; }
}
else if (b >= a && b >= c)
{
if ((b * b) < (a * a + c * c))
{
ci = circle.Center;
}
else { ci = (p1 + p3) / 2; sign = 3; }
}
else
{ //Print("error");
}
Point3d p1p2 = (p1 + p2) / 2;
Point3d p1p3 = (p1 + p3) / 2;
Point3d p2p3 = (p3 + p2) / 2;
if (sign == 0)
{
ps[f[0]].Am += areaTri(ci, p1, p1p2) + areaTri(ci, p1, p1p3);
ps[f[1]].Am += areaTri(ci, p2, p1p2) + areaTri(ci, p2, p2p3);
ps[f[2]].Am += areaTri(ci, p3, p1p3) + areaTri(ci, p3, p2p3);
}
else if (sign == 1)
{
ps[f[1]].Am += areaTri(ci, p2, p1p2);
ps[f[2]].Am += areaTri(ci, p3, p1p3);
ps[f[0]].Am += areaTri(ci, p1, p1p2) + areaTri(ci, p1, p1p3);
}
else if (sign == 2)
{
ps[f[1]].Am += areaTri(ci, p2, p2p3);
ps[f[0]].Am += areaTri(ci, p1, p1p3);
ps[f[2]].Am += areaTri(ci, p3, p1p3) + areaTri(ci, p3, p2p3);
}
else if (sign == 3)
{
ps[f[0]].Am += areaTri(ci, p1, p1p2);
ps[f[2]].Am += areaTri(ci, p3, p2p3);
ps[f[1]].Am += areaTri(ci, p2, p1p2) + areaTri(ci, p2, p2p3);
}
else
{// Print("error");
}
//////////////////
ps[f[0]].KG += Vector3d.VectorAngle(p2 - p1, p3 - p1);
ps[f[1]].KG += Vector3d.VectorAngle(p1 - p2, p3 - p2);
ps[f[2]].KG += Vector3d.VectorAngle(p2 - p3, p1 - p3);
/////////////////
}
for (int i = 0; i < el.Count; i++)
{
int[] f = el.GetConnectedFaces(i);
if (f.Length == 2)
{
///////////////
int pi1 = el.GetTopologyVertices(i).I;
int pi2 = el.GetTopologyVertices(i).J;
int pf1 = 0; int pf2 = 0;
int[] vi1 = vs.IndicesFromFace(f[0]);
for (int j = 0; j < 3; j++)
{
if (vi1[j] != pi1 && vi1[j] != pi2)
{
pf1 = vi1[j]; break;
}
}
int[] vi2 = vs.IndicesFromFace(f[1]);
for (int j = 0; j < 3; j++)
{
if (vi2[j] != pi1 && vi2[j] != pi2)
{
pf2 = vi2[j]; break;
}
}
double ang1 = Vector3d.VectorAngle(vs[pi1] - vs[pf1], vs[pi2] - vs[pf1]);
double ang2 = Vector3d.VectorAngle(vs[pi1] - vs[pf2], vs[pi2] - vs[pf2]);
if (ang1 == Math.PI / 2) { ang1 = 0; } else { ang1 = 1 / Math.Tan(ang1); }
if (ang2 == Math.PI / 2) { ang2 = 0; } else { ang2 = 1 / Math.Tan(ang2); }
double total = ang1 + ang2;
double t1 = Vector3d.Multiply(ps[pi1].n, (vs[pi1] - vs[pi2]));
double t2 = Vector3d.Multiply(ps[pi2].n, (vs[pi2] - vs[pi1]));
ps[pi1].KH += t1 * total;
ps[pi2].KH += t2 * total;
////////////////
}
}
}
private void setoutPutData(int i3, string p, IGH_DataAccess DA)
{
//Rhino.Geometry.NurbsSurface.CreateFromCorners()
//Line input
if (matchLine.Match(p).Value != "")
{
if (p.Contains(@")', 'gCPy.Line("))
{
p = p.Replace("'gCPy.Line(", "'(").Replace("'", "").Replace("[", "").Replace("]", "").Replace("(", "").Replace("),", "#").Replace(")", "");
string[] lines = p.Split('#');
List <Rhino.Geometry.Line> lns = new List <Rhino.Geometry.Line>();
for (int i = 0; i < lines.Length; i++)
{
var thisL = lines[i].Split(',');
Rhino.Geometry.Line lx = new Rhino.Geometry.Line(double.Parse(thisL[0].Trim()),
double.Parse(thisL[1].Trim()),
double.Parse(thisL[2].Trim()),
double.Parse(thisL[3].Trim()),
double.Parse(thisL[4].Trim()),
double.Parse(thisL[5].Trim()));
lns.Add(lx);
}
DA.SetDataList(i3, lns);
}
// Single Point input
else
{
var numbers = matchLine.Match(p).Value.Split(',');
Line lx = new Line(double.Parse(numbers[0]), double.Parse(numbers[1]), double.Parse(numbers[2]),
double.Parse(numbers[3]), double.Parse(numbers[4]), double.Parse(numbers[5]));
DA.SetData(i3, lx);
}
}
//Point input
else if (matchPoint.Match(p).Value != "")
{
// Point List input
if (p.Contains(@")', 'gCPy.Point("))
{
p = p.Replace("'gCPy.Point(", "'(").Replace("'", "").Replace("[", "").Replace("]", "").Replace("(", "").Replace("),", "#").Replace(")", "");
string[] points = p.Split('#');
List <Rhino.Geometry.Point3d> pts = new List <Rhino.Geometry.Point3d>();
for (int i = 0; i < points.Length; i++)
{
var thisP = points[i].Split(',');
Rhino.Geometry.Point3d px = new Rhino.Geometry.Point3d(new Point3d(double.Parse(thisP[0].Trim()), double.Parse(thisP[1].Trim()), double.Parse(thisP[2].Trim())));
pts.Add(px);
}
DA.SetDataList(i3, pts);
}
// Single Point input
else
{
var numbers = matchPoint.Match(p).Value.Split(',');
Rhino.Geometry.Point px = new Rhino.Geometry.Point(new Point3d(double.Parse(numbers[0]), double.Parse(numbers[1]), double.Parse(numbers[2])));
DA.SetData(i3, px);
}
}
else if (matchCircle.Match(p).Value != "")
{
var numbers = matchCircle.Match(p).Value.Split(',');
Rhino.Geometry.Plane pl = new Plane(new Point3d(double.Parse(numbers[0]), double.Parse(numbers[1]), double.Parse(numbers[2])),
new Vector3d(double.Parse(numbers[4]), double.Parse(numbers[5]), double.Parse(numbers[6])),
new Vector3d(double.Parse(numbers[7]), double.Parse(numbers[8]), double.Parse(numbers[9])));
Rhino.Geometry.Circle cx = new Rhino.Geometry.Circle(pl, double.Parse(numbers[3]));
DA.SetData(i3, cx);
}
else if (matchSurface.Match(p).Value != "")
{
var numbers = matchSurface.Match(p).Value.Split(',');
NurbsSurface srf = NurbsSurface.CreateFromCorners(new Point3d(double.Parse(numbers[0]), double.Parse(numbers[1]), double.Parse(numbers[2])),
new Point3d(double.Parse(numbers[3]), double.Parse(numbers[4]), double.Parse(numbers[5])),
new Point3d(double.Parse(numbers[6]), double.Parse(numbers[7]), double.Parse(numbers[8])),
new Point3d(double.Parse(numbers[9]), double.Parse(numbers[10]), double.Parse(numbers[11])));
DA.SetData(i3, srf);
}
else
{
DA.SetData(i3, p);
}
}
/// <summary>
/// Initializes a new <see cref="ArcCurve"/> instance,
/// copying the shape of a <see cref="Circle"/>.
/// <para>Parameterization will be [0;circle.Circumference]</para>
/// </summary>
/// <param name="circle">The original circle.</param>
public ArcCurve(Circle circle)
{
IntPtr ptr = UnsafeNativeMethods.ON_ArcCurve_New4(ref circle);
ConstructNonConstObject(ptr);
}
/***************************************************/
public static void RenderRhinoWires(RHG.Circle circle, Rhino.Display.DisplayPipeline pipeline, Color bhColour, int thickness)
{
pipeline.DrawCircle(circle, bhColour, thickness);
}
// If m_height1 == m_height2, the cylinder is infinite,
// Otherwise, m_height1 < m_height2 and the center of
// the "bottom" cap is
// m_basecircle.plane.origin + m_height1*m_basecircle.plane.zaxis,
// and the center of the top cap is
// m_basecircle.plane.origin + m_height2*m_basecircle.plane.zaxis.
/// <summary>
/// Constructs a new cylinder with infinite height.
/// </summary>
/// <param name="baseCircle">Base circle for infinite cylinder.</param>
public Cylinder(Circle baseCircle)
{
m_basecircle = baseCircle;
m_height1 = 0.0;
m_height2 = 0.0;
}
/// <summary>
/// Adds a new, colored arc to the display list.
/// </summary>
/// <param name="circle">Circle to add.</param>
/// <param name="color">Color of circle.</param>
public void AddCircle(Circle circle, Color color)
{
if (m_disposed) { throw new ObjectDisposedException("This CustomDisplay instance has been disposed and cannot be modified"); }
AddCircle(circle, color, 1);
}
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;
}
}
}
/// <summary>
/// Adds a new, colored circle to the display list.
/// </summary>
/// <param name="circle">Circle to add.</param>
/// <param name="color">Color of circle.</param>
/// <param name="thickness">Thickness of circle.</param>
public void AddCircle(Circle circle, Color color, int thickness)
{
if (m_disposed) { throw new ObjectDisposedException("This CustomDisplay instance has been disposed and cannot be modified"); }
if (!circle.IsValid) { return; }
AddArc(new Arc(circle, 2.0 * Math.PI), color, thickness);
}
/// <summary>
/// Try to convert this curve into a Circle using a custom tolerance.
/// </summary>
/// <param name="circle">On success, the Circle will be filled in.</param>
/// <param name="tolerance">Tolerance to use when checking.</param>
/// <returns>true if the curve could be converted into a Circle within tolerance.</returns>
/// <example>
/// <code source='examples\vbnet\ex_circlecenter.vb' lang='vbnet'/>
/// <code source='examples\cs\ex_circlecenter.cs' lang='cs'/>
/// <code source='examples\py\ex_circlecenter.py' lang='py'/>
/// </example>
public bool TryGetCircle(out Circle circle, double tolerance)
{
circle = new Circle();
Arc arc;
if (TryGetArc(out arc, tolerance))
{
if (arc.IsCircle)
{
circle = new Circle(arc);
return true;
}
}
return false;
}
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);
}
public Mesh MeshTorus(Circle c, double t)
{
double cut = 64;
List<Polyline> ls2 = new List<Polyline>();
for (int i = 0; i < cut; i++)
{
List<Point3d> ls = new List<Point3d>();
ls.Add(new Point3d(1, 0, 0));
ls.Add(new Point3d(0.707, 0, 0.707));
ls.Add(new Point3d(0, 0, 1));
ls.Add(new Point3d(-0.707, 0, 0.707));
ls.Add(new Point3d(-1, 0, 0));
ls.Add(new Point3d(-0.707, 0, -0.707));
ls.Add(new Point3d(0, 0, -1));
ls.Add(new Point3d(0.707, 0, -0.707));
Polyline l1 = new Polyline();
l1.AddRange(ls);
l1.Reverse();
l1.Transform(Transform.Scale(Point3d.Origin, t));
//l1.Transform(Transform.Translation(new Vector3d(c.Radius - t, 0, 0)));
l1.Transform(Transform.Translation(new Vector3d(c.Radius, 0, 0)));
l1.Transform(Transform.Rotation(Math.PI / (double)cut * 2 * i, Point3d.Origin));
ls2.Add(l1);
}
Mesh mesh1 = MeshLoft(ls2, true, true);
mesh1.Transform(Transform.PlaneToPlane(Plane.WorldXY, c.Plane));
return mesh1;
}
/***************************************************/
public static BHG.Circle FromRhino(this RHG.Circle circle)
{
return(new BHG.Circle {
Centre = circle.Center.FromRhino(), Normal = circle.Normal.FromRhino(), Radius = circle.Radius
});
}