brep-io-kernel 1.0.0

package/src/BREP/SolidMethods/authoring.js

@@ -0,0 +1,112 @@
+import { Manifold } from "../SolidShared.js";
+
+/**
+ * Solid authoring helpers: vertex/face ID management and convenience geometry.
+ */
+
+/** Exact key for vertex uniquing (change to tolerance if needed). */
+export function _key([x, y, z]) {
+    return `${x},${y},${z}`;
+}
+
+/** Return the index of `p`, adding it to the vertex buffer if new. */
+export function _getPointIndex(p) {
+    // Validate that all coordinates are finite before adding to vertex buffer
+    if (!Array.isArray(p) || p.length < 3) {
+        console.error('Invalid point passed to _getPointIndex:', p);
+        throw new Error('Point must be an array with at least 3 elements');
+    }
+    
+    const x = p[0], y = p[1], z = p[2];
+    if (!isFinite(x) || !isFinite(y) || !isFinite(z)) {
+        console.error('Non-finite coordinates in _getPointIndex:', {x, y, z});
+        throw new Error(`Invalid point coordinates: (${x}, ${y}, ${z}) - must be finite numbers`);
+    }
+    
+    const k = this._key(p);
+    const found = this._vertKeyToIndex.get(k);
+    if (found !== undefined) return found;
+    const idx = this._vertProperties.length / 3;
+    this._vertProperties.push(x, y, z);
+    this._vertKeyToIndex.set(k, idx);
+    return idx;
+}
+
+/** Map face name to unique Manifold ID, creating one if absent. */
+export function _getOrCreateID(faceName) {
+    if (!this._faceNameToID.has(faceName)) {
+        const id = Manifold.reserveIDs(1); // globally unique, propagates through CSG
+        this._faceNameToID.set(faceName, id);
+        this._idToFaceName.set(id, faceName);
+    }
+    return this._faceNameToID.get(faceName);
+}
+
+/**
+ * Add a single triangle (CCW winding recommended).
+ * @param {string} faceName
+ * @param {[number,number,number]} v1
+ * @param {[number,number,number]} v2
+ * @param {[number,number,number]} v3
+ */
+export function addTriangle(faceName, v1, v2, v3) {
+    const id = this._getOrCreateID(faceName);
+    const i1 = this._getPointIndex(v1);
+    const i2 = this._getPointIndex(v2);
+    const i3 = this._getPointIndex(v3);
+    this._triVerts.push(i1, i2, i3);
+    this._triIDs.push(id);
+    this._dirty = true;
+    this._faceIndex = null;
+    return this;
+}
+
+/**
+ * Add a helper/auxiliary edge polyline to this solid (e.g., a centerline).
+ * @param {string} name Label for the edge
+ * @param {Array<[number,number,number]>} points Polyline points
+ * @param {object} [options]
+ * @param {boolean} [options.closedLoop=false] Render the edge as a closed loop when visualized
+ * @param {boolean} [options.polylineWorld=false] Whether the points are already in world space
+ * @param {'OVERLAY'|'BASE'|string} [options.materialKey='OVERLAY'] Material tag for visualization
+ */
+export function addAuxEdge(name, points, options = {}) {
+    try {
+        const toArr = (p) => {
+            if (Array.isArray(p) && p.length === 3) return [p[0], p[1], p[2]];
+            if (p && typeof p === 'object') {
+                const x = +p.x, y = +p.y, z = +p.z;
+                if (Number.isFinite(x) && Number.isFinite(y) && Number.isFinite(z)) return [x, y, z];
+            }
+            return null;
+        };
+        const pts = Array.isArray(points)
+            ? points.map(toArr).filter(Boolean)
+            : [];
+        if (pts.length < 2) return this;
+        const label = name || 'EDGE';
+        const hasCenterlineOption = Object.prototype.hasOwnProperty.call(options || {}, 'centerline');
+        const inferredCenterline = typeof label === 'string' && /centerline/i.test(label);
+        const centerline = hasCenterlineOption ? !!options.centerline : inferredCenterline;
+        const entry = {
+            name: label,
+            points: pts,
+            closedLoop: !!options.closedLoop,
+            polylineWorld: !!options.polylineWorld,
+            materialKey: options.materialKey || 'OVERLAY',
+            centerline,
+        };
+        if (!Array.isArray(this._auxEdges)) this._auxEdges = [];
+        this._auxEdges.push(entry);
+    } catch { /* ignore */ }
+    return this;
+}
+
+/** Convenience: add a two-point centerline. */
+export function addCenterline(a, b, name = 'CENTERLINE', options = {}) {
+    const A = Array.isArray(a) ? a : [a?.x || 0, a?.y || 0, a?.z || 0];
+    const B = Array.isArray(b) ? b : [b?.x || 0, b?.y || 0, b?.z || 0];
+    const opts = { ...(options || {}) };
+    if (!Object.prototype.hasOwnProperty.call(opts, 'centerline')) opts.centerline = true;
+    return this.addAuxEdge(name, [A, B], opts);
+}

