@buerli.io/core 0.5.0-beta.1 → 0.5.0-beta.3

package/build/cjs/types/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./IGraphicPackage"), exports);
+__exportStar(require("./InteractionInfo"), exports);
+__exportStar(require("./IStructurePatch"), exports);
+__exportStar(require("./IStructureTree"), exports);

package/build/cjs/utils/Math.js

@@ -0,0 +1,91 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MathUtils = void 0;
+const THREE = __importStar(require("three"));
+const degToRad = THREE.MathUtils.degToRad;
+const tolerance = 1e-6;
+exports.MathUtils = {
+    convertToMatrix4: function (coordinateSystem) {
+        const [orig, vx, vy, vz] = coordinateSystem.map(row => new THREE.Vector3().fromArray(row));
+        return new THREE.Matrix4().makeBasis(vx, vy, vz).setPosition(orig);
+    },
+    convertToMatrix3: function (coordinateSystem) {
+        const [, vx, vy, vz] = coordinateSystem;
+        return new THREE.Matrix3().fromArray([...vx, ...vy, ...vz]);
+    },
+    convertToCoordinateSystem: function (matrix) {
+        const position = new THREE.Vector3();
+        const xAxis = new THREE.Vector3();
+        const yAxis = new THREE.Vector3();
+        const zAxis = new THREE.Vector3();
+        position.setFromMatrixPosition(matrix);
+        matrix.extractBasis(xAxis, yAxis, zAxis);
+        const coordSys = [];
+        coordSys[0] = [position.x, position.y, position.z];
+        coordSys[1] = [xAxis.x, xAxis.y, xAxis.z];
+        coordSys[2] = [yAxis.x, yAxis.y, yAxis.z];
+        coordSys[3] = [zAxis.x, zAxis.y, zAxis.z];
+        return coordSys;
+    },
+    round(value, digits) {
+        if (isNaN(value))
+            return NaN;
+        const factor = Math.pow(10, digits);
+        return Math.round(value * factor) / factor;
+    },
+    /**
+     * Calculates a transformation matrix.
+     *
+     * xDir and yDir are NOT orthogonal in general case, thus the y-axis is calculated as a series of cross products.
+     *
+     * @param originPos The origin position.
+     * @param xDir The x direction.
+     * @param yDir The y direction.
+     * @param offset The offset vector.
+     * @param rotation The rotation vector.
+     * @param inverted The inverted flag --- 0: do not invert; 1: do invert.
+     * @returns The calculated THREE.Matrix4
+     */
+    calcluateTransform: function (originPos, xDir, yDir, offset, rotation, inverted) {
+        rotation = new THREE.Vector3(degToRad(rotation.x), degToRad(rotation.y), degToRad(rotation.z));
+        const xAxis = xDir.clone().normalize();
+        let yDir_ = yDir.clone().normalize();
+        if (Math.abs(yDir_.dot(xAxis.clone())) > 1 - tolerance) {
+            yDir_ = Math.abs(xAxis.y) !== 1 ? new THREE.Vector3(0.0, 1.0, 0.0) : new THREE.Vector3(1.0, 0.0, 0.0);
+        }
+        const zAxis = xAxis.clone().cross(yDir_).normalize();
+        const yAxis = zAxis.clone().cross(xAxis).normalize();
+        if (inverted) {
+            xAxis.negate();
+            zAxis.negate();
+        }
+        const mLocal = new THREE.Matrix4()
+            .makeRotationFromEuler(new THREE.Euler(rotation.x, rotation.y, rotation.z))
+            .setPosition(offset.x, offset.y, offset.z);
+        const mGlobal = new THREE.Matrix4().makeBasis(xAxis, yAxis, zAxis).setPosition(originPos);
+        return mGlobal.clone().multiply(mLocal);
+    },
+};

package/build/cjs/utils/Measure.js

