Exemple #1
0
        public void imethod_0(Interface8 reader)
        {
            this.enum23_0 = Class647.smethod_0(reader);
            if (this.enum23_0 == Class647.Enum23.const_2)
            {
                return;
            }
            this.int_2 = reader.imethod_5();
            this.int_3 = reader.imethod_5();
            if (this.enum23_0 == Class647.Enum23.const_1)
            {
                this.enum2_0 = Class195.smethod_0(reader);
            }
            this.enum34_0 = Class883.smethod_0(reader);
            this.enum34_1 = Class883.smethod_0(reader);
            this.enum49_0 = Class1028.smethod_0(reader);
            this.enum49_1 = Class1028.smethod_0(reader);
            int length1 = reader.imethod_5();
            int length2 = reader.imethod_5();
            int num1    = 2;
            int num2    = 2;

            this.double_0 = new double[length1];
            this.int_0    = new int[length1];
            for (int index = 0; index < length1; ++index)
            {
                this.double_0[index] = reader.imethod_8();
                this.int_0[index]    = reader.imethod_5();
                num1 += this.int_0[index];
            }
            this.double_1 = new double[length2];
            this.int_1    = new int[length2];
            for (int index = 0; index < length2; ++index)
            {
                this.double_1[index] = reader.imethod_8();
                this.int_1[index]    = reader.imethod_5();
                num2 += this.int_1[index];
            }
            int num3 = num1 - this.int_2 - 1;
            int num4 = num2 - this.int_3 - 1;

            this.point3D_0 = new Point3D[num3 * num4];
            if (this.enum23_0 == Class647.Enum23.const_1)
            {
                this.double_2 = new double[num3 * num4];
                for (int index = 0; index < this.point3D_0.Length; ++index)
                {
                    this.point3D_0[index] = Class794.smethod_15(reader);
                    this.double_2[index]  = reader.imethod_8();
                }
            }
            else
            {
                for (int index = 0; index < this.point3D_0.Length; ++index)
                {
                    this.point3D_0[index] = Class794.smethod_15(reader);
                }
            }
        }
