brep-io-kernel 1.0.0

package/src/BREP/SolidMethods/meshQueries.js

@@ -0,0 +1,264 @@
+/**
+ * Mesh queries and face utilities.
+ */
+
+/** Return the underlying MeshGL (fresh from Manifold so it reflects any CSG). */
+export function getMesh() {
+    return this._manifoldize().getMesh();
+}
+
+/** Build a cache: faceID -> array of triangle indices. */
+export function _ensureFaceIndex() {
+    if (this._faceIndex) return;
+    const mesh = this.getMesh();
+    const { triVerts, faceID } = mesh;
+    const triCount = (triVerts.length / 3) | 0;
+    const map = new Map();
+    if (faceID && faceID.length === triCount) {
+        for (let t = 0; t < triCount; t++) {
+            const id = faceID[t];
+            let arr = map.get(id);
+            if (!arr) { arr = []; map.set(id, arr); }
+            arr.push(t);
+        }
+    }
+    this._faceIndex = map;
+    try { if (mesh && typeof mesh.delete === 'function') mesh.delete(); } catch { }
+}
+
+/**
+ * Get all triangles belonging to a face by name.
+ * Returns objects with positions; also includes vertex indices.
+ */
+export function getFace(name) {
+    const id = this._faceNameToID.get(name);
+    if (id === undefined) return [];
+
+    this._ensureFaceIndex();
+    const mesh = this.getMesh();
+    const { vertProperties, triVerts } = mesh;
+    const tris = this._faceIndex.get(id) || [];
+
+    const out = [];
+    for (let idx = 0; idx < tris.length; idx++) {
+        const t = tris[idx];
+        const base = t * 3;
+        const i0 = triVerts[base + 0];
+        const i1 = triVerts[base + 1];
+        const i2 = triVerts[base + 2];
+
+        const p0 = [
+            vertProperties[i0 * 3 + 0],
+            vertProperties[i0 * 3 + 1],
+            vertProperties[i0 * 3 + 2],
+        ];
+        const p1 = [
+            vertProperties[i1 * 3 + 0],
+            vertProperties[i1 * 3 + 1],
+            vertProperties[i1 * 3 + 2],
+        ];
+        const p2 = [
+            vertProperties[i2 * 3 + 0],
+            vertProperties[i2 * 3 + 1],
+            vertProperties[i2 * 3 + 2],
+        ];
+
+        out.push({ faceName: name, indices: [i0, i1, i2], p1: p0, p2: p1, p3: p2 });
+    }
+    try { return out; } finally { try { if (mesh && typeof mesh.delete === 'function') mesh.delete(); } catch { } }
+}
+
+/**
+ * Enumerate faces with their triangles in one pass.
+ */
+export function getFaces(includeEmpty = false) {
+    this._ensureFaceIndex();
+    const mesh = this.getMesh();
+    const { vertProperties, triVerts } = mesh;
+
+    const out = [];
+    const nameToTris = new Map();
+    if (includeEmpty) {
+        for (const fname of this.getFaceNames()) nameToTris.set(fname, []);
+    }
+
+    for (const [id, triList] of this._faceIndex.entries()) {
+        const name = this._idToFaceName.get(id) || `FACE_${id}`;
+        let arr = nameToTris.get(name);
+        if (!arr) { arr = []; nameToTris.set(name, arr); }
+        for (let idx = 0; idx < triList.length; idx++) {
+            const t = triList[idx];
+            const base = t * 3;
+            const i0 = triVerts[base + 0];
+            const i1 = triVerts[base + 1];
+            const i2 = triVerts[base + 2];
+            const p0 = [
+                vertProperties[i0 * 3 + 0],
+                vertProperties[i0 * 3 + 1],
+                vertProperties[i0 * 3 + 2],
+            ];
+            const p1 = [
+                vertProperties[i1 * 3 + 0],
+                vertProperties[i1 * 3 + 1],
+                vertProperties[i1 * 3 + 2],
+            ];
+            const p2 = [
+                vertProperties[i2 * 3 + 0],
+                vertProperties[i2 * 3 + 1],
+                vertProperties[i2 * 3 + 2],
+            ];
+            arr.push({ faceName: name, indices: [i0, i1, i2], p1: p0, p2: p1, p3: p2 });
+        }
+    }
+
+    for (const [faceName, triangles] of nameToTris.entries()) {
+        out.push({ faceName, triangles });
+    }
+    return out;
+}
+
+/**
+ * Compute connected polylines for boundary edges between pairs of face labels.
+ */
+export function getBoundaryEdgePolylines() {
+    const mesh = this.getMesh();
+    try {
+        const { vertProperties, triVerts, faceID } = mesh;
+        const triCount = (triVerts.length / 3) | 0;
+        const nv = (vertProperties.length / 3) | 0;
+        const NV = BigInt(nv);
+        const ukey = (a, b) => {
+            const A = BigInt(a); const B = BigInt(b);
+            return A < B ? A * NV + B : B * NV + A;
+        };
+
+        const e2t = new Map(); // key -> [{id, a, b, tri}...]
+        for (let t = 0; t < triCount; t++) {
+            const id = faceID ? faceID[t] : undefined;
+            const base = t * 3;
+            const i0 = triVerts[base + 0], i1 = triVerts[base + 1], i2 = triVerts[base + 2];
+            const edges = [[i0, i1], [i1, i2], [i2, i0]];
+            for (let k = 0; k < 3; k++) {
+                const a = edges[k][0], b = edges[k][1];
+                const key = ukey(a, b);
+                let arr = e2t.get(key);
+                if (!arr) { arr = []; e2t.set(key, arr); }
+                arr.push({ id, a, b, tri: t });
+            }
+        }
+
+        const pairToEdges = new Map(); // pairKey(JSON '[nameA,nameB]') -> array of [u,v]
+        for (const [, arr] of e2t.entries()) {
+            if (arr.length !== 2) continue;
+            const a = arr[0], b = arr[1];
+            if (a.id === b.id) continue;
+            const nameA = this._idToFaceName.get(a.id) || `FACE_${a.id}`;
+            const nameB = this._idToFaceName.get(b.id) || `FACE_${b.id}`;
+            const pair = nameA < nameB ? [nameA, nameB] : [nameB, nameA];
+            const pairKey = JSON.stringify(pair);
+            let list = pairToEdges.get(pairKey);
+            if (!list) { list = []; pairToEdges.set(pairKey, list); }
+            const v0 = Math.min(a.a, a.b);
+            const v1 = Math.max(a.a, a.b);
+            list.push([v0, v1]);
+        }
+
+        const polylines = [];
+        for (const [pairKey, edges] of pairToEdges.entries()) {
+            const adj = new Map(); // v -> Set(neighbors)
+            const edgeVisited = new Set(); // `${min},${max}`
+            const ek = (u, v) => (u < v ? `${u},${v}` : `${v},${u}`);
+            for (const [u, v] of edges) {
+                if (!adj.has(u)) adj.set(u, new Set());
+                if (!adj.has(v)) adj.set(v, new Set());
+                adj.get(u).add(v);
+                adj.get(v).add(u);
+            }
+
+            const [faceA, faceB] = JSON.parse(pairKey);
+            let idx = 0;
+
+            const visitChainFrom = (start) => {
+                const chain = [];
+                let prev = -1;
+                let curr = start;
+                chain.push(curr);
+                while (true) {
+                    const nbrs = adj.get(curr) || new Set();
+                    let next = undefined;
+                    for (const n of nbrs) {
+                        const key = ek(curr, n);
+                        if (edgeVisited.has(key)) continue;
+                        if (n === prev) continue;
+                        next = n; edgeVisited.add(key); break;
+                    }
+                    if (next === undefined) break;
+                    prev = curr; curr = next; chain.push(curr);
+                }
+                return chain;
+            };
+
+            for (const [v, nbrs] of adj.entries()) {
+                if ((nbrs.size | 0) === 1) {
+                    const n = [...nbrs][0];
+                    const key = ek(v, n);
+                    if (edgeVisited.has(key)) continue;
+                    const chain = visitChainFrom(v);
+                    const positions = chain.map(vi => [
+                        vertProperties[vi * 3 + 0],
+                        vertProperties[vi * 3 + 1],
+                        vertProperties[vi * 3 + 2],
+                    ]);
+                    polylines.push({ name: `${faceA}|${faceB}[${idx++}]`, faceA, faceB, indices: chain, positions, closedLoop: false });
+                }
+            }
+
+            const buildLoopFromEdge = (startU, startV) => {
+                const chain = [startU, startV];
+                let prev = startU;
+                let curr = startV;
+                edgeVisited.add(ek(startU, startV));
+                while (true) {
+                    const nbrs = adj.get(curr) || new Set();
+                    let next = undefined;
+                    for (const n of nbrs) {
+                        if (n === prev) continue;
+                        const key = ek(curr, n);
+                        if (edgeVisited.has(key)) continue;
+                        next = n; break;
+                    }
+                    if (next === undefined) break;
+                    edgeVisited.add(ek(curr, next));
+                    chain.push(next);
+                    prev = curr; curr = next;
+                }
+                const start = chain[0];
+                const last = chain[chain.length - 1];
+                const nbrsLast = adj.get(last) || new Set();
+                if (nbrsLast.has(start)) {
+                    edgeVisited.add(ek(last, start));
+                    chain.push(start);
+                }
+                return chain;
+            };
+
+            for (const [u, nbrs] of adj.entries()) {
+                for (const v of nbrs) {
+                    const key = ek(u, v);
+                    if (edgeVisited.has(key)) continue;
+                    const chain = buildLoopFromEdge(u, v);
+                    const positions = chain.map(vi => [
+                        vertProperties[vi * 3 + 0],
+                        vertProperties[vi * 3 + 1],
+                        vertProperties[vi * 3 + 2],
+                    ]);
+                    const closed = chain.length >= 3 && chain[0] === chain[chain.length - 1];
+                    polylines.push({ name: `${faceA}|${faceB}[${idx++}]`, faceA, faceB, indices: chain, positions, closedLoop: closed });
+                }
+            }
+        }
+
+        return polylines;
+    } finally { try { if (mesh && typeof mesh.delete === 'function') mesh.delete(); } catch { } }
+}
+

