示例#1
0
        /// <summary>
        /// Create Edge (Circle) from Rhino closed ArcCurve.
        /// </summary>
        public static Geometry.Edge FromRhinoCircle(this Rhino.Geometry.ArcCurve obj)
        {
            double    radius      = obj.Radius;
            FdPoint3d centerPoint = obj.Arc.Center.FromRhino();

            // lcs
            FdCoordinateSystem cs = obj.FromRhinoCurve();

            // return
            return(new Geometry.Edge(radius, centerPoint, cs));
        }
示例#2
0
        /// <summary>
        /// Create Edge (Arc2) from Rhino open ArcCurve.
        /// </summary>
        public static Geometry.Edge FromRhinoArc2(this Rhino.Geometry.ArcCurve obj)
        {
            FdPoint3d startPoint = obj.Arc.StartPoint.FromRhino();
            FdPoint3d midPoint   = obj.Arc.MidPoint.FromRhino();
            FdPoint3d endPoint   = obj.Arc.EndPoint.FromRhino();

            // lcs
            FdCoordinateSystem cs = obj.FromRhinoCurve();

            // return
            return(new Geometry.Edge(startPoint, midPoint, endPoint, cs));
        }
示例#3
0
        /// <summary>
        /// Create Edge (Arc1) from Rhino open ArcCurve.
        /// </summary>
        public static Geometry.Edge FromRhinoArc1(this Rhino.Geometry.ArcCurve obj)
        {
            double     radius      = obj.Arc.Radius;
            double     startAngle  = 0;
            double     endAngle    = obj.Arc.EndAngle - obj.Arc.StartAngle;
            FdPoint3d  centerPoint = obj.Arc.Center.FromRhino();
            FdVector3d xAxis       = new FdVector3d(centerPoint, obj.Arc.StartPoint.FromRhino());

            // lcs
            FdCoordinateSystem cs = obj.FromRhinoCurve();

            // return
            return(new Geometry.Edge(radius, startAngle, endAngle, centerPoint, xAxis, cs));
        }
示例#4
0
        /// <summary>
        /// Create Edge (Line or Arc2) from Rhino LineCurve or open ArcCurve.
        /// Used for bar definition.
        /// </summary>
        public static Geometry.Edge FromRhinoLineOrArc2(this Rhino.Geometry.Curve obj)
        {
            // check length
            if (obj.GetLength() < FemDesign.Tolerance.Point3d)
            {
                throw new System.ArgumentException("Curve has no length.");
            }

            // if ArcCurve
            if (obj.GetType() == typeof(Rhino.Geometry.ArcCurve))
            {
                Rhino.Geometry.ArcCurve arcCurve = (Rhino.Geometry.ArcCurve)obj;

                // if Arc
                if (!obj.IsClosed)
                {
                    return(arcCurve.FromRhinoArc2());
                }

                else
                {
                    throw new System.ArgumentException($"Curve type: {obj.GetType()}, is not Line or Arc.");
                }
            }

            // if LineCurve
            else if (obj.GetType() == typeof(Rhino.Geometry.LineCurve))
            {
                return(((Rhino.Geometry.LineCurve)obj).FromRhinoLineCurve());
            }

            // if PolylineCurve
            else if (obj.GetType() == typeof(Rhino.Geometry.PolylineCurve))
            {
                if (obj.SpanCount == 1)
                {
                    Rhino.Geometry.LineCurve lnCrv = new Rhino.Geometry.LineCurve(obj.PointAtStart, obj.PointAtEnd);
                    return(lnCrv.FromRhinoLineCurve());
                }
                else
                {
                    throw new System.ArgumentException($"PolylineCurve with SpanCount: {obj.SpanCount}, is not supported for conversion to an Edge.");
                }
            }

            else
            {
                throw new System.ArgumentException($"Curve type: {obj.GetType()}, is not Line or Arc.");
            }
        }
示例#5
0
        /// <summary>
        /// Convert a Rhino Curve to Edge
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="arcType1">True if output is general purpose Edge. False if output is BarPart Edge.</param>
        /// <returns></returns>
        public static Geometry.Edge FromRhino(this Rhino.Geometry.Curve obj)
        {
            // check length
            if (obj.GetLength() < FemDesign.Tolerance.Point3d)
            {
                throw new System.ArgumentException("Curve has no length.");
            }

            // if ArcCurve
            if (obj.GetType() == typeof(Rhino.Geometry.ArcCurve))
            {
                Rhino.Geometry.ArcCurve arcCurve = (Rhino.Geometry.ArcCurve)obj;

                // if Arc
                if (!obj.IsClosed)
                {
                    return(arcCurve.FromRhinoArc1());
                }

                // if Circle
                else
                {
                    return(arcCurve.FromRhinoCircle());
                }
            }

            // if LineCurve
            else if (obj.GetType() == typeof(Rhino.Geometry.LineCurve))
            {
                return(((Rhino.Geometry.LineCurve)obj).FromRhinoLineCurve());
            }

            // if NurbsCurve
            else if (obj.GetType() == typeof(Rhino.Geometry.NurbsCurve))
            {
                return(((Rhino.Geometry.NurbsCurve)obj).FromRhinoNurbsCurve());
            }

            // else
            else
            {
                throw new System.ArgumentException($"Curve type: {obj.GetType()}, is not supported for conversion to an Edge.");
            }
        }
