예제 #1
0
        public Glulam Trim(Interval domain, double overlap)
        {
            double l1 = Centreline.GetLength(new Interval(Centreline.Domain.Min, domain.Min));
            double l2 = Centreline.GetLength(new Interval(Centreline.Domain.Min, domain.Max));
            double t1, t2;

            if (!Centreline.LengthParameter(l1 - overlap, out t1))
            {
                t1 = domain.Min;
            }
            if (!Centreline.LengthParameter(l2 + overlap, out t2))
            {
                t2 = domain.Max;
            }

            domain = new Interval(
                Math.Max(t1, Centreline.Domain.Min),
                Math.Min(t2, Centreline.Domain.Max));

            double length = Centreline.GetLength(domain);

            if (domain.IsDecreasing || length < overlap || length < Glulam.OverlapTolerance)
            {
                return(null);
            }

            double percentage = length / Centreline.GetLength();

            GlulamData data = Data.Duplicate();

            data.Samples = Math.Max(6, (int)(data.Samples * percentage));


            Curve trimmed_curve = Centreline.Trim(domain);

            GlulamOrientation trimmed_orientation = Orientation.Trim(domain);

            trimmed_orientation.Remap(Centreline, trimmed_curve);

            Glulam glulam = CreateGlulam(trimmed_curve, trimmed_orientation, data);

            return(glulam);
        }
예제 #2
0
        /// <summary>
        /// Split glulam into two at parameter t, with an overlap of a certain length.
        /// </summary>
        /// <param name="t">Curve parameter to split glulam at.</param>
        /// <param name="overlap">Amount of overlap.</param>
        /// <returns>List of new glulams.</returns>
        public List <Glulam> Split(double t, double overlap)
        {
            if (overlap < Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance)
            {
                return(Split(t));
            }

            if (!Centreline.Domain.IncludesParameter(t))
            {
                return(null);
            }
            double split_length = Centreline.GetLength(new Interval(Centreline.Domain.Min, t));

            double t1;
            double t2;

            if (!Centreline.LengthParameter(split_length + (overlap / 2), out t1))
            {
                return(null);
            }
            if (!Centreline.LengthParameter(split_length - (overlap / 2), out t2))
            {
                return(null);
            }

            if (!Centreline.Domain.IncludesParameter(t1) || !Centreline.Domain.IncludesParameter(t2))
            {
                return(null);
            }

            Curve[] split_curves;
            Plane   split_plane;
            double  percentage;

            Glulam     Blank1, Blank2;
            GlulamData Data1, Data2;
            {
                percentage   = (t1 - Centreline.Domain.Min) / (Centreline.Domain.Max - Centreline.Domain.Min);
                split_plane  = GetPlane(t1);
                split_curves = Centreline.Split(t1);
                if (split_curves == null || split_curves.Length != 2)
                {
                    return(null);
                }

                var SplitOrientation = Orientation.Split(new double[] { t1 });

                Data1         = Data.Duplicate();
                Data1.Samples = Math.Max(2, (int)(Data.Samples * percentage));

                Blank1 = CreateGlulam(split_curves[0], SplitOrientation[0], Data1);
            }
            {
                percentage   = (t2 - Centreline.Domain.Min) / (Centreline.Domain.Max - Centreline.Domain.Min);
                split_plane  = GetPlane(t2);
                split_curves = Centreline.Split(t2);
                if (split_curves == null || split_curves.Length != 2)
                {
                    return(null);
                }

                var SplitOrientation = Orientation.Split(new double[] { t2 });

                Data2         = Data.Duplicate();
                Data2.Samples = Math.Max(2, (int)(Data.Samples * (1 - percentage)));

                Blank2 = CreateGlulam(split_curves[1], SplitOrientation[1], Data2);
            }

            List <Glulam> blanks = new List <Glulam>()
            {
                Blank1, Blank2
            };

            return(blanks);
        }