remesh-threejs 0.3.0 → 0.3.1

package/dist/remesh-threejs.js

@@ -4425,6 +4425,435 @@ class DuplicateFaceRepair extends RepairOperation {
     return false;
   }
 }
+class NonManifoldEdgeRepair extends RepairOperation {
+  constructor(mesh, verbose = false, strategy = "auto") {
+    super(mesh, verbose);
+    this.nonManifoldEdges = [];
+    this.strategy = strategy;
+  }
+  detect() {
+    this.nonManifoldEdges = [];
+    for (const edge of this.mesh.edges.values()) {
+      if (edge.allHalfedges.length > 2) {
+        this.nonManifoldEdges.push(edge);
+      }
+    }
+    if (this.verbose && this.nonManifoldEdges.length > 0) {
+      console.log(`Found ${this.nonManifoldEdges.length} non-manifold edges`);
+    }
+    return this.nonManifoldEdges.length;
+  }
+  repair() {
+    let fixedCount = 0;
+    for (const edge of this.nonManifoldEdges) {
+      if (!this.mesh.edges.has(edge.id)) continue;
+      const repairStrategy = this.determineStrategy(edge);
+      if (repairStrategy === "split") {
+        if (this.splitNonManifoldEdge(edge)) {
+          fixedCount++;
+        }
+      } else {
+        if (this.collapseNonManifoldEdge(edge)) {
+          fixedCount++;
+        }
+      }
+    }
+    if (this.verbose && fixedCount > 0) {
+      console.log(`Repaired ${fixedCount} non-manifold edges`);
+    }
+    return fixedCount;
+  }
+  /**
+   * Determine which strategy to use for a specific edge.
+   */
+  determineStrategy(edge) {
+    if (this.strategy !== "auto") {
+      return this.strategy;
+    }
+    const avgEdgeLength = this.computeAverageEdgeLength();
+    const edgeLength = edge.length;
+    return edgeLength > avgEdgeLength ? "split" : "collapse";
+  }
+  /**
+   * Compute average edge length in the mesh.
+   */
+  computeAverageEdgeLength() {
+    let totalLength = 0;
+    let count = 0;
+    for (const edge of this.mesh.edges.values()) {
+      totalLength += edge.length;
+      count++;
+    }
+    return count > 0 ? totalLength / count : 1;
+  }
+  /**
+   * Split a non-manifold edge by duplicating vertices.
+   */
+  splitNonManifoldEdge(edge) {
+    try {
+      const [v0, v1] = edge.getVertices();
+      if (!v0 || !v1) return false;
+      const halfedges = [...edge.allHalfedges];
+      if (halfedges.length <= 2) return false;
+      for (let i = 2; i < halfedges.length; i++) {
+        const he = halfedges[i];
+        if (!he || !he.face) continue;
+        const newVertex = this.mesh.createVertex(v1.position.clone());
+        const faceVertices = he.face.getVertices();
+        if (!faceVertices) continue;
+        const vertexIndices = [];
+        for (const v of faceVertices) {
+          if (v.id === v1.id) {
+            vertexIndices.push(newVertex.id);
+          } else {
+            vertexIndices.push(v.id);
+          }
+        }
+        this.mesh.faces.delete(he.face.id);
+        const vertices = vertexIndices.map((id) => this.mesh.vertices.get(id));
+        if (!vertices[0] || !vertices[1] || !vertices[2]) continue;
+        this.mesh.createFace(vertices[0], vertices[1], vertices[2]);
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Collapse a non-manifold edge by removing excess faces.
+   */
+  collapseNonManifoldEdge(edge) {
+    try {
+      const halfedges = [...edge.allHalfedges];
+      if (halfedges.length <= 2) return false;
+      let removedCount = 0;
+      for (let i = 2; i < halfedges.length; i++) {
+        const he = halfedges[i];
+        if (!he || !he.face) continue;
+        this.mesh.faces.delete(he.face.id);
+        const faceHalfedges = he.face.getHalfedges();
+        if (faceHalfedges) {
+          for (const fhe of faceHalfedges) {
+            this.mesh.halfedges.delete(fhe.id);
+            fhe.edge.allHalfedges = fhe.edge.allHalfedges.filter((h) => h.id !== fhe.id);
+          }
+        }
+        removedCount++;
+      }
+      return removedCount > 0;
+    } catch {
+      return false;
+    }
+  }
+  getName() {
+    return "Remove Non-Manifold Edges";
+  }
+  canParallelize() {
+    return this.nonManifoldEdges.length > 100;
+  }
+}
+class HoleFiller extends RepairOperation {
+  constructor(mesh, verbose = false, maxHoleSize = 100, preserveBoundary = false) {
+    super(mesh, verbose);
+    this.holes = [];
+    this.maxHoleSize = maxHoleSize;
+    this.preserveBoundary = preserveBoundary;
+  }
+  detect() {
+    this.holes = [];
+    const boundaryEdges = [];
+    for (const edge of this.mesh.edges.values()) {
+      if (edge.allHalfedges.length === 1) {
+        boundaryEdges.push(edge);
+      }
+    }
+    if (boundaryEdges.length === 0) {
+      return 0;
+    }
+    this.holes = this.extractBoundaryLoops(boundaryEdges);
+    this.holes = this.holes.filter((hole) => hole.vertices.length <= this.maxHoleSize);
+    if (this.verbose && this.holes.length > 0) {
+      console.log(`Found ${this.holes.length} holes`);
+    }
+    return this.holes.length;
+  }
+  repair() {
+    if (this.preserveBoundary) {
+      return 0;
+    }
+    let fixedCount = 0;
+    for (const hole of this.holes) {
+      const triangles = this.triangulateBoundaryLoop(hole);
+      if (triangles.length > 0) {
+        for (const tri of triangles) {
+          try {
+            this.mesh.createFace(tri.v0, tri.v1, tri.v2);
+          } catch {
+            continue;
+          }
+        }
+        fixedCount++;
+      }
+    }
+    if (this.verbose && fixedCount > 0) {
+      console.log(`Filled ${fixedCount} holes`);
+    }
+    return fixedCount;
+  }
+  /**
+   * Extract boundary loops from a set of boundary edges.
+   */
+  extractBoundaryLoops(boundaryEdges) {
+    const loops = [];
+    const visited = /* @__PURE__ */ new Set();
+    for (const startEdge of boundaryEdges) {
+      if (visited.has(startEdge.id)) continue;
+      const loop = [];
+      const loopEdges = [];
+      let currentEdge = startEdge;
+      let iterations = 0;
+      const maxIterations = 1e4;
+      do {
+        if (iterations++ > maxIterations) break;
+        visited.add(currentEdge.id);
+        const [v0, v1] = currentEdge.getVertices();
+        if (!v0 || !v1) break;
+        loop.push(v0);
+        loopEdges.push(currentEdge);
+        const nextEdge = this.findNextBoundaryEdge(v1, currentEdge, boundaryEdges);
+        if (!nextEdge || nextEdge === startEdge) {
+          loop.push(v1);
+          break;
+        }
+        currentEdge = nextEdge;
+      } while (currentEdge !== startEdge);
+      if (loop.length >= 3) {
+        loops.push({ vertices: loop, edges: loopEdges });
+      }
+    }
+    return loops;
+  }
+  /**
+   * Find the next boundary edge connected to a vertex.
+   */
+  findNextBoundaryEdge(vertex, currentEdge, boundaryEdges) {
+    for (const edge of boundaryEdges) {
+      if (edge === currentEdge) continue;
+      const [v0, v1] = edge.getVertices();
+      if (!v0 || !v1) continue;
+      if (v0.id === vertex.id || v1.id === vertex.id) {
+        return edge;
+      }
+    }
+    return null;
+  }
+  /**
+   * Triangulate a boundary loop using ear clipping algorithm.
+   */
+  triangulateBoundaryLoop(loop) {
+    const triangles = [];
+    const vertices = [...loop.vertices];
+    let iterations = 0;
+    const maxIterations = vertices.length * vertices.length;
+    while (vertices.length > 3 && iterations++ < maxIterations) {
+      const earIndex = this.findEar(vertices);
+      if (earIndex === -1) {
+        break;
+      }
+      const prev = (earIndex - 1 + vertices.length) % vertices.length;
+      const next = (earIndex + 1) % vertices.length;
+      const v0 = vertices[prev];
+      const v1 = vertices[earIndex];
+      const v2 = vertices[next];
+      if (!v0 || !v1 || !v2) break;
+      triangles.push({ v0, v1, v2 });
+      vertices.splice(earIndex, 1);
+    }
+    if (vertices.length === 3) {
+      const v0 = vertices[0];
+      const v1 = vertices[1];
+      const v2 = vertices[2];
+      if (v0 && v1 && v2) {
+        triangles.push({ v0, v1, v2 });
+      }
+    }
+    return triangles;
+  }
+  /**
+   * Find an "ear" in the polygon (a triangle with no vertices inside).
+   */
+  findEar(vertices) {
+    const n = vertices.length;
+    for (let i = 0; i < n; i++) {
+      const prev = (i - 1 + n) % n;
+      const next = (i + 1) % n;
+      const v0 = vertices[prev];
+      const v1 = vertices[i];
+      const v2 = vertices[next];
+      if (!v0 || !v1 || !v2) continue;
+      const area = triangleArea(v0.position, v1.position, v2.position);
+      if (area < 1e-10) continue;
+      let isEar = true;
+      for (let j = 0; j < n; j++) {
+        if (j === prev || j === i || j === next) continue;
+        const vj = vertices[j];
+        if (!vj) continue;
+        if (isPointInTriangle(vj.position, v0.position, v1.position, v2.position)) {
+          isEar = false;
+          break;
+        }
+      }
+      if (isEar) {
+        return i;
+      }
+    }
+    return -1;
+  }
+  getName() {
+    return "Fill Holes";
+  }
+  canParallelize() {
+    return this.holes.length > 10;
+  }
+}
+class NormalUnifier extends RepairOperation {
+  constructor(mesh, verbose = false, seedFaceIndex = 0) {
+    super(mesh, verbose);
+    this.inconsistentFaces = [];
+    this.seedFaceIndex = seedFaceIndex;
+  }
+  detect() {
+    this.inconsistentFaces = [];
+    const faces = Array.from(this.mesh.faces.values());
+    if (faces.length === 0) return 0;
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [];
+    const seedFace = faces[this.seedFaceIndex] || faces[0];
+    if (!seedFace) return 0;
+    queue.push(seedFace);
+    visited.add(seedFace.id);
+    while (queue.length > 0) {
+      const face = queue.shift();
+      const neighbors = this.getNeighborFaces(face);
+      for (const neighbor of neighbors) {
+        const neighborId = neighbor.id;
+        if (visited.has(neighborId)) continue;
+        visited.add(neighborId);
+        const sharedEdge = this.getSharedEdge(face, neighbor);
+        if (sharedEdge && !this.areNormalsConsistent(face, neighbor, sharedEdge)) {
+          this.inconsistentFaces.push(neighbor);
+        }
+        queue.push(neighbor);
+      }
+    }
+    if (this.verbose && this.inconsistentFaces.length > 0) {
+      console.log(`Found ${this.inconsistentFaces.length} faces with inconsistent normals`);
+    }
+    return this.inconsistentFaces.length;
+  }
+  repair() {
+    let fixedCount = 0;
+    for (const face of this.inconsistentFaces) {
+      if (this.flipFaceOrientation(face)) {
+        fixedCount++;
+      }
+    }
+    if (this.verbose && fixedCount > 0) {
+      console.log(`Unified normals for ${fixedCount} faces`);
+    }
+    return fixedCount;
+  }
+  /**
+   * Get faces that share an edge with the given face.
+   */
+  getNeighborFaces(face) {
+    const neighbors = [];
+    const halfedges = face.getHalfedges();
+    if (!halfedges) return neighbors;
+    for (const he of halfedges) {
+      if (he.twin && he.twin.face && he.twin.face !== face) {
+        neighbors.push(he.twin.face);
+      }
+    }
+    return neighbors;
+  }
+  /**
+   * Find the edge shared between two faces.
+   */
+  getSharedEdge(face1, face2) {
+    const halfedges1 = face1.getHalfedges();
+    const halfedges2 = face2.getHalfedges();
+    if (!halfedges1 || !halfedges2) return null;
+    for (const he1 of halfedges1) {
+      for (const he2 of halfedges2) {
+        if (he1.edge === he2.edge) {
+          return he1.edge;
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Check if two faces have consistent normal orientation across their shared edge.
+   */
+  areNormalsConsistent(face1, face2, sharedEdge) {
+    const he1 = this.getHalfedgeInFace(face1, sharedEdge);
+    const he2 = this.getHalfedgeInFace(face2, sharedEdge);
+    if (!he1 || !he2) return true;
+    const [v1_start, v1_end] = this.getHalfedgeVertices(he1);
+    const [v2_start, v2_end] = this.getHalfedgeVertices(he2);
+    if (!v1_start || !v1_end || !v2_start || !v2_end) return true;
+    return v1_start.id === v2_end.id && v1_end.id === v2_start.id;
+  }
+  /**
+   * Get the halfedge in a face that corresponds to a given edge.
+   */
+  getHalfedgeInFace(face, edge) {
+    const halfedges = face.getHalfedges();
+    if (!halfedges) return null;
+    for (const he of halfedges) {
+      if (he.edge === edge) {
+        return he;
+      }
+    }
+    return null;
+  }
+  /**
+   * Get the start and end vertices of a halfedge.
+   */
+  getHalfedgeVertices(he) {
+    var _a;
+    return [he.vertex, ((_a = he.next) == null ? void 0 : _a.vertex) || null];
+  }
+  /**
+   * Flip the orientation of a face by reversing its halfedge order.
+   */
+  flipFaceOrientation(face) {
+    try {
+      const halfedges = face.getHalfedges();
+      if (!halfedges || halfedges.length !== 3) return false;
+      const [he0, he1, he2] = halfedges;
+      const temp0 = he0.next;
+      he0.next = he0.prev;
+      he0.prev = temp0;
+      const temp1 = he1.next;
+      he1.next = he1.prev;
+      he1.prev = temp1;
+      const temp2 = he2.next;
+      he2.next = he2.prev;
+      he2.prev = temp2;
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  getName() {
+    return "Unify Normals";
+  }
+  canParallelize() {
+    return false;
+  }
+}
 class MeshRepairer {
   constructor(meshOrGeometry, options) {
     this.operations = [];
@@ -4484,6 +4913,33 @@ class MeshRepairer {
     this.operations.push(new DuplicateFaceRepair(this.mesh, this.options.verbose));
     return this;
   }
+  /**
+   * Remove non-manifold edges by splitting or collapsing.
+   * @param strategy - Repair strategy: 'split', 'collapse', or 'auto' (default: 'auto')
+   * @returns this for chaining
+   */
+  removeNonManifoldEdges(strategy) {
+    this.operations.push(new NonManifoldEdgeRepair(this.mesh, this.options.verbose, strategy));
+    return this;
+  }
+  /**
+   * Fill boundary loops (holes) with triangulation.
+   * @param maxHoleSize - Maximum number of edges in a hole to fill (default: 100)
+   * @returns this for chaining
+   */
+  fillHoles(maxHoleSize) {
+    this.operations.push(new HoleFiller(this.mesh, this.options.verbose, maxHoleSize));
+    return this;
+  }
+  /**
+   * Unify face orientations to make normals consistent.
+   * @param seedFaceIndex - Index of the face to use as orientation reference (default: 0)
+   * @returns this for chaining
+   */
+  unifyNormals(seedFaceIndex) {
+    this.operations.push(new NormalUnifier(this.mesh, this.options.verbose, seedFaceIndex));
+    return this;
+  }
   /**
    * Run all common repairs in optimal order.
    * @returns this for chaining
@@ -4492,6 +4948,8 @@ class MeshRepairer {
     this.removeIsolatedVertices();
     this.removeDuplicateFaces();
     this.removeDegenerateFaces();
+    this.fillHoles();
+    this.unifyNormals();
     return this;
   }
   /**
@@ -4594,6 +5052,30 @@ function removeDuplicateFaces(geometry, options) {
     stats
   };
 }
+function removeNonManifoldEdges(geometry, options) {
+  const repairer = new MeshRepairer(geometry, options);
+  const stats = repairer.removeNonManifoldEdges(options == null ? void 0 : options.strategy).execute();
+  return {
+    geometry: repairer.toBufferGeometry(),
+    stats
+  };
+}
+function fillHoles(geometry, options) {
+  const repairer = new MeshRepairer(geometry, options);
+  const stats = repairer.fillHoles(options == null ? void 0 : options.maxHoleSize).execute();
+  return {
+    geometry: repairer.toBufferGeometry(),
+    stats
+  };
+}
+function unifyNormals(geometry, options) {
+  const repairer = new MeshRepairer(geometry, options);
+  const stats = repairer.unifyNormals(options == null ? void 0 : options.seedFaceIndex).execute();
+  return {
+    geometry: repairer.toBufferGeometry(),
+    stats
+  };
+}
 export {
   AdaptiveRemesher,
   BVH,
@@ -4610,10 +5092,13 @@ export {
   Face,
   FeatureSkeleton,
   Halfedge,
+  HoleFiller,
   IsolatedVertexRepair,
   ManifoldAnalyzer,
   MeshRepairer,
+  NonManifoldEdgeRepair,
   NonManifoldMesh,
+  NormalUnifier,
   QualityMetrics,
   RepairOperation,
   SkeletonBuilder,
@@ -4663,6 +5148,7 @@ export {
   exportClassificationGeometry,
   exportQualityGeometry,
   exportSkeletonGeometry,
+  fillHoles,
   flipEdge,
   fromVector3,
   getHighValenceVertices,
@@ -4698,6 +5184,7 @@ export {
   removeDegenerateFaces,
   removeDuplicateFaces,
   removeIsolatedVertices,
+  removeNonManifoldEdges,
   repairMesh,
   scale,
   smoothAllVertices,
@@ -4713,6 +5200,7 @@ export {
   triangleInradius,
   triangleNormal,
   triangleQuality,
+  unifyNormals,
   validateGeometry,
   validateTopology
 };