Beispiel #1
0
        public Brep CreateBraceBrep(string idSection, double rotate, StbBraceKind_structure kind, IReadOnlyList <Point3d> sectionPoints, Vector3d memberAxis)
        {
            List <Curve> curveList = CreateFromEachBraceKind(idSection, kind, sectionPoints);

            Utils.RotateCurveList(memberAxis, curveList, rotate, sectionPoints);
            return(Utils.CreateCapedBrepFromLoft(curveList, _tolerance[0]));
        }
        public GH_Structure <GH_Brep> Brace(IEnumerable <StbBrace> braces)
        {
            var brepList = new GH_Structure <GH_Brep>();

            if (braces == null)
            {
                return(brepList);
            }

            foreach ((StbBrace brace, int i) in braces.Select((brace, index) => (brace, index)))
            {
                StbBraceKind_structure kind = brace.kind_structure;

                StbNode[] endNodes =
                {
                    _nodes.First(node => node.id == brace.id_node_start),
                    _nodes.First(node => node.id == brace.id_node_end)
                };
                Point3d[] offset =
                {
                    new Point3d(brace.offset_start_X, brace.offset_start_Y, brace.offset_start_Z),
                    new Point3d(brace.offset_end_X,   brace.offset_end_Y,   brace.offset_end_Z)
                };
                Point3d[] sectionPoints =
                {
                    new Point3d(endNodes[0].X, endNodes[0].Y, endNodes[0].Z) + offset[0],
                    Point3d.Origin,
                    Point3d.Origin,
                    new Point3d(endNodes[1].X, endNodes[1].Y, endNodes[1].Z) + offset[1]
                };
                Vector3d memberAxis = sectionPoints[3] - sectionPoints[0];
                sectionPoints[1] = sectionPoints[0] + memberAxis / memberAxis.Length * brace.joint_start;
                sectionPoints[2] = sectionPoints[3] - memberAxis / memberAxis.Length * brace.joint_end;

                var brepMaker = new BrepMaker.Brace(_sections, _tolerance);
                brepList.Append(new GH_Brep(brepMaker.CreateBraceBrep(brace.id_section, brace.rotate, kind, sectionPoints, memberAxis)), new GH_Path(0, i));
            }

            return(brepList);
        }
Beispiel #3
0
        private List <Curve> CreateFromEachBraceKind(string idSection, StbBraceKind_structure kind, IReadOnlyList <Point3d> sectionPoints)
        {
            List <Curve> curveList;

            switch (kind)
            {
            case StbBraceKind_structure.S:
                StbSecBrace_S sSec    = _sections.StbSecBrace_S.First(sec => sec.id == idSection);
                object[]      figures = sSec.StbSecSteelFigureBrace_S.Items;
                curveList = SecSteelBraceToCurves(figures, sectionPoints);
                break;

            case StbBraceKind_structure.RC:
            case StbBraceKind_structure.SRC:
                throw new ArgumentException("Unsupported brace structure type");

            default:
                throw new ArgumentOutOfRangeException();
            }

            return(curveList);
        }
Beispiel #4
0
        private static GH_Structure <GH_String> GetTagStrings(IEnumerable <StbBrace> braces, StbSections sections)
        {
            var ghSecStrings = new GH_Structure <GH_String>();

            if (braces == null)
            {
                return(ghSecStrings);
            }

            foreach (var item in braces.Select((brace, index) => new { brace, index }))
            {
                string secId  = item.brace.id_section;
                var    ghPath = new GH_Path(0, item.index);
                StbBraceKind_structure kindStruct = item.brace.kind_structure;

                switch (kindStruct)
                {
                case StbBraceKind_structure.S:
                    StbSecBrace_S secS = sections.StbSecBrace_S.First(i => i.id == secId);
                    foreach (object figureObj in secS.StbSecSteelFigureBrace_S.Items)
                    {
                        ghSecStrings.AppendRange(TagUtils.GetBraceSSection(figureObj), ghPath);
                    }
                    break;

                case StbBraceKind_structure.RC:
                case StbBraceKind_structure.SRC:
                    throw new ArgumentException("Unsupported section type.");

                default:
                    throw new ArgumentOutOfRangeException();
                }
            }

            return(ghSecStrings);
        }