예제 #1
0
        internal static global::Topologic.Shell ShellByMesh(Mesh bhomMesh)
        {
            List <global::Topologic.Face> faces = new List <global::Topologic.Face>();

            foreach (BH.oM.Geometry.Face bhomFace in bhomMesh.Faces)
            {
                List <Point> bhomControlPoints = new List <Point>();
                Point        p1 = bhomMesh.Vertices[bhomFace.A];
                bhomControlPoints.Add(p1);
                Point p2 = bhomMesh.Vertices[bhomFace.B];
                bhomControlPoints.Add(p2);
                Point p3 = bhomMesh.Vertices[bhomFace.C];
                bhomControlPoints.Add(p3);
                Point p4 = null;
                if (bhomFace.D >= 0)
                {
                    p4 = bhomMesh.Vertices[bhomFace.D];
                    bhomControlPoints.Add(p4);
                }
                bhomControlPoints.Add(p1); // close the wire
                Polyline bhomBoundary = new Polyline {
                    ControlPoints = bhomControlPoints
                };
                BH.oM.Geometry.PlanarSurface bhomPlanarSurface = new BH.oM.Geometry.PlanarSurface(bhomBoundary, null);
                global::Topologic.Face       face = Create.FaceByPlanarSurface(bhomPlanarSurface);
                faces.Add(face);
            }
            return(global::Topologic.Shell.ByFaces(faces, 0.0001));
        }
예제 #2
0
        /***************************************************/

        private static BHG.PlanarSurface ToBHoMPlanarSurface(this RHG.BrepFace face)
        {
            RHG.Surface rhSurf = face.UnderlyingSurface();
            if (rhSurf == null)
            {
                return(null);
            }

            BHG.PlanarSurface bhs = rhSurf.FromRhino() as BHG.PlanarSurface;
            List <BHG.ICurve> internalBoundaries = new List <BHG.ICurve>();

            BHG.ICurve externalBoundary = bhs.ExternalBoundary;
            foreach (RHG.BrepLoop loop in face.Loops)
            {
                if (loop.LoopType == RHG.BrepLoopType.Inner)
                {
                    internalBoundaries.Add(new BHG.PolyCurve {
                        Curves = loop.Trims.Select(x => rhSurf.Pushup(x, BHG.Tolerance.Distance).FromRhino()).ToList()
                    });
                }
                else if (loop.LoopType == RHG.BrepLoopType.Outer)
                {
                    externalBoundary = new BHG.PolyCurve {
                        Curves = loop.Trims.Select(x => rhSurf.Pushup(x, BHG.Tolerance.Distance).FromRhino()).ToList()
                    }
                }
                ;
            }

            return(BH.Engine.Geometry.Create.PlanarSurface(externalBoundary, internalBoundaries));
        }
예제 #3
0
        internal static global::Topologic.Face FaceBySurface(ISurface bhomSurface)
        {
            BH.oM.Geometry.PlanarSurface bhomPlanarSurface = bhomSurface as BH.oM.Geometry.PlanarSurface;
            if (bhomPlanarSurface != null)
            {
                return(FaceByPlanarSurface(bhomPlanarSurface));
            }

            throw new NotImplementedException("This type of BHoM surface is not yet supported.");
        }
예제 #4
0
        internal static BH.oM.Geometry.PlanarSurface PlanarSurface(global::Topologic.Face face)
        {
            Polyline      bhomExternalBoundary               = Convert.Polyline(face.ExternalBoundary);
            List <ICurve> bhomInternalBoundaries             = new List <ICurve>();
            List <global::Topologic.Wire> internalBoundaries = face.InternalBoundaries;

            foreach (global::Topologic.Wire internalBoundary in internalBoundaries)
            {
                bhomInternalBoundaries.Add(Convert.Polyline(internalBoundary));
            }
            BH.oM.Geometry.PlanarSurface planarSurface = new BH.oM.Geometry.PlanarSurface(bhomExternalBoundary, bhomInternalBoundaries);
            return(planarSurface);
        }