Exemple #2
0
        public override void vmethod_0(Interface8 reader)
        {
            Class647.Enum23 enum23 = Class647.smethod_0(reader);
            if (enum23 == Class647.Enum23.const_2)
            {
                return;
            }
            int degree = reader.imethod_5();

            this.enum34_0 = Class883.smethod_0(reader);
            int length1 = reader.imethod_5();

            this.double_0 = new double[length1];
            this.int_0    = new int[length1];
            double[] knots   = new double[length1 * degree + 2];
            int      length2 = 0;

            for (int index1 = 0; index1 < length1; ++index1)
            {
                double num1 = reader.imethod_8();
                this.double_0[index1] = num1;
                int num2 = reader.imethod_5();
                this.int_0[index1] = num2;
                if (index1 == 0 || index1 == length1 - 1)
                {
                    ++num2;
                }
                for (int index2 = 0; index2 < num2; ++index2)
                {
                    knots[length2++] = num1;
                }
            }
            if (length2 < knots.Length)
            {
                double[] numArray = new double[length2];
                Array.Copy((Array)knots, 0, (Array)numArray, 0, length2);
                knots = numArray;
            }
            Point3D[] controlPoints = new Point3D[length2 - degree - 1];
            double[]  weights       = new double[length2 - degree - 1];
            for (int index = 0; index < controlPoints.Length; ++index)
            {
                controlPoints[index] = Class794.smethod_15(reader);
                if (enum23 == Class647.Enum23.const_1)
                {
                    weights[index] = reader.imethod_8();
                }
            }
            if (enum23 == Class647.Enum23.const_1)
            {
                this.splineCurve3D_0 = new SplineCurve3D(degree, knots, controlPoints, weights);
            }
            else
            {
                this.splineCurve3D_0 = new SplineCurve3D(degree, knots, controlPoints);
            }
        }
    internal static void smethod_0(Class857 A_0, bool A_1)
    {
        int      num    = 4;
        Class396 class2 = A_0.method_11();
        string   str    = class2.method_1();
        Class93  class3 = smethod_1(class2.method_12(BookmarkStart.b("䰩䴫䌭夯帱䴳", 4), null));

        smethod_2(A_0, class3);
        while (class2.method_9(str))
        {
            string key = class2.method_1();
            if (key != null)
            {
                int num2;
                if (Class1160.dictionary_185 == null)
                {
                    Dictionary <string, int> dictionary1 = new Dictionary <string, int>(11);
                    dictionary1.Add(BookmarkStart.b("帩䤫嘭䐯ἱ䐳䐵圷䨹夻䰽㐿⭁⅃㕅", num), 0);
                    dictionary1.Add(BookmarkStart.b("娩䴫尭儯唱䘳圵䠷刹ᄻ丽㈿ⵁ㑃⍅㩇㹉╋⭍⍏", num), 1);
                    dictionary1.Add(BookmarkStart.b("天䤫䴭䐯嬱嬳堵ᔷ䨹主儽〿❁㙃㉅ⅇ⽉㽋", num), 2);
                    dictionary1.Add(BookmarkStart.b("帩䴫䰭尯圱ᤳ䘵䨷唹䰻嬽㈿㙁ⵃ⍅㭇", num), 3);
                    dictionary1.Add(BookmarkStart.b("帩䴫䰭尯圱ᤳ唵圷嘹䤻匽⸿潁㑃㑅❇㩉⥋㱍⑏㭑ㅓ╕", num), 4);
                    dictionary1.Add(BookmarkStart.b("帩䴫䰭尯圱ᤳ䐵圷䴹ᄻ丽㈿ⵁ㑃⍅㩇㹉╋⭍⍏", num), 5);
                    dictionary1.Add(BookmarkStart.b("帩䴫䰭尯圱ᤳ唵崷嘹倻ጽ〿ぁ⭃㙅ⵇ㡉㡋❍㕏⅑", num), 6);
                    dictionary1.Add(BookmarkStart.b("䴩師伭䀯娱崳唵ᔷ䨹主儽〿❁㙃㉅ⅇ⽉㽋", num), 7);
                    dictionary1.Add(BookmarkStart.b("堩夫䰭䤯ἱ䐳䐵圷䨹夻䰽㐿⭁⅃㕅", num), 8);
                    dictionary1.Add(BookmarkStart.b("丩師伭䜯嬱娳儵ᔷ䨹崻夽┿潁㑃㑅❇㩉⥋㱍⑏㭑ㅓ╕", num), 9);
                    dictionary1.Add(BookmarkStart.b("䤩䐫伭䈯䘱ᤳ䘵䨷唹䰻嬽㈿㙁ⵃ⍅㭇", num), 10);
                    Class1160.dictionary_185 = dictionary1;
                }
                if (Class1160.dictionary_185.TryGetValue(key, out num2))
                {
                    switch (num2)
                    {
                    case 0:
                        goto Label_0175;

                    case 1:
                    {
                        if (class3 is Class97)
                        {
                            Class413.smethod_0(A_0, (Class97)class3);
                        }
                        continue;
                    }

                    case 2:
                    {
                        if (class3 is Class95)
                        {
                            Class242.smethod_0(A_0, (Class95)class3);
                        }
                        continue;
                    }

                    case 3:
                    {
                        if (class3 is Class106)
                        {
                            Class853.smethod_0(A_0, (Class106)class3);
                        }
                        continue;
                    }

                    case 4:
                    {
                        if (class3 is Class94)
                        {
                            Class853.smethod_5(A_0, (Class94)class3);
                        }
                        continue;
                    }

                    case 5:
                    {
                        if (class3 is Class103)
                        {
                            Class853.smethod_1(A_0, (Class103)class3);
                        }
                        continue;
                    }

                    case 6:
                    {
                        if (class3 is Class100)
                        {
                            Class853.smethod_2(A_0, (Class100)class3);
                        }
                        continue;
                    }

                    case 7:
                    {
                        if (class3 is Class98)
                        {
                            Class794.smethod_0(A_0, (Class98)class3);
                        }
                        continue;
                    }

                    case 8:
                    {
                        if (class3 is Class105)
                        {
                            Class1095.smethod_0(A_0, (Class105)class3);
                        }
                        continue;
                    }

                    case 9:
                    {
                        if (class3 is Class104)
                        {
                            Class529.smethod_0(A_0, (Class104)class3);
                        }
                        continue;
                    }

                    case 10:
                    {
                        if (class3 is Class99)
                        {
                            Class648.smethod_0(A_0, (Class99)class3);
                        }
                        continue;
                    }
                    }
                }
            }
            goto Label_02BD;
Label_0175:
            if (class3 is Class96)
            {
                Class96         class4 = (Class96)class3;
                CharacterFormat format = Class1141.smethod_0(A_0, (Class96)class3);
                if (format.Count > 0)
                {
                    class4.method_14(format);
                }
                if (class3.method_8() != null)
                {
                    format.CharStyleName = class3.method_8();
                }
            }
            continue;
Label_02BD:
            class2.vmethod_1();
        }
        A_0.method_13().method_1(class3, A_0.method_20(), A_1);
    }
