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

package/build/cjs/utils/Timing.js

@@ -1,34 +1,34 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Timing = void 0;
-const uuid_1 = require("uuid");
-const cache = {};
-const start = (key = (0, uuid_1.v4)()) => {
-    cache[key] = { startTime: performance.now(), previousTime: performance.now() };
-    return key;
-};
-const measure = (key, mode = 'fromStart') => {
-    if (!cache[key])
-        return Number.NaN;
-    const curr = performance.now();
-    const prev = mode === 'fromPrevious' ? cache[key].previousTime : cache[key].startTime;
-    cache[key] = Object.assign(Object.assign({}, cache[key]), { previousTime: curr });
-    return curr - prev;
-};
-const stop = (key) => {
-    if (!cache[key])
-        return Number.NaN;
-    const curr = performance.now();
-    const prev = cache[key].startTime;
-    delete cache[key];
-    return curr - prev;
-};
-const dump = (key, message = '', mode = 'fromStart') => {
-    console.info(`${message ? message : key + ':'} ${measure(key, mode).toFixed(2)}ms`);
-};
-exports.Timing = {
-    start,
-    stop,
-    measure,
-    dump,
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Timing = void 0;
+const uuid_1 = require("uuid");
+const cache = {};
+const start = (key = (0, uuid_1.v4)()) => {
+    cache[key] = { startTime: performance.now(), previousTime: performance.now() };
+    return key;
+};
+const measure = (key, mode = 'fromStart') => {
+    if (!cache[key])
+        return Number.NaN;
+    const curr = performance.now();
+    const prev = mode === 'fromPrevious' ? cache[key].previousTime : cache[key].startTime;
+    cache[key] = Object.assign(Object.assign({}, cache[key]), { previousTime: curr });
+    return curr - prev;
+};
+const stop = (key) => {
+    if (!cache[key])
+        return Number.NaN;
+    const curr = performance.now();
+    const prev = cache[key].startTime;
+    delete cache[key];
+    return curr - prev;
+};
+const dump = (key, message = '', mode = 'fromStart') => {
+    console.info(`${message ? message : key + ':'} ${measure(key, mode).toFixed(2)}ms`);
+};
+exports.Timing = {
+    start,
+    stop,
+    measure,
+    dump,
+};

package/build/esm/geometry/ThreeGeometryCreator.js

@@ -1,291 +1,291 @@
-import * as THREE from 'three';
-import { ContainerType, GraphicType, } from '../re-export';
-const convertType = (contType) => {
-    let type = GraphicType.NONE;
-    switch (contType) {
-        case ContainerType.BREP:
-            type = GraphicType.BREP;
-            break;
-        case ContainerType.CURVEARRAY:
-            type = GraphicType.CURVEARRAY;
-            break;
-        case ContainerType.POLYBREP:
-            type = GraphicType.POLYBREP;
-            break;
-    }
-    return type;
-};
-/**
- * Creates THREE geometry based on the data within a @see IGraphicContainer.
- */
-export class ThreeGeometryCreator {
-    constructor() {
-        this.coordHeightTolerance = 0.01;
-    }
-    getMetadata(geometry, container, color, opacity = 0) {
-        var _a;
-        const geomProps = geometry ? geometry.properties : {};
-        if (geomProps && geomProps.material) {
-            color = geomProps.material.color || color;
-            opacity = geomProps.material.opacity || opacity;
-        }
-        // Provide values as a CSS color string, which will be gamma corrected by three.js
-        const rgbColor = color ? new THREE.Color(`rgb(${color[0]}, ${color[1]}, ${color[2]})`) : undefined;
-        const layer = geomProps && geomProps.layer ? geomProps.layer : container.properties.layer;
-        return {
-            color: rgbColor,
-            opacity,
-            layer,
-            container: { id: container.id, ownerId: container.owner, type: convertType(container.type) },
-            operationId: (_a = geometry === null || geometry === void 0 ? void 0 : geometry.properties) === null || _a === void 0 ? void 0 : _a.operationId,
-            rawGraphic: geometry,
-        };
-    }
-    createGeometry(container, color) {
-        var _a, _b, _c, _d;
-        const { id: graphicId, properties, type: contType } = container;
-        const type = convertType(contType);
-        const box = { min: new THREE.Vector3(...properties.min), max: new THREE.Vector3(...properties.max) };
-        const meshes = [];
-        const lines = [];
-        const edges = [];
-        const arcs = [];
-        const pointMap = {};
-        const map = {};
-        if (container.meshes) {
-            container.meshes.forEach(mesh => {
-                const elem = this.createSurface(mesh, container, color);
-                if (elem.isValid) {
-                    meshes.push(elem);
-                    map[mesh.id] = elem;
-                }
-                else {
-                    // TODO: The server should not send invalid meshes.
-                    console.warn(`Invalid mesh detected`);
-                }
-            });
-        }
-        if (container.lines) {
-            container.lines.forEach(line => {
-                const elem = this.createLine(line, container, pointMap, color);
-                lines.push(elem);
-                map[line.id] = elem;
-            });
-        }
-        if (container.edges) {
-            container.edges.forEach(edge => {
-                const elem = this.createEdge(edge, container, pointMap, color);
-                edges.push(elem);
-                map[edge.id] = elem;
-            });
-        }
-        if (container.arcs) {
-            container.arcs.forEach(arc => {
-                const elem = this.createArc(arc, container, pointMap, color);
-                arcs.push(elem);
-                map[arc.id] = elem;
-            });
-        }
-        const points = Object.values(pointMap);
-        return Object.assign({ graphicId,
-            type,
-            map,
-            meshes,
-            lines,
-            edges,
-            arcs,
-            points,
-            box }, this.getMetadata(null, container, (_b = (_a = container.properties) === null || _a === void 0 ? void 0 : _a.material) === null || _b === void 0 ? void 0 : _b.color, (_d = (_c = container.properties) === null || _c === void 0 ? void 0 : _c.material) === null || _d === void 0 ? void 0 : _d.opacity));
-    }
-    createSurface(mesh, container, color) {
-        let meshGeom = this.createMesh(mesh, container, color);
-        switch (meshGeom.type) {
-            case GraphicType.PLANE:
-                meshGeom = this.createPlane(mesh, meshGeom);
-                break;
-            case GraphicType.CYLINDER:
-                meshGeom = this.createCylinder(mesh, meshGeom);
-                break;
-            case GraphicType.CONE:
-                meshGeom = this.createCone(mesh, meshGeom);
-                break;
-            case GraphicType.SPHERE:
-                meshGeom = this.createSphere(mesh, meshGeom);
-                break;
-        }
-        return meshGeom;
-    }
-    createMesh(mesh, container, color) {
-        const graphicId = mesh.id;
-        const loops = mesh.loops;
-        const type = mesh.properties.surface.type;
-        const geometry = new THREE.BufferGeometry();
-        geometry.setIndex(mesh.indices);
-        geometry.setAttribute('position', new THREE.Float32BufferAttribute(mesh.vertices, 3));
-        mesh.normals && geometry.setAttribute('normal', new THREE.Float32BufferAttribute(mesh.normals, 3));
-        return Object.assign({ 
-            // TODO: The server should not send invalid meshes.
-            isValid: mesh.vertices && mesh.vertices.length > 0, geometry,
-            graphicId,
-            type,
-            loops }, this.getMetadata(mesh, container, color));
-    }
-    createPlane(mesh, meshGeom) {
-        const type = GraphicType.PLANE;
-        const { normal: n, pointOnPlane: p } = mesh.properties.surface;
-        const pointOnPlane = new THREE.Vector3(p[0], p[1], p[2]);
-        const normal = new THREE.Vector3(n[0], n[1], n[2]).normalize();
-        return Object.assign(Object.assign({}, meshGeom), { type, pointOnPlane, normal });
-    }
-    createCylinder(mesh, meshGeom) {
-        const type = GraphicType.CYLINDER;
-        const { origin: o, axis: a, height, radius } = mesh.properties.surface;
-        const origin = new THREE.Vector3(o[0], o[1], o[2]);
-        const axis = new THREE.Vector3(a[0], a[1], a[2]).normalize();
-        return Object.assign(Object.assign({}, meshGeom), { type, origin, axis, height, radius });
-    }
-    createCone(mesh, meshGeom) {
-        const type = GraphicType.CONE;
-        const { origin: o, axis: a, height, radiusBottom, radiusTop } = mesh.properties.surface;
-        const origin = new THREE.Vector3(o[0], o[1], o[2]);
-        const axis = new THREE.Vector3(a[0], a[1], a[2]).normalize();
-        return Object.assign(Object.assign({}, meshGeom), { type, origin, axis, height, radiusBottom, radiusTop });
-    }
-    createSphere(mesh, meshGeom) {
-        const type = GraphicType.SPHERE;
-        const { radius } = mesh.properties.surface;
-        return Object.assign(Object.assign({}, meshGeom), { type, radius });
-    }
-    createLine(line, container, points, color) {
-        const graphicId = line.id;
-        let type = GraphicType.LINE;
-        if (container.type === ContainerType.CURVEARRAY) {
-            type = GraphicType.CURVELINE;
-        }
-        const pts = line.points;
-        const [startId, endId] = line.pointIds;
-        const start = new THREE.Vector3(pts[0], pts[1], pts[2]);
-        const end = new THREE.Vector3(pts[3], pts[4], pts[5]);
-        this.insertPoint(container, `${startId}|point`, startId, start.clone(), line.id, 'start', points);
-        this.insertPoint(container, `${endId}|point`, endId, end.clone(), line.id, 'end', points);
-        const geometry = new THREE.BufferGeometry().setFromPoints([start.clone(), end.clone()]);
-        return Object.assign(Object.assign({ geometry,
-            graphicId, type: type }, this.getMetadata(line, container, color)), { start: start.clone(), end: end.clone() });
-    }
-    createEdge(edge, container, points, color) {
-        const threePts = [];
-        const graphicId = edge.id;
-        let type = GraphicType.NURBSCURVE;
-        if (container.type === ContainerType.CURVEARRAY) {
-            type = GraphicType.CURVESPLINE;
-        }
-        const pts = edge.points;
-        for (let i = 0, length = pts.length / 3; i < length; i++) {
-            threePts.push(new THREE.Vector3(pts[i * 3], pts[i * 3 + 1], pts[i * 3 + 2]));
-            // Each segment has to be defined with start and end to use it for BufferGeometry
-            if (i > 0) {
-                threePts.push(new THREE.Vector3(pts[i * 3], pts[i * 3 + 1], pts[i * 3 + 2]));
-            }
-        }
-        // Seems like the three BufferGeometryUtils expect an edge to have an even number of points.
-        // Just add the end point twice if this is not the case.
-        if (threePts.length % 2 !== 0) {
-            threePts.push(threePts[threePts.length - 1].clone());
-        }
-        const start = threePts[0].clone();
-        const end = threePts[threePts.length - 1].clone();
-        const startId = edge.pointIds[0];
-        const endId = edge.pointIds[edge.pointIds.length - 1];
-        this.insertPoint(container, `${startId}|point`, startId, start, edge.id, 'start', points);
-        this.insertPoint(container, `${endId}|point`, endId, end, edge.id, 'end', points);
-        const geometry = new THREE.BufferGeometry().setFromPoints(threePts);
-        return Object.assign(Object.assign({ geometry,
-            graphicId, type: type }, this.getMetadata(edge, container, color)), { start: start.clone(), end: end.clone() });
-    }
-    createArc(arc, container, points, color) {
-        const graphicId = arc.id;
-        let type = arc.isCircle ? GraphicType.CIRCLE : GraphicType.ARC;
-        if (container.type === ContainerType.CURVEARRAY) {
-            type = arc.isCircle ? GraphicType.CURVECIRCLE : GraphicType.CURVEARC;
-        }
-        // take half of coordHeightTolerance used for faces, as classcad does it in the tessellation process
-        const coordHeight = this.coordHeightTolerance / 2;
-        const radius = arc.radius;
-        const center = new THREE.Vector3(arc.center[0], arc.center[1], arc.center[2]);
-        const normal = new THREE.Vector3(arc.zAxis[0], arc.zAxis[1], arc.zAxis[2]).normalize();
-        const startVector = new THREE.Vector3(arc.xAxis[0], arc.xAxis[1], arc.xAxis[2]).normalize().multiplyScalar(radius);
-        const theta = arc.isCircle ? Math.PI * 2 : arc.angle;
-        // calculate angle for one segment to fulfill coordHeight tolerance
-        let alpha = 2 * Math.acos(1 - coordHeight / radius);
-        // calculate number of segments
-        let segments = Math.ceil(Math.abs(arc.angle) / alpha);
-        // choose at minimum three segments
-        segments = Math.max(3, segments);
-        // adjust angle to match with number of segments, still fulfilling coordHeigth tolerance
-        alpha = theta / segments;
-        const threePts = [];
-        const matrix = new THREE.Matrix4().makeRotationAxis(normal, alpha);
-        const startPoint = center.clone();
-        startPoint.add(startVector);
-        threePts.push(startPoint);
-        for (let i = 0; i < segments; i++) {
-            startVector.applyMatrix4(matrix);
-            const nextPoint = center.clone();
-            nextPoint.add(startVector);
-            threePts.push(nextPoint.clone());
-            // Each segment has to be defined with start and end to use it for BufferGeometry
-            threePts.push(nextPoint.clone());
-        }
-        // Seems like the three BufferGeometryUtils expect an edge to have an even number of points.
-        // Just add the end point twice if this is not the case.
-        if (threePts.length % 2 !== 0) {
-            threePts.push(threePts[threePts.length - 1].clone());
-        }
-        const [startId, endId] = arc.pointIds;
-        const start = threePts[0].clone();
-        const end = threePts[threePts.length - 1].clone();
-        this.insertPoint(container, `${startId}|point`, startId, start, arc.id, 'start', points);
-        this.insertPoint(container, `${endId}|point`, endId, end, arc.id, 'end', points);
-        const geometry = new THREE.BufferGeometry().setFromPoints(threePts);
-        return Object.assign(Object.assign({ geometry,
-            graphicId, type: type }, this.getMetadata(arc, container, color)), { normal: normal.clone(), center: center.clone(), start: start.clone(), end: end.clone(), radius: arc.radius, angle: arc.angle });
-    }
-    createPoint(container, key, graphicId, position, ownerId, type) {
-        return Object.assign(Object.assign({ key,
-            graphicId, type: (container.type === ContainerType.CURVEARRAY ? GraphicType.CURVEPOINT : GraphicType.POINT) }, this.getMetadata(null, container)), { position: position.clone(), geometry: position.clone(), owners: [{ ownerId, type }] });
-    }
-    insertPoint(container, key, graphicId, position, ownerId, type, points) {
-        const existingPoint = points[key];
-        if (existingPoint) {
-            const filteredOwners = existingPoint.owners.filter(gr => gr.ownerId === ownerId && gr.type === type);
-            if (filteredOwners.length <= 0) {
-                existingPoint.owners.push({ ownerId, type });
-            }
-        }
-        else {
-            points[key] = this.createPoint(container, key, graphicId, position, ownerId, type);
-        }
-    }
-}
-export const EMPTY_CONTAINER_GEOMETRY = () => {
-    return {
-        graphicId: Number.NaN,
-        type: GraphicType.NONE,
-        map: {},
-        meshes: [],
-        lines: [],
-        edges: [],
-        arcs: [],
-        points: [],
-        box: { min: new THREE.Vector3(), max: new THREE.Vector3() },
-        container: { id: Number.NaN, ownerId: Number.NaN, type: GraphicType.NONE },
-        color: new THREE.Color(),
-        opacity: 1.0,
-        layer: null,
-        operationId: Number.NaN,
-        rawGraphic: null,
-    };
-};
-export const isEqualGeometry = (a, b) => {
-    return a.graphicId === b.graphicId && a.type === b.type;
-};
+import * as THREE from 'three';
+import { ContainerType, GraphicType, } from '../re-export';
+const convertType = (contType) => {
+    let type = GraphicType.NONE;
+    switch (contType) {
+        case ContainerType.BREP:
+            type = GraphicType.BREP;
+            break;
+        case ContainerType.CURVEARRAY:
+            type = GraphicType.CURVEARRAY;
+            break;
+        case ContainerType.POLYBREP:
+            type = GraphicType.POLYBREP;
+            break;
+    }
+    return type;
+};
+/**
+ * Creates THREE geometry based on the data within a @see IGraphicContainer.
+ */
+export class ThreeGeometryCreator {
+    constructor() {
+        this.coordHeightTolerance = 0.01;
+    }
+    getMetadata(geometry, container, color, opacity = 0) {
+        var _a;
+        const geomProps = geometry ? geometry.properties : {};
+        if (geomProps && geomProps.material) {
+            color = geomProps.material.color || color;
+            opacity = geomProps.material.opacity || opacity;
+        }
+        // Provide values as a CSS color string, which will be gamma corrected by three.js
+        const rgbColor = color ? new THREE.Color(`rgb(${color[0]}, ${color[1]}, ${color[2]})`) : undefined;
+        const layer = geomProps && geomProps.layer ? geomProps.layer : container.properties.layer;
+        return {
+            color: rgbColor,
+            opacity,
+            layer,
+            container: { id: container.id, ownerId: container.owner, type: convertType(container.type) },
+            operationId: (_a = geometry === null || geometry === void 0 ? void 0 : geometry.properties) === null || _a === void 0 ? void 0 : _a.operationId,
+            rawGraphic: geometry,
+        };
+    }
+    createGeometry(container, color) {
+        var _a, _b, _c, _d;
+        const { id: graphicId, properties, type: contType } = container;
+        const type = convertType(contType);
+        const box = { min: new THREE.Vector3(...properties.min), max: new THREE.Vector3(...properties.max) };
+        const meshes = [];
+        const lines = [];
+        const edges = [];
+        const arcs = [];
+        const pointMap = {};
+        const map = {};
+        if (container.meshes) {
+            container.meshes.forEach(mesh => {
+                const elem = this.createSurface(mesh, container, color);
+                if (elem.isValid) {
+                    meshes.push(elem);
+                    map[mesh.id] = elem;
+                }
+                else {
+                    // TODO: The server should not send invalid meshes.
+                    console.warn(`Invalid mesh detected`);
+                }
+            });
+        }
+        if (container.lines) {
+            container.lines.forEach(line => {
+                const elem = this.createLine(line, container, pointMap, color);
+                lines.push(elem);
+                map[line.id] = elem;
+            });
+        }
+        if (container.edges) {
+            container.edges.forEach(edge => {
+                const elem = this.createEdge(edge, container, pointMap, color);
+                edges.push(elem);
+                map[edge.id] = elem;
+            });
+        }
+        if (container.arcs) {
+            container.arcs.forEach(arc => {
+                const elem = this.createArc(arc, container, pointMap, color);
+                arcs.push(elem);
+                map[arc.id] = elem;
+            });
+        }
+        const points = Object.values(pointMap);
+        return Object.assign({ graphicId,
+            type,
+            map,
+            meshes,
+            lines,
+            edges,
+            arcs,
+            points,
+            box }, this.getMetadata(null, container, (_b = (_a = container.properties) === null || _a === void 0 ? void 0 : _a.material) === null || _b === void 0 ? void 0 : _b.color, (_d = (_c = container.properties) === null || _c === void 0 ? void 0 : _c.material) === null || _d === void 0 ? void 0 : _d.opacity));
+    }
+    createSurface(mesh, container, color) {
+        let meshGeom = this.createMesh(mesh, container, color);
+        switch (meshGeom.type) {
+            case GraphicType.PLANE:
+                meshGeom = this.createPlane(mesh, meshGeom);
+                break;
+            case GraphicType.CYLINDER:
+                meshGeom = this.createCylinder(mesh, meshGeom);
+                break;
+            case GraphicType.CONE:
+                meshGeom = this.createCone(mesh, meshGeom);
+                break;
+            case GraphicType.SPHERE:
+                meshGeom = this.createSphere(mesh, meshGeom);
+                break;
+        }
+        return meshGeom;
+    }
+    createMesh(mesh, container, color) {
+        const graphicId = mesh.id;
+        const loops = mesh.loops;
+        const type = mesh.properties.surface.type;
+        const geometry = new THREE.BufferGeometry();
+        geometry.setIndex(mesh.indices);
+        geometry.setAttribute('position', new THREE.Float32BufferAttribute(mesh.vertices, 3));
+        mesh.normals && geometry.setAttribute('normal', new THREE.Float32BufferAttribute(mesh.normals, 3));
+        return Object.assign({ 
+            // TODO: The server should not send invalid meshes.
+            isValid: mesh.vertices && mesh.vertices.length > 0, geometry,
+            graphicId,
+            type,
+            loops }, this.getMetadata(mesh, container, color));
+    }
+    createPlane(mesh, meshGeom) {
+        const type = GraphicType.PLANE;
+        const { normal: n, pointOnPlane: p } = mesh.properties.surface;
+        const pointOnPlane = new THREE.Vector3(p[0], p[1], p[2]);
+        const normal = new THREE.Vector3(n[0], n[1], n[2]).normalize();
+        return Object.assign(Object.assign({}, meshGeom), { type, pointOnPlane, normal });
+    }
+    createCylinder(mesh, meshGeom) {
+        const type = GraphicType.CYLINDER;
+        const { origin: o, axis: a, height, radius } = mesh.properties.surface;
+        const origin = new THREE.Vector3(o[0], o[1], o[2]);
+        const axis = new THREE.Vector3(a[0], a[1], a[2]).normalize();
+        return Object.assign(Object.assign({}, meshGeom), { type, origin, axis, height, radius });
+    }
+    createCone(mesh, meshGeom) {
+        const type = GraphicType.CONE;
+        const { origin: o, axis: a, height, radiusBottom, radiusTop } = mesh.properties.surface;
+        const origin = new THREE.Vector3(o[0], o[1], o[2]);
+        const axis = new THREE.Vector3(a[0], a[1], a[2]).normalize();
+        return Object.assign(Object.assign({}, meshGeom), { type, origin, axis, height, radiusBottom, radiusTop });
+    }
+    createSphere(mesh, meshGeom) {
+        const type = GraphicType.SPHERE;
+        const { radius } = mesh.properties.surface;
+        return Object.assign(Object.assign({}, meshGeom), { type, radius });
+    }
+    createLine(line, container, points, color) {
+        const graphicId = line.id;
+        let type = GraphicType.LINE;
+        if (container.type === ContainerType.CURVEARRAY) {
+            type = GraphicType.CURVELINE;
+        }
+        const pts = line.points;
+        const [startId, endId] = line.pointIds;
+        const start = new THREE.Vector3(pts[0], pts[1], pts[2]);
+        const end = new THREE.Vector3(pts[3], pts[4], pts[5]);
+        this.insertPoint(container, `${startId}|point`, startId, start.clone(), line.id, 'start', points);
+        this.insertPoint(container, `${endId}|point`, endId, end.clone(), line.id, 'end', points);
+        const geometry = new THREE.BufferGeometry().setFromPoints([start.clone(), end.clone()]);
+        return Object.assign(Object.assign({ geometry,
+            graphicId, type: type }, this.getMetadata(line, container, color)), { start: start.clone(), end: end.clone() });
+    }
+    createEdge(edge, container, points, color) {
+        const threePts = [];
+        const graphicId = edge.id;
+        let type = GraphicType.NURBSCURVE;
+        if (container.type === ContainerType.CURVEARRAY) {
+            type = GraphicType.CURVESPLINE;
+        }
+        const pts = edge.points;
+        for (let i = 0, length = pts.length / 3; i < length; i++) {
+            threePts.push(new THREE.Vector3(pts[i * 3], pts[i * 3 + 1], pts[i * 3 + 2]));
+            // Each segment has to be defined with start and end to use it for BufferGeometry
+            if (i > 0) {
+                threePts.push(new THREE.Vector3(pts[i * 3], pts[i * 3 + 1], pts[i * 3 + 2]));
+            }
+        }
+        // Seems like the three BufferGeometryUtils expect an edge to have an even number of points.
+        // Just add the end point twice if this is not the case.
+        if (threePts.length % 2 !== 0) {
+            threePts.push(threePts[threePts.length - 1].clone());
+        }
+        const start = threePts[0].clone();
+        const end = threePts[threePts.length - 1].clone();
+        const startId = edge.pointIds[0];
+        const endId = edge.pointIds[edge.pointIds.length - 1];
+        this.insertPoint(container, `${startId}|point`, startId, start, edge.id, 'start', points);
+        this.insertPoint(container, `${endId}|point`, endId, end, edge.id, 'end', points);
+        const geometry = new THREE.BufferGeometry().setFromPoints(threePts);
+        return Object.assign(Object.assign({ geometry,
+            graphicId, type: type }, this.getMetadata(edge, container, color)), { start: start.clone(), end: end.clone() });
+    }
+    createArc(arc, container, points, color) {
+        const graphicId = arc.id;
+        let type = arc.isCircle ? GraphicType.CIRCLE : GraphicType.ARC;
+        if (container.type === ContainerType.CURVEARRAY) {
+            type = arc.isCircle ? GraphicType.CURVECIRCLE : GraphicType.CURVEARC;
+        }
+        // take half of coordHeightTolerance used for faces, as classcad does it in the tessellation process
+        const coordHeight = this.coordHeightTolerance / 2;
+        const radius = arc.radius;
+        const center = new THREE.Vector3(arc.center[0], arc.center[1], arc.center[2]);
+        const normal = new THREE.Vector3(arc.zAxis[0], arc.zAxis[1], arc.zAxis[2]).normalize();
+        const startVector = new THREE.Vector3(arc.xAxis[0], arc.xAxis[1], arc.xAxis[2]).normalize().multiplyScalar(radius);
+        const theta = arc.isCircle ? Math.PI * 2 : arc.angle;
+        // calculate angle for one segment to fulfill coordHeight tolerance
+        let alpha = 2 * Math.acos(1 - coordHeight / radius);
+        // calculate number of segments
+        let segments = Math.ceil(Math.abs(arc.angle) / alpha);
+        // choose at minimum three segments
+        segments = Math.max(3, segments);
+        // adjust angle to match with number of segments, still fulfilling coordHeigth tolerance
+        alpha = theta / segments;
+        const threePts = [];
+        const matrix = new THREE.Matrix4().makeRotationAxis(normal, alpha);
+        const startPoint = center.clone();
+        startPoint.add(startVector);
+        threePts.push(startPoint);
+        for (let i = 0; i < segments; i++) {
+            startVector.applyMatrix4(matrix);
+            const nextPoint = center.clone();
+            nextPoint.add(startVector);
+            threePts.push(nextPoint.clone());
+            // Each segment has to be defined with start and end to use it for BufferGeometry
+            threePts.push(nextPoint.clone());
+        }
+        // Seems like the three BufferGeometryUtils expect an edge to have an even number of points.
+        // Just add the end point twice if this is not the case.
+        if (threePts.length % 2 !== 0) {
+            threePts.push(threePts[threePts.length - 1].clone());
+        }
+        const [startId, endId] = arc.pointIds;
+        const start = threePts[0].clone();
+        const end = threePts[threePts.length - 1].clone();
+        this.insertPoint(container, `${startId}|point`, startId, start, arc.id, 'start', points);
+        this.insertPoint(container, `${endId}|point`, endId, end, arc.id, 'end', points);
+        const geometry = new THREE.BufferGeometry().setFromPoints(threePts);
+        return Object.assign(Object.assign({ geometry,
+            graphicId, type: type }, this.getMetadata(arc, container, color)), { normal: normal.clone(), center: center.clone(), start: start.clone(), end: end.clone(), radius: arc.radius, angle: arc.angle });
+    }
+    createPoint(container, key, graphicId, position, ownerId, type) {
+        return Object.assign(Object.assign({ key,
+            graphicId, type: (container.type === ContainerType.CURVEARRAY ? GraphicType.CURVEPOINT : GraphicType.POINT) }, this.getMetadata(null, container)), { position: position.clone(), geometry: position.clone(), owners: [{ ownerId, type }] });
+    }
+    insertPoint(container, key, graphicId, position, ownerId, type, points) {
+        const existingPoint = points[key];
+        if (existingPoint) {
+            const filteredOwners = existingPoint.owners.filter(gr => gr.ownerId === ownerId && gr.type === type);
+            if (filteredOwners.length <= 0) {
+                existingPoint.owners.push({ ownerId, type });
+            }
+        }
+        else {
+            points[key] = this.createPoint(container, key, graphicId, position, ownerId, type);
+        }
+    }
+}
+export const EMPTY_CONTAINER_GEOMETRY = () => {
+    return {
+        graphicId: Number.NaN,
+        type: GraphicType.NONE,
+        map: {},
+        meshes: [],
+        lines: [],
+        edges: [],
+        arcs: [],
+        points: [],
+        box: { min: new THREE.Vector3(), max: new THREE.Vector3() },
+        container: { id: Number.NaN, ownerId: Number.NaN, type: GraphicType.NONE },
+        color: new THREE.Color(),
+        opacity: 1.0,
+        layer: null,
+        operationId: Number.NaN,
+        rawGraphic: null,
+    };
+};
+export const isEqualGeometry = (a, b) => {
+    return a.graphicId === b.graphicId && a.type === b.type;
+};

package/build/esm/geometry/index.js

@@ -1 +1 @@
-export * from './ThreeGeometryCreator';
+export * from './ThreeGeometryCreator';