Beispiel #1
0
        public static SpeckleObject ToSpeckle(this NurbsCurve curve)
        {
            SpeckleObject speckleCurve;

            if (curve.IsLinear())
            {
                using (Line line = curve.GetAsLine()) { speckleCurve = line.ToSpeckle(); }
            }
            else if (curve.IsArc())
            {
                using (Arc arc = curve.GetAsArc()) { speckleCurve = arc.ToSpeckle(); }
            }
            else if (curve.IsCircle())
            {
                using (Circle circle = curve.GetAsCircle()) { speckleCurve = circle.ToSpeckle(); }
            }
            else if (curve.IsEllipse())
            {
                using (Ellipse ellipse = curve.GetAsEllipse()) { speckleCurve = ellipse.ToSpeckle(); }
            }
            else
            {
                // SpeckleCurve DisplayValue
                Curve[]       curves = curve.ApproximateWithArcAndLineSegments();
                List <double> polylineCoordinates = curves.SelectMany(c => new Point[2] {
                    c.StartPoint, c.EndPoint
                }.ToFlatArray()).ToList();
                polylineCoordinates.AddRange(curves.Last().EndPoint.ToArray());
                curves.ForEach(c => c.Dispose());

                SpecklePolyline displayValue = new SpecklePolyline(polylineCoordinates);
                List <double>   dsKnots      = curve.Knots().ToList();
                dsKnots.RemoveAt(dsKnots.Count - 1);
                dsKnots.RemoveAt(0);

                SpeckleCurve spkCurve = new SpeckleCurve(displayValue);
                spkCurve.Weights  = curve.Weights().ToList();
                spkCurve.Points   = curve.ControlPoints().ToFlatArray().ToList();
                spkCurve.Knots    = dsKnots;
                spkCurve.Degree   = curve.Degree;
                spkCurve.Periodic = curve.IsPeriodic;
                spkCurve.Rational = curve.IsRational;
                spkCurve.Closed   = curve.IsClosed;
                spkCurve.Domain   = new SpeckleInterval(curve.StartParameter(), curve.EndParameter());
                //spkCurve.Properties

                spkCurve.GenerateHash();

                speckleCurve = spkCurve;
            }
            speckleCurve.Properties = curve.GetSpeckleProperties();
            return(speckleCurve);
        }
        // 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);
        }