Exemple #1
0
 /// <summary>
 /// DS Circle to SpeckleCircle.
 /// </summary>
 /// <param name="circ"></param>
 /// <returns></returns>
 public Circle CircleToSpeckle(DS.Circle circ)
 {
     using (DS.Vector xAxis = DS.Vector.ByTwoPoints(circ.CenterPoint, circ.StartPoint))
         using (DS.Plane plane = DS.Plane.ByOriginNormalXAxis(circ.CenterPoint, circ.Normal, xAxis))
         {
             var myCircle = new Circle(PlaneToSpeckle(plane), circ.Radius, ModelUnits);
             CopyProperties(myCircle, circ);
             return(myCircle);
         }
 }
        /// <summary>
        /// SpeckleCircle to DS Circle. Rotating the circle is due to a bug in ProtoGeometry
        /// that will be solved on Dynamo 2.1.
        /// </summary>
        /// <param name="circ"></param>
        /// <returns></returns>
        public DS.Circle CircleToNative(Circle circ)
        {
            using (DS.Plane basePlane = PlaneToNative(circ.plane))
                using (DS.Circle preCircle = DS.Circle.ByPlaneRadius(basePlane, ScaleToNative(circ.radius.Value, circ.units)))
                    using (DS.Vector preXvector = DS.Vector.ByTwoPoints(preCircle.CenterPoint, preCircle.StartPoint))
                    {
                        double angle  = preXvector.AngleAboutAxis(basePlane.XAxis, basePlane.Normal);
                        var    circle = (DS.Circle)preCircle.Rotate(basePlane, angle);

                        return(circle.SetDynamoProperties <DS.Circle>(GetDynamicMembersFromBase(circ)));
                    }
        }
Exemple #3
0
        /// <summary>
        /// DS Vector to array of coordinates
        /// </summary>
        /// <param name="vc"></param>
        /// <returns></returns>
        //public double[] VectorToArray(DS.Vector vc)
        //{
        //  return new double[] { vc.X, vc.Y, vc.Z };
        //}

        /// <summary>
        /// Array of coordinates to DS Vector
        /// </summary>
        /// <param name="arr"></param>
        /// <returns></returns>
        //public DS.Vector VectorToVector(double[] arr)
        //{
        //  return DS.Vector.ByCoordinates(arr[0], arr[1], arr[2]);
        //}

        #endregion

        #region Planes

        /// <summary>
        /// DS Plane to Plane
        /// </summary>
        /// <param name="plane"></param>
        /// <returns></returns>
        public Plane PlaneToSpeckle(DS.Plane plane)
        {
            var p = new Plane(
                PointToSpeckle(plane.Origin),
                VectorToSpeckle(plane.Normal),
                VectorToSpeckle(plane.XAxis),
                VectorToSpeckle(plane.YAxis),
                ModelUnits);

            CopyProperties(p, plane);
            return(p);
        }
        /// <summary>
        /// DS Vector to array of coordinates
        /// </summary>
        /// <param name="vc"></param>
        /// <returns></returns>
        //public double[] VectorToArray(DS.Vector vc)
        //{
        //  return new double[] { vc.X, vc.Y, vc.Z };
        //}

        /// <summary>
        /// Array of coordinates to DS Vector
        /// </summary>
        /// <param name="arr"></param>
        /// <returns></returns>
        //public DS.Vector VectorToVector(double[] arr)
        //{
        //  return DS.Vector.ByCoordinates(arr[0], arr[1], arr[2]);
        //}

        #endregion

        #region Planes

        /// <summary>
        /// DS Plane to Plane
        /// </summary>
        /// <param name="plane"></param>
        /// <returns></returns>
        public Plane PlaneToSpeckle(DS.Plane plane, string units = null)
        {
            var u = units ?? ModelUnits;
            var p = new Plane(
                PointToSpeckle(plane.Origin, u),
                VectorToSpeckle(plane.Normal, u),
                VectorToSpeckle(plane.XAxis, u),
                VectorToSpeckle(plane.YAxis, u),
                ModelUnits);

            CopyProperties(p, plane);
            return(p);
        }
 /// <summary>
 /// SpeckleArc to DS Arc
 /// </summary>
 /// <param name="a"></param>
 /// <returns></returns>
 public DS.Arc ArcToNative(Arc a)
 {
     using (DS.Plane basePlane = PlaneToNative(a.plane))
         using (DS.Point startPoint = (DS.Point)basePlane.Origin.Translate(basePlane.XAxis, ScaleToNative(a.radius.Value, a.units)))
         {
             var arc = DS.Arc.ByCenterPointStartPointSweepAngle(
                 basePlane.Origin,
                 startPoint,
                 a.angleRadians.Value.ToDegrees(),
                 basePlane.Normal
                 );
             return(arc.SetDynamoProperties <DS.Arc>(GetDynamicMembersFromBase(a)));
         }
 }
        /// <summary>
        /// DS Circle to SpeckleCircle.
        /// </summary>
        /// <param name="circ"></param>
        /// <returns></returns>
        public Circle CircleToSpeckle(DS.Circle circ, string units = null)
        {
            var u = units ?? ModelUnits;

            using (DS.Vector xAxis = DS.Vector.ByTwoPoints(circ.CenterPoint, circ.StartPoint))
                using (DS.Plane plane = DS.Plane.ByOriginNormalXAxis(circ.CenterPoint, circ.Normal, xAxis))
                {
                    var myCircle = new Circle(PlaneToSpeckle(plane, u), circ.Radius, u);
                    CopyProperties(myCircle, circ);
                    myCircle.length = circ.Length;
                    myCircle.bbox   = BoxToSpeckle(circ.BoundingBox.ToCuboid(), u);
                    return(myCircle);
                }
        }