@@ -0,0 +1,560 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Measure = exports.MeasureResultType = void 0;
+/* eslint-disable max-lines */
+const THREE = __importStar(require("three"));
+const store_1 = require("./../store");
+const types_1 = require("./../types");
+var MeasureResultType;
+(function (MeasureResultType) {
+    MeasureResultType["NONE"] = "none";
+    MeasureResultType["VALUE"] = "value";
+    MeasureResultType["DISTANCE"] = "linear";
+    MeasureResultType["ANGLE"] = "angular";
+    MeasureResultType["VECTOR"] = "vector";
+    MeasureResultType["POSITION"] = "position";
+})(MeasureResultType = exports.MeasureResultType || (exports.MeasureResultType = {}));
+const tolerance = 1e-3;
+exports.Measure = {
+    transform(items, drawingId) {
+        const drawing = (0, store_1.getDrawing)(drawingId);
+        const transformed = [];
+        for (const item of items) {
+            const matrix = drawing.api.structure.calculateGlobalTransformation(item.productId);
+            const matrix3 = new THREE.Matrix3().setFromMatrix4(matrix);
+            const newItem = Object.assign({}, item);
+            switch (newItem.type) {
+                case types_1.GraphicType.POINT:
+                case types_1.GraphicType.CURVEPOINT:
+                    const point = newItem;
+                    point.position = point.position.clone().applyMatrix4(matrix);
+                    break;
+                case types_1.GraphicType.LINE:
+                case types_1.GraphicType.CURVELINE:
+                    const line = newItem;
+                    line.start = line.start.clone().applyMatrix4(matrix);
+                    line.end = line.end.clone().applyMatrix4(matrix);
+                    break;
+                case types_1.GraphicType.PLANE:
+                    const plane = newItem;
+                    plane.normal = plane.normal.clone().applyMatrix3(matrix3);
+                    plane.normal.normalize();
+                    plane.pointOnPlane = plane.pointOnPlane.clone().applyMatrix4(matrix);
+                    break;
+                case types_1.GraphicType.CYLINDER:
+                    const cylinder = newItem;
+                    cylinder.axis = cylinder.axis.clone().applyMatrix3(matrix3);
+                    cylinder.axis.normalize();
+                    cylinder.origin = cylinder.origin.clone().applyMatrix4(matrix);
+                    break;
+                case types_1.GraphicType.CONE:
+                    const cone = newItem;
+                    cone.axis = cone.axis.clone().applyMatrix3(matrix3);
+                    cone.axis.normalize();
+                    cone.origin = cone.origin.clone().applyMatrix4(matrix);
+                    break;
+                case types_1.GraphicType.ARC:
+                case types_1.GraphicType.CURVEARC:
+                    const arc = newItem;
+                    arc.normal = arc.normal.clone().applyMatrix3(matrix3);
+                    arc.normal.normalize();
+                    arc.center = arc.center.clone().applyMatrix4(matrix);
+                    break;
+                case types_1.GraphicType.CIRCLE:
+                case types_1.GraphicType.CURVECIRCLE:
+                    const circle = newItem;
+                    circle.normal = circle.normal.clone().applyMatrix3(matrix3);
+                    circle.normal.normalize();
+                    circle.center = circle.center.clone().applyMatrix4(matrix);
+                    break;
+                default:
+                    break;
+            }
+            transformed.push(newItem);
+        }
+        return transformed;
+    },
+    getInfo(objects, drawingId) {
+        const transformed = exports.Measure.transform(objects, drawingId);
+        const results = [];
+        const dir = (start, end) => end.clone().sub(start).normalize();
+        const getPointOnCircumference = (center, axis, radius) => {
+            const axisNormalized = axis.clone().normalize();
+            const helperVec = axisNormalized.x !== 1 ? new THREE.Vector3(1, 0, 0) : new THREE.Vector3(0, 1, 0);
+            const tangent = axisNormalized.clone().cross(helperVec).normalize();
+            return center.clone().addScaledVector(tangent, radius);
+        };
+        for (const element of transformed) {
+            switch (element.type) {
+                case types_1.GraphicType.POINT:
+                case types_1.GraphicType.CURVEPOINT:
+                    const point = element;
+                    results.push({
+                        description: 'Position',
+                        type: MeasureResultType.POSITION,
+                        measureData: { value: point.position.clone() },
+                    });
+                    break;
+                case types_1.GraphicType.LINE:
+                case types_1.GraphicType.CURVELINE:
+                    const line = element;
+                    const absoluteDistance = line.start.distanceTo(line.end);
+                    results.push({
+                        description: 'Line length',
+                        type: MeasureResultType.DISTANCE,
+                        measureData: { value: absoluteDistance, start: line.start.clone(), end: line.end.clone() },
+                    });
+                    break;
+                case types_1.GraphicType.EDGE:
+                case types_1.GraphicType.CURVESPLINE:
+                    const edge = element;
+                    results.push({
+                        description: 'Edge start',
+                        type: MeasureResultType.POSITION,
+                        measureData: { value: edge.start.clone() },
+                    });
+                    results.push({
+                        description: 'Edge end',
+                        type: MeasureResultType.POSITION,
+                        measureData: { value: edge.start.clone() },
+                    });
+                    break;
+                case types_1.GraphicType.ARC:
+                case types_1.GraphicType.CURVEARC:
+                    const arc = element;
+                    const arcNEnd = arc.center.clone().addScaledVector(arc.normal.clone().normalize(), 40);
+                    const pointOnArc = getPointOnCircumference(arc.center, arc.normal, arc.radius);
+                    results.push({
+                        description: 'Arc center',
+                        type: MeasureResultType.POSITION,
+                        measureData: { value: arc.center.clone() },
+                    });
+                    results.push({
+                        description: 'Arc normal',
+                        type: MeasureResultType.VECTOR,
+                        measureData: { value: arc.normal.clone(), start: arc.center.clone(), end: arcNEnd },
+                    });
+                    results.push({
+                        description: 'Arc radius',
+                        type: MeasureResultType.DISTANCE,
+                        measureData: { value: arc.radius, start: arc.center.clone(), end: pointOnArc },
+                    });
+                    break;
+                case types_1.GraphicType.CIRCLE:
+                case types_1.GraphicType.CURVECIRCLE:
+                    const circle = element;
+                    const circleNEnd = circle.center.clone().addScaledVector(circle.normal.clone().normalize(), 40);
+                    const pointOnCircle = getPointOnCircumference(circle.center, circle.normal, circle.radius);
+                    results.push({
+                        description: 'Circle center',
+                        type: MeasureResultType.POSITION,
+                        measureData: { value: circle.center.clone() },
+                    });
+                    results.push({
+                        description: 'Circle normal',
+                        type: MeasureResultType.VECTOR,
+                        measureData: { value: circle.normal.clone(), start: circle.center.clone(), end: circleNEnd },
+                    });
+                    results.push({
+                        description: 'Circle radius',
+                        type: MeasureResultType.DISTANCE,
+                        measureData: { value: circle.radius, start: circle.center.clone(), end: pointOnCircle },
+                    });
+                    break;
+                case types_1.GraphicType.PLANE:
+                    const plane = element;
+                    const planeNEnd = plane.pointOnPlane.clone().addScaledVector(plane.normal.clone().normalize(), 40);
+                    results.push({
+                        description: 'Plane normal',
+                        type: MeasureResultType.VECTOR,
+                        measureData: { value: plane.normal, start: plane.pointOnPlane.clone(), end: planeNEnd },
+                    });
+                    break;
+                case types_1.GraphicType.CYLINDER:
+                    const cylinder = element;
+                    const cylAxisNormalized = cylinder.axis.clone().normalize();
+                    const cylNEnd = cylinder.origin.clone().addScaledVector(cylAxisNormalized, cylinder.height + 40);
+                    const pointOnCyl = getPointOnCircumference(cylinder.origin, cylinder.axis, cylinder.radius);
+                    const cylHStart = cylinder.origin
+                        .clone()
+                        .addScaledVector(dir(cylinder.origin, pointOnCyl), cylinder.radius + 3);
+                    const cylHEnd = cylHStart.clone().addScaledVector(cylAxisNormalized, cylinder.height);
+                    results.push({
+                        description: 'Cylinder origin',
+                        type: MeasureResultType.POSITION,
+                        measureData: { value: cylinder.origin.clone() },
+                    });
+                    results.push({
+                        description: 'Cylinder axis',
+                        type: MeasureResultType.VECTOR,
+                        measureData: { value: cylinder.axis, start: cylinder.origin.clone(), end: cylNEnd },
+                    });
+                    results.push({
+                        description: 'Cylinder radius',
+                        type: MeasureResultType.DISTANCE,
+                        measureData: { value: cylinder.radius, start: cylinder.origin.clone(), end: pointOnCyl },
+                    });
+                    results.push({
+                        description: 'Cylinder height',
+                        type: MeasureResultType.DISTANCE,
+                        measureData: { value: cylinder.height, start: cylHStart, end: cylHEnd },
+                    });
+                    break;
+                case types_1.GraphicType.CONE:
+                    const cone = element;
+                    const isExpanding = cone.radiusBottom < cone.radiusTop;
+                    const R = Math.max(cone.radiusBottom, cone.radiusTop);
+                    const r = Math.min(cone.radiusBottom, cone.radiusTop);
+                    const coneAxisNormalized = cone.axis.clone().normalize();
+                    const coneCenterTop = cone.origin.clone().addScaledVector(coneAxisNormalized, cone.height);
+                    const coneEnd = coneCenterTop.clone().addScaledVector(coneAxisNormalized, 40);
+                    const coneCenterMinR = isExpanding ? cone.origin.clone() : coneCenterTop.clone();
+                    const coneCenterMaxR = isExpanding ? coneCenterTop.clone() : cone.origin.clone();
+                    const pointOnConeBottom = getPointOnCircumference(cone.origin, cone.axis, cone.radiusBottom);
+                    const pointOnConeTop = getPointOnCircumference(coneCenterTop, cone.axis, cone.radiusTop);
+                    const pointOnConeMinR = isExpanding ? pointOnConeBottom : pointOnConeTop;
+                    const pointOnConeMaxR = isExpanding ? pointOnConeTop : pointOnConeBottom;
+                    const coneHStart = coneCenterMaxR.clone().addScaledVector(dir(coneCenterMaxR, pointOnConeMaxR), R + 3);
+                    const coneHEnd = coneHStart
+                        .clone()
+                        .addScaledVector(coneAxisNormalized, isExpanding ? -cone.height : cone.height);
+                    results.push({
+                        description: 'Cone origin',
+                        type: MeasureResultType.POSITION,
+                        measureData: { value: cone.origin.clone() },
+                    });
+                    results.push({
+                        description: 'Cone axis',
+                        type: MeasureResultType.VECTOR,
+                        measureData: { value: cone.axis, start: cone.origin.clone(), end: coneEnd },
+                    });
+                    results.push({
+                        description: 'Cone radius (min)',
+                        type: MeasureResultType.DISTANCE,
+                        measureData: { value: r, start: coneCenterMinR, end: pointOnConeMinR },
+                    });
+                    results.push({
+                        description: 'Cone radius (max)',
+                        type: MeasureResultType.DISTANCE,
+                        measureData: { value: R, start: coneCenterMaxR, end: pointOnConeMaxR },
+                    });
+                    results.push({
+                        description: 'Cone height',
+                        type: MeasureResultType.DISTANCE,
+                        measureData: { value: cone.height, start: coneHStart, end: coneHEnd },
+                    });
+                    break;
+                case types_1.GraphicType.SPHERE:
+                    const sphere = element;
+                    results.push({
+                        description: 'Sphere radius',
+                        type: MeasureResultType.VALUE,
+                        measureData: { value: sphere.radius },
+                    });
+                    break;
+                case types_1.GraphicType.NURBS:
+                    results.push({ description: 'NURBS', type: MeasureResultType.NONE });
+                    break;
+                case types_1.GraphicType.NURBSSURFACE:
+                    results.push({ description: 'NURBS Surface', type: MeasureResultType.NONE });
+                    break;
+                default:
+                    results.push({ description: 'Undefined', type: MeasureResultType.NONE });
+                    break;
+            }
+        }
+        return results;
+    },
+    calculateMeasures(objects, drawingId) {
+        const transformed = exports.Measure.transform(objects, drawingId);
+        const first = transformed[0];
+        const second = transformed[1];
+        let results = [];
+        switch (first.type) {
+            case types_1.GraphicType.POINT:
+            case types_1.GraphicType.CURVEPOINT:
+                switch (second.type) {
+                    case types_1.GraphicType.POINT:
+                    case types_1.GraphicType.CURVEPOINT:
+                        results = exports.Measure.calculatePointPoint(first.position, second.position);
+                        break;
+                    case types_1.GraphicType.LINE:
+                    case types_1.GraphicType.CURVELINE:
+                        results = exports.Measure.calculatePointLine(first, second);
+                        break;
+                    case types_1.GraphicType.PLANE:
+                        results = exports.Measure.calculatePointPlane(first, second);
+                        break;
+                    case types_1.GraphicType.ARC:
+                    case types_1.GraphicType.CIRCLE:
+                        results = exports.Measure.calculatePointPoint(first.position.clone(), second.center.clone());
+                        break;
+                    default:
+                        results = exports.Measure.getInfo(objects, drawingId);
+                        break;
+                }
+                break;
+            case types_1.GraphicType.LINE:
+            case types_1.GraphicType.CURVELINE:
+                switch (second.type) {
+                    case types_1.GraphicType.POINT:
+                    case types_1.GraphicType.CURVEPOINT:
+                        results = exports.Measure.calculatePointLine(second, first);
+                        break;
+                    case types_1.GraphicType.LINE:
+                    case types_1.GraphicType.CURVELINE:
+                        results = exports.Measure.calculateLineLine(first, second);
+                        break;
+                    case types_1.GraphicType.PLANE:
+                        results = exports.Measure.calculateLinePlane(first, second);
+                        break;
+                    default:
+                        results = exports.Measure.getInfo(objects, drawingId);
+                        break;
+                }
+                break;
+            case types_1.GraphicType.CIRCLE:
+            case types_1.GraphicType.ARC:
+                switch (second.type) {
+                    case types_1.GraphicType.ARC:
+                    case types_1.GraphicType.CIRCLE:
+                        results = exports.Measure.calculatePointPoint(first.center, second.center);
+                        break;
+                    case types_1.GraphicType.POINT:
+                        results = exports.Measure.calculatePointPoint(first.center, second.position);
+                        break;
+                    default:
+                        results = exports.Measure.getInfo(objects, drawingId);
+                        break;
+                }
+                break;
+            case types_1.GraphicType.PLANE:
+                switch (second.type) {
+                    case types_1.GraphicType.POINT:
+                    case types_1.GraphicType.CURVEPOINT:
+                        results = exports.Measure.calculatePointPlane(second, first);
+                        break;
+                    case types_1.GraphicType.LINE:
+                    case types_1.GraphicType.CURVELINE:
+                        results = exports.Measure.calculateLinePlane(second, first);
+                        break;
+                    case types_1.GraphicType.ARC:
+                    case types_1.GraphicType.CURVEARC:
+                        results = exports.Measure.calculateArcPlane(second, first);
+                        break;
+                    case types_1.GraphicType.PLANE:
+                        results = exports.Measure.calculatePlanePlane(first, second);
+                        break;
+                    default:
+                        results = exports.Measure.getInfo(objects, drawingId);
+                        break;
+                }
+                break;
+            default:
+                results = exports.Measure.getInfo(objects, drawingId);
+                break;
+        }
+        return results;
+    },
+    calculatePointPoint(point1, point2) {
+        const p1 = point1.clone();
+        const p2 = point2.clone();
+        const distance = p1.distanceTo(p2);
+        const dx = Math.abs(p1.x - p2.x);
+        const dy = Math.abs(p1.y - p2.y);
+        const dz = Math.abs(p1.z - p2.z);
+        const px = p1.clone().setX(p2.x);
+        const pxy = px.clone().setY(p2.y);
+        return [
+            {
+                description: 'Distance',
+                type: MeasureResultType.DISTANCE,
+                measureData: { value: distance, start: p1, end: p2 },
+            },
+            { description: 'dx', type: MeasureResultType.DISTANCE, measureData: { value: dx, start: p1, end: px } },
+            { description: 'dy', type: MeasureResultType.DISTANCE, measureData: { value: dy, start: px, end: pxy } },
+            { description: 'dz', type: MeasureResultType.DISTANCE, measureData: { value: dz, start: pxy, end: p2 } },
+        ];
+    },
+    calculatePointLine(point, line) {
+        const [start, end] = exports.Measure.getPointLineMPoints(point.position, line.start, line.end);
+        const distance = start.distanceTo(end);
+        return [
+            {
+                description: 'Distance',
+                type: MeasureResultType.DISTANCE,
+                measureData: { value: distance, start, end },
+            },
+        ];
+    },
+    calculatePointPlane(point, plane) {
+        const [start, end] = exports.Measure.getPointPlaneMPoints(point.position, plane.pointOnPlane, plane.normal);
+        const distance = start.distanceTo(end);
+        return [
+            {
+                description: 'Distance',
+                type: MeasureResultType.DISTANCE,
+                measureData: { value: distance, start, end },
+            },
+        ];
+    },
+    calculateLineLine(first, second) {
+        const [start, end] = exports.Measure.getLineLineMPoints(first.start, first.end, second.start, second.end);
+        const distance = start && end ? start.distanceTo(end) : NaN;
+        const [dir1, dir2] = exports.Measure.getLineLineMDirs(first.start, first.end, second.start, second.end);
+        const angle = exports.Measure.degrees(dir1.angleTo(dir2));
+        const angleS = 180 - angle;
+        return [
+            {
+                description: 'Distance',
+                type: MeasureResultType.DISTANCE,
+                measureData: start && end ? { value: distance, start, end } : undefined,
+            },
+            {
+                description: 'Angle1',
+                type: MeasureResultType.ANGLE,
+                measureData: { value: angle, center: first.start, dir1, dir2 },
+            },
+            {
+                description: 'Angle2',
+                type: MeasureResultType.ANGLE,
+                measureData: { value: angleS, center: first.start, dir1, dir2: dir2.clone().negate() },
+            },
+        ];
+    },
+    calculateLinePlane(line, plane) {
+        const [start, end] = exports.Measure.getLinePlaneMPoints(line.start, line.end, plane.pointOnPlane, plane.normal);
+        const distance = start && end ? start.distanceTo(end) : NaN;
+        return [
+            {
+                description: 'Distance',
+                type: MeasureResultType.DISTANCE,
+                measureData: start && end ? { value: distance, start, end } : undefined,
+            },
+        ];
+    },
+    calculateArcPlane(arc, plane) {
+        const [start, end] = exports.Measure.getArcPlaneMPoints(arc.center, arc.normal, plane.pointOnPlane, plane.normal);
+        const distance = start && end ? start.distanceTo(end) : NaN;
+        return [
+            {
+                description: 'Distance',
+                type: MeasureResultType.DISTANCE,
+                measureData: start && end ? { value: distance, start, end } : undefined,
+            },
+        ];
+    },
+    calculatePlanePlane(plane1, plane2) {
+        const [start, end] = exports.Measure.getPlanePlaneMPoints(plane1.pointOnPlane, plane1.normal, plane2.pointOnPlane, plane2.normal);
+        const distance = start && end ? start.distanceTo(end) : NaN;
+        const [dir1, dir2] = exports.Measure.getPlanePlaneMDirs(plane1.normal, plane2.normal);
+        const angle = dir1 && dir2 ? exports.Measure.degrees(dir1.angleTo(dir2)) : exports.Measure.degrees(plane1.normal.angleTo(plane2.normal));
+        return [
+            {
+                description: 'Distance',
+                type: MeasureResultType.DISTANCE,
+                measureData: start && end ? { value: distance, start, end } : undefined,
+            },
+            {
+                description: 'Angle',
+                type: MeasureResultType.ANGLE,
+                measureData: dir1 && dir2 ? { value: angle, center: plane1.pointOnPlane.clone(), dir1, dir2 } : undefined,
+            },
+        ];
+    },
+    degrees(radians) {
+        return (radians / Math.PI) * 180;
+    },
+    areParallel(vec1, vec2) {
+        const val = Math.abs(vec1.clone().cross(vec2).length());
+        return val < tolerance;
+    },
+    arePerpendicular(vec1, vec2) {
+        const val = Math.abs(vec1.clone().normalize().dot(vec2.clone().normalize()));
+        return val < tolerance;
+    },
+    getPointLineMPoints(pointsPos, startPos, endPos) {
+        const p1 = pointsPos.clone();
+        const lineDir = endPos.clone().sub(startPos);
+        const p2 = pointsPos.clone().sub(startPos).projectOnVector(lineDir).add(startPos);
+        return [p1, p2];
+    },
+    getPointPlaneMPoints(pointPos, pointOnPlane, normal) {
+        const p1 = pointPos.clone();
+        const offsetV = pointPos.clone().sub(pointOnPlane).projectOnVector(normal);
+        const p2 = pointPos.clone().sub(offsetV);
+        return [p1, p2];
+    },
+    getLineLineMPoints(start1Pos, end1Pos, start2Pos, end2Pos) {
+        const vec1 = start1Pos.clone().sub(end1Pos);
+        const vec2 = start2Pos.clone().sub(end2Pos);
+        if (exports.Measure.areParallel(vec1, vec2)) {
+            // lines are parallel
+            const vecAB = start1Pos.clone().sub(start2Pos);
+            if (!exports.Measure.areParallel(vecAB, vec1)) {
+                // lines are not conincident
+                return exports.Measure.getPointLineMPoints(start1Pos, start2Pos, end2Pos);
+            }
+        }
+        return [undefined, undefined];
+    },
+    getLinePlaneMPoints(startPos, endPos, pointOnPlane, normal) {
+        const vec = startPos.clone().sub(endPos);
+        if (exports.Measure.arePerpendicular(vec, normal)) {
+            // line is perpendicular to plane normal
+            return exports.Measure.getPointPlaneMPoints(startPos, pointOnPlane, normal);
+        }
+        return [undefined, undefined];
+    },
+    getArcPlaneMPoints(arcCenter, arcNormal, pointOnPlane, planeNormal) {
+        if (exports.Measure.areParallel(arcNormal, planeNormal)) {
+            // parallel
+            return exports.Measure.getPointPlaneMPoints(arcCenter, pointOnPlane, planeNormal);
+        }
+        return [undefined, undefined];
+    },
+    getPlanePlaneMPoints(pointOnPlane1, normal1, pointOnPlane2, normal2) {
+        if (exports.Measure.areParallel(normal1, normal2)) {
+            // parallel
+            return exports.Measure.getPointPlaneMPoints(pointOnPlane1, pointOnPlane2, normal2);
+        }
+        return [undefined, undefined];
+    },
+    getLineLineMDirs(start1Pos, end1Pos, start2Pos, end2Pos) {
+        const vec1 = end1Pos.clone().sub(start1Pos);
+        const vec2 = end2Pos.clone().sub(start2Pos);
+        return [vec1, vec2];
+    },
+    getPlanePlaneMDirs(normal1, normal2) {
+        if (!exports.Measure.areParallel(normal1, normal2)) {
+            const tangent1 = normal1.clone().projectOnPlane(normal2).normalize();
+            const tangent2 = normal2.clone().projectOnPlane(normal1).normalize();
+            const angle = tangent1.angleTo(tangent2);
+            return angle <= Math.PI / 2 ? [tangent1, tangent2] : [tangent1, tangent2.negate()];
+        }
+        return [undefined, undefined];
+    },
+};