Пример #1
0
        private ISurface CreatePlanarSurface(Point center, Vector dir,
                                             Vector refDir, out IMathVector refVec)
        {
            refVec = m_MathUtils.CreateVector(refDir.ToArray()) as IMathVector;

            return(m_Modeler.CreatePlanarSurface2(center.ToArray(), dir.ToArray(), refVec.ArrayData) as ISurface);
        }
Пример #2
0
        public static ISurface CreatePlanarSurface(this IModeler activeModeler, PointDirection3 plane)
        {
            var planeDirection = plane.Direction;
            var vRef           = planeDirection.Orthogonal();
            var mathVector     = planeDirection;
            var vRootPoint     = plane.Point;

            return((ISurface)activeModeler.CreatePlanarSurface2(vRootPoint.ToDoubles(), mathVector.ToDoubles(), vRef.ToDoubles()));
        }
Пример #3
0
        private IBody2 CreateBodyFromSketchContour(IModeler modeler,
                                                   IMathUtility mathUtils, ISketchContour skCont, double height, bool midPlane)
        {
            var sketch = skCont.Sketch;

            if (sketch.Is3D())
            {
                throw new UserErrorException("Only 2D sketches are supported");
            }

            var transform = sketch.ModelToSketchTransform.IInverse();

            var boundary = (skCont.GetEdges() as object[])
                           .Cast <IEdge>()
                           .Select(e =>
            {
                var curve = e.IGetCurve().ICopy();    //must copy curve otherwise CreateTrimmedSheet4 is failing
                return(curve);
            }).ToArray();

            var centerPt = mathUtils.CreatePoint(new double[] { 0, 0, 0 }) as IMathPoint;
            var dirVec   = mathUtils.CreateVector(new double[] { 0, 0, 1 }) as IMathVector;
            var refVec   = mathUtils.CreateVector(new double[] { 1, 0, 0 }) as IMathVector;

            centerPt = centerPt.IMultiplyTransform(transform);
            dirVec   = dirVec.IMultiplyTransform(transform);
            refVec   = refVec.IMultiplyTransform(transform);

            if (midPlane)
            {
                var dirRevVec = new Vector(dirVec.ArrayData as double[]);
                dirRevVec.Scale(-1);

                var origPt = new Point(centerPt.ArrayData as double[]);

                MoveCurves(origPt, dirRevVec, height / 2, boundary, mathUtils);
                centerPt = mathUtils.CreatePoint(origPt.Move(dirRevVec, height / 2).ToArray()) as IMathPoint;
            }

            var surf = modeler.CreatePlanarSurface2(centerPt.ArrayData, dirVec.ArrayData, refVec.ArrayData) as ISurface;

            var sheetBody = surf.CreateTrimmedSheet4(boundary, true) as Body2;

            if (sheetBody == null)
            {
                throw new NullReferenceException("Failed to create trimmed sheet from surface region");
            }

            var solidBody = modeler.CreateExtrudedBody(sheetBody, dirVec as MathVector, height) as IBody2;

            var faces = (solidBody.GetFaces() as object[]).Cast <IFace2>().ToArray();

            return(modeler.CreateSheetFromFaces(faces));
        }
        //TODO: calculate height based on bounding box
        private IBody2 CreateBodyFromSketchContour(IModeler modeler,
                                                   IMathUtility mathUtils, ISketchContour skCont, double height = 1000)
        {
            var sketch = skCont.Sketch;

            if (sketch.Is3D())
            {
                throw new UserErrorException("Only 2D sketches are supported");
            }

            var transform = sketch.ModelToSketchTransform.IInverse();

            var boundary = (skCont.GetEdges() as object[])
                           .Cast <IEdge>()
                           .Select(e =>
            {
                var curve = e.IGetCurve().ICopy();    //must copy curve otherwise CreateTrimmedSheet4 is failing
                return(curve);
            }).ToArray();

            var centerPt = mathUtils.CreatePoint(new double[] { 0, 0, 0 }) as IMathPoint;
            var dirVec   = mathUtils.CreateVector(new double[] { 0, 0, 1 }) as IMathVector;
            var refVec   = mathUtils.CreateVector(new double[] { 1, 0, 0 }) as IMathVector;

            centerPt = centerPt.IMultiplyTransform(transform);
            dirVec   = dirVec.IMultiplyTransform(transform);
            refVec   = refVec.IMultiplyTransform(transform);

            var surf = modeler.CreatePlanarSurface2(centerPt.ArrayData, dirVec.ArrayData, refVec.ArrayData) as ISurface;

            var sheetBody = surf.CreateTrimmedSheet4(boundary, true) as Body2;

            if (sheetBody == null)
            {
                throw new NullReferenceException("Failed to create trimmed sheet from surface region");
            }

            var firstBody  = modeler.CreateExtrudedBody(sheetBody, dirVec as MathVector, height * 0.9 / 2) as IBody2;
            var secondBody = modeler.CreateExtrudedBody(sheetBody, dirVec.IScale(-1), height * 0.9 / 2) as IBody2;

            int err;
            var res = firstBody.Operations2((int)swBodyOperationType_e.SWBODYADD, secondBody, out err) as object[];

            return(res.First() as IBody2);
        }
