@buerli.io/core 1.0.1 → 1.1.0-beta.7

package/build/esm/utils/Measure.js

@@ -1,550 +1,550 @@
-/* eslint-disable max-lines */
-import * as THREE from 'three';
-import { GraphicType } from '../re-export';
-import { getDrawing } from './../store';
-export var MeasureResultType;
-(function (MeasureResultType) {
-    MeasureResultType["NONE"] = "none";
-    MeasureResultType["VALUE"] = "value";
-    MeasureResultType["DISTANCE"] = "linear";
-    MeasureResultType["ANGLE"] = "angular";
-    MeasureResultType["VECTOR"] = "vector";
-    MeasureResultType["POSITION"] = "position";
-})(MeasureResultType || (MeasureResultType = {}));
-const tolerance = 1e-3;
-export const Measure = {
-    transform(items, drawingId) {
-        const drawing = 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 GraphicType.POINT:
-                case GraphicType.CURVEPOINT:
-                    const point = newItem;
-                    point.position = point.position.clone().applyMatrix4(matrix);
-                    break;
-                case GraphicType.LINE:
-                case GraphicType.CURVELINE:
-                    const line = newItem;
-                    line.start = line.start.clone().applyMatrix4(matrix);
-                    line.end = line.end.clone().applyMatrix4(matrix);
-                    break;
-                case GraphicType.PLANE:
-                    const plane = newItem;
-                    plane.normal = plane.normal.clone().applyMatrix3(matrix3);
-                    plane.normal.normalize();
-                    plane.pointOnPlane = plane.pointOnPlane.clone().applyMatrix4(matrix);
-                    break;
-                case GraphicType.CYLINDER:
-                    const cylinder = newItem;
-                    cylinder.axis = cylinder.axis.clone().applyMatrix3(matrix3);
-                    cylinder.axis.normalize();
-                    cylinder.origin = cylinder.origin.clone().applyMatrix4(matrix);
-                    break;
-                case GraphicType.CONE:
-                    const cone = newItem;
-                    cone.axis = cone.axis.clone().applyMatrix3(matrix3);
-                    cone.axis.normalize();
-                    cone.origin = cone.origin.clone().applyMatrix4(matrix);
-                    break;
-                case GraphicType.ARC:
-                case GraphicType.CURVEARC:
-                    const arc = newItem;
-                    arc.normal = arc.normal.clone().applyMatrix3(matrix3);
-                    arc.normal.normalize();
-                    arc.center = arc.center.clone().applyMatrix4(matrix);
-                    arc.start = arc.start.clone().applyMatrix4(matrix);
-                    arc.end = arc.end.clone().applyMatrix4(matrix);
-                    break;
-                case GraphicType.CIRCLE:
-                case GraphicType.CURVECIRCLE:
-                    const circle = newItem;
-                    circle.normal = circle.normal.clone().applyMatrix3(matrix3);
-                    circle.normal.normalize();
-                    circle.center = circle.center.clone().applyMatrix4(matrix);
-                    circle.start = circle.start.clone().applyMatrix4(matrix);
-                    circle.end = circle.end.clone().applyMatrix4(matrix);
-                    break;
-                default:
-                    break;
-            }
-            transformed.push(newItem);
-        }
-        return transformed;
-    },
-    getInfo(objects, drawingId) {
-        const transformed = 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 GraphicType.POINT:
-                case GraphicType.CURVEPOINT:
-                    const point = element;
-                    results.push({
-                        description: 'Position',
-                        type: MeasureResultType.POSITION,
-                        measureData: { value: point.position.clone() },
-                    });
-                    break;
-                case GraphicType.LINE:
-                case 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 GraphicType.NURBSCURVE:
-                case 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.end.clone() },
-                    });
-                    break;
-                case GraphicType.ARC:
-                case 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 start',
-                        type: MeasureResultType.POSITION,
-                        measureData: { value: arc.start.clone() },
-                    });
-                    results.push({
-                        description: 'Arc end',
-                        type: MeasureResultType.POSITION,
-                        measureData: { value: arc.end.clone() },
-                    });
-                    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 GraphicType.CIRCLE:
-                case 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 },
-                    });
-                    results.push({
-                        description: 'Circle start/end',
-                        type: MeasureResultType.POSITION,
-                        measureData: { value: circle.start.clone() },
-                    });
-                    break;
-                case 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 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 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 GraphicType.SPHERE:
-                    const sphere = element;
-                    results.push({
-                        description: 'Sphere radius',
-                        type: MeasureResultType.VALUE,
-                        measureData: { value: sphere.radius },
-                    });
-                    break;
-                case 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 = Measure.transform(objects, drawingId);
-        const first = transformed[0];
-        const second = transformed[1];
-        let results = [];
-        switch (first.type) {
-            case GraphicType.POINT:
-            case GraphicType.CURVEPOINT:
-                switch (second.type) {
-                    case GraphicType.POINT:
-                    case GraphicType.CURVEPOINT:
-                        results = Measure.calculatePointPoint(first.position, second.position);
-                        break;
-                    case GraphicType.LINE:
-                    case GraphicType.CURVELINE:
-                        results = Measure.calculatePointLine(first, second);
-                        break;
-                    case GraphicType.PLANE:
-                        results = Measure.calculatePointPlane(first, second);
-                        break;
-                    case GraphicType.ARC:
-                    case GraphicType.CIRCLE:
-                        results = Measure.calculatePointPoint(first.position.clone(), second.center.clone());
-                        break;
-                    default:
-                        results = Measure.getInfo(objects, drawingId);
-                        break;
-                }
-                break;
-            case GraphicType.LINE:
-            case GraphicType.CURVELINE:
-                switch (second.type) {
-                    case GraphicType.POINT:
-                    case GraphicType.CURVEPOINT:
-                        results = Measure.calculatePointLine(second, first);
-                        break;
-                    case GraphicType.LINE:
-                    case GraphicType.CURVELINE:
-                        results = Measure.calculateLineLine(first, second);
-                        break;
-                    case GraphicType.PLANE:
-                        results = Measure.calculateLinePlane(first, second);
-                        break;
-                    default:
-                        results = Measure.getInfo(objects, drawingId);
-                        break;
-                }
-                break;
-            case GraphicType.CIRCLE:
-            case GraphicType.ARC:
-                switch (second.type) {
-                    case GraphicType.ARC:
-                    case GraphicType.CIRCLE:
-                        results = Measure.calculatePointPoint(first.center, second.center);
-                        break;
-                    case GraphicType.POINT:
-                        results = Measure.calculatePointPoint(first.center, second.position);
-                        break;
-                    default:
-                        results = Measure.getInfo(objects, drawingId);
-                        break;
-                }
-                break;
-            case GraphicType.PLANE:
-                switch (second.type) {
-                    case GraphicType.POINT:
-                    case GraphicType.CURVEPOINT:
-                        results = Measure.calculatePointPlane(second, first);
-                        break;
-                    case GraphicType.LINE:
-                    case GraphicType.CURVELINE:
-                        results = Measure.calculateLinePlane(second, first);
-                        break;
-                    case GraphicType.ARC:
-                    case GraphicType.CURVEARC:
-                        results = Measure.calculateArcPlane(second, first);
-                        break;
-                    case GraphicType.PLANE:
-                        results = Measure.calculatePlanePlane(first, second);
-                        break;
-                    default:
-                        results = Measure.getInfo(objects, drawingId);
-                        break;
-                }
-                break;
-            default:
-                results = 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] = 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] = 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] = Measure.getLineLineMPoints(first.start, first.end, second.start, second.end);
-        const distance = start && end ? start.distanceTo(end) : NaN;
-        const [dir1, dir2] = Measure.getLineLineMDirs(first.start, first.end, second.start, second.end);
-        const angle = 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] = 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] = 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] = Measure.getPlanePlaneMPoints(plane1.pointOnPlane, plane1.normal, plane2.pointOnPlane, plane2.normal);
-        const distance = start && end ? start.distanceTo(end) : NaN;
-        const [dir1, dir2] = Measure.getPlanePlaneMDirs(plane1.normal, plane2.normal);
-        const angle = dir1 && dir2 ? Measure.degrees(dir1.angleTo(dir2)) : 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 (Measure.areParallel(vec1, vec2)) {
-            // lines are parallel
-            const vecAB = start1Pos.clone().sub(start2Pos);
-            if (!Measure.areParallel(vecAB, vec1)) {
-                // lines are not conincident
-                return Measure.getPointLineMPoints(start1Pos, start2Pos, end2Pos);
-            }
-        }
-        return [undefined, undefined];
-    },
-    getLinePlaneMPoints(startPos, endPos, pointOnPlane, normal) {
-        const vec = startPos.clone().sub(endPos);
-        if (Measure.arePerpendicular(vec, normal)) {
-            // line is perpendicular to plane normal
-            return Measure.getPointPlaneMPoints(startPos, pointOnPlane, normal);
-        }
-        return [undefined, undefined];
-    },
-    getArcPlaneMPoints(arcCenter, arcNormal, pointOnPlane, planeNormal) {
-        if (Measure.areParallel(arcNormal, planeNormal)) {
-            // parallel
-            return Measure.getPointPlaneMPoints(arcCenter, pointOnPlane, planeNormal);
-        }
-        return [undefined, undefined];
-    },
-    getPlanePlaneMPoints(pointOnPlane1, normal1, pointOnPlane2, normal2) {
-        if (Measure.areParallel(normal1, normal2)) {
-            // parallel
-            return 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 (!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];
-    },
-};
+/* eslint-disable max-lines */
+import * as THREE from 'three';
+import { GraphicType } from '../re-export';
+import { getDrawing } from './../store';
+export var MeasureResultType;
+(function (MeasureResultType) {
+    MeasureResultType["NONE"] = "none";
+    MeasureResultType["VALUE"] = "value";
+    MeasureResultType["DISTANCE"] = "linear";
+    MeasureResultType["ANGLE"] = "angular";
+    MeasureResultType["VECTOR"] = "vector";
+    MeasureResultType["POSITION"] = "position";
+})(MeasureResultType || (MeasureResultType = {}));
+const tolerance = 1e-3;
+export const Measure = {
+    transform(items, drawingId) {
+        const drawing = 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 GraphicType.POINT:
+                case GraphicType.CURVEPOINT:
+                    const point = newItem;
+                    point.position = point.position.clone().applyMatrix4(matrix);
+                    break;
+                case GraphicType.LINE:
+                case GraphicType.CURVELINE:
+                    const line = newItem;
+                    line.start = line.start.clone().applyMatrix4(matrix);
+                    line.end = line.end.clone().applyMatrix4(matrix);
+                    break;
+                case GraphicType.PLANE:
+                    const plane = newItem;
+                    plane.normal = plane.normal.clone().applyMatrix3(matrix3);
+                    plane.normal.normalize();
+                    plane.pointOnPlane = plane.pointOnPlane.clone().applyMatrix4(matrix);
+                    break;
+                case GraphicType.CYLINDER:
+                    const cylinder = newItem;
+                    cylinder.axis = cylinder.axis.clone().applyMatrix3(matrix3);
+                    cylinder.axis.normalize();
+                    cylinder.origin = cylinder.origin.clone().applyMatrix4(matrix);
+                    break;
+                case GraphicType.CONE:
+                    const cone = newItem;
+                    cone.axis = cone.axis.clone().applyMatrix3(matrix3);
+                    cone.axis.normalize();
+                    cone.origin = cone.origin.clone().applyMatrix4(matrix);
+                    break;
+                case GraphicType.ARC:
+                case GraphicType.CURVEARC:
+                    const arc = newItem;
+                    arc.normal = arc.normal.clone().applyMatrix3(matrix3);
+                    arc.normal.normalize();
+                    arc.center = arc.center.clone().applyMatrix4(matrix);
+                    arc.start = arc.start.clone().applyMatrix4(matrix);
+                    arc.end = arc.end.clone().applyMatrix4(matrix);
+                    break;
+                case GraphicType.CIRCLE:
+                case GraphicType.CURVECIRCLE:
+                    const circle = newItem;
+                    circle.normal = circle.normal.clone().applyMatrix3(matrix3);
+                    circle.normal.normalize();
+                    circle.center = circle.center.clone().applyMatrix4(matrix);
+                    circle.start = circle.start.clone().applyMatrix4(matrix);
+                    circle.end = circle.end.clone().applyMatrix4(matrix);
+                    break;
+                default:
+                    break;
+            }
+            transformed.push(newItem);
+        }
+        return transformed;
+    },
+    getInfo(objects, drawingId) {
+        const transformed = 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 GraphicType.POINT:
+                case GraphicType.CURVEPOINT:
+                    const point = element;
+                    results.push({
+                        description: 'Position',
+                        type: MeasureResultType.POSITION,
+                        measureData: { value: point.position.clone() },
+                    });
+                    break;
+                case GraphicType.LINE:
+                case 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 GraphicType.NURBSCURVE:
+                case 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.end.clone() },
+                    });
+                    break;
+                case GraphicType.ARC:
+                case 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 start',
+                        type: MeasureResultType.POSITION,
+                        measureData: { value: arc.start.clone() },
+                    });
+                    results.push({
+                        description: 'Arc end',
+                        type: MeasureResultType.POSITION,
+                        measureData: { value: arc.end.clone() },
+                    });
+                    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 GraphicType.CIRCLE:
+                case 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 },
+                    });
+                    results.push({
+                        description: 'Circle start/end',
+                        type: MeasureResultType.POSITION,
+                        measureData: { value: circle.start.clone() },
+                    });
+                    break;
+                case 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 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 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 GraphicType.SPHERE:
+                    const sphere = element;
+                    results.push({
+                        description: 'Sphere radius',
+                        type: MeasureResultType.VALUE,
+                        measureData: { value: sphere.radius },
+                    });
+                    break;
+                case 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 = Measure.transform(objects, drawingId);
+        const first = transformed[0];
+        const second = transformed[1];
+        let results = [];
+        switch (first.type) {
+            case GraphicType.POINT:
+            case GraphicType.CURVEPOINT:
+                switch (second.type) {
+                    case GraphicType.POINT:
+                    case GraphicType.CURVEPOINT:
+                        results = Measure.calculatePointPoint(first.position, second.position);
+                        break;
+                    case GraphicType.LINE:
+                    case GraphicType.CURVELINE:
+                        results = Measure.calculatePointLine(first, second);
+                        break;
+                    case GraphicType.PLANE:
+                        results = Measure.calculatePointPlane(first, second);
+                        break;
+                    case GraphicType.ARC:
+                    case GraphicType.CIRCLE:
+                        results = Measure.calculatePointPoint(first.position.clone(), second.center.clone());
+                        break;
+                    default:
+                        results = Measure.getInfo(objects, drawingId);
+                        break;
+                }
+                break;
+            case GraphicType.LINE:
+            case GraphicType.CURVELINE:
+                switch (second.type) {
+                    case GraphicType.POINT:
+                    case GraphicType.CURVEPOINT:
+                        results = Measure.calculatePointLine(second, first);
+                        break;
+                    case GraphicType.LINE:
+                    case GraphicType.CURVELINE:
+                        results = Measure.calculateLineLine(first, second);
+                        break;
+                    case GraphicType.PLANE:
+                        results = Measure.calculateLinePlane(first, second);
+                        break;
+                    default:
+                        results = Measure.getInfo(objects, drawingId);
+                        break;
+                }
+                break;
+            case GraphicType.CIRCLE:
+            case GraphicType.ARC:
+                switch (second.type) {
+                    case GraphicType.ARC:
+                    case GraphicType.CIRCLE:
+                        results = Measure.calculatePointPoint(first.center, second.center);
+                        break;
+                    case GraphicType.POINT:
+                        results = Measure.calculatePointPoint(first.center, second.position);
+                        break;
+                    default:
+                        results = Measure.getInfo(objects, drawingId);
+                        break;
+                }
+                break;
+            case GraphicType.PLANE:
+                switch (second.type) {
+                    case GraphicType.POINT:
+                    case GraphicType.CURVEPOINT:
+                        results = Measure.calculatePointPlane(second, first);
+                        break;
+                    case GraphicType.LINE:
+                    case GraphicType.CURVELINE:
+                        results = Measure.calculateLinePlane(second, first);
+                        break;
+                    case GraphicType.ARC:
+                    case GraphicType.CURVEARC:
+                        results = Measure.calculateArcPlane(second, first);
+                        break;
+                    case GraphicType.PLANE:
+                        results = Measure.calculatePlanePlane(first, second);
+                        break;
+                    default:
+                        results = Measure.getInfo(objects, drawingId);
+                        break;
+                }
+                break;
+            default:
+                results = 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] = 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] = 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] = Measure.getLineLineMPoints(first.start, first.end, second.start, second.end);
+        const distance = start && end ? start.distanceTo(end) : NaN;
+        const [dir1, dir2] = Measure.getLineLineMDirs(first.start, first.end, second.start, second.end);
+        const angle = 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] = 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] = 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] = Measure.getPlanePlaneMPoints(plane1.pointOnPlane, plane1.normal, plane2.pointOnPlane, plane2.normal);
+        const distance = start && end ? start.distanceTo(end) : NaN;
+        const [dir1, dir2] = Measure.getPlanePlaneMDirs(plane1.normal, plane2.normal);
+        const angle = dir1 && dir2 ? Measure.degrees(dir1.angleTo(dir2)) : 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 (Measure.areParallel(vec1, vec2)) {
+            // lines are parallel
+            const vecAB = start1Pos.clone().sub(start2Pos);
+            if (!Measure.areParallel(vecAB, vec1)) {
+                // lines are not conincident
+                return Measure.getPointLineMPoints(start1Pos, start2Pos, end2Pos);
+            }
+        }
+        return [undefined, undefined];
+    },
+    getLinePlaneMPoints(startPos, endPos, pointOnPlane, normal) {
+        const vec = startPos.clone().sub(endPos);
+        if (Measure.arePerpendicular(vec, normal)) {
+            // line is perpendicular to plane normal
+            return Measure.getPointPlaneMPoints(startPos, pointOnPlane, normal);
+        }
+        return [undefined, undefined];
+    },
+    getArcPlaneMPoints(arcCenter, arcNormal, pointOnPlane, planeNormal) {
+        if (Measure.areParallel(arcNormal, planeNormal)) {
+            // parallel
+            return Measure.getPointPlaneMPoints(arcCenter, pointOnPlane, planeNormal);
+        }
+        return [undefined, undefined];
+    },
+    getPlanePlaneMPoints(pointOnPlane1, normal1, pointOnPlane2, normal2) {
+        if (Measure.areParallel(normal1, normal2)) {
+            // parallel
+            return 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 (!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];
+    },
+};