Exemple #4
0
        public virtual void vmethod_2(Class95 firstLoop, Class608 wires)
        {
            Interface26 pointParamMapper = this.PointParamMapper;

            if (pointParamMapper != null)
            {
                List <Polygon2D> polygon2DList1 = new List <Polygon2D>();
                List <Polygon2D> polygon2DList2 = new List <Polygon2D>();
                foreach (Class95 loop in (IEnumerable <Class95>)Class80.smethod_0 <Class95>(firstLoop))
                {
                    Class917  approximation = new Class917();
                    Polygon2D polygon2D1    = new Polygon2D();
                    foreach (ns9.Class107 coedge in (IEnumerable <ns9.Class107>)loop.Coedges)
                    {
                        ns9.Class88 curve = (ns9.Class88)coedge.Edge.Curve;
                        if (curve != null)
                        {
                            curve.CurvePrimitive.imethod_3(loop, curve, coedge, approximation, wires.Accuracy);
                        }
                        else
                        {
                            Polyline2D polyline2D = this.vmethod_1(coedge);
                            polygon2D1.AddRange((IEnumerable <Point2D>)polyline2D);
                        }
                    }
                    if (polygon2D1.Count > 0)
                    {
                        if (pointParamMapper.IsRightHandedParametric)
                        {
                            if (polygon2D1.GetArea() >= 0.0)
                            {
                                polygon2DList1.Add(polygon2D1);
                            }
                            else
                            {
                                polygon2DList2.Add(polygon2D1);
                            }
                        }
                        else if (polygon2D1.GetArea() < 0.0)
                        {
                            polygon2DList1.Add(polygon2D1);
                        }
                        else
                        {
                            polygon2DList2.Add(polygon2D1);
                        }
                    }
                    Point3D[] points = approximation.Points;
                    if (points.Length > 0)
                    {
                        Polygon2D polygon2D2 = new Polygon2D(points.Length);
                        foreach (Point3D point in points)
                        {
                            polygon2D2.Add(pointParamMapper.imethod_0(point));
                        }
                        if (pointParamMapper.IsRightHandedParametric)
                        {
                            if (polygon2D2.GetArea() >= 0.0)
                            {
                                polygon2DList1.Add(polygon2D2);
                            }
                            else
                            {
                                polygon2DList2.Add(polygon2D2);
                            }
                        }
                        else if (polygon2D2.GetArea() < 0.0)
                        {
                            polygon2DList1.Add(polygon2D2);
                        }
                        else
                        {
                            polygon2DList2.Add(polygon2D2);
                        }
                    }
                }
                if (polygon2DList1.Count == 0 && polygon2DList2.Count != 0)
                {
                    foreach (List <Point2D> point2DList in polygon2DList2)
                    {
                        point2DList.Reverse();
                    }
                    polygon2DList1.AddRange((IEnumerable <Polygon2D>)polygon2DList2);
                    polygon2DList2.Clear();
                }
                Polygon2D[] paramShape = Class794.smethod_9(this.ExtendedIntervalU, this.ExtendedIntervalV, polygon2DList1.ToArray(), polygon2DList2.ToArray(), pointParamMapper.IsRightHandedParametric, wires.Accuracy.Epsilon);
                if (paramShape == null)
                {
                    return;
                }
                foreach (Polygon2D polygon2D in paramShape)
                {
                    Polygon3D polygon3D = new Polygon3D(polygon2D.Count);
                    foreach (Point2D point2D in (List <Point2D>)polygon2D)
                    {
                        polygon3D.Add(pointParamMapper.imethod_1(point2D.X, point2D.Y));
                    }
                    wires.method_9((ICollection <Point3D>)polygon3D, true);
                }
                this.vmethod_0(wires, paramShape, pointParamMapper);
            }
            else
            {
                Class80.smethod_2((Class80)firstLoop, wires);
            }
        }