예제 #5
0
        internal static global::Topologic.Face FaceByPlanarSurface(BH.oM.Geometry.PlanarSurface bhomPlanarSurface)
        {
            ICurve        bhomExternalBoundary   = bhomPlanarSurface.ExternalBoundary;
            List <ICurve> bhomInternalBoundaries = bhomPlanarSurface.InternalBoundaries;

            global::Topologic.Wire        externalBoundary   = Create.WireByCurve(bhomExternalBoundary);
            List <global::Topologic.Wire> internalBoundaries = new List <global::Topologic.Wire>();

            if (bhomInternalBoundaries != null)
            {
                foreach (ICurve bhomInternalBoundary in bhomInternalBoundaries)
                {
                    global::Topologic.Wire internalBoundary = Create.WireByCurve(bhomInternalBoundary);
                    internalBoundaries.Add(internalBoundary);
                }
            }
            return(global::Topologic.Face.ByExternalInternalBoundaries(externalBoundary, internalBoundaries));
        }
예제 #6
0
        /***************************************************/

        public static RHG.Brep ToRhino(this BHG.PlanarSurface planarSurface)
        {
            if (planarSurface == null || planarSurface.ExternalBoundary == null)
            {
                return(null);
            }

            RHG.Curve externalCurve = planarSurface.ExternalBoundary.IToRhino();
            if (externalCurve == null || !externalCurve.IsPlanar(BHG.Tolerance.Distance))
            {
                return(null);
            }

            List <RHG.Curve> rhCurves = new List <RHG.Curve>();

            if (planarSurface.InternalBoundaries != null)
            {
                rhCurves.AddRange(planarSurface.InternalBoundaries.Select(c => c.IToRhino()).Where(c => c.IsPlanar(BHG.Tolerance.Distance)).ToList());
                if (rhCurves.Count < planarSurface.InternalBoundaries.Count)
                {
                    int skipped = planarSurface.InternalBoundaries.Count - rhCurves.Count;
                    Reflection.Compute.RecordWarning($"{skipped} internal boundaries skipped due to a failed planarity test.");
                }
            }
            rhCurves.Add(externalCurve);

            RHG.Brep[] rhSurfaces = RHG.Brep.CreatePlanarBreps(rhCurves);
            if (rhSurfaces == null)
            {
                return(null);
            }

            if (rhSurfaces.Length > 1)
            {
                //If more than one surface is extracted, try boolean difference of the curves to generate the geometry
                List <RHG.Curve> inner = new List <RHG.Curve>(rhCurves);
                inner.RemoveAt(inner.Count - 1);

                RHG.Curve[] difference = RHG.Curve.CreateBooleanDifference(externalCurve, inner);
                //Internal and external edges fully overlap -> 0 edges -> empty Brep
                if (difference == null || difference.Length == 0)
                {
                    return(null);
                }

                RHG.Brep[] rhSurfacesFromDifference = RHG.Brep.CreatePlanarBreps(difference);
                if (rhSurfacesFromDifference == null)
                {
                    return(null);
                }

                if (rhSurfacesFromDifference.Length > 1)
                {
                    Reflection.Compute.RecordWarning("Surface edges are not coplanar or their intersection is not empty." +
                                                     "The conversion to Rhino results into multiple Breps and only the first brep will be returned.");
                }
                else if (rhSurfacesFromDifference.Length == 1)
                {
                    Reflection.Compute.RecordWarning("The internal edges overlap with the external." +
                                                     "Boolean intersection has been used to try to get out the correct geometry." +
                                                     "Topology might have changed for the surface obejct");
                    return(rhSurfacesFromDifference.FirstOrDefault());
                }
            }
            return(rhSurfaces.FirstOrDefault());
        }
예제 #7
0
        /***************************************************/

        public static void RenderMeshes(BHG.PlanarSurface surface, Rhino.Display.DisplayPipeline pipeline, DisplayMaterial material)
        {
            pipeline.DrawBrepShaded(surface.ToRhino(), material);
        }
예제 #8
0
        /***************************************************/

        public static void RenderWires(BHG.PlanarSurface surface, Rhino.Display.DisplayPipeline pipeline, Color bhColour)
        {
            pipeline.DrawBrepWires(surface.ToRhino(), bhColour, 0);
        }