/// <summary> /// Verifies a PolylineCurve is a rectangle /// </summary> public static bool IsRectangle(PolylineCurve curve) { // Curve should be a valid, closed, planar polyline curve with 5 points if (curve == null || !curve.IsValid || !curve.IsClosed || !curve.IsPlanar() || curve.PointCount != 5) return false; // Angle between each segment should be 90 degrees const double angle = 90.0 * (Math.PI / 180.0); for (var i = 1; i < curve.PointCount - 1; i++) { var p0 = curve.Point(i - 1); var p1 = curve.Point(i); var p2 = curve.Point(i + 1); var v0 = p1 - p0; v0.Unitize(); var v1 = p1 - p2; v1.Unitize(); var a = Vector3d.VectorAngle(v0, v1); if (Math.Abs(angle - a) >= RhinoMath.DefaultAngleTolerance) return false; } return true; }
bool IGH_TypeHint.Cast(object data, out object target) { bool toReturn = base.Cast(data, out target); if (toReturn && target != null) { Type t = target.GetType(); if (t == typeof(Line)) target = new LineCurve((Line)target); else if (t == typeof(Arc)) target = new ArcCurve((Arc)target); else if (t == typeof(Circle)) target = new ArcCurve((Circle)target); else if (t == typeof(Ellipse)) target = ((Ellipse)target).ToNurbsCurve(); else if (t == typeof(Box)) target = Brep.CreateFromBox((Box)target); else if (t == typeof(BoundingBox)) target = Brep.CreateFromBox((BoundingBox)target); else if (t == typeof(Rectangle3d)) target = ((Rectangle3d)target).ToNurbsCurve(); else if (target is Polyline) target = new PolylineCurve((Polyline)target); } return toReturn; }
public SilkwormSegment(Curve curve, int mainSegmentCount, int subSegmentCount, double maxAngleRadians, double maxChordLengthRatio, double maxAspectRatio, double tolerance, double minEdgeLength, double maxEdgeLength, bool keepStartPoint) { if (curve != null) { //See if curve can be represented as a polyline already if (curve.TryGetPolyline(out Pline)) { PolylineCurve plinecurve = new PolylineCurve(Pline); //Segments = plinecurve.DuplicateSegments().ToList(); Segments = DuplicateSegments(plinecurve); } //Try to see if conversion will work if (curve.ToPolyline(mainSegmentCount, subSegmentCount, maxAngleRadians, maxChordLengthRatio, maxAspectRatio, tolerance, minEdgeLength, maxEdgeLength, keepStartPoint) != null) { //Convert PolylineCurve plinec = curve.ToPolyline(mainSegmentCount, subSegmentCount, maxAngleRadians, maxChordLengthRatio, maxAspectRatio, tolerance, minEdgeLength, maxEdgeLength, keepStartPoint); if (plinec.TryGetPolyline(out Pline)) { PolylineCurve plinecurve = new PolylineCurve(Pline); //Segments = plinecurve.DuplicateSegments().ToList(); Segments = DuplicateSegments(plinecurve); } } } }
public SilkwormSegment(Curve curve) { if (curve != null) { //See if curve can be represented as a polyline already if (curve.TryGetPolyline(out Pline)) { PolylineCurve plinecurve = new PolylineCurve(Pline); //Segments = plinecurve.DuplicateSegments().ToList(); Segments = DuplicateSegments(plinecurve); } //Try to see if conversion will work if (curve.ToPolyline(0, 0, 0.05, 0.1, 0, 0, 0.1, 0, true) != null) { //Convert PolylineCurve plinec = curve.ToPolyline(0, 0, 0.05, 0.1, 0, 0, 0.1, 0, true); if (plinec.TryGetPolyline(out Pline)) { PolylineCurve plinecurve = new PolylineCurve(Pline); //Segments = plinecurve.DuplicateSegments().ToList(); Segments = DuplicateSegments(plinecurve); } } } }
bool IGH_TypeHint.Cast(object data, out object target) { bool toReturn = base.Cast(data, out target); if (m_component.DocStorageMode == DocReplacement.DocStorage.AutomaticMarshal && target != null) { Type t = target.GetType(); if (t == typeof (Line)) target = new LineCurve((Line) target); else if (t == typeof (Arc)) target = new ArcCurve((Arc) target); else if (t == typeof (Circle)) target = new ArcCurve((Circle) target); else if (t == typeof (Ellipse)) target = ((Ellipse) target).ToNurbsCurve(); else if (t == typeof (Box)) target = Brep.CreateFromBox((Box) target); else if (t == typeof (BoundingBox)) target = Brep.CreateFromBox((BoundingBox) target); else if (t == typeof (Rectangle3d)) target = ((Rectangle3d) target).ToNurbsCurve(); else if (t == typeof (Polyline)) target = new PolylineCurve((Polyline) target); } return toReturn; }
/// <summary> /// Verifies a Polyline is a rectangle /// </summary> public static bool IsRectangle(Polyline polyline) { if (polyline == null) return false; var curve = new PolylineCurve(polyline); return curve.IsValid && IsRectangle(curve); }
/// <summary> /// Initializes a new polyline curve by copying its content from another polyline curve. /// </summary> /// <param name="other">Another polyline curve.</param> public PolylineCurve(PolylineCurve other) { IntPtr pOther= IntPtr.Zero; if (null != other) pOther = other.ConstPointer(); IntPtr ptr = UnsafeNativeMethods.ON_PolylineCurve_New(pOther); ConstructNonConstObject(ptr); }
/***************************************************/ public static void RenderRhinoWires(RHG.PolylineCurve polyline, Rhino.Display.DisplayPipeline pipeline, Color bhColour, int thickness) { RHG.Polyline poly; if (polyline.TryGetPolyline(out poly)) { pipeline.DrawPolyline(poly, bhColour, thickness); } }
/***************************************************/ public static bool IsEqual(this BHG.Polyline bhPolyline, RHG.PolylineCurve rhPolylineCurve, double tolerance = BHG.Tolerance.Distance) { if (bhPolyline == null & rhPolylineCurve == null) { return(true); } RHG.Polyline rhPolyline; rhPolylineCurve.TryGetPolyline(out rhPolyline); return(bhPolyline.IsEqual(rhPolyline, tolerance)); }
/***************************************************/ public static BHG.Polyline FromRhino(this RHG.PolylineCurve polyline) { if (polyline == null) { return(null); } if (!polyline.IsPolyline()) { return(null); } RHG.Polyline rPolyline; polyline.TryGetPolyline(out rPolyline); return(rPolyline.FromRhino()); }
public override void InitializeAgent() { // layoutAcademy = GameObject.FindObjectOfType<Academy>().GetComponent<LayoutAcademy>(); layoutArea = transform.parent.GetComponent <LayoutArea>(); //transform.position = layoutAcademy.agentPosition[agentNumber]; transform.position = layoutArea.agentPosition[agentNumber]; //gridSize = layoutAcademy.gridSize; gridSize = layoutArea.gridSize; x_Ex = layoutArea.x_Ex; y_Ex = layoutArea.y_Ex; shape = layoutArea.shape; offsetShape = layoutArea.offsetShape; }
bool IGH_TypeHint.Cast(object data, out object target) { bool toReturn = base.Cast(data, out target); if (toReturn && _component.DocStorageMode == DocReplacement.DocStorage.AutomaticMarshal && target != null) { Type t = target.GetType(); if (t == typeof (Polyline)) target = new PolylineCurve((Polyline) target); } return toReturn; }
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; List <RG.Point3d> pts = new List <RG.Point3d> { new RG.Point3d(0, 0, 0), new RG.Point3d(5, 10, 0), new RG.Point3d(15, 0, 0), new RG.Point3d(20, 0, 0) }; RG.PolylineCurve pc = new RG.PolylineCurve(pts); RG.NurbsCurve nurb = pc.ToNurbsCurve(); nurb.IncreaseDegree(3); var knots = ToDoubleArray(nurb.Knots, nurb.Degree); var controlPoints = ToXYZArray(nurb.Points, 1); var weights = nurb.Points.ConvertAll(x => x.Weight); XYZ normal = new XYZ(0, 0, 1); XYZ origin = new XYZ(0, 0, 0); Plane rvtPlane = Plane.CreateByNormalAndOrigin(normal, origin); //var plane = sketchPlane.GetPlane().ToPlane(); Curve rvtN = NurbSpline.CreateCurve(nurb.Degree, knots, controlPoints); using (Transaction t = new Transaction(doc, "a")) { t.Start(); SketchPlane sketchPlane = SketchPlane.Create(doc, rvtPlane); ModelCurve mc = doc.Create.NewModelCurve(rvtN, sketchPlane); TaskDialog.Show("r", mc.Id.ToString()); t.Commit(); } return(Result.Succeeded); }
/// <summary> /// Creates grips /// </summary> public bool CreateGrips(PolylineCurve polylineCurve) { if (!SampleCsRectangleHelper.IsRectangle(polylineCurve)) return false; if (GripCount > 0) return false; Plane plane; if (!polylineCurve.TryGetPlane(out plane)) return false; m_plane = plane; m_active_rectangle = new Point3d[5]; for (var i = 0; i < polylineCurve.PointCount; i++) m_active_rectangle[i] = polylineCurve.Point(i); m_original_rectangle = new Point3d[5]; Array.Copy(m_active_rectangle, m_original_rectangle, 5); var line = new Line(); for (var i = 0; i < 4; i++) { var gi = 2 * i; line.From = m_active_rectangle[i]; line.To = m_active_rectangle[i + 1]; m_sample_cs_rectangle_grips[gi].OriginalLocation = line.From; m_sample_cs_rectangle_grips[gi + 1].OriginalLocation = 0.5 * line.From + 0.5 * line.To; m_sample_cs_rectangle_grips[gi].Active = true; m_sample_cs_rectangle_grips[gi + 1].Active = true; } for (var i = 0; i < 8; i++) AddGrip(m_sample_cs_rectangle_grips[i]); return true; }
private float[] GetFourAxis(Rhino.Geometry.Point3d agentPt, Rhino.Geometry.PolylineCurve shapeCrv) { hitsPoints.Clear(); wall[0] = Rhino.Geometry.Surface.CreateExtrusion(shapeCrv, Rhino.Geometry.Vector3d.ZAxis) as Rhino.Geometry.GeometryBase; ray = new Rhino.Geometry.Ray3d(agentPt, Rhino.Geometry.Vector3d.XAxis); hits = Rhino.Geometry.Intersect.Intersection.RayShoot(ray, wall, 1); hitsPoints.AddRange(hits); ray = new Rhino.Geometry.Ray3d(agentPt, Rhino.Geometry.Vector3d.YAxis); hits = Rhino.Geometry.Intersect.Intersection.RayShoot(ray, wall, 1); hitsPoints.AddRange(hits); ray = new Rhino.Geometry.Ray3d(agentPt, Rhino.Geometry.Vector3d.XAxis * -1); hits = Rhino.Geometry.Intersect.Intersection.RayShoot(ray, wall, 1); hitsPoints.AddRange(hits); ray = new Rhino.Geometry.Ray3d(agentPt, Rhino.Geometry.Vector3d.YAxis * -1); hits = Rhino.Geometry.Intersect.Intersection.RayShoot(ray, wall, 1); hitsPoints.AddRange(hits); for (int i = 0; i < hitsPoints.Count; i++) { var dir = hitsPoints[i] - agentPt; Vector2 hitVec = new Vector2((float)dir.X / (float)(gridSize * x_Ex), (float)dir.Y / (float)(gridSize * y_Ex)); if (hitVec.x != 0) { rtnValues[i] = Mathf.Abs(hitVec.x); } if (hitVec.y != 0) { rtnValues[i] = Mathf.Abs(hitVec.y); } } return(rtnValues); }
//HATCH FILL REGION - infills a planar region with a hatching pattern public void Filler(List<double> infDens, List<double> infRot) { double tolerance = 0.001; //double overlaptol = 0.0; double crossSecHyp = Math.Sqrt(Math.Pow(crossSec, 2) * 2); curveInfill = new List<Curve>[planarBreps.Count]; //Create List of Infill Curves for each Planar Region for (int u = 0; u < planarBreps.Count; u++) { //Rotate Plane for Filling double rotationRad = infRot[u] * 0.0174532925; Plane plane = Plane.WorldXY; plane.Rotate(rotationRad, Plane.WorldXY.ZAxis); //Create Bounding Box Box bbox = new Box(); planarBreps[u].GetBoundingBox(plane, out bbox); //Get Corners Point3d[] cornerPts = bbox.GetCorners(); //Draw Parallel Lines LineCurve baseLine = new LineCurve(cornerPts[0], cornerPts[1]); LineCurve baseLine2 = new LineCurve(cornerPts[3], cornerPts[2]); //int nPts = (int)Math.Round((baseLine.Line.Length/crossSec),0); Point3d[] basePts = new Point3d[0]; Point3d[] basePts2 = new Point3d[0]; double length = baseLine.Line.Length; double floatdivisions = length / crossSec; double density = infDens[u]; int divisions = (int)Math.Round((floatdivisions * density)); //Divide Lines by Fill Density ratio baseLine.DivideByCount(divisions, true, out basePts); baseLine2.DivideByCount(divisions, true, out basePts2); if (divisions == 0) { curveInfill[u] = new List<Curve>(); return; } Curve[][] intCurve = new Curve[basePts.Length][]; List<Curve> intCurves = new List<Curve>(); for (int i = 0; i < basePts.Length; i++) { LineCurve intLine = new LineCurve(basePts[i], basePts2[i]); Point3d[] intPts = new Point3d[0]; BrepFace r_Infill = planarBreps[u].Faces[0]; Curve[] int_Curve = new Curve[0]; //Intersect Curves with Regions Intersection.CurveBrepFace(intLine, r_Infill, tolerance, out int_Curve, out intPts); intCurve[i] = int_Curve; //Convert resulting Curves into LineCurves for (int j = 0; j < int_Curve.Length; j++) { LineCurve line = new LineCurve(int_Curve[j].PointAtStart, int_Curve[j].PointAtEnd); intCurve[i][j] = line; //intCurves[j].Add(int_Curve[j]); intCurves.Add(line); } } //Rotate Array List<Curve>[] int_Curves = RotatetoListArray(intCurve); List<Curve> joinLines = new List<Curve>(); List<Curve> p_lines = new List<Curve>(); for (int l = 0; l < int_Curves.Length; l++) { for (int k = 1; k < int_Curves[l].Count; k += 2) { int_Curves[l][k].Reverse(); } } //Create a list of points for all connected lines in the infill. Do this for each seperate string of segments for (int l = 0; l < int_Curves.Length; l++) { List<Point3d> plinePts = new List<Point3d>(); if (int_Curves[l].Count > 0) { plinePts.Add(int_Curves[l][0].PointAtStart); for (int k = 1; k < int_Curves[l].Count; k++) { plinePts.Add(int_Curves[l][k - 1].PointAtEnd); plinePts.Add(int_Curves[l][k].PointAtStart); plinePts.Add(int_Curves[l][k].PointAtEnd); } PolylineCurve plCurve = new PolylineCurve(plinePts); Curve curve = plCurve.ToNurbsCurve(); p_lines.Add(curve); } } List<Curve> curve_s = p_lines; curveInfill[u] = p_lines; } }
public List<Curve> DuplicateSegments(PolylineCurve plinecurve) { List<Curve> lines = new List<Curve>(); ; for (int i = 1; i < plinecurve.PointCount; i++) { Point3d PtA = plinecurve.Point(i - 1); Point3d PtB = plinecurve.Point(i); lines.Add(new LineCurve(PtA, PtB)); } return lines; }
static internal IEnumerable <Rhino.Geometry.GeometryBase> ToRhino(this IEnumerable <Autodesk.Revit.DB.GeometryObject> geometries) { var scaleFactor = Revit.ModelUnits; foreach (var geometry in geometries) { switch (geometry) { case Autodesk.Revit.DB.GeometryInstance instance: foreach (var g in instance.GetInstanceGeometry().ToRhino()) { yield return(g); } break; case Autodesk.Revit.DB.Mesh mesh: var m = mesh.ToRhino(); m.Faces.ConvertTrianglesToQuads(Revit.AngleTolerance, 0.0); if (scaleFactor != 1.0) { m?.Scale(scaleFactor); } yield return(m); break; case Autodesk.Revit.DB.Solid solid: var s = solid.ToRhino(); if (scaleFactor != 1.0) { s?.Scale(scaleFactor); } yield return(s); break; case Autodesk.Revit.DB.Curve curve: var c = curve.ToRhino(); if (scaleFactor != 1.0) { c?.Scale(scaleFactor); } yield return(c); break; case Autodesk.Revit.DB.PolyLine polyline: var p = new Rhino.Geometry.PolylineCurve(polyline.GetCoordinates().ToRhino()); if (scaleFactor != 1.0) { p?.Scale(scaleFactor); } yield return(p); break; } } }
static internal IEnumerable <Rhino.Geometry.Curve> GetPreviewWires(this IEnumerable <Autodesk.Revit.DB.GeometryObject> geometries) { var scaleFactor = Revit.ModelUnits; foreach (var geometry in geometries) { var gs = Revit.ActiveDBDocument.GetElement(geometry.GraphicsStyleId) as GraphicsStyle; if (geometry.Visibility != Visibility.Visible) { continue; } switch (geometry) { case Autodesk.Revit.DB.GeometryInstance instance: foreach (var g in instance.GetInstanceGeometry().GetPreviewWires()) { yield return(g); } break; case Autodesk.Revit.DB.Solid solid: if (solid.Faces.IsEmpty) { continue; } foreach (var edge in solid.Edges.OfType <Edge>()) { var s = edge.AsCurve().ToRhino(); if (scaleFactor != 1.0) { s?.Scale(scaleFactor); } yield return(s); } break; case Autodesk.Revit.DB.Curve curve: var c = curve.ToRhino(); if (scaleFactor != 1.0) { c?.Scale(scaleFactor); } yield return(c); break; case Autodesk.Revit.DB.PolyLine polyline: if (polyline.NumberOfCoordinates <= 0) { continue; } var p = new Rhino.Geometry.PolylineCurve(polyline.GetCoordinates().ToRhino()); if (scaleFactor != 1.0) { p?.Scale(scaleFactor); } yield return(p); break; } } }
internal static GeometryBase CreateGeometryHelper(IntPtr pGeometry, object parent, int subobject_index) { if (IntPtr.Zero == pGeometry) return null; int type = UnsafeNativeMethods.ON_Geometry_GetGeometryType(pGeometry); if (type < 0) return null; GeometryBase rc = null; switch (type) { case idxON_Curve: //1 rc = new Curve(pGeometry, parent, subobject_index); break; case idxON_NurbsCurve: //2 rc = new NurbsCurve(pGeometry, parent, subobject_index); break; case idxON_PolyCurve: // 3 rc = new PolyCurve(pGeometry, parent, subobject_index); break; case idxON_PolylineCurve: //4 rc = new PolylineCurve(pGeometry, parent, subobject_index); break; case idxON_ArcCurve: //5 rc = new ArcCurve(pGeometry, parent, subobject_index); break; case idxON_LineCurve: //6 rc = new LineCurve(pGeometry, parent, subobject_index); break; case idxON_Mesh: //7 rc = new Mesh(pGeometry, parent); break; case idxON_Point: //8 rc = new Point(pGeometry, parent); break; case idxON_TextDot: //9 rc = new TextDot(pGeometry, parent); break; case idxON_Surface: //10 rc = new Surface(pGeometry, parent); break; case idxON_Brep: //11 rc = new Brep(pGeometry, parent); break; case idxON_NurbsSurface: //12 rc = new NurbsSurface(pGeometry, parent); break; case idxON_RevSurface: //13 rc = new RevSurface(pGeometry, parent); break; case idxON_PlaneSurface: //14 rc = new PlaneSurface(pGeometry, parent); break; case idxON_ClippingPlaneSurface: //15 rc = new ClippingPlaneSurface(pGeometry, parent); break; case idxON_Annotation2: // 16 rc = new AnnotationBase(pGeometry, parent); break; case idxON_Hatch: // 17 rc = new Hatch(pGeometry, parent); break; case idxON_TextEntity2: //18 rc = new TextEntity(pGeometry, parent); break; case idxON_SumSurface: //19 rc = new SumSurface(pGeometry, parent); break; case idxON_BrepFace: //20 { int faceindex = -1; IntPtr pBrep = UnsafeNativeMethods.ON_BrepSubItem_Brep(pGeometry, ref faceindex); if (pBrep != IntPtr.Zero && faceindex >= 0) { Brep b = new Brep(pBrep, parent); rc = b.Faces[faceindex]; } } break; case idxON_BrepEdge: // 21 { int edgeindex = -1; IntPtr pBrep = UnsafeNativeMethods.ON_BrepSubItem_Brep(pGeometry, ref edgeindex); if (pBrep != IntPtr.Zero && edgeindex >= 0) { Brep b = new Brep(pBrep, parent); rc = b.Edges[edgeindex]; } } break; case idxON_InstanceDefinition: // 22 rc = new InstanceDefinitionGeometry(pGeometry, parent); break; case idxON_InstanceReference: // 23 rc = new InstanceReferenceGeometry(pGeometry, parent); break; #if USING_V5_SDK case idxON_Extrusion: //24 rc = new Extrusion(pGeometry, parent); break; #endif case idxON_LinearDimension2: //25 rc = new LinearDimension(pGeometry, parent); break; case idxON_PointCloud: // 26 rc = new PointCloud(pGeometry, parent); break; case idxON_DetailView: // 27 rc = new DetailView(pGeometry, parent); break; case idxON_AngularDimension2: // 28 rc = new AngularDimension(pGeometry, parent); break; case idxON_RadialDimension2: // 29 rc = new RadialDimension(pGeometry, parent); break; case idxON_Leader: // 30 rc = new Leader(pGeometry, parent); break; case idxON_OrdinateDimension2: // 31 rc = new OrdinateDimension(pGeometry, parent); break; case idxON_Light: //32 rc = new Light(pGeometry, parent); break; case idxON_PointGrid: //33 rc = new Point3dGrid(pGeometry, parent); break; case idxON_MorphControl: //34 rc = new MorphControl(pGeometry, parent); break; case idxON_BrepLoop: //35 { int loopindex = -1; IntPtr pBrep = UnsafeNativeMethods.ON_BrepSubItem_Brep(pGeometry, ref loopindex); if (pBrep != IntPtr.Zero && loopindex >= 0) { Brep b = new Brep(pBrep, parent); rc = b.Loops[loopindex]; } } break; case idxON_BrepTrim: // 36 { int trimindex = -1; IntPtr pBrep = UnsafeNativeMethods.ON_BrepSubItem_Brep(pGeometry, ref trimindex); if (pBrep != IntPtr.Zero && trimindex >= 0) { Brep b = new Brep(pBrep, parent); rc = b.Trims[trimindex]; } } break; default: rc = new UnknownGeometry(pGeometry, parent, subobject_index); break; } return rc; }
DataTree<Curve> GetContourTree(Mesh mesh, List<double> contourZList) { DataTree<Curve> contourTree = new DataTree<Curve>(); int i = 0; foreach (double z in contourZList) { Polyline[] contour = Rhino.Geometry.Intersect.Intersection.MeshPlane(mesh, new Plane(new Point3d(0, 0, z), new Vector3d(0, 0, 1))); foreach (Polyline contourItem in contour) { PolylineCurve pCurve = new PolylineCurve(contourItem); contourTree.Add(pCurve, new GH_Path(0, i)); } i++; } return contourTree; }
internal static GeometryBase CreateGeometryHelper(IntPtr pGeometry, object parent, int subobjectIndex) { if (IntPtr.Zero == pGeometry) { return(null); } var type = UnsafeNativeMethods.ON_Geometry_GetGeometryType(pGeometry); if (type < 0) { return(null); } GeometryBase rc = null; switch (type) { case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Curve: //1 rc = new Curve(pGeometry, parent, subobjectIndex); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_NurbsCurve: //2 rc = new NurbsCurve(pGeometry, parent, subobjectIndex); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_PolyCurve: // 3 rc = new PolyCurve(pGeometry, parent, subobjectIndex); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_PolylineCurve: //4 rc = new PolylineCurve(pGeometry, parent, subobjectIndex); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_ArcCurve: //5 rc = new ArcCurve(pGeometry, parent, subobjectIndex); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_LineCurve: //6 rc = new LineCurve(pGeometry, parent, subobjectIndex); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Mesh: //7 rc = new Mesh(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Point: //8 rc = new Point(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_TextDot: //9 rc = new TextDot(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Surface: //10 rc = new Surface(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Brep: //11 rc = new Brep(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_NurbsSurface: //12 rc = new NurbsSurface(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_RevSurface: //13 rc = new RevSurface(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_PlaneSurface: //14 rc = new PlaneSurface(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_ClippingPlaneSurface: //15 rc = new ClippingPlaneSurface(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Hatch: // 17 rc = new Hatch(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_SumSurface: //19 rc = new SumSurface(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_BrepFace: //20 { int faceindex = -1; IntPtr ptr_brep = UnsafeNativeMethods.ON_BrepSubItem_Brep(pGeometry, ref faceindex); if (ptr_brep != IntPtr.Zero && faceindex >= 0) { Brep b = new Brep(ptr_brep, parent); rc = b.Faces[faceindex]; } } break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_BrepEdge: // 21 { int edgeindex = -1; IntPtr ptr_brep = UnsafeNativeMethods.ON_BrepSubItem_Brep(pGeometry, ref edgeindex); if (ptr_brep != IntPtr.Zero && edgeindex >= 0) { Brep b = new Brep(ptr_brep, parent); rc = b.Edges[edgeindex]; } } break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_InstanceReference: // 23 rc = new InstanceReferenceGeometry(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Extrusion: //24 rc = new Extrusion(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_PointCloud: // 26 rc = new PointCloud(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_DetailView: // 27 rc = new DetailView(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Light: //32 rc = new Light(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_PointGrid: //33 rc = new Point3dGrid(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_MorphControl: //34 rc = new MorphControl(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_BrepLoop: //35 { int loopindex = -1; IntPtr ptr_brep = UnsafeNativeMethods.ON_BrepSubItem_Brep(pGeometry, ref loopindex); if (ptr_brep != IntPtr.Zero && loopindex >= 0) { Brep b = new Brep(ptr_brep, parent); rc = b.Loops[loopindex]; } } break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_BrepTrim: // 36 { int trimindex = -1; IntPtr ptr_brep = UnsafeNativeMethods.ON_BrepSubItem_Brep(pGeometry, ref trimindex); if (ptr_brep != IntPtr.Zero && trimindex >= 0) { Brep b = new Brep(ptr_brep, parent); rc = b.Trims[trimindex]; } } break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Leader: // 38 rc = new Leader(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_SubD: // 39 rc = new SubD(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_DimLinear: //40 rc = new LinearDimension(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_DimAngular: //41 rc = new AngularDimension(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_DimRadial: //42 rc = new RadialDimension(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_DimOrdinate: //43 rc = new OrdinateDimension(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Centermark: //44 rc = new Centermark(pGeometry, parent); break; case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Text: //45 rc = new TextEntity(pGeometry, parent); break; default: rc = new UnknownGeometry(pGeometry, parent, subobjectIndex); break; } return(rc); }
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> /// Verifies a set of points is a rectangle /// </summary> public static bool IsRectangle(IEnumerable<Point3d> points) { var curve = new PolylineCurve(points); return curve.IsValid && IsRectangle(curve); }
private Brep[] GetBorderWalls(Curve borderCrv, IEnumerable<Point3d> pts, IEnumerable<Vector3d> nrmls, double dist) { List<Point3d> ptsOut = new List<Point3d>(); List<Point3d> ptsIn = new List<Point3d>(); IEnumerator ptEnum = pts.GetEnumerator(); IEnumerator nrmlEnum = nrmls.GetEnumerator(); while ((ptEnum.MoveNext()) && (nrmlEnum.MoveNext())) { Point3d pt = (Point3d)ptEnum.Current; Vector3d nrml = (Vector3d)nrmlEnum.Current; Transform mvOut = Transform.Translation(nrml * dist); Transform mvIn = Transform.Translation(nrml * -dist); Point3d ptOut = new Point3d(pt); Point3d ptIn = new Point3d(pt); ptOut.Transform(mvOut); ptIn.Transform(mvIn); ptsOut.Add(ptOut); ptsIn.Add(ptIn); } Curve crvOut; Curve crvIn; if (borderCrv.IsPolyline()) { crvOut = new PolylineCurve(ptsOut); crvIn = new PolylineCurve(ptsIn); } else { crvOut = Curve.CreateInterpolatedCurve(ptsOut, 3); crvIn = Curve.CreateInterpolatedCurve(ptsIn, 3); } List<Curve> crvs = new List<Curve>(); crvs.Add(crvOut); crvs.Add(crvIn); Brep[] lofts = Brep.CreateFromLoft(crvs, Point3d.Unset, Point3d.Unset, LoftType.Normal, false); Interval interval = new Interval(0, 1); double u, v; u = v = 0.05; BrepFace loftFace = lofts[0].Faces[0]; loftFace.SetDomain(0, interval); loftFace.SetDomain(1, interval); while (u < 1 && v < 1) { if (loftFace.IsPointOnFace(u, v).Equals(PointFaceRelation.Interior)) { break; } u += .05; v += .05; } Point3d loftPt = loftFace.PointAt(u, v); Vector3d loftNrml = loftFace.NormalAt(u, v); Point3d loftPtOut = loftPt; Point3d loftPtIn = loftPt; loftPtOut.Transform(Transform.Translation(loftNrml)); loftNrml.Reverse(); loftPtIn.Transform(Transform.Translation(loftNrml)); Point3d envPtOut = environment.ClosestPoint(loftPtOut); Point3d envPtIn = environment.ClosestPoint(loftPtIn); if (loftPtOut.DistanceTo(envPtOut) < loftPtIn.DistanceTo(envPtIn)) { foreach (Brep brep in lofts) { brep.Flip(); } } return lofts; }
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> /// Constructs a new surface of revolution from a generatrix polyline and an axis. /// <para>This overload accepts a slice start and end angles.</para> /// </summary> /// <param name="revolutePolyline">A generatrix.</param> /// <param name="axisOfRevolution">An axis.</param> /// <param name="startAngleRadians">An angle in radias for the start.</param> /// <param name="endAngleRadians">An angle in radias for the end.</param> /// <returns>A new surface of revolution, or null if any of the inputs is invalid or on error.</returns> public static RevSurface Create(Polyline revolutePolyline, Line axisOfRevolution, double startAngleRadians, double endAngleRadians) { using (PolylineCurve plc = new PolylineCurve(revolutePolyline)) { return Create(plc, axisOfRevolution, startAngleRadians, endAngleRadians); } }
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; //Reference adaptive = uidoc.Selection.PickObject(ObjectType.Element, "Select adaptive family"); //Element adaptiveEle = doc.GetElement(adaptive); //PlanarFace pf = GetFace(adaptiveEle); //TaskDialog.Show("tr", "I am done"); //TaskDialog.Show("tr", "so done"); //TaskDialog.Show("tr", "done done"); List <RG.Point3d> pts = new List <RG.Point3d> { new RG.Point3d(0, 0, 0), new RG.Point3d(5, 10, 0), new RG.Point3d(15, 5, 0), new RG.Point3d(20, 0, 0) }; RG.PolylineCurve pc = new RG.PolylineCurve(pts); RG.Interval d = pc.Domain; //TaskDialog.Show("r", d.ToString()); RG.NurbsCurve value = pc.ToNurbsCurve(); value.IncreaseDegree(3); int newDegree = 3; var degree = value.Degree; var knots = ToDoubleArray(value.Knots, newDegree); var controlPoints = ToXYZArray(value.Points, 1); var weights = value.Points.ConvertAll(x => x.Weight); XYZ normal = new XYZ(0, 0, 1); XYZ origin = new XYZ(0, 0, 0); Plane rvtPlane = Plane.CreateByNormalAndOrigin(normal, origin); string knot = ""; foreach (var item in knots) { knot += item.ToString() + "\n"; } //TaskDialog.Show("r", knot); //TaskDialog.Show("R", $"ControlPoints > Degree: {controlPoints.Length} > {degree}\nKnots = degree + control points + 1 = {controlPoints.Length + degree + 1} "); Curve rvtN = NurbSpline.CreateCurve(newDegree, knots, controlPoints); //Trace.WriteLine() using (Transaction t = new Transaction(doc, "a")) { t.Start(); SketchPlane sketchPlane = SketchPlane.Create(doc, rvtPlane); doc.Create.NewModelCurve(rvtN, sketchPlane); t.Commit(); } return(Result.Succeeded); }
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> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { #region INPUTS List<Curve> things = new List<Curve>(); if (!DA.GetDataList(0, things)) return; #region Optional Inputs int mainSegmentCount = 0; if (!DA.GetData(1, ref mainSegmentCount)) { } int subSegmentCount = 0; if (!DA.GetData(2, ref subSegmentCount)) { } double maxAngleRadians = 0.05; if (!DA.GetData(3, ref maxAngleRadians)) { } double maxChordLengthRatio = 0.1; if (!DA.GetData(4, ref maxChordLengthRatio)) { } double maxAspectRatio = 0; if (!DA.GetData(5, ref maxAspectRatio)) { } double tolerance = 0; if (!DA.GetData(6, ref tolerance)) { } double minEdgeLength = 0.1; if (!DA.GetData(7, ref minEdgeLength)) { } double maxEdgeLength = 0; if (!DA.GetData(8, ref maxEdgeLength)) { } bool keepStartPoint = true; if (!DA.GetData(9, ref keepStartPoint)) { } #endregion #endregion List<Curve>[] lines = new List<Curve>[things.Count]; List<PolylineCurve> polylines = new List<PolylineCurve>(); GH_Structure<GH_Curve> Lines = new GH_Structure<GH_Curve>(); for (int i = 0; i < things.Count; i++) { SilkwormSegment segment = new SilkwormSegment(things[i], mainSegmentCount, subSegmentCount, maxAngleRadians, maxChordLengthRatio, maxAspectRatio, tolerance, minEdgeLength, maxEdgeLength, keepStartPoint); lines[i] = new List<Curve>(); lines[i].AddRange(segment.Segments); PolylineCurve pline = new PolylineCurve(segment.Pline); polylines.Add(pline); } // if (lines.GetUpperBound(0) > 1) // { // for (int i = 0; i < lines.Length; i++) // { // if (lines[i] != null) // { // for (int j = 0; j < lines[i].Count; j++) // { // GH_Curve glines = new GH_Curve(lines[i][j]); // Lines.Insert(glines, new GH_Path(i), j); // } // } // } // } //if (!DA.SetDataTree(0, Lines)) { return; } if (!DA.SetDataList(0, polylines)) { return; } }
/// <summary> /// Gets a polyline approximation of a curve. /// </summary> /// <param name="mainSegmentCount"> /// If mainSegmentCount <= 0, then both subSegmentCount and mainSegmentCount are ignored. /// If mainSegmentCount > 0, then subSegmentCount must be >= 1. In this /// case the nurb will be broken into mainSegmentCount equally spaced /// chords. If needed, each of these chords can be split into as many /// subSegmentCount sub-parts if the subdivision is necessary for the /// mesh to meet the other meshing constraints. In particular, if /// subSegmentCount = 0, then the curve is broken into mainSegmentCount /// pieces and no further testing is performed.</param> /// <param name="subSegmentCount">An amount of subsegments.</param> /// <param name="maxAngleRadians"> /// ( 0 to pi ) Maximum angle (in radians) between unit tangents at /// adjacent vertices.</param> /// <param name="maxChordLengthRatio">Maximum permitted value of /// (distance chord midpoint to curve) / (length of chord).</param> /// <param name="maxAspectRatio">If maxAspectRatio < 1.0, the parameter is ignored. /// If 1 <= maxAspectRatio < sqrt(2), it is treated as if maxAspectRatio = sqrt(2). /// This parameter controls the maximum permitted value of /// (length of longest chord) / (length of shortest chord).</param> /// <param name="tolerance">If tolerance = 0, the parameter is ignored. /// This parameter controls the maximum permitted value of the /// distance from the curve to the polyline.</param> /// <param name="minEdgeLength">The minimum permitted edge length.</param> /// <param name="maxEdgeLength">If maxEdgeLength = 0, the parameter /// is ignored. This parameter controls the maximum permitted edge length. /// </param> /// <param name="keepStartPoint">If true the starting point of the curve /// is added to the polyline. If false the starting point of the curve is /// not added to the polyline.</param> /// <param name="curveDomain">This subdomain of the NURBS curve is approximated.</param> /// <returns>PolylineCurve on success, null on error.</returns> public PolylineCurve ToPolyline(int mainSegmentCount, int subSegmentCount, double maxAngleRadians, double maxChordLengthRatio, double maxAspectRatio, double tolerance, double minEdgeLength, double maxEdgeLength, bool keepStartPoint, Interval curveDomain) { IntPtr ptr = ConstPointer(); PolylineCurve poly = new PolylineCurve(); IntPtr polyOut = poly.NonConstPointer(); bool rc = UnsafeNativeMethods.RHC_RhinoConvertCurveToPolyline(ptr, mainSegmentCount, subSegmentCount, maxAngleRadians, maxChordLengthRatio, maxAspectRatio, tolerance, minEdgeLength, maxEdgeLength, polyOut, keepStartPoint, curveDomain, false); if (!rc) { poly.Dispose(); poly = null; } return poly; }
/// <summary> /// Constructs a nurbs curve representation of this polyline. /// </summary> /// <returns>A Nurbs curve shaped like this polyline or null on failure.</returns> public NurbsCurve ToNurbsCurve() { if (m_size < 2) { return null; } PolylineCurve pl_crv = new PolylineCurve(this); return pl_crv.ToNurbsCurve(); }