package/src/BREP/SolidMethods/booleanOps.js

@@ -0,0 +1,230 @@
+import { Manifold } from "../SolidShared.js";
+
+/**
+ * Boolean operations and manifold reconstruction helpers.
+ */
+
+export function _combineIdMaps(other) {
+    const merged = new Map(this._idToFaceName);
+    for (const [id, name] of other._idToFaceName.entries()) {
+        merged.set(id, name);
+    }
+    return merged;
+}
+
+function _collapseFaceIdsByName(solid) {
+    if (!solid || !solid._faceNameToID || !solid._idToFaceName || !Array.isArray(solid._triIDs)) return;
+    const nameToId = solid._faceNameToID;
+    let changed = false;
+
+    for (let i = 0; i < solid._triIDs.length; i++) {
+        const id = solid._triIDs[i];
+        const name = solid._idToFaceName.get(id);
+        if (!name) continue;
+        const canonical = nameToId.get(name);
+        if (canonical !== undefined && canonical !== id) {
+            solid._triIDs[i] = canonical;
+            changed = true;
+        }
+    }
+
+    if (!changed) return;
+
+    solid._idToFaceName = new Map(
+        [...solid._faceNameToID.entries()].map(([name, id]) => [id, name]),
+    );
+    solid._faceIndex = null;
+    solid._dirty = true;
+    try { if (solid._manifold && typeof solid._manifold.delete === 'function') solid._manifold.delete(); } catch { }
+    solid._manifold = null;
+}
+
+function baseSolidCtor(obj) {
+    const ctor = obj && obj.constructor;
+    return (ctor && ctor.BaseSolid) ? ctor.BaseSolid : ctor;
+}
+
+export function union(other) {
+    const Solid = baseSolidCtor(this);
+    const outManifold = Manifold.union(this._manifoldize(), other._manifoldize());
+    const mergedMap = this._combineIdMaps(other);
+    const out = Solid._fromManifold(outManifold, mergedMap);
+    try { out.owningFeatureID = this?.owningFeatureID || other?.owningFeatureID || out?.owningFeatureID || null; } catch { }
+    try { out._auxEdges = [...(this._auxEdges || []), ...(other?._auxEdges || [])]; } catch { }
+    try { out._faceMetadata = this._combineFaceMetadata(other); } catch { }
+    try { out._edgeMetadata = this._combineEdgeMetadata(other); } catch { }
+    _collapseFaceIdsByName(out);
+    return out;
+}
+
+export function subtract(other) {
+    const Solid = baseSolidCtor(this);
+    const outManifold = this._manifoldize().subtract(other._manifoldize());
+
+    const mergedMap = this._combineIdMaps(other);
+    const out = Solid._fromManifold(outManifold, mergedMap);
+    try { out.owningFeatureID = this?.owningFeatureID || other?.owningFeatureID || out?.owningFeatureID || null; } catch { }
+    try { out._auxEdges = [...(this._auxEdges || []), ...(other?._auxEdges || [])]; } catch { }
+    try { out._faceMetadata = this._combineFaceMetadata(other); } catch { }
+    try { out._edgeMetadata = this._combineEdgeMetadata(other); } catch { }
+    _collapseFaceIdsByName(out);
+
+    return out;
+}
+
+export function intersect(other) {
+    const Solid = baseSolidCtor(this);
+    const outManifold = Manifold.intersection(this._manifoldize(), other._manifoldize());
+    const mergedMap = this._combineIdMaps(other);
+    const out = Solid._fromManifold(outManifold, mergedMap);
+    try { out.owningFeatureID = this?.owningFeatureID || other?.owningFeatureID || out?.owningFeatureID || null; } catch { }
+    try { out._auxEdges = [...(this._auxEdges || []), ...(other?._auxEdges || [])]; } catch { }
+    try { out._faceMetadata = this._combineFaceMetadata(other); } catch { }
+    try { out._edgeMetadata = this._combineEdgeMetadata(other); } catch { }
+    _collapseFaceIdsByName(out);
+    return out;
+}
+
+/**
+ * Boolean difference A − B using Manifold's built-in API.
+ * Equivalent to `subtract`, provided for semantic clarity.
+ */
+export function difference(other) {
+    const Solid = baseSolidCtor(this);
+    const outManifold = Manifold.difference(this._manifoldize(), other._manifoldize());
+    const mergedMap = this._combineIdMaps(other);
+    const out = Solid._fromManifold(outManifold, mergedMap);
+    try { out.owningFeatureID = this?.owningFeatureID || other?.owningFeatureID || out?.owningFeatureID || null; } catch { }
+    try { out._auxEdges = [...(this._auxEdges || []), ...(other?._auxEdges || [])]; } catch { }
+    try { out._faceMetadata = this._combineFaceMetadata(other); } catch { }
+    try { out._edgeMetadata = this._combineEdgeMetadata(other); } catch { }
+    _collapseFaceIdsByName(out);
+    return out;
+}
+
+export function setTolerance(tolerance) {
+    const Solid = baseSolidCtor(this);
+    const m = this._manifoldize();
+    const outM = m.setTolerance(tolerance);
+    const mapCopy = new Map(this._idToFaceName);
+    const out = Solid._fromManifold(outM, mapCopy);
+    try { out._auxEdges = Array.isArray(this._auxEdges) ? this._auxEdges.slice() : []; } catch { }
+    try { out._faceMetadata = new Map(this._faceMetadata); } catch { }
+    try { out._edgeMetadata = new Map(this._edgeMetadata); } catch { }
+    return out;
+}
+export function simplify(tolerance = undefined, updateInPlace = false) {
+    const Solid = this.constructor;
+    const m = this._manifoldize();
+
+    // Run simplify on the manifold
+    const outM = (tolerance === undefined) ? m.simplify() : m.simplify(tolerance);
+
+    // Read back the simplified mesh and update this Solid in-place
+    let meshOut = null;
+    try {
+        meshOut = outM.getMesh();
+
+        // Replace geometry arrays
+        this._numProp = meshOut.numProp;
+        this._vertProperties = Array.from(meshOut.vertProperties);
+        this._triVerts = Array.from(meshOut.triVerts);
+        this._triIDs = Solid._expandTriIDsFromMesh(meshOut);
+
+        // Rebuild vertex key map
+        this._vertKeyToIndex = new Map();
+        for (let i = 0; i < this._vertProperties.length; i += 3) {
+            const x = this._vertProperties[i + 0];
+            const y = this._vertProperties[i + 1];
+            const z = this._vertProperties[i + 2];
+            this._vertKeyToIndex.set(`${x},${y},${z}`, (i / 3) | 0);
+        }
+
+        // Keep existing face name map; best-effort completion for any new IDs
+        const completeMap = new Map(this._idToFaceName);
+        try {
+            const ids = meshOut.faceID && meshOut.faceID.length ? meshOut.faceID : null;
+            const triCount = (meshOut.triVerts?.length || 0) / 3 | 0;
+            if (ids && ids.length === triCount) {
+                const seen = new Set();
+                for (let t = 0; t < triCount; t++) {
+                    const id = ids[t] >>> 0;
+                    if (seen.has(id)) continue;
+                    seen.add(id);
+                    if (!completeMap.has(id)) completeMap.set(id, `FACE_${id}`);
+                }
+            } else if (!ids) {
+                if (!completeMap.has(0)) completeMap.set(0, 'FACE_0');
+            }
+        } catch { /* ignore */ }
+        this._idToFaceName = completeMap;
+        this._faceNameToID = new Map(
+            [...this._idToFaceName.entries()].map(([id, name]) => [name, id]),
+        );
+
+        // Replace cached manifold and reset caches
+        try { if (this._manifold && this._manifold !== outM && typeof this._manifold.delete === 'function') this._manifold.delete(); } catch { }
+        this._manifold = outM;
+        this._dirty = false;
+        this._faceIndex = null;
+    } finally {
+        try { if (meshOut && typeof meshOut.delete === 'function') meshOut.delete(); } catch { }
+    }
+
+    const returnObject = updateInPlace ? this : Solid._fromManifold(outM, this._idToFaceName);
+
+    this._manifoldize();
+    // Return the mutated Solid (chainable)
+    return returnObject;
+}
+
+export function _expandTriIDsFromMesh(mesh) {
+    if (mesh.faceID && mesh.faceID.length) {
+        return Array.from(mesh.faceID);
+    }
+    return new Array((mesh.triVerts.length / 3) | 0).fill(0);
+}
+
+export function _fromManifold(manifoldObj, idToFaceName) {
+    const Solid = this;
+    const mesh = manifoldObj.getMesh();
+    const solid = new Solid();
+
+    solid._numProp = mesh.numProp;
+    solid._vertProperties = Array.from(mesh.vertProperties);
+    solid._triVerts = Array.from(mesh.triVerts);
+    solid._triIDs = Solid._expandTriIDsFromMesh(mesh);
+
+    for (let i = 0; i < mesh.vertProperties.length; i += 3) {
+        const x = mesh.vertProperties[i + 0];
+        const y = mesh.vertProperties[i + 1];
+        const z = mesh.vertProperties[i + 2];
+        solid._vertKeyToIndex.set(`${x},${y},${z}`, i / 3);
+    }
+
+    const completeMap = new Map(idToFaceName);
+    try {
+        const ids = mesh.faceID && mesh.faceID.length ? mesh.faceID : null;
+        const triCount = (mesh.triVerts?.length || 0) / 3 | 0;
+        if (ids && ids.length === triCount) {
+            const seen = new Set();
+            for (let t = 0; t < triCount; t++) {
+                const id = ids[t] >>> 0;
+                if (seen.has(id)) continue;
+                seen.add(id);
+                if (!completeMap.has(id)) completeMap.set(id, `FACE_${id}`);
+            }
+        } else if (!ids) {
+            if (!completeMap.has(0)) completeMap.set(0, 'FACE_0');
+        }
+    } catch (_) { /* best-effort completion */ }
+
+    solid._idToFaceName = new Map(completeMap);
+    solid._faceNameToID = new Map(
+        [...solid._idToFaceName.entries()].map(([id, name]) => [name, id]),
+    );
+
+    solid._manifold = manifoldObj;
+    solid._dirty = false;
+    try { return solid; } finally { try { if (mesh && typeof mesh.delete === 'function') mesh.delete(); } catch { } }
+}