Exemple #7
0
        /// <summary>
        /// DS Ellipse to SpeckleEllipse
        /// </summary>
        /// <param name="e"></param>
        /// <returns></returns>
        public Ellipse EllipseToSpeckle(DS.Ellipse e)
        {
            using (DS.Plane basePlane = DS.Plane.ByOriginNormalXAxis(e.CenterPoint, e.Normal, e.MajorAxis))
            {
                var ellipse = new Ellipse(
                    PlaneToSpeckle(basePlane),
                    e.MajorAxis.Length,
                    e.MinorAxis.Length,
                    new Interval(e.StartParameter(), e.EndParameter()),
                    null,
                    ModelUnits);

                CopyProperties(ellipse, e);
                return(ellipse);
            }
        }
Exemple #8
0
        /// <summary>
        /// DS Arc to SpeckleArc
        /// </summary>
        /// <param name="a"></param>
        /// <returns></returns>
        public Arc ArcToSpeckle(DS.Arc a)
        {
            using (DS.Vector xAxis = DS.Vector.ByTwoPoints(a.CenterPoint, a.StartPoint))
                using (DS.Plane basePlane = DS.Plane.ByOriginNormalXAxis(a.CenterPoint, a.Normal, xAxis))
                {
                    var arc = new Arc(
                        PlaneToSpeckle(basePlane),
                        a.Radius,
                        0, // This becomes 0 as arcs are interpreted to start from the plane's X axis.
                        a.SweepAngle.ToRadians(),
                        a.SweepAngle.ToRadians(),
                        ModelUnits
                        );

                    CopyProperties(arc, a);

                    return(arc);
                }
        }
        /// <summary>
        /// DS Ellipse to SpeckleEllipse
        /// </summary>
        /// <param name="e"></param>
        /// <returns></returns>
        public Ellipse EllipseToSpeckle(DS.Ellipse e, string units = null)
        {
            var u = units ?? ModelUnits;

            using (DS.Plane basePlane = DS.Plane.ByOriginNormalXAxis(e.CenterPoint, e.Normal, e.MajorAxis))
            {
                var ellipse = new Ellipse(
                    PlaneToSpeckle(basePlane, u),
                    e.MajorAxis.Length,
                    e.MinorAxis.Length,
                    new Interval(e.StartParameter(), e.EndParameter()),
                    null,
                    u);

                CopyProperties(ellipse, e);

                ellipse.length = e.Length;
                ellipse.bbox   = BoxToSpeckle(e.BoundingBox.ToCuboid(), u);

                return(ellipse);
            }
        }
        /// <summary>
        /// DS Arc to SpeckleArc
        /// </summary>
        /// <param name="a"></param>
        /// <returns></returns>
        public Arc ArcToSpeckle(DS.Arc a, string units = null)
        {
            var u = units ?? ModelUnits;

            using (DS.Vector xAxis = DS.Vector.ByTwoPoints(a.CenterPoint, a.StartPoint))
                using (DS.Plane basePlane = DS.Plane.ByOriginNormalXAxis(a.CenterPoint, a.Normal, xAxis))
                {
                    var arc = new Arc(
                        PlaneToSpeckle(basePlane, u),
                        a.Radius,
                        0, // This becomes 0 as arcs are interpreted to start from the plane's X axis.
                        a.SweepAngle.ToRadians(),
                        a.SweepAngle.ToRadians(),
                        u
                        );

                    CopyProperties(arc, a);
                    arc.length = a.Length;
                    arc.bbox   = BoxToSpeckle(a.BoundingBox.ToCuboid(), u);
                    return(arc);
                }
        }