package/src/BREP/SolidMethods/metadata.js

@@ -0,0 +1,106 @@
+/**
+ * Face and edge metadata helpers.
+ */
+
+/** Set metadata for a face (e.g., radius for cylindrical faces). */
+export function setFaceMetadata(faceName, metadata) {
+    if (!metadata || typeof metadata !== 'object') return this;
+    const existing = this.getFaceMetadata(faceName);
+    const base = existing && typeof existing === 'object' ? existing : {};
+    this._faceMetadata.set(faceName, { ...base, ...metadata });
+    return this;
+}
+
+/** Get metadata for a face. */
+export function getFaceMetadata(faceName) {
+    return this._faceMetadata.get(faceName) || {};
+}
+
+/** Convenience: list all face names present in this solid. */
+export function getFaceNames() {
+    return [...this._faceNameToID.keys()];
+}
+
+/** Rename a face; if newName exists, merge triangles/metadata into it. */
+export function renameFace(oldName, newName) {
+    if (!oldName || !newName || oldName === newName) return this;
+    const oldId = this._faceNameToID.get(oldName);
+    if (oldId === undefined) return this;
+
+    const newId = this._faceNameToID.get(newName);
+    const oldMeta = (this._faceMetadata && this._faceMetadata.get(oldName));
+    const newMeta = (this._faceMetadata && this._faceMetadata.get(newName));
+    const mergedMeta = (oldMeta || newMeta) ? { ...(oldMeta || {}), ...(newMeta || {}) } : null;
+
+    // Simple rename when the target name is unused (or maps to the same ID).
+    if (newId === undefined || newId === oldId) {
+        this._faceNameToID.delete(oldName);
+        this._faceNameToID.set(newName, oldId);
+        if (this._idToFaceName) this._idToFaceName.set(oldId, newName);
+        if (this._faceMetadata) {
+            if (mergedMeta) this._faceMetadata.set(newName, mergedMeta);
+            this._faceMetadata.delete(oldName);
+        }
+        return this;
+    }
+
+    // Merge: retarget all triangles using oldId to the existing newId.
+    let changed = false;
+    for (let i = 0; i < this._triIDs.length; i++) {
+        if (this._triIDs[i] === oldId) {
+            this._triIDs[i] = newId;
+            changed = true;
+        }
+    }
+
+    this._faceNameToID.delete(oldName);
+    if (this._idToFaceName) {
+        this._idToFaceName.delete(oldId);
+        this._idToFaceName.set(newId, newName);
+    }
+    if (this._faceMetadata) {
+        if (mergedMeta) this._faceMetadata.set(newName, mergedMeta);
+        this._faceMetadata.delete(oldName);
+    }
+    if (changed) {
+        this._dirty = true;
+        this._faceIndex = null;
+    }
+    return this;
+}
+
+/** Set metadata for an edge. */
+export function setEdgeMetadata(edgeName, metadata) {
+    if (!metadata || typeof metadata !== 'object') return this;
+    const existing = this.getEdgeMetadata(edgeName);
+    const base = existing && typeof existing === 'object' ? existing : {};
+    this._edgeMetadata.set(edgeName, { ...base, ...metadata });
+    return this;
+}
+
+/** Get metadata for an edge. */
+export function getEdgeMetadata(edgeName) {
+    return this._edgeMetadata.get(edgeName) || null;
+}
+
+/** Combine face metadata maps across two solids. */
+export function _combineFaceMetadata(other) {
+    const merged = new Map(this._faceMetadata);
+    if (other && other._faceMetadata) {
+        for (const [faceName, metadata] of other._faceMetadata.entries()) {
+            merged.set(faceName, { ...metadata });
+        }
+    }
+    return merged;
+}
+
+/** Combine edge metadata maps across two solids. */
+export function _combineEdgeMetadata(other) {
+    const merged = new Map(this._edgeMetadata);
+    if (other && other._edgeMetadata) {
+        for (const [edgeName, metadata] of other._edgeMetadata.entries()) {
+            merged.set(edgeName, { ...metadata });
+        }
+    }
+    return merged;
+}