package/src/BREP/SolidMethods/chamfer.js

@@ -0,0 +1,122 @@
+// Solid.chamfer implementation: wraps ChamferSolid builder and applies booleans.
+import { resolveEdgesFromInputs } from './edgeResolution.js';
+
+/**
+ * Apply chamfers to this Solid and return a new Solid with the result.
+ *
+ * @param {Object} opts
+ * @param {number} opts.distance Required chamfer distance (> 0)
+ * @param {string[]} [opts.edgeNames] Optional edge names to chamfer
+ * @param {any[]} [opts.edges] Optional pre-resolved Edge objects (must belong to this Solid)
+ * @param {'INSET'|'OUTSET'|string} [opts.direction='INSET'] Boolean behavior (subtract vs union)
+ * @param {number} [opts.inflate=0.1] Grow/shrink chamfer tool (negated for OUTSET)
+ * @param {boolean} [opts.debug=false] Enable debug helpers on ChamferSolid
+ * @param {string} [opts.featureID='CHAMFER'] For naming of intermediates and result
+ * @param {number} [opts.sampleCount] Optional sampling override for chamfer strip
+ * @param {boolean} [opts.snapSeamToEdge] Snap seam to the edge
+ * @param {number} [opts.sideStripSubdiv] Side strip subdivisions
+ * @param {number} [opts.seamInsetScale] Inset scale for seam
+ * @param {boolean} [opts.flipSide] Flip side selection
+ * @param {number} [opts.debugStride] Sampling stride for debug output
+ * @returns {import('../BetterSolid.js').Solid}
+ */
+export async function chamfer(opts = {}) {
+  const { ChamferSolid } = await import("../chamfer.js");
+  const distance = Number(opts.distance);
+  if (!Number.isFinite(distance) || distance <= 0) {
+    throw new Error(`Solid.chamfer: distance must be > 0, got ${opts.distance}`);
+  }
+  const dir = String(opts.direction || 'INSET').toUpperCase();
+  const inflateRaw = Number.isFinite(opts.inflate) ? Number(opts.inflate) : 0.1;
+  const inflateForSolid = (dir === 'OUTSET') ? -inflateRaw : inflateRaw;
+  const debug = !!opts.debug;
+  const featureID = opts.featureID || 'CHAMFER';
+  console.log('[Solid.chamfer] Begin', {
+    featureID,
+    solid: this?.name,
+    distance,
+    direction: dir,
+    inflate: inflateRaw,
+    inflateApplied: inflateForSolid,
+    debug,
+    requestedEdgeNames: Array.isArray(opts.edgeNames) ? opts.edgeNames : [],
+    providedEdgeCount: Array.isArray(opts.edges) ? opts.edges.length : 0,
+  });
+
+  // Resolve edges from names and/or provided objects
+  const unique = resolveEdgesFromInputs(this, { edgeNames: opts.edgeNames, edges: opts.edges });
+  if (unique.length === 0) {
+    console.warn('[Solid.chamfer] No edges resolved on target solid; returning clone.', { featureID, solid: this?.name });
+    const c = this.clone();
+    try { c.name = this.name; } catch { }
+    return c;
+  }
+
+  const chamferSolids = [];
+  let idx = 0;
+  for (const e of unique) {
+    const name = `${featureID}_CHAMFER_${idx++}`;
+    try {
+      const chamfer = new ChamferSolid({
+        edgeToChamfer: e,
+        distance,
+        direction: dir,
+        inflate: inflateForSolid,
+        debug,
+        sampleCount: opts.sampleCount,
+        snapSeamToEdge: opts.snapSeamToEdge,
+        sideStripSubdiv: opts.sideStripSubdiv,
+        seamInsetScale: opts.seamInsetScale,
+        flipSide: opts.flipSide,
+        debugStride: opts.debugStride,
+      });
+      try { chamfer.name = name; } catch { }
+      chamferSolids.push(chamfer);
+    } catch (err) {
+      console.warn('[Solid.chamfer] Failed to build chamfer solid for edge', { edge: e?.name, error: err?.message || err });
+    }
+  }
+
+  if (chamferSolids.length === 0) {
+    console.error('[Solid.chamfer] All chamfer solids failed; returning clone.', { featureID, edgeCount: unique.length });
+    const c = this.clone();
+    try { c.name = this.name; } catch { }
+    return c;
+  }
+  console.log('[Solid.chamfer] Built chamfer solids for edges', chamferSolids.length);
+
+  // Apply to base solid (union for OUTSET, subtract for INSET)
+  let result = this;
+  for (const chamferSolid of chamferSolids) {
+    const beforeTri = Array.isArray(result?._triVerts) ? (result._triVerts.length / 3) : 0;
+    result = (dir === 'OUTSET') ? result.union(chamferSolid) : result.subtract(chamferSolid);
+    const afterTri = Array.isArray(result?._triVerts) ? (result._triVerts.length / 3) : 0;
+    console.log('[Solid.chamfer] Applied chamfer boolean', {
+      featureID,
+      operation: (dir === 'OUTSET') ? 'union' : 'subtract',
+      beforeTriangles: beforeTri,
+      afterTriangles: afterTri,
+    });
+    try { result.name = this.name; } catch { }
+  }
+
+  // Expose chamfer tool solids for debug/inspection (e.g., ChamferFeature)
+  try { result.__debugChamferSolids = chamferSolids; } catch { }
+
+  const finalTriCount = Array.isArray(result?._triVerts) ? (result._triVerts.length / 3) : 0;
+  const finalVertCount = Array.isArray(result?._vertProperties) ? (result._vertProperties.length / 3) : 0;
+  if (!result || finalTriCount === 0 || finalVertCount === 0) {
+    console.error('[Solid.chamfer] Chamfer result is empty or missing geometry.', {
+      featureID,
+      finalTriCount,
+      finalVertCount,
+      edgeCount: unique.length,
+      direction: dir,
+      inflate: inflateRaw,
+    });
+  } else {
+    console.log('[Solid.chamfer] Completed', { featureID, triangles: finalTriCount, vertices: finalVertCount });
+  }
+
+  return result;
+}

package/src/BREP/SolidMethods/edgeResolution.js

@@ -0,0 +1,25 @@
+export function resolveEdgesFromInputs(solid, { edgeNames, edges } = {}) {
+  const edgeObjs = [];
+  const wantNames = Array.isArray(edgeNames) ? Array.from(new Set(edgeNames.map(String))) : [];
+  if (wantNames.length) {
+    for (const ch of solid?.children || []) {
+      if (ch && ch.type === 'EDGE' && wantNames.includes(ch.name)) {
+        if (ch.parentSolid === solid || ch.parent === solid) edgeObjs.push(ch);
+      }
+    }
+  }
+  if (Array.isArray(edges)) {
+    for (const e of edges) {
+      if (e && (e.parentSolid === solid || e.parent === solid)) edgeObjs.push(e);
+    }
+  }
+  const unique = [];
+  const seen = new Set();
+  for (const e of edgeObjs) {
+    if (e && !seen.has(e)) {
+      seen.add(e);
+      unique.push(e);
+    }
+  }
+  return unique;
+}