// Arc
 // Rh Capture can be a circle OR an arc
 public static SpeckleObject ToSpeckle(this ArcCurve a)
 {
     if (a.IsClosed)
     {
         Circle preCircle;
         a.TryGetCircle(out preCircle);
         SpeckleCircle myCircle = preCircle.ToSpeckle();
         myCircle.Domain     = a.Domain.ToSpeckle();
         myCircle.Properties = a.UserDictionary.ToSpeckle(root: a);
         myCircle.GenerateHash();
         return(myCircle);
     }
     else
     {
         Arc preArc;
         a.TryGetArc(out preArc);
         SpeckleArc myArc = preArc.ToSpeckle();
         myArc.Domain     = a.Domain.ToSpeckle();
         myArc.Properties = a.UserDictionary.ToSpeckle(root: a);
         myArc.GenerateHash();
         return(myArc);
     }
 }
        // Curve
        public static SpeckleObject ToSpeckle(this NurbsCurve curve)
        {
            var properties = curve.UserDictionary.ToSpeckle(root: curve);

            if (curve.IsArc(Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance))
            {
                Arc        getObj; curve.TryGetArc(out getObj);
                SpeckleArc myObject = getObj.ToSpeckle(); myObject.Properties = properties; myObject.GenerateHash();
                return(myObject);
            }

            if (curve.IsCircle(Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance))
            {
                Circle        getObj; curve.TryGetCircle(out getObj);
                SpeckleCircle myObject = getObj.ToSpeckle(); myObject.Properties = properties; myObject.GenerateHash();
                return(myObject);
            }

            if (curve.IsEllipse(Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance))
            {
                Ellipse        getObj; curve.TryGetEllipse(out getObj);
                SpeckleEllipse myObject = getObj.ToSpeckle(); myObject.Properties = properties; myObject.GenerateHash();
                return(myObject);
            }

            if (curve.IsLinear(Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance) || curve.IsPolyline()) // defaults to polyline
            {
                Polyline      getObj; curve.TryGetPolyline(out getObj);
                SpeckleObject myObject = getObj.ToSpeckle(); myObject.Properties = properties; myObject.GenerateHash();
                return(myObject);
            }

            Polyline poly;

            curve.ToPolyline(0, 1, 0, 0, 0, 0.1, 0, 0, true).TryGetPolyline(out poly);

            SpecklePolyline displayValue;

            if (poly.Count == 2)
            {
                displayValue       = new SpecklePolyline();
                displayValue.Value = new List <double> {
                    poly[0].X, poly[0].Y, poly[0].Z, poly[1].X, poly[1].Y, poly[1].Z
                };
                displayValue.GenerateHash();
            }
            else
            {
                displayValue = poly.ToSpeckle() as SpecklePolyline;
            }

            SpeckleCurve myCurve    = new SpeckleCurve(displayValue);
            NurbsCurve   nurbsCurve = curve.ToNurbsCurve();

            myCurve.Weights  = nurbsCurve.Points.Select(ctp => ctp.Weight).ToList();
            myCurve.Points   = nurbsCurve.Points.Select(ctp => ctp.Location).ToFlatArray().ToList();
            myCurve.Knots    = nurbsCurve.Knots.ToList();
            myCurve.Degree   = nurbsCurve.Degree;
            myCurve.Periodic = nurbsCurve.IsPeriodic;
            myCurve.Rational = nurbsCurve.IsRational;
            myCurve.Domain   = nurbsCurve.Domain.ToSpeckle();
            myCurve.Closed   = nurbsCurve.IsClosed;

            myCurve.Properties = properties;
            myCurve.GenerateHash();

            return(myCurve);
        }