package/src/BREP/SolidMethods/metrics.js

@@ -0,0 +1,51 @@
+/**
+ * Geometric measurements.
+ */
+import { computeTriangleArea } from '../triangleUtils.js';
+
+export function volume() {
+    const mesh = this.getMesh();
+    try {
+        const vp = mesh.vertProperties;
+        const tv = mesh.triVerts;
+        let vol6 = 0;
+        for (let t = 0; t < tv.length; t += 3) {
+            const i0 = tv[t] * 3, i1 = tv[t + 1] * 3, i2 = tv[t + 2] * 3;
+            const x0 = vp[i0], y0 = vp[i0 + 1], z0 = vp[i0 + 2];
+            const x1 = vp[i1], y1 = vp[i1 + 1], z1 = vp[i1 + 2];
+            const x2 = vp[i2], y2 = vp[i2 + 1], z2 = vp[i2 + 2];
+            vol6 += x0 * (y1 * z2 - z1 * y2)
+                - y0 * (x1 * z2 - z1 * x2)
+                + z0 * (x1 * y2 - y1 * x2);
+        }
+        return Math.abs(vol6) / 6.0;
+    } finally { try { if (mesh && typeof mesh.delete === 'function') mesh.delete(); } catch { } }
+}
+
+export function surfaceArea() {
+    const mesh = this.getMesh();
+    try {
+        const vp = mesh.vertProperties;
+        const tv = mesh.triVerts;
+        let area = 0;
+        for (let t = 0; t < tv.length; t += 3) {
+            const i0 = tv[t] * 3, i1 = tv[t + 1] * 3, i2 = tv[t + 2] * 3;
+            const ax = vp[i0], ay = vp[i0 + 1], az = vp[i0 + 2];
+            const bx = vp[i1], by = vp[i1 + 1], bz = vp[i1 + 2];
+            const cx = vp[i2], cy = vp[i2 + 1], cz = vp[i2 + 2];
+            area += computeTriangleArea(ax, ay, az, bx, by, bz, cx, cy, cz);
+        }
+        return area;
+    } finally { try { if (mesh && typeof mesh.delete === 'function') mesh.delete(); } catch { } }
+}
+
+/**
+ * Count triangles in the current mesh.
+ */
+export function getTriangleCount() {
+    const mesh = this.getMesh();
+    try {
+        const tv = mesh.triVerts;
+        return (tv.length / 3) | 0;
+    } finally { try { if (mesh && typeof mesh.delete === 'function') mesh.delete(); } catch { } }
+}