opengeometry 2.0.17 → 2.0.18

package/index.js

@@ -582,10 +582,13 @@ class OGAnalyticBrep {
   }
   /**
    * @param {number} deflection
+   * @param {string | null} [options_json]
    * @returns {OGAnalyticTessellation}
    */
-  tessellate(deflection) {
-    const ret = wasm.oganalyticbrep_tessellate(this.__wbg_ptr, deflection);
+  tessellate(deflection, options_json) {
+    var ptr0 = isLikeNone(options_json) ? 0 : passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    const ret = wasm.oganalyticbrep_tessellate(this.__wbg_ptr, deflection, ptr0, len0);
     if (ret[2]) {
       throw takeFromExternrefTable0(ret[1]);
     }
@@ -7133,7 +7136,7 @@ class AnalyticSolid extends THREE.Group {
             throw new Error("STL deflection must be finite and positive");
         }
         const placed = this.worldKernel();
-        const result = tessellate_brep(placed.get_brep_serialized(), deflection * GEOMETRY_DEFLECTION_SHARE);
+        const result = placed.tessellate(deflection * GEOMETRY_DEFLECTION_SHARE);
         try {
             const positions = result.positions();
             const indices = result.indices();
@@ -7260,7 +7263,7 @@ class AnalyticSolid extends THREE.Group {
             && (!Number.isSafeInteger(options.maxTriangles) || options.maxTriangles <= 0 || options.maxTriangles > 2000000)) {
             throw new Error("maxTriangles must be an integer between 1 and 2000000");
         }
-        const result = tessellate_brep(this.kernel.get_brep_serialized(), deflection, options.maxTriangles === undefined ? undefined : JSON.stringify({ max_triangles: options.maxTriangles }));
+        const result = this.kernel.tessellate(deflection, options.maxTriangles === undefined ? undefined : JSON.stringify({ max_triangles: options.maxTriangles }));
         try {
             return {
                 positions: result.positions(), normals: result.normals(), indices: result.indices(),
@@ -7386,24 +7389,92 @@ class AnalyticSolid extends THREE.Group {
         return this.kernel.placed(JSON.stringify(frame), scale);
     }
 }
+function arcBoxPointsOf(arc) {
+    const quarterTurn = Math.PI / 2;
+    const axisDirections = [[1, 0], [0, 1], [-1, 0], [0, -1]];
+    const endAngle = arc.startAngle + arc.sweepAngle;
+    const points = [arc.startAngle, endAngle].map((angle) => [
+        arc.center[0] + arc.radius * Math.cos(angle), arc.center[1] + arc.radius * Math.sin(angle),
+    ]);
+    const firstQuarter = Math.ceil(Math.min(arc.startAngle, endAngle) / quarterTurn);
+    const lastStep = Number.isFinite(firstQuarter)
+        ? Math.min(Math.floor(Math.max(arc.startAngle, endAngle) / quarterTurn) - firstQuarter, 3)
+        : -1;
+    for (let step = 0; step <= lastStep; step += 1) {
+        const direction = axisDirections[(((firstQuarter + step) % 4) + 4) % 4];
+        points.push([arc.center[0] + arc.radius * direction[0], arc.center[1] + arc.radius * direction[1]]);
+    }
+    return points;
+}
+function pointBoxOf(options) {
+    var _a;
+    const points = options.kind === "polygonLoft"
+        ? [...options.lower, ...options.upper]
+        : options.kind === "planarPolyhedron" ? [...options.vertices] : [];
+    const addProfilePoint = (point, height) => {
+        points.push([point[0], point[1], 0], [point[0], point[1], height]);
+    };
+    if (options.kind === "linearExtrusion") {
+        for (const loop of [options.outer, ...options.holes]) {
+            for (const point of loop)
+                addProfilePoint(point, options.height);
+        }
+    }
+    else if (options.kind === "arcEdgedExtrusion") {
+        for (const ring of [options.outer, ...((_a = options.holes) !== null && _a !== void 0 ? _a : [])]) {
+            for (const edge of ring) {
+                const corners = edge.kind === "line" ? [edge.from, edge.to] : arcBoxPointsOf(edge);
+                for (const corner of corners)
+                    addProfilePoint(corner, options.height);
+            }
+        }
+    }
+    if (points.length === 0)
+        return undefined;
+    const box = { lo: [Infinity, Infinity, Infinity], hi: [-Infinity, -Infinity, -Infinity] };
+    for (const point of points) {
+        for (let axis = 0; axis < 3; axis += 1) {
+            box.lo[axis] = Math.min(box.lo[axis], point[axis]);
+            box.hi[axis] = Math.max(box.hi[axis], point[axis]);
+        }
+    }
+    return box;
+}
+function reachBoxOf(options, box) {
+    if (options.kind !== "arcEdgedExtrusion")
+        return box;
+    const reachBox = { lo: [box.lo[0], box.lo[1], box.lo[2]], hi: [box.hi[0], box.hi[1], box.hi[2]] };
+    for (const edge of options.outer) {
+        if (edge.kind === "line")
+            continue;
+        for (const axis of [0, 1]) {
+            reachBox.lo[axis] = Math.min(reachBox.lo[axis], edge.center[axis] - edge.radius);
+            reachBox.hi[axis] = Math.max(reachBox.hi[axis], edge.center[axis] + edge.radius);
+        }
+    }
+    return reachBox;
+}
+function worldReachOf(frame, box) {
+    const farthest = [0, 0, 0];
+    for (const alongX of [box.lo[0], box.hi[0]]) {
+        for (const alongY of [box.lo[1], box.hi[1]]) {
+            for (const alongZ of [box.lo[2], box.hi[2]]) {
+                for (let axis = 0; axis < 3; axis += 1) {
+                    const coordinate = frame.origin[axis] + alongX * frame.x[axis] + alongY * frame.y[axis] + alongZ * frame.z[axis];
+                    farthest[axis] = Math.max(farthest[axis], Math.abs(coordinate));
+                }
+            }
+        }
+    }
+    return Math.hypot(farthest[0], farthest[1], farthest[2]);
+}
 function createPrimitiveKernel(options, ogid) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d;
     const frame = (_a = options.frame) !== null && _a !== void 0 ? _a : (options.kind === "planarPolyhedron" || options.kind === "polygonLoft"
         ? { origin: [0, 0, 0], x: [1, 0, 0], y: [0, 1, 0], z: [0, 0, 1] }
         : { origin: [0, 0, 0], x: [1, 0, 0], y: [0, 0, -1], z: [0, 1, 0] });
-    const profileExtent = options.kind === "linearExtrusion"
-        ? [options.outer, ...options.holes].reduce((extent, loop) => (loop.reduce((loopExtent, point) => Math.max(loopExtent, Math.abs(point[0]), Math.abs(point[1])), extent)), 0)
-        : options.kind === "arcEdgedExtrusion"
-            ? [options.outer, ...((_b = options.holes) !== null && _b !== void 0 ? _b : [])].reduce((extent, ring) => ring.reduce((loopExtent, edge) => edge.kind === "line"
-                ? Math.max(loopExtent, ...edge.from.map(Math.abs), ...edge.to.map(Math.abs))
-                : Math.max(loopExtent, Math.abs(edge.center[0]) + edge.radius, Math.abs(edge.center[1]) + edge.radius), extent), 0)
-            : 0;
-    const loftExtent = options.kind === "polygonLoft"
-        ? [...options.lower, ...options.upper].reduce((extent, point) => Math.max(extent, ...point.map(Math.abs)), 0)
-        : 0;
-    const polyhedronExtent = options.kind === "planarPolyhedron"
-        ? options.vertices.reduce((extent, point) => Math.max(extent, Math.abs(point[0]), Math.abs(point[1]), Math.abs(point[2])), 0)
-        : 0;
+    const pointBox = pointBoxOf(options);
+    const pointSize = pointBox ? Math.max(...pointBox.hi.map((high, axis) => high - pointBox.lo[axis])) : 0;
     const size = options.kind === "torus"
         ? 2 * (options.majorRadius + options.minorRadius)
         : options.kind === "coaxialCircleLoft"
@@ -7413,13 +7484,13 @@ function createPrimitiveKernel(options, ogid) {
                 : options.kind === "chamferedCuboid"
                     ? Math.max(options.width, options.depth, options.height)
                     : options.kind === "linearExtrusion" || options.kind === "arcEdgedExtrusion"
-                        ? Math.max(options.height, profileExtent)
+                        ? pointSize
                         : options.kind === "polygonLoft"
-                            ? loftExtent
+                            ? pointSize
                             : options.kind === "boxWithArchedOpening"
                                 ? Math.max(options.width, options.depth, options.height)
                                 : options.kind === "planarPolyhedron"
-                                    ? polyhedronExtent
+                                    ? pointSize
                                     : options.kind === "frustum"
                                         ? Math.max(2 * options.lowerRadius, 2 * options.upperRadius, options.height)
                                         : options.kind === "annularSectorExtrusion" || options.kind === "annularSectorExtrusionWithOpenings" || options.kind === "annularSectorExtrusionWithArchedOpening"
@@ -7429,9 +7500,9 @@ function createPrimitiveKernel(options, ogid) {
                                                 : options.kind === "sphere"
                                                     ? 2 * options.radius
                                                     : Math.max(2 * options.radius, options.height);
-    const coordinateFloor = Math.max(...frame.origin.map(Math.abs)) * 64 * Number.EPSILON;
+    const coordinateFloor = 128 * Number.EPSILON * worldReachOf(frame, pointBox ? reachBoxOf(options, pointBox) : { lo: [-size, -size, -size], hi: [size, size, size] });
     const geometric = Math.max(1e-9, size * 1e-8, coordinateFloor);
-    const accuracy = (_c = options.accuracy) !== null && _c !== void 0 ? _c : {
+    const accuracy = (_b = options.accuracy) !== null && _b !== void 0 ? _b : {
         geometric, intersection: geometric / 4, tessellation: 0.001, exchange: 0.00001,
     };
     const dimensions = options.kind === "torus"
@@ -7450,7 +7521,7 @@ function createPrimitiveKernel(options, ogid) {
                                 ? { outer: options.outer.map((edge) => edge.kind === "line" ? edge : {
                                         kind: "arc", center: edge.center, radius: edge.radius,
                                         start_angle: edge.startAngle, sweep_angle: edge.sweepAngle,
-                                    }), holes: ((_d = options.holes) !== null && _d !== void 0 ? _d : []).map((ring) => ring.map((edge) => edge.kind === "line" ? edge : {
+                                    }), holes: ((_c = options.holes) !== null && _c !== void 0 ? _c : []).map((ring) => ring.map((edge) => edge.kind === "line" ? edge : {
                                         kind: "arc", center: edge.center, radius: edge.radius,
                                         start_angle: edge.startAngle, sweep_angle: edge.sweepAngle,
                                     })), height: options.height }
@@ -7463,7 +7534,7 @@ function createPrimitiveKernel(options, ogid) {
                                             : {
                                                 kind: "indexed",
                                                 upper_start: options.alignment.upperStartIndex,
-                                                reverse_upper: (_e = options.alignment.reverseUpper) !== null && _e !== void 0 ? _e : false,
+                                                reverse_upper: (_d = options.alignment.reverseUpper) !== null && _d !== void 0 ? _d : false,
                                             },
                                     }
                                     : options.kind === "boxWithArchedOpening"