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; } }
/// <summary> /// Returns a Windows Media Path Geometry from a Rhinocommon Arc /// </summary> /// <param name="input">Rhinocommon Arc</param> /// <returns>System Windows Media Path Geometry</returns> public static Sm.PathGeometry ToGeometry(this Rg.Arc input) { Sm.ArcSegment arc = new Sm.ArcSegment(); Sm.PathFigure figure = new Sm.PathFigure(); Sm.PathGeometry geometry = new Sm.PathGeometry(); Sm.PathFigureCollection figureCollection = new Sm.PathFigureCollection(); Sm.PathSegmentCollection segmentCollection = new Sm.PathSegmentCollection(); figure.StartPoint = input.StartPoint.ToWindowsPoint(); arc.Point = input.EndPoint.ToWindowsPoint(); arc.Size = new Sw.Size(input.Radius, input.Radius); if (Rg.Vector3d.VectorAngle(input.Plane.Normal, Rg.Vector3d.ZAxis) > 0) { arc.SweepDirection = Sm.SweepDirection.Counterclockwise; } else { arc.SweepDirection = Sm.SweepDirection.Clockwise; } arc.IsLargeArc = (input.Angle > Math.PI); segmentCollection.Add(arc); figure.Segments = segmentCollection; figureCollection.Add(figure); geometry.Figures = figureCollection; return(geometry); }
/// <summary> /// Returns a Windows Media Path from a Rhinocommon Arc /// </summary> /// <param name="input">Rhinocommon Arc</param> /// <returns>System Windows Shapes Path</returns> public static Sh.Path ToPath(this Rg.Arc input) { Sh.Path path = new Sh.Path(); path.Data = input.ToGeometry(); return(path); }
/***************************************************/ /**** Public Methods - Curves ****/ /***************************************************/ public static BHG.Arc FromRhino(this RHG.Arc arc) { BHG.CoordinateSystem.Cartesian system = arc.Plane.FromRhino(); return(new BHG.Arc { CoordinateSystem = system, StartAngle = arc.StartAngle, EndAngle = arc.EndAngle, Radius = arc.Radius }); }
/***************************************************/ /**** Public Methods - Curves ****/ /***************************************************/ public static bool IsEqual(this BHG.Arc bhArc, RHG.Arc rhArc, double tolerance = BHG.Tolerance.Distance) { if (bhArc == null & rhArc == default(RHG.Arc)) { return(true); } return(bhArc.CoordinateSystem.IsEqual(rhArc.Plane, tolerance) && Math.Abs(bhArc.Radius - rhArc.Radius) < tolerance && Math.Abs(bhArc.StartAngle - rhArc.StartAngle) < tolerance && Math.Abs(bhArc.EndAngle - rhArc.EndAngle) < tolerance); }
/// <summary> /// Convert a Rhino arc to a Nucleus one /// </summary> /// <param name="arc"></param> /// <returns></returns> public static Arc Convert(RC.Arc arc) { if (arc.IsCircle) { return(new Arc(Convert(new RC.Circle(arc)))); } else { return(new Arc(Convert(arc.StartPoint), Convert(arc.MidPoint), Convert(arc.EndPoint))); } throw new NotImplementedException(); }
/***************************************************/ 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 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); }
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 static string ToSVG(this Rg.Arc input) { return("M " + input.StartPoint.ToSVG() + " A " + input.Radius + "," + input.Radius + " " + input.AngleDegrees + " " + Convert.ToInt32(input.Angle > Math.PI) + "," + Convert.ToInt32(!(Rg.Vector3d.VectorAngle(input.Plane.ZAxis, Rg.Vector3d.ZAxis) > 0)) + " " + input.EndPoint.ToSVG() + " "); }
/***************************************************/ /**** Public Methods - Curves ****/ /***************************************************/ public static void RenderRhinoWires(RHG.Arc arc, Rhino.Display.DisplayPipeline pipeline, Color bhColour, int thickness) { pipeline.DrawArc(arc, bhColour, thickness); }
public SilkwormMovement(Dictionary <string, string> Settings, List <Line> lines) { double eLengthAll = 0; double fTimeAll = 0; SilkwormCalculator calc = new SilkwormCalculator(Settings); //Core Default Settings for extrusion flow and speed generated in here #region Build Silkworm Model from Geometry and Printer Settings //Output Holder List <SilkwormLine> sLines = new List <SilkwormLine>(); for (int i = 0; i < lines.Count; i++) { GH_Line sMove = new GH_Line(lines[i]); //if((GH_Line)MInnerArray[j-1] = null){return ;} GH_Line sMove_1 = new GH_Line(); if (i == 0) { sMove_1 = new GH_Line(lines[i]); } else { sMove_1 = new GH_Line(lines[i - 1]); } #region Extrusion Flow Module /* * Some Extrusion Calculation Guidelines (from Josef Prusa's Calculator: http://calculator.josefprusa.cz/) *-- WOH smaller than 2.0 produces weak parts * --WOH bigger than 3 decreases the detail of printed part, because of thick line * * layer height (LH)= height of each printed layer above the previous * width over height (WOH) = line width/ layer height * free extrusion diameter (extDia) = nozzle diamter + 0.08mm * line width (LW) = LH * WOH * free extrusion cross section area (freeExt) = (extDia/2)*(extDia/2)*Math.PI * minimal extrusion cross section area for stable extrusion (minExt) = freeExt*0.5 * Extruded line cross section area (extLine) = extLine = LW * LH; * Suggested bridge flow-rate multiplier = (freeExt*0.7)/extLine * Predicted smallest feature printable in XY = lineWidth/2 * angleHelp = Math.sqrt((lineWidth/2)*(lineWidth/2)+LH*LH) * angleHelp = Math.asin((lineWidth/2)/angleHelp) * Predicted maximim overhang angle = angleHelp * (180/Math.PI) */ double nozDia = double.Parse(Settings["nozzle_diameter"]); double filDia = double.Parse(Settings["filament_diameter"]); //Calculate Flow Rate as a Ratio of Filament Diameter to Nozzle Diameter double FlM = ((Math.Pow(nozDia / 2, 2) * Math.PI) / (Math.Pow(filDia / 2, 2) * Math.PI)); //double FlM = 0.66; #endregion #region Print Feedrate Module Line line = sMove.Value; Line line_1 = sMove_1.Value; Vector3d vecA = line.Direction; Vector3d vecA_1 = line_1.Direction; Arc arc = new Rhino.Geometry.Arc(line_1.From, vecA_1, line.To); //double vecAngle = Rhino.Geometry.Vector3d.VectorAngle(vecA, vecA_1); //Speed on an Arc = sqrt((Accel * Radius) / sqrt(2)) double accel = double.Parse(Settings["perimeter_acceleration"]); double fRate = ( Math.Max( Math.Min( Math.Sqrt((accel * arc.Radius) / (Math.Sqrt(2))), double.Parse(Settings["perimeter_speed"])), double.Parse(Settings["min_print_speed"])) * 60); //Start speed as perimeter speed if (i == 0) { fRate = double.Parse(Settings["perimeter_speed"]) * 60; } #endregion sLines.Add(new SilkwormLine(FlM, fRate, line)); } #endregion //Property Assignment sMovement = sLines; Length = eLengthAll; Time = fTimeAll; ZDomain = new Interval(sLines[0].sLine.FromZ, sLines[sLines.Count - 1].sLine.ToZ); complete = true; Configuration = Settings; //Add Lift Delimiter sDelimiter = new Type.Delimiter( double.Parse(Settings["retract_lift"]), double.Parse(Settings["retract_length"]), double.Parse(Settings["retract_restart_extra"]), double.Parse(Settings["retract_speed"]), double.Parse(Settings["travel_speed"])); }
public Geometry(Rg.Arc arc) { curveType = CurveTypes.Arc; curve = arc.ToNurbsCurve(); }