okgeometry-api 1.1.2 → 1.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okgeometry-api",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "description": "Geometry engine API for AEC applications — NURBS, meshes, booleans, intersections. Powered by Rust/WASM.",
   "type": "module",
   "main": "dist/index.js",

package/src/Mesh.ts

@@ -278,77 +278,52 @@ export class Mesh {
     }));
   }
 
-  private static buildBooleanDebugProbes(
+  private static buildDirectionalDebugProbes(
     inputA: Mesh,
     inputB: Mesh,
     result: Mesh,
-    options?: MeshBooleanDebugOptions,
+    center: Point,
+    pad: number,
+    maxDistance: number,
+    maxHits: number,
+    probeIds: Array<"posX" | "negX" | "posY" | "negY" | "posZ" | "negZ">,
+    labelPrefix = "",
   ): MeshBooleanDebugProbe[] {
-    const boundsA = Mesh.toDebugBounds(inputA.getBounds());
-    const boundsB = Mesh.toDebugBounds(inputB.getBounds());
-    const resultBounds = Mesh.toDebugBounds(result.getBounds());
-    const min = new Point(
-      Math.min(boundsA.min.x, boundsB.min.x, resultBounds.min.x),
-      Math.min(boundsA.min.y, boundsB.min.y, resultBounds.min.y),
-      Math.min(boundsA.min.z, boundsB.min.z, resultBounds.min.z),
-    );
-    const max = new Point(
-      Math.max(boundsA.max.x, boundsB.max.x, resultBounds.max.x),
-      Math.max(boundsA.max.y, boundsB.max.y, resultBounds.max.y),
-      Math.max(boundsA.max.z, boundsB.max.z, resultBounds.max.z),
-    );
-    const center = new Point(
-      (min.x + max.x) * 0.5,
-      (min.y + max.y) * 0.5,
-      (min.z + max.z) * 0.5,
-    );
-    const diag = Math.max(
-      1e-6,
-      Math.hypot(max.x - min.x, max.y - min.y, max.z - min.z),
-    );
-    const padScale = Number.isFinite(options?.rayPaddingScale)
-      ? Math.max(0.01, options?.rayPaddingScale ?? 0.25)
-      : 0.25;
-    const pad = Math.max(1e-3, diag * padScale);
-    const maxHits = Mesh.clampDebugHitCount(options?.maxRayHits);
-    const probeIds = options?.probes?.length
-      ? options.probes
-      : Mesh.DEFAULT_BOOLEAN_DEBUG_PROBES;
+    const prefixed = (id: string) => (labelPrefix ? `${labelPrefix}:${id}` : id);
     const probeSpecs: Record<
       "posX" | "negX" | "posY" | "negY" | "posZ" | "negZ",
       { origin: Point; direction: Vec3 }
     > = {
       posX: {
-        origin: new Point(max.x + pad, center.y, center.z),
+        origin: new Point(center.x + pad, center.y, center.z),
         direction: new Vec3(-1, 0, 0),
       },
       negX: {
-        origin: new Point(min.x - pad, center.y, center.z),
+        origin: new Point(center.x - pad, center.y, center.z),
         direction: new Vec3(1, 0, 0),
       },
       posY: {
-        origin: new Point(center.x, max.y + pad, center.z),
+        origin: new Point(center.x, center.y + pad, center.z),
         direction: new Vec3(0, -1, 0),
       },
       negY: {
-        origin: new Point(center.x, min.y - pad, center.z),
+        origin: new Point(center.x, center.y - pad, center.z),
         direction: new Vec3(0, 1, 0),
       },
       posZ: {
-        origin: new Point(center.x, center.y, max.z + pad),
+        origin: new Point(center.x, center.y, center.z + pad),
         direction: new Vec3(0, 0, -1),
       },
       negZ: {
-        origin: new Point(center.x, center.y, min.z - pad),
+        origin: new Point(center.x, center.y, center.z - pad),
         direction: new Vec3(0, 0, 1),
       },
     };
-    const maxDistance = diag + pad * 2;
 
     return probeIds.map((id) => {
       const spec = probeSpecs[id];
       return {
-        label: id,
+        label: prefixed(id),
         origin: spec.origin,
         direction: spec.direction,
         maxDistance,
@@ -359,6 +334,67 @@ export class Mesh {
     });
   }
 
+  private static buildBooleanDebugProbes(
+    inputA: Mesh,
+    inputB: Mesh,
+    result: Mesh,
+    options?: MeshBooleanDebugOptions,
+  ): MeshBooleanDebugProbe[] {
+    const boundsA = Mesh.toDebugBounds(inputA.getBounds());
+    const boundsB = Mesh.toDebugBounds(inputB.getBounds());
+    const resultBounds = Mesh.toDebugBounds(result.getBounds());
+    const min = new Point(
+      Math.min(boundsA.min.x, boundsB.min.x, resultBounds.min.x),
+      Math.min(boundsA.min.y, boundsB.min.y, resultBounds.min.y),
+      Math.min(boundsA.min.z, boundsB.min.z, resultBounds.min.z),
+    );
+    const max = new Point(
+      Math.max(boundsA.max.x, boundsB.max.x, resultBounds.max.x),
+      Math.max(boundsA.max.y, boundsB.max.y, resultBounds.max.y),
+      Math.max(boundsA.max.z, boundsB.max.z, resultBounds.max.z),
+    );
+    const center = new Point(
+      (min.x + max.x) * 0.5,
+      (min.y + max.y) * 0.5,
+      (min.z + max.z) * 0.5,
+    );
+    const diag = Math.max(
+      1e-6,
+      Math.hypot(max.x - min.x, max.y - min.y, max.z - min.z),
+    );
+    const padScale = Number.isFinite(options?.rayPaddingScale)
+      ? Math.max(0.01, options?.rayPaddingScale ?? 0.25)
+      : 0.25;
+    const pad = Math.max(1e-3, diag * padScale);
+    const maxHits = Mesh.clampDebugHitCount(options?.maxRayHits);
+    const probeIds = options?.probes?.length
+      ? options.probes
+      : Mesh.DEFAULT_BOOLEAN_DEBUG_PROBES;
+    const maxDistance = diag + pad * 2;
+    const sceneCenterProbes = Mesh.buildDirectionalDebugProbes(
+      inputA,
+      inputB,
+      result,
+      center,
+      pad,
+      maxDistance,
+      maxHits,
+      probeIds,
+    );
+    const inputBCenterProbes = Mesh.buildDirectionalDebugProbes(
+      inputA,
+      inputB,
+      result,
+      boundsB.center,
+      pad,
+      maxDistance,
+      maxHits,
+      probeIds,
+      "inputB",
+    );
+    return sceneCenterProbes.concat(inputBCenterProbes);
+  }
+
   private static createBooleanDebugReport(
     inputA: Mesh,
     inputB: Mesh,
@@ -376,6 +412,65 @@ export class Mesh {
     };
   }
 
+  private static roundDebugScalar(value: number): number {
+    return Number.isFinite(value) ? Number(value.toFixed(4)) : value;
+  }
+
+  private static summarizeDebugHit(hit: MeshDebugRayHit | undefined): {
+    point: { x: number; y: number; z: number };
+    normal: { x: number; y: number; z: number };
+    faceIndex: number;
+    distance: number;
+  } | null {
+    if (!hit) return null;
+    return {
+      point: {
+        x: Mesh.roundDebugScalar(hit.point.x),
+        y: Mesh.roundDebugScalar(hit.point.y),
+        z: Mesh.roundDebugScalar(hit.point.z),
+      },
+      normal: {
+        x: Mesh.roundDebugScalar(hit.normal.x),
+        y: Mesh.roundDebugScalar(hit.normal.y),
+        z: Mesh.roundDebugScalar(hit.normal.z),
+      },
+      faceIndex: hit.faceIndex,
+      distance: Mesh.roundDebugScalar(hit.distance),
+    };
+  }
+
+  private static summarizeDebugProbe(probe: MeshBooleanDebugProbe): {
+    label: string;
+    origin: { x: number; y: number; z: number };
+    direction: { x: number; y: number; z: number };
+    inputAFirst: ReturnType<typeof Mesh.summarizeDebugHit>;
+    inputBFirst: ReturnType<typeof Mesh.summarizeDebugHit>;
+    resultFirst: ReturnType<typeof Mesh.summarizeDebugHit>;
+    inputAHits: number;
+    inputBHits: number;
+    resultHits: number;
+  } {
+    return {
+      label: probe.label,
+      origin: {
+        x: Mesh.roundDebugScalar(probe.origin.x),
+        y: Mesh.roundDebugScalar(probe.origin.y),
+        z: Mesh.roundDebugScalar(probe.origin.z),
+      },
+      direction: {
+        x: Mesh.roundDebugScalar(probe.direction.x),
+        y: Mesh.roundDebugScalar(probe.direction.y),
+        z: Mesh.roundDebugScalar(probe.direction.z),
+      },
+      inputAFirst: Mesh.summarizeDebugHit(probe.inputAHits[0]),
+      inputBFirst: Mesh.summarizeDebugHit(probe.inputBHits[0]),
+      resultFirst: Mesh.summarizeDebugHit(probe.resultHits[0]),
+      inputAHits: probe.inputAHits.length,
+      inputBHits: probe.inputBHits.length,
+      resultHits: probe.resultHits.length,
+    };
+  }
+
   private static logSubtractDebugSuccess(
     inputA: Mesh,
     inputB: Mesh,
@@ -390,13 +485,30 @@ export class Mesh {
         "subtraction",
         { maxRayHits: 2, probes: ["posX", "negX", "posY"] },
       );
+      const probeSummary = report.probes.map((probe) => Mesh.summarizeDebugProbe(probe));
       console.log("[okgeometry-api] Mesh.subtract debug", {
         options: options ?? null,
         inputA: report.inputA,
         inputB: report.inputB,
         result: report.resultSummary,
-        probes: report.probes,
+        deltas: {
+          faceCount: report.resultSummary.faceCount - report.inputA.faceCount,
+          vertexCount: report.resultSummary.vertexCount - report.inputA.vertexCount,
+        },
+        probeSummary,
+        report,
+      });
+      console.log("[okgeometry-api] Mesh.subtract summary", {
+        inputAFaces: report.inputA.faceCount,
+        inputBFaces: report.inputB.faceCount,
+        resultFaces: report.resultSummary.faceCount,
+        inputAVerts: report.inputA.vertexCount,
+        inputBVerts: report.inputB.vertexCount,
+        resultVerts: report.resultSummary.vertexCount,
+        resultClosed: report.resultSummary.isClosedVolume,
+        resultTopology: report.resultSummary.topology,
       });
+      console.log("[okgeometry-api] Mesh.subtract probeSummary", probeSummary);
     } catch (debugError) {
       console.error("[okgeometry-api] Mesh.subtract debug logging failed", debugError);
     }