Esempio n. 1
0
        // Token: 0x06000151 RID: 337 RVA: 0x00005EE8 File Offset: 0x000040E8
        public Torus3?TryGetTorus(out AffineTransform3 location)
        {
            TorusSurface torusSurface = this.Surface as TorusSurface;

            if (torusSurface != null)
            {
                AffineTransform3 affineTransform = Transform3Factory.CreateOrthonormalBasis(torusSurface.UnitZ);
                location = new AffineTransform3(affineTransform.AxisX, affineTransform.AxisY, affineTransform.AxisZ, torusSurface.Origin);
                return(new Torus3?(new Torus3(torusSurface.MajorRadius, torusSurface.MinorRadius)));
            }
            SurfaceOfRevolution surfaceOfRevolution = this.Surface as SurfaceOfRevolution;

            if (surfaceOfRevolution != null)
            {
                CircleCurve3 circleCurve = surfaceOfRevolution.Meridian as CircleCurve3;
                if (circleCurve != null)
                {
                    UnitVector3 normalized = (circleCurve.Origin - surfaceOfRevolution.Origin).GetNormalized();
                    UnitVector3 axisY      = surfaceOfRevolution.Direction.UnitCross(normalized);
                    location = new AffineTransform3(normalized, axisY, surfaceOfRevolution.Direction, surfaceOfRevolution.Origin);
                    return(new Torus3?(new Torus3((surfaceOfRevolution.Origin - circleCurve.Origin).Length, circleCurve.Radius)));
                }
            }
            location = AffineTransform3.Identity;
            return(null);
        }
Esempio n. 2
0
        // Token: 0x06000146 RID: 326 RVA: 0x00005CA4 File Offset: 0x00003EA4
        public Face(Cylinder3 cylinder)
        {
            AffineTransform3 affineTransform = Transform3Factory.CreateOrthonormalBasis(cylinder.Axis.Direction);

            this.Surface     = new CylinderSurface(cylinder.Axis.Origin, affineTransform.AxisX, affineTransform.AxisY, true, cylinder.Radius);
            this.Orientation = Orientation.Forward;
            this.Wires       = new List <Wire3>().AsReadOnly();
        }
Esempio n. 3
0
        // Token: 0x06000145 RID: 325 RVA: 0x00005C40 File Offset: 0x00003E40
        public Face(Plane3 plane)
        {
            AffineTransform3 affineTransform = Transform3Factory.CreateOrthonormalBasis(plane.Normal);

            this.Surface     = new PlaneSurface(plane.Normal * plane.Constant, affineTransform.AxisX, affineTransform.AxisY, true);
            this.Orientation = Orientation.Forward;
            this.Wires       = new List <Wire3>().AsReadOnly();
        }
Esempio n. 4
0
        // Token: 0x06000014 RID: 20 RVA: 0x00002B48 File Offset: 0x00000D48
        private static AffineTransform3 CreateSegmentTransform(AffineTransform3 transform, EdgeArc3 edgeArc, int segmentIndex, int segmentCount)
        {
            if (segmentIndex + 1 == segmentCount)
            {
                AffineTransform3 affineTransform = Transform3Factory.CreateFromAxisAngle(edgeArc.Arc.Circle.Normal, edgeArc.Arc.DeltaAngle, edgeArc.Arc.Circle.Center).Transform(transform);
                UnitVector3      normalized      = (edgeArc.Arc.Circle.UnitV * edgeArc.Arc.DeltaAngle.Cos - edgeArc.Arc.Circle.UnitU * edgeArc.Arc.DeltaAngle.Sin).GetNormalized();
                UnitVector3      axisY           = normalized.UnitCross(affineTransform.AxisX);
                return(new AffineTransform3(axisY.UnitCross(normalized), axisY, normalized, edgeArc.Arc.EndPoint));
            }
            Angle angle = edgeArc.Arc.DeltaAngle * (((double)segmentIndex + 1.0) / (double)segmentCount);

            return(Transform3Factory.CreateFromAxisAngle(edgeArc.Arc.Circle.Normal, angle, edgeArc.Arc.Circle.Center).Transform(transform));
        }
Esempio n. 5
0
        // Token: 0x06000012 RID: 18 RVA: 0x000029D0 File Offset: 0x00000BD0
        private static void CreateTesselatedEdgeArc(List <Vector3> vertices, List <int[]> wires, IList <Vector3> sweepContour, Angle curveTesselation, ref AffineTransform3 transform, EdgeArc3 edgeArc)
        {
            if (edgeArc.Arc.DeltaAngle.Radians < 0.001)
            {
                return;
            }
            if (edgeArc.Arc.StartAngle.Radians != 0.0)
            {
                throw new NotSupportedException("The start angle of the arc should be zero.");
            }
            int num = Math.Max(1, (int)(Math.Abs(edgeArc.Arc.DeltaAngle.Radians) / curveTesselation.Radians + 0.9));

            for (int i = 0; i < num; i++)
            {
                AffineTransform3 transform2 = SweptDiskSolidExtensions.CreateSegmentTransform(transform, edgeArc, i, num);
                SweptDiskSolidExtensions.CreateTransformedSweep(vertices, sweepContour, transform2);
                SweptDiskSolidExtensions.BuildWires(vertices, wires, sweepContour.Count);
            }
            AffineTransform3 transformer = Transform3Factory.CreateFromAxisAngle(edgeArc.Arc.Circle.Normal, edgeArc.Arc.DeltaAngle, edgeArc.Arc.Circle.Center);

            transform = transformer.Transform(transform);
        }
Esempio n. 6
0
        // Token: 0x0600000E RID: 14 RVA: 0x000026EC File Offset: 0x000008EC
        public static FacetedBRep ConvertToFacetedBRep(this SweptDiskSolid sweptDiskSolid, Angle tesselation, double epsilon = 1E-05)
        {
            Wire3 wire = sweptDiskSolid.Wire;

            if (wire.Edges.Count == 0 || wire.ContinuousError > epsilon || tesselation.Radians < epsilon)
            {
                return(null);
            }
            IEdge3           edge            = wire.Edges[0];
            AffineTransform3 affineTransform = Transform3Factory.CreateOrthonormalBasis(edge.StartDirection);
            AffineTransform3 transform       = new AffineTransform3(affineTransform.AxisX, affineTransform.AxisY, affineTransform.AxisZ, edge.StartPoint);
            IList <Vector3>  sweepContour    = SweptDiskSolidExtensions.CreateSweepContour(Math.Round(Angle.FullCircle / tesselation, MidpointRounding.AwayFromZero), sweptDiskSolid.Radius);
            List <Vector3>   list            = new List <Vector3>();
            List <int[]>     list2           = new List <int[]>();

            SweptDiskSolidExtensions.AddStartFace(list, list2, sweepContour, transform);
            foreach (IEdge3 edge2 in wire.Edges)
            {
                SweptDiskSolidExtensions.CreateTesselatedEdge(list, list2, sweepContour, tesselation, ref transform, edge2);
            }
            SweptDiskSolidExtensions.AddEndFace(list, list2, sweepContour);
            return(new FacetedBRep(list.ToArray(), list2.ToArray(), new Dictionary <int, int[][]>()));
        }