@buerli.io/core 0.4.0-beta.4 → 0.4.0-beta.5

package/build/store/states/geometry.d.ts

@@ -26,7 +26,15 @@ export declare type GeometryConfig = {
     points?: ElementConfig;
 };
 export declare type GeometryData = {
-    cache: Record<GraphicID, ContainerGeometryT>;
+    cache: Record<GraphicID, ContainerGeometryT & {
+        /**
+         * The dirty stamp will be updated, as soon as a client side modification of the geometry will happen!
+         * Examples: 'setColor' or 'setOpacity'
+         *
+         * Can for example be used to trigger the render process for this container.
+         */
+        dirtyStamp?: number;
+    }>;
     stamp: number;
     bounds: GeometryBounds;
     config: {

package/build/store/states/geometry.js

@@ -37,7 +37,7 @@ export const geometryApi = (set, get, buerliApi) => ({
             if (container) {
                 geom = new ThreeGeometryCreator().createGeometry(container, color);
                 set(state => {
-                    const geometryCache = Object.assign(Object.assign({}, state.geometry.cache), { [containerId]: geom });
+                    const geometryCache = Object.assign(Object.assign({}, state.geometry.cache), { [containerId]: Object.assign(Object.assign({}, geom), { dirtyStamp: Date.now() }) });
                     return {
                         geometry: Object.assign(Object.assign({}, state.geometry), { cache: geometryCache, stamp: Date.now() }),
                     };
@@ -52,14 +52,14 @@ export const geometryApi = (set, get, buerliApi) => ({
         cachedGeom.color = thCol;
         cachedGeom.meshes.forEach(mesh => (mesh.color = thCol));
         set(state => ({
-            geometry: Object.assign(Object.assign({}, state.geometry), { cache: Object.assign(Object.assign({}, state.geometry.cache), { [containerId]: cachedGeom }), stamp: Date.now() }),
+            geometry: Object.assign(Object.assign({}, state.geometry), { cache: Object.assign(Object.assign({}, state.geometry.cache), { [containerId]: Object.assign(Object.assign({}, cachedGeom), { dirtyStamp: Date.now() }) }) }),
         }));
     },
     setOpacity: (containerId, opacity) => {
         const cachedGeom = Object.assign(Object.assign({}, get().geometry.cache[containerId]), { opacity });
         cachedGeom.meshes.forEach(mesh => (mesh.opacity = opacity));
         set(state => ({
-            geometry: Object.assign(Object.assign({}, state.geometry), { cache: Object.assign(Object.assign({}, state.geometry.cache), { [containerId]: cachedGeom }), stamp: Date.now() }),
+            geometry: Object.assign(Object.assign({}, state.geometry), { cache: Object.assign(Object.assign({}, state.geometry.cache), { [containerId]: Object.assign(Object.assign({}, cachedGeom), { dirtyStamp: Date.now() }) }) }),
         }));
     },
     setConfig: (objId, config) => {

package/build/types/index.d.ts

@@ -1,4 +1,3 @@
-export * from './ErrorTypes';
 export * from './IGraphicPackage';
 export * from './InteractionInfo';
 export * from './IStructurePatch';

package/build/types/index.js

@@ -1,4 +1,3 @@
-export * from './ErrorTypes';
 export * from './IGraphicPackage';
 export * from './InteractionInfo';
 export * from './IStructurePatch';

package/build/utils/Math.d.ts

@@ -3,4 +3,19 @@ export declare const MathUtils: {
     convertToMatrix4: (coordinateSystem: number[][]) => THREE.Matrix4;
     convertToMatrix3: (coordinateSystem: number[][]) => THREE.Matrix3;
     convertToCoordinateSystem: (matrix: THREE.Matrix4) => number[][];
+    round(value: number, digits: number): number;
+    /**
+     * 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: (originPos: THREE.Vector3, xDir: THREE.Vector3, yDir: THREE.Vector3, offset: THREE.Vector3, rotation: THREE.Vector3, inverted: 0 | 1) => THREE.Matrix4;
 };

package/build/utils/Math.js

@@ -1,4 +1,6 @@
 import * as THREE from 'three';
+const degToRad = THREE.MathUtils.degToRad;
+const tolerance = 1e-6;
 export const MathUtils = {
     convertToMatrix4: function (coordinateSystem) {
         const [orig, vx, vy, vz] = coordinateSystem.map(row => new THREE.Vector3().fromArray(row));
@@ -22,4 +24,42 @@ export const MathUtils = {
         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/utils/Measure.d.ts

@@ -1,21 +1,32 @@
 import * as THREE from 'three';
 import { ArcGeometry, LineGeometry, PlaneGeometry, PointGeometry, ProductElement } from './../geometry';
 import { DrawingID } from './../store/states/drawing';
+export declare type ValueMeasureData = {
+    value: number;
+};
 export declare type LinearMeasureData = {
+    value: number;
     start: THREE.Vector3;
     end: THREE.Vector3;
 };
 export declare type AngularMeasureData = {
+    value: number;
     center: THREE.Vector3;
     dir1: THREE.Vector3;
     dir2: THREE.Vector3;
 };
 export declare type PositionMeasureData = {
-    pos: THREE.Vector3;
+    value: THREE.Vector3;
+};
+export declare type VectorMeasureData = {
+    value: THREE.Vector3;
+    start: THREE.Vector3;
+    end: THREE.Vector3;
 };
-declare type MeasureData = LinearMeasureData | AngularMeasureData | PositionMeasureData;
+declare type MeasureData = LinearMeasureData | AngularMeasureData | PositionMeasureData | VectorMeasureData | ValueMeasureData;
 export declare enum MeasureResultType {
     NONE = "none",
+    VALUE = "value",
     DISTANCE = "linear",
     ANGLE = "angular",
     VECTOR = "vector",
@@ -23,7 +34,6 @@ export declare enum MeasureResultType {
 }
 export declare type MeasureResult = {
     description: string;
-    value: string | number;
     type: MeasureResultType;
     measureData?: MeasureData;
 };
@@ -32,99 +42,14 @@ export declare const Measure: {
     transform(items: Item[], drawingId: DrawingID): Item[];
     getInfo(objects: Item[], drawingId: DrawingID): MeasureResult[];
     calculateMeasures(objects: Item[], drawingId: DrawingID): MeasureResult[];
-    calculatePointPoint(point1: PointGeometry, point2: PointGeometry): {
-        value: number;
-        description: string;
-        type: MeasureResultType;
-        measureData: {
-            start: THREE.Vector3;
-            end: THREE.Vector3;
-        };
-    }[];
-    calculatePointLine(point: PointGeometry, line: LineGeometry): {
-        value: number;
-        description: string;
-        type: MeasureResultType;
-        measureData: {
-            start: THREE.Vector3;
-            end: THREE.Vector3;
-        };
-    }[];
-    calculatePointPlane(point: PointGeometry, plane: PlaneGeometry): {
-        value: number;
-        description: string;
-        type: MeasureResultType;
-        measureData: {
-            start: THREE.Vector3;
-            end: THREE.Vector3;
-        };
-    }[];
-    calculateLineLine(first: LineGeometry, second: LineGeometry): ({
-        value: number;
-        description: string;
-        type: MeasureResultType;
-        measureData: {
-            start: THREE.Vector3;
-            end: THREE.Vector3;
-            center?: undefined;
-            dir1?: undefined;
-            dir2?: undefined;
-        } | undefined;
-    } | {
-        value: number;
-        description: string;
-        type: MeasureResultType;
-        measureData: {
-            center: THREE.Vector3;
-            dir1: THREE.Vector3;
-            dir2: THREE.Vector3;
-            start?: undefined;
-            end?: undefined;
-        };
-    })[];
-    calculateLinePlane(line: LineGeometry, plane: PlaneGeometry): {
-        value: number;
-        description: string;
-        type: MeasureResultType;
-        measureData: {
-            start: THREE.Vector3;
-            end: THREE.Vector3;
-        } | undefined;
-    }[];
-    calculateArcPlane(arc: ArcGeometry, plane: PlaneGeometry): {
-        value: number;
-        description: string;
-        type: MeasureResultType;
-        measureData: {
-            start: THREE.Vector3;
-            end: THREE.Vector3;
-        } | undefined;
-    }[];
-    calculatePlanePlane(plane1: PlaneGeometry, plane2: PlaneGeometry): ({
-        value: number;
-        description: string;
-        type: MeasureResultType;
-        measureData: {
-            start: THREE.Vector3;
-            end: THREE.Vector3;
-            center?: undefined;
-            dir1?: undefined;
-            dir2?: undefined;
-        } | undefined;
-    } | {
-        value: number;
-        description: string;
-        type: MeasureResultType;
-        measureData: {
-            center: THREE.Vector3;
-            dir1: THREE.Vector3;
-            dir2: THREE.Vector3;
-            start?: undefined;
-            end?: undefined;
-        } | undefined;
-    })[];
+    calculatePointPoint(point1: THREE.Vector3, point2: THREE.Vector3): MeasureResult[];
+    calculatePointLine(point: PointGeometry, line: LineGeometry): MeasureResult[];
+    calculatePointPlane(point: PointGeometry, plane: PlaneGeometry): MeasureResult[];
+    calculateLineLine(first: LineGeometry, second: LineGeometry): MeasureResult[];
+    calculateLinePlane(line: LineGeometry, plane: PlaneGeometry): MeasureResult[];
+    calculateArcPlane(arc: ArcGeometry, plane: PlaneGeometry): MeasureResult[];
+    calculatePlanePlane(plane1: PlaneGeometry, plane2: PlaneGeometry): MeasureResult[];
     degrees(radians: number): number;
-    round(value: number, digits: number): number;
     areParallel(vec1: THREE.Vector3, vec2: THREE.Vector3): boolean;
     arePerpendicular(vec1: THREE.Vector3, vec2: THREE.Vector3): boolean;
     getPointLineMPoints(pointsPos: THREE.Vector3, startPos: THREE.Vector3, endPos: THREE.Vector3): [THREE.Vector3, THREE.Vector3];

package/build/utils/Measure.js

@@ -5,6 +5,7 @@ import { GraphicType } from './../types';
 export var MeasureResultType;
 (function (MeasureResultType) {
     MeasureResultType["NONE"] = "none";
+    MeasureResultType["VALUE"] = "value";
     MeasureResultType["DISTANCE"] = "linear";
     MeasureResultType["ANGLE"] = "angular";
     MeasureResultType["VECTOR"] = "vector";
@@ -73,10 +74,6 @@ export const Measure = {
     getInfo(objects, drawingId) {
         const transformed = Measure.transform(objects, drawingId);
         const results = [];
-        const vecToStr = (point) => `[ ${point
-            .toArray()
-            .map(n => Math.round(n * 100) / 100)
-            .join(', ')} ]`;
         const dir = (start, end) => end.clone().sub(start).normalize();
         const getPointOnCircumference = (center, axis, radius) => {
             const axisNormalized = axis.clone().normalize();
@@ -90,32 +87,34 @@ export const Measure = {
                 case GraphicType.CURVEPOINT:
                     const point = element;
                     results.push({
-                        value: vecToStr(point.position),
                         description: 'Position',
                         type: MeasureResultType.POSITION,
+                        measureData: { value: point.position.clone() },
                     });
                     break;
                 case GraphicType.LINE:
                 case GraphicType.CURVELINE:
                     const line = element;
-                    let absoluteDistance = line.start.distanceTo(line.end);
-                    absoluteDistance = Measure.round(absoluteDistance, 3);
+                    const absoluteDistance = line.start.distanceTo(line.end);
                     results.push({
-                        value: absoluteDistance,
                         description: 'Line length',
                         type: MeasureResultType.DISTANCE,
-                        measureData: { start: line.start.clone(), end: line.end.clone() },
+                        measureData: { value: absoluteDistance, start: line.start.clone(), end: line.end.clone() },
                     });
                     break;
                 case GraphicType.EDGE:
                 case GraphicType.CURVESPLINE:
                     const edge = element;
                     results.push({
-                        value: vecToStr(edge.start),
                         description: 'Edge start',
                         type: MeasureResultType.POSITION,
+                        measureData: { value: edge.start.clone() },
+                    });
+                    results.push({
+                        description: 'Edge end',
+                        type: MeasureResultType.POSITION,
+                        measureData: { value: edge.start.clone() },
                     });
-                    results.push({ value: vecToStr(edge.end), description: 'Edge end', type: MeasureResultType.POSITION });
                     break;
                 case GraphicType.ARC:
                 case GraphicType.CURVEARC:
@@ -123,22 +122,19 @@ export const Measure = {
                     const arcNEnd = arc.center.clone().addScaledVector(arc.normal.clone().normalize(), 40);
                     const pointOnArc = getPointOnCircumference(arc.center, arc.normal, arc.radius);
                     results.push({
-                        value: vecToStr(arc.center),
                         description: 'Arc center',
                         type: MeasureResultType.POSITION,
-                        measureData: { pos: arc.center.clone() },
+                        measureData: { value: arc.center.clone() },
                     });
                     results.push({
-                        value: vecToStr(arc.normal),
                         description: 'Arc normal',
                         type: MeasureResultType.VECTOR,
-                        measureData: { start: arc.center.clone(), end: arcNEnd },
+                        measureData: { value: arc.normal.clone(), start: arc.center.clone(), end: arcNEnd },
                     });
                     results.push({
-                        value: arc.radius,
                         description: 'Arc radius',
                         type: MeasureResultType.DISTANCE,
-                        measureData: { start: arc.center.clone(), end: pointOnArc },
+                        measureData: { value: arc.radius, start: arc.center.clone(), end: pointOnArc },
                     });
                     break;
                 case GraphicType.CIRCLE:
@@ -147,32 +143,28 @@ export const Measure = {
                     const circleNEnd = circle.center.clone().addScaledVector(circle.normal.clone().normalize(), 40);
                     const pointOnCircle = getPointOnCircumference(circle.center, circle.normal, circle.radius);
                     results.push({
-                        value: vecToStr(circle.center),
                         description: 'Circle center',
                         type: MeasureResultType.POSITION,
-                        measureData: { pos: circle.center.clone() },
+                        measureData: { value: circle.center.clone() },
                     });
                     results.push({
-                        value: vecToStr(circle.normal),
                         description: 'Circle normal',
                         type: MeasureResultType.VECTOR,
-                        measureData: { start: circle.center.clone(), end: circleNEnd },
+                        measureData: { value: circle.normal.clone(), start: circle.center.clone(), end: circleNEnd },
                     });
                     results.push({
-                        value: circle.radius,
                         description: 'Circle radius',
                         type: MeasureResultType.DISTANCE,
-                        measureData: { start: circle.center.clone(), end: pointOnCircle },
+                        measureData: { value: circle.radius, start: circle.center.clone(), end: pointOnCircle },
                     });
                     break;
                 case GraphicType.PLANE:
                     const plane = element;
                     const planeNEnd = plane.pointOnPlane.clone().addScaledVector(plane.normal.clone().normalize(), 40);
                     results.push({
-                        value: vecToStr(plane.normal),
                         description: 'Plane normal',
                         type: MeasureResultType.VECTOR,
-                        measureData: { start: plane.pointOnPlane.clone(), end: planeNEnd },
+                        measureData: { value: plane.normal, start: plane.pointOnPlane.clone(), end: planeNEnd },
                     });
                     break;
                 case GraphicType.CYLINDER:
@@ -185,28 +177,24 @@ export const Measure = {
                         .addScaledVector(dir(cylinder.origin, pointOnCyl), cylinder.radius + 3);
                     const cylHEnd = cylHStart.clone().addScaledVector(cylAxisNormalized, cylinder.height);
                     results.push({
-                        value: vecToStr(cylinder.origin),
                         description: 'Cylinder origin',
                         type: MeasureResultType.POSITION,
-                        measureData: { pos: cylinder.origin.clone() },
+                        measureData: { value: cylinder.origin.clone() },
                     });
                     results.push({
-                        value: vecToStr(cylinder.axis),
                         description: 'Cylinder axis',
                         type: MeasureResultType.VECTOR,
-                        measureData: { start: cylinder.origin.clone(), end: cylNEnd },
+                        measureData: { value: cylinder.axis, start: cylinder.origin.clone(), end: cylNEnd },
                     });
                     results.push({
-                        value: cylinder.radius,
                         description: 'Cylinder radius',
                         type: MeasureResultType.DISTANCE,
-                        measureData: { start: cylinder.origin.clone(), end: pointOnCyl },
+                        measureData: { value: cylinder.radius, start: cylinder.origin.clone(), end: pointOnCyl },
                     });
                     results.push({
-                        value: cylinder.height,
                         description: 'Cylinder height',
                         type: MeasureResultType.DISTANCE,
-                        measureData: { start: cylHStart, end: cylHEnd },
+                        measureData: { value: cylinder.height, start: cylHStart, end: cylHEnd },
                     });
                     break;
                 case GraphicType.CONE:
@@ -228,48 +216,47 @@ export const Measure = {
                         .clone()
                         .addScaledVector(coneAxisNormalized, isExpanding ? -cone.height : cone.height);
                     results.push({
-                        value: vecToStr(cone.origin),
                         description: 'Cone origin',
                         type: MeasureResultType.POSITION,
-                        measureData: { pos: cone.origin.clone() },
+                        measureData: { value: cone.origin.clone() },
                     });
                     results.push({
-                        value: vecToStr(cone.axis),
                         description: 'Cone axis',
                         type: MeasureResultType.VECTOR,
-                        measureData: { start: cone.origin.clone(), end: coneEnd },
+                        measureData: { value: cone.axis, start: cone.origin.clone(), end: coneEnd },
                     });
                     results.push({
-                        value: r,
                         description: 'Cone radius (min)',
                         type: MeasureResultType.DISTANCE,
-                        measureData: { start: coneCenterMinR, end: pointOnConeMinR },
+                        measureData: { value: r, start: coneCenterMinR, end: pointOnConeMinR },
                     });
                     results.push({
-                        value: R,
                         description: 'Cone radius (max)',
                         type: MeasureResultType.DISTANCE,
-                        measureData: { start: coneCenterMaxR, end: pointOnConeMaxR },
+                        measureData: { value: R, start: coneCenterMaxR, end: pointOnConeMaxR },
                     });
                     results.push({
-                        value: cone.height,
                         description: 'Cone height',
                         type: MeasureResultType.DISTANCE,
-                        measureData: { start: coneHStart, end: coneHEnd },
+                        measureData: { value: cone.height, start: coneHStart, end: coneHEnd },
                     });
                     break;
                 case GraphicType.SPHERE:
                     const sphere = element;
-                    results.push({ value: sphere.radius, description: 'Sphere radius', type: MeasureResultType.DISTANCE });
+                    results.push({
+                        description: 'Sphere radius',
+                        type: MeasureResultType.VALUE,
+                        measureData: { value: sphere.radius },
+                    });
                     break;
                 case GraphicType.NURBS:
-                    results.push({ value: '', description: 'NURBS', type: MeasureResultType.NONE });
+                    results.push({ description: 'NURBS', type: MeasureResultType.NONE });
                     break;
                 case GraphicType.NURBSSURFACE:
-                    results.push({ value: '', description: 'NURBS Surface', type: MeasureResultType.NONE });
+                    results.push({ description: 'NURBS Surface', type: MeasureResultType.NONE });
                     break;
                 default:
-                    results.push({ value: '', description: 'Undefined', type: MeasureResultType.NONE });
+                    results.push({ description: 'Undefined', type: MeasureResultType.NONE });
                     break;
             }
         }
@@ -286,7 +273,7 @@ export const Measure = {
                 switch (second.type) {
                     case GraphicType.POINT:
                     case GraphicType.CURVEPOINT:
-                        results = Measure.calculatePointPoint(first, second);
+                        results = Measure.calculatePointPoint(first.position, second.position);
                         break;
                     case GraphicType.LINE:
                     case GraphicType.CURVELINE:
@@ -295,6 +282,10 @@ export const Measure = {
                     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;
@@ -319,6 +310,21 @@ export const Measure = {
                         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:
@@ -348,133 +354,114 @@ export const Measure = {
         return results;
     },
     calculatePointPoint(point1, point2) {
-        let distance = point1.position.distanceTo(point2.position);
-        distance = Measure.round(distance, 3);
-        const dx = Measure.round(Math.abs(point1.position.x - point2.position.x), 3);
-        const dy = Measure.round(Math.abs(point1.position.y - point2.position.y), 3);
-        const dz = Measure.round(Math.abs(point1.position.z - point2.position.z), 3);
-        const p1 = point1.position.clone();
-        const p2 = point2.position.clone();
+        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 [
             {
-                value: distance,
                 description: 'Distance',
                 type: MeasureResultType.DISTANCE,
-                measureData: { start: p1, end: p2 },
+                measureData: { value: distance, start: p1, end: p2 },
             },
-            { value: dx, description: 'dx', type: MeasureResultType.DISTANCE, measureData: { start: p1, end: px } },
-            { value: dy, description: 'dy', type: MeasureResultType.DISTANCE, measureData: { start: px, end: pxy } },
-            { value: dz, description: 'dz', type: MeasureResultType.DISTANCE, measureData: { start: pxy, 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 = Measure.round(start.distanceTo(end), 3);
+        const distance = start.distanceTo(end);
         return [
             {
-                value: distance,
                 description: 'Distance',
                 type: MeasureResultType.DISTANCE,
-                measureData: { start, end },
+                measureData: { value: distance, start, end },
             },
         ];
     },
     calculatePointPlane(point, plane) {
         const [start, end] = Measure.getPointPlaneMPoints(point.position, plane.pointOnPlane, plane.normal);
-        const distance = Measure.round(start.distanceTo(end), 3);
+        const distance = start.distanceTo(end);
         return [
             {
-                value: distance,
                 description: 'Distance',
                 type: MeasureResultType.DISTANCE,
-                measureData: { start, end },
+                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 ? Measure.round(start.distanceTo(end), 3) : NaN;
+        const distance = start && end ? start.distanceTo(end) : NaN;
         const [dir1, dir2] = Measure.getLineLineMDirs(first.start, first.end, second.start, second.end);
-        const angle = Measure.round(Measure.degrees(dir1.angleTo(dir2)), 3);
+        const angle = Measure.degrees(dir1.angleTo(dir2));
         const angleS = 180 - angle;
         return [
             {
-                value: distance,
                 description: 'Distance',
                 type: MeasureResultType.DISTANCE,
-                measureData: start && end ? { start, end } : undefined,
+                measureData: start && end ? { value: distance, start, end } : undefined,
             },
             {
-                value: angle,
                 description: 'Angle1',
                 type: MeasureResultType.ANGLE,
-                measureData: { center: first.start, dir1, dir2 },
+                measureData: { value: angle, center: first.start, dir1, dir2 },
             },
             {
-                value: angleS,
                 description: 'Angle2',
                 type: MeasureResultType.ANGLE,
-                measureData: { center: first.start, dir1, dir2: dir2.clone().negate() },
+                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 ? Measure.round(start.distanceTo(end), 3) : NaN;
+        const distance = start && end ? start.distanceTo(end) : NaN;
         return [
             {
-                value: distance,
                 description: 'Distance',
                 type: MeasureResultType.DISTANCE,
-                measureData: start && end ? { start, end } : undefined,
+                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 ? Measure.round(start.distanceTo(end), 3) : NaN;
+        const distance = start && end ? start.distanceTo(end) : NaN;
         return [
             {
-                value: distance,
                 description: 'Distance',
                 type: MeasureResultType.DISTANCE,
-                measureData: start && end ? { start, end } : undefined,
+                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 ? Measure.round(start.distanceTo(end), 3) : NaN;
+        const distance = start && end ? start.distanceTo(end) : NaN;
         const [dir1, dir2] = Measure.getPlanePlaneMDirs(plane1.normal, plane2.normal);
-        const angle = dir1 && dir2
-            ? Measure.round(Measure.degrees(dir1.angleTo(dir2)), 3)
-            : Measure.round(Measure.degrees(plane1.normal.angleTo(plane2.normal)), 3);
+        const angle = dir1 && dir2 ? Measure.degrees(dir1.angleTo(dir2)) : Measure.degrees(plane1.normal.angleTo(plane2.normal));
         return [
             {
-                value: distance,
                 description: 'Distance',
                 type: MeasureResultType.DISTANCE,
-                measureData: start && end ? { start, end } : undefined,
+                measureData: start && end ? { value: distance, start, end } : undefined,
             },
             {
-                value: angle,
                 description: 'Angle',
                 type: MeasureResultType.ANGLE,
-                measureData: dir1 && dir2 ? { center: plane1.pointOnPlane.clone(), dir1, dir2 } : undefined,
+                measureData: dir1 && dir2 ? { value: angle, center: plane1.pointOnPlane.clone(), dir1, dir2 } : undefined,
             },
         ];
     },
     degrees(radians) {
         return (radians / Math.PI) * 180;
     },
-    round(value, digits) {
-        if (isNaN(value))
-            return NaN;
-        const factor = Math.pow(10, digits);
-        return Math.round(value * factor) / factor;
-    },
     areParallel(vec1, vec2) {
         const val = Math.abs(vec1.clone().cross(vec2).length());
         return val < tolerance;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buerli.io/core",
-  "version": "0.4.0-beta.4",
+  "version": "0.4.0-beta.5",
   "description": "buerli state management",
   "author": "AWV Informatik AG <info@awv-informatik.ch>",
   "license": "ISC",

package/build/types/ErrorTypes.d.ts

@@ -1,5 +0,0 @@
-export interface ICoreError {
-    errorState: number;
-    errorCode: number;
-    errorMessage: string;
-}

package/build/types/ErrorTypes.js

@@ -1 +0,0 @@
-export {};