示例#6
0
        bool CreateSolid(double tolerance, out Rhino.Geometry.Brep outBrep)
        {
            outBrep = null;

            Rhino.Geometry.Point3d  origin = new Rhino.Geometry.Point3d(0.0, 0.0, 0.0);
            Rhino.Geometry.Circle   circle = new Rhino.Geometry.Circle(origin, 10.0);
            Rhino.Geometry.ArcCurve curve  = new Rhino.Geometry.ArcCurve(circle);

            Rhino.Geometry.Vector3d direction = new Rhino.Geometry.Vector3d(0, 0, 10);
            Rhino.Geometry.Surface  surface   = Rhino.Geometry.Surface.CreateExtrusion(curve, direction);

            Rhino.Geometry.Brep brep  = Rhino.Geometry.Brep.CreateFromSurface(surface);
            Rhino.Geometry.Brep solid = brep.CapPlanarHoles(tolerance);

            bool rc = solid.IsValid;

            if (rc)
            {
                outBrep = solid;
            }

            return(rc);
        }
        private void ExtractGeometry(Grasshopper.Kernel.Types.IGH_Goo iGoo, ref List <Rhino.Geometry.GeometryBase> resGeom)
        {
            if (iGoo is Grasshopper.Kernel.Types.GH_GeometryGroup group)
            {
                foreach (var geomGoo in group.Objects)
                {
                    ExtractGeometry(geomGoo, ref resGeom);
                }
                return;
            }

            Rhino.Geometry.GeometryBase geometryBase = null;
            try
            {
                switch (iGoo.ScriptVariable())
                {
                case Rhino.Geometry.Point3d point:
                    geometryBase = new Rhino.Geometry.Point(point);
                    break;

                case Rhino.Geometry.Line line:
                    geometryBase = new Rhino.Geometry.LineCurve(line);
                    break;

                case Rhino.Geometry.Rectangle3d rect:
                    geometryBase = rect.ToNurbsCurve();
                    break;

                case Rhino.Geometry.Arc arc:
                    geometryBase = new Rhino.Geometry.ArcCurve(arc);
                    break;

                case Rhino.Geometry.Circle circle:
                    geometryBase = new Rhino.Geometry.ArcCurve(circle);
                    break;

                case Rhino.Geometry.Ellipse ellipse:
                    geometryBase = ellipse.ToNurbsCurve();
                    break;

                case Rhino.Geometry.Curve curve:
                    geometryBase = curve;
                    break;

                case Rhino.Geometry.Box box:
                    geometryBase = Rhino.Geometry.Mesh.CreateFromBox(box, 1, 1, 1); break;

                case Rhino.Geometry.Mesh mesh:
                    geometryBase = mesh; break;

                case Rhino.Geometry.Brep brep:
                {
                    if (!CompoundDrawable.IsRenderMode)
                    {
                        foreach (var crv in brep.GetWireframe(-1))
                        {
                            resGeom.Add(crv);
                        }
                    }
                    else
                    {
                        var previewMesh = new Rhino.Geometry.Mesh();
                        previewMesh.Append(Rhino.Geometry.Mesh.CreateFromBrep(brep, MeshParameters));
                        geometryBase = previewMesh;
                    }
                    break;
                }

                case Rhino.Geometry.Plane plane:
                {
                    double len = 4.0;
                    var    x   = new Rhino.Geometry.Interval(-len, len);
                    var    y   = new Rhino.Geometry.Interval(-len, len);
                    geometryBase = Rhino.Geometry.Mesh.CreateFromPlane(plane, x, y, 5, 5);
                    break;
                }

                default:
                {
                    System.Diagnostics.Debug.Fail("Not supported GH type", iGoo.GetType().ToString());
                    break;
                }
                }
            }
            catch (Exception e)
            {
                System.Diagnostics.Debug.Fail(e.Source, e.Message);
            }

            if (geometryBase != null)
            {
                resGeom.Add(geometryBase);
            }
        }