コード例 #1
0
        static Surface ToRhinoSurface(this DB.Face face)
        {
            Surface surface = default;

            using (var faceSurface = face.GetSurface())
            {
                var bboxUV = face.GetBoundingBox();

                switch (faceSurface)
                {
                case DB.Plane planeSurface:                     surface = planeSurface.ToRhino(bboxUV);       break;

                case DB.ConicalSurface conicalSurface:          surface = conicalSurface.ToRhino(bboxUV);     break;

                case DB.CylindricalSurface cylindricalSurface:  surface = cylindricalSurface.ToRhino(bboxUV); break;

                case DB.RevolvedSurface revolvedSurface:        surface = revolvedSurface.ToRhino(bboxUV);    break;

                case DB.RuledSurface ruledSurface:              surface = ruledSurface.ToRhino(bboxUV);       break;

                case DB.HermiteSurface hermiteSurface:
                    try
                    {
                        using (var nurbsData = DB.ExportUtils.GetNurbsSurfaceDataForFace(face))
                            surface = nurbsData.ToRhino(bboxUV);
                    }
                    catch (Autodesk.Revit.Exceptions.ArgumentException) { }
                    break;

                default: throw new NotImplementedException();
                }
            }

            return(surface);
        }
コード例 #2
0
        public Surface FaceToSpeckle(DB.Face face, out bool parametricOrientation, double relativeTolerance = 0.0, string units = null)
        {
            var u = units ?? ModelUnits;

            using (var surface = face.GetSurface())
                parametricOrientation = surface.OrientationMatchesParametricOrientation;

            switch (face)
            {
            case null:
                return(null);

            case PlanarFace planar:
                return(FaceToSpeckle(planar, relativeTolerance, u));

            case ConicalFace conical:
                return(FaceToSpeckle(conical, relativeTolerance, u));

            case CylindricalFace cylindrical:
                return(FaceToSpeckle(cylindrical, relativeTolerance, u));

            case RevolvedFace revolved:
                return(FaceToSpeckle(revolved, relativeTolerance, u));

            case RuledFace ruled:
                return(FaceToSpeckle(ruled, relativeTolerance, u));

            case HermiteFace hermite:
                return(FaceToSpeckle(hermite, face.GetBoundingBox(), u));

            default:
                throw new NotImplementedException();
            }
        }
コード例 #3
0
        public Geometry.Surface FaceToSpeckle(DB.Face face, DB.BoundingBoxUV uvBox, string units = null)
        {
#if (REVIT2021 || REVIT2022)
            var surf = DB.ExportUtils.GetNurbsSurfaceDataForSurface(face.GetSurface());
#else
            var surf = DB.ExportUtils.GetNurbsSurfaceDataForFace(face);
#endif
            var spcklSurface = NurbsSurfaceToSpeckle(surf, face.GetBoundingBox(), units ?? ModelUnits);
            return(spcklSurface);
        }
コード例 #4
0
        public Geometry.Surface FaceToSpeckle(DB.Face face, DB.BoundingBoxUV uvBox)
        {
#if REVIT2021
            var surf = DB.ExportUtils.GetNurbsSurfaceDataForSurface(face.GetSurface());
#else
            var surf = DB.ExportUtils.GetNurbsSurfaceDataForFace(face);
#endif

            var spcklSurface = NurbsSurfaceToSpeckle(surf, face.GetBoundingBox());
            return(spcklSurface);
        }
コード例 #5
0
        public static Surface ToRhinoSurface(DB.Face face, out bool parametricOrientation, double relativeTolerance = 0.0)
        {
            using (var surface = face.GetSurface())
                parametricOrientation = surface.MatchesParametricOrientation();

            switch (face)
            {
            case null: return(null);

            case DB.PlanarFace planar:            return(ToRhinoSurface(planar, relativeTolerance));

            case DB.ConicalFace conical:          return(ToRhinoSurface(conical, relativeTolerance));

            case DB.CylindricalFace cylindrical:  return(ToRhinoSurface(cylindrical, relativeTolerance));

            case DB.RevolvedFace revolved:        return(ToRhinoSurface(revolved, relativeTolerance));

            case DB.RuledFace ruled:              return(ToRhinoSurface(ruled, relativeTolerance));

            case DB.HermiteFace hermite:          return(ToRhinoSurface(hermite, relativeTolerance));

            default: throw new NotImplementedException();
            }
        }