コード例 #1
0
        public List <Brep> CreateWallBrep()
        {
            double      offsetDistance1 = this.thickness / 2 + offset;
            double      offsetDistance2 = this.thickness / 2 - offset;
            List <Brep> solids          = new List <Brep>();
            Brep        solid           = new Brep();

            for (int i = 0; i < this.wall.Surfaces.Count; i++)
            {
                Surface offsetSurface1 = this.wall.Surfaces[i].Offset(offsetDistance1, Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance);
                Surface offsetSurface2 = this.wall.Surfaces[i].Offset(-1 * offsetDistance2, Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance);

                List <Brep> solidBreps = new List <Brep>();

                Brep         wallBrep1  = offsetSurface1.ToBrep();
                BrepEdgeList brepEdges1 = wallBrep1.Edges;

                Brep         wallBrep2  = offsetSurface2.ToBrep();
                BrepEdgeList brepEdges2 = wallBrep2.Edges;

                solidBreps.Add(wallBrep1);
                solidBreps.Add(wallBrep2);

                BrepFace wallSurface = wallBrep1.Faces[0];
                solids.Add(Brep.CreateFromOffsetFace(wallSurface, -1 * this.thickness, Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance, false, true));
            }

            return(solids);
        }
コード例 #2
0
        /// <summary>
        /// This is the method that actually does the work.
        /// </summary>
        /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param>
        protected override void SolveInstance(IGH_DataAccess DA)
        {
            GeometryBase Geom = default(GeometryBase);
            Vector3d     Direction = default(Vector3d);
            bool         IsDubleSide = true, IsCape = true;
            Brep         Output = default(Brep);

            if (!DA.GetData(0, ref Geom))
            {
                return;
            }
            if (!DA.GetData(1, ref Direction))
            {
                return;
            }
            if (!DA.GetData(2, ref IsDubleSide))
            {
                return;
            }
            if (!DA.GetData(3, ref IsCape))
            {
                return;
            }

            if (Geom is Curve)
            {
                Curve Crv = Geom as Curve;
                Output = this.ExtrudeCurveBothSide(Crv, Direction, IsDubleSide, IsCape);
            }
            else if (Geom is Surface)
            {
                Surface Srf = Geom as Surface;
                //
                //实现在函数里面书写函数
                //
                //
                Func <Surface, Curve> CreateBoundary = _Srf =>
                {
                    Brep      b    = _Srf.ToBrep();
                    CurveList Crvs = new CurveList();

                    BrepEdgeList es = b.Edges;

                    foreach (BrepEdge e in es)
                    {
                        Crvs.Add(e.EdgeCurve);
                    }
                    return(Curve.JoinCurves(Crvs)[0]);
                };
                Curve Crv = CreateBoundary(Srf);
                Output = this.ExtrudeCurveBothSide(Crv, Direction, IsDubleSide, IsCape);
            }
            if (Output == null)
            {
                this.AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "输入的几何体不是平面几何体");
            }
            DA.SetData(0, Output);
        }
コード例 #3
0
        private Curve GetSurfaceBoundary(Surface Srf)
        {
            Brep      b    = Srf.ToBrep();
            CurveList Crvs = new CurveList();

            BrepEdgeList es = b.Edges;

            foreach (BrepEdge e in es)
            {
                Crvs.Add(e.EdgeCurve);
            }
            return(Curve.JoinCurves(Crvs)[0]);
        }
コード例 #4
0
        /// <summary>
        /// This Method converts the two input curvelist to a meshlist
        /// </summary>
        /// <param name="sidewalkList"></param>
        /// <param name="_FootprintList"></param>
        /// <returns></returns>
        private static List <Mesh> SidewalkCrvToMesh(List <Curve> sidewalkList, List <Curve> _FootprintList)
        {
            List <Brep> outLine = new List <Brep>();
            List <Brep> inLine  = new List <Brep>();


            foreach (Curve sw in sidewalkList)
            {
                Curve  sidewalk           = sw.Simplify(CurveSimplifyOptions.All, 1, 2);
                Brep[] planarSidewalkList = Brep.CreatePlanarBreps(sidewalk, 1.0);

                outLine.AddRange(from Brep planarSidewalk in planarSidewalkList
                                 select planarSidewalk);
            }

            Curve[] footprintCrvList = Curve.CreateBooleanUnion(_FootprintList, 1.0);

            foreach (Curve footprint in footprintCrvList)
            {
                Brep[] planarBuildingList = Brep.CreatePlanarBreps(footprint, 1.0);

                inLine.AddRange(from Brep planarFootprints in planarBuildingList
                                select planarFootprints);
            }

            Brep[]      sidewalks      = Brep.CreateBooleanDifference(outLine, inLine, 1.0);
            List <Mesh> sidewalkMeshes = new List <Mesh>();

            foreach (Brep sw in sidewalks)
            {
                Mesh[] sideWalkMeshList = Mesh.CreateFromBrep(sw, MeshingParameters.FastRenderMesh);

                sidewalkMeshes.AddRange(from Mesh mesh in sideWalkMeshList
                                        select mesh);
                BrepEdgeList edges = sw.Edges;
            }

            return(sidewalkMeshes);
        }