Пример #5
0
        private static ISurface CreatePlanarSurface(IModeler modeler, Point center, Vector dir,
                                                    ref Vector refDir, out IMathVector refVec)
        {
            if (refDir == null)
            {
                var transform = GetTransformBetweenVectors(new Vector(0, 0, 1), dir, center);

                refVec = (m_MathUtils.CreateVector(
                              new double[] { 1, 0, 0 }) as IMathVector)
                         .MultiplyTransform(transform) as IMathVector;

                refDir = new Vector(refVec.ArrayData as double[]);
            }
            else
            {
                refVec = m_MathUtils.CreateVector(refDir.ToArray()) as IMathVector;
            }

            return(modeler.CreatePlanarSurface2(center.ToArray(), dir.ToArray(), refVec.ArrayData) as ISurface);
        }
        public static IBody2 CreateSemiCirclularSheet
            (this IModeler modeler
            , Vector3 center
            , Vector3 vNormal
            , Vector3 vRef // Horizontal
            , double radius)
        {
            // Should be orthogonal
            Debug.Assert(vRef.Dot(vNormal) < 1e-9);

            var math          = SwAddinBase.Active.Math;
            var centerSw      = center.ToSwMathPoint();
            var vNormalSw     = vNormal.ToSwMathPoint();
            var vNormalOrthSw = vRef.ToSWVector(math).Normalise();

            var centerDbls      = centerSw.ArrayData;
            var vNormalDbls     = vNormalSw.ArrayData;
            var vNormalOrthDbls = vNormalOrthSw.ArrayData;

            var surf = (Surface)modeler.CreatePlanarSurface2(centerDbls, vNormalDbls, vNormalOrthDbls);


            var startPoint = center + radius * vRef.Unit();
            var endPoint   = center - radius * vRef.Unit();

            var startPointDbls = startPoint.ToDoubles();
            var endPointDbls   = endPoint.ToDoubles();


            var arco = modeler.CreateArc
                           (centerDbls, vNormalDbls, radius, startPointDbls, endPointDbls);

            var arc           = (Curve)arco;
            var arcStartPoint = startPoint;
            var arcEndPoint   = endPoint;

            var trimmedArc = arc.CreateTrimmedCurve2(arcStartPoint.X, arcStartPoint.Y, arcStartPoint.Z, arcEndPoint.X, arcEndPoint.Y, arcEndPoint.Z);
            var line       = modeler.CreateTrimmedLine(arcEndPoint, arcStartPoint);

            return((IBody2)surf.CreateTrimmedSheet(new[] { trimmedArc, line }));
        }
        public static IBody2 CreateCirclularSheet
            (this IModeler modeler
            , Vector3 center
            , Vector3 vNormal
            , Vector3 vRef
            , double radius)
        {
            // Should be orthogonal
            Debug.Assert(vRef.Dot(vNormal) < 1e-9);

            var math          = SwAddinBase.Active.Math;
            var centerSw      = center.ToSwMathPoint();
            var vNormalSw     = vNormal.ToSwMathPoint();
            var vNormalOrthSw = vRef.ToSWVector(math).Normalise();

            var centerDbls      = centerSw.ArrayData;
            var vNormalDbls     = vNormalSw.ArrayData;
            var vNormalOrthDbls = vNormalOrthSw.ArrayData;

            var surf = (Surface)modeler.CreatePlanarSurface2(centerDbls, vNormalDbls, vNormalOrthDbls);


            var startPoint = centerSw.AddTs(vNormalOrthSw.ScaleTs(radius));

            var startPointDbls = startPoint.ArrayData;


            var arco = modeler.CreateArc
                           (centerDbls, vNormalDbls, radius, startPointDbls, startPointDbls);

            var arc           = (Curve)arco;
            var arcStartPoint = arc.StartPoint();
            var arcEndPoint   = arc.EndPoint();

            var trimmedArc = arc.CreateTrimmedCurve2(arcStartPoint.X, arcStartPoint.Y, arcStartPoint.Z, arcEndPoint.X, arcEndPoint.Y, arcEndPoint.Z);

            return((IBody2)surf.CreateTrimmedSheet(new[] { trimmedArc }));
        }