remesh-threejs 0.2.1 → 0.3.0

package/dist/remesh-threejs.js

@@ -4240,12 +4240,368 @@ function createRemesher(geometry, options = {}) {
   const mesh = NonManifoldMesh.fromBufferGeometry(geometry, options.featureEdges);
   return new AdaptiveRemesher(mesh, options);
 }
+class RepairOperation {
+  constructor(mesh, verbose = false) {
+    this.mesh = mesh;
+    this.verbose = verbose;
+  }
+  /**
+   * Execute the operation (detect + repair).
+   * @returns Operation statistics
+   */
+  execute() {
+    const startTime = performance.now();
+    const defectsFound = this.detect();
+    if (defectsFound === 0) {
+      return {
+        operation: this.getName(),
+        defectsFound: 0,
+        defectsFixed: 0,
+        timeMs: performance.now() - startTime,
+        success: true
+      };
+    }
+    const defectsFixed = this.repair();
+    const timeMs = performance.now() - startTime;
+    const result = {
+      operation: this.getName(),
+      defectsFound,
+      defectsFixed,
+      timeMs,
+      success: defectsFixed === defectsFound
+    };
+    if (defectsFixed < defectsFound) {
+      result.reason = `Only fixed ${defectsFixed}/${defectsFound} defects`;
+    }
+    return result;
+  }
+}
+class IsolatedVertexRepair extends RepairOperation {
+  constructor() {
+    super(...arguments);
+    this.isolatedVertices = [];
+  }
+  detect() {
+    this.isolatedVertices = [];
+    for (const vertex of this.mesh.vertices.values()) {
+      if (!vertex.halfedge || vertex.degree() === 0) {
+        this.isolatedVertices.push(vertex);
+      }
+    }
+    if (this.verbose && this.isolatedVertices.length > 0) {
+      console.log(`Found ${this.isolatedVertices.length} isolated vertices`);
+    }
+    return this.isolatedVertices.length;
+  }
+  repair() {
+    let fixedCount = 0;
+    for (const vertex of this.isolatedVertices) {
+      this.mesh.vertices.delete(vertex.id);
+      fixedCount++;
+    }
+    if (this.verbose && fixedCount > 0) {
+      console.log(`Removed ${fixedCount} isolated vertices`);
+    }
+    return fixedCount;
+  }
+  getName() {
+    return "Remove Isolated Vertices";
+  }
+  canParallelize() {
+    return this.isolatedVertices.length > 1e3;
+  }
+}
+class DegenerateFaceRepair extends RepairOperation {
+  constructor(mesh, verbose = false, areaThreshold = 1e-10) {
+    super(mesh, verbose);
+    this.degenerateFaces = [];
+    this.areaThreshold = areaThreshold;
+  }
+  detect() {
+    this.degenerateFaces = [];
+    for (const face of this.mesh.faces.values()) {
+      const vertices = face.getVertices();
+      if (!vertices || vertices.length !== 3) continue;
+      const [v0, v1, v2] = vertices;
+      if (v0.id === v1.id || v1.id === v2.id || v2.id === v0.id) {
+        this.degenerateFaces.push(face);
+        continue;
+      }
+      const area = triangleArea(v0.position, v1.position, v2.position);
+      if (area < this.areaThreshold) {
+        this.degenerateFaces.push(face);
+      }
+    }
+    if (this.verbose && this.degenerateFaces.length > 0) {
+      console.log(`Found ${this.degenerateFaces.length} degenerate faces`);
+    }
+    return this.degenerateFaces.length;
+  }
+  repair() {
+    let fixedCount = 0;
+    for (const face of this.degenerateFaces) {
+      const halfedges = face.getHalfedges();
+      if (!halfedges) continue;
+      this.mesh.faces.delete(face.id);
+      for (const he of halfedges) {
+        this.mesh.halfedges.delete(he.id);
+        he.edge.allHalfedges = he.edge.allHalfedges.filter((h) => h.id !== he.id);
+      }
+      fixedCount++;
+    }
+    if (this.verbose && fixedCount > 0) {
+      console.log(`Removed ${fixedCount} degenerate faces`);
+    }
+    return fixedCount;
+  }
+  getName() {
+    return "Remove Degenerate Faces";
+  }
+  canParallelize() {
+    return this.degenerateFaces.length > 1e3;
+  }
+}
+class DuplicateFaceRepair extends RepairOperation {
+  constructor() {
+    super(...arguments);
+    this.duplicates = /* @__PURE__ */ new Map();
+  }
+  detect() {
+    this.duplicates.clear();
+    const faceMap = /* @__PURE__ */ new Map();
+    for (const face of this.mesh.faces.values()) {
+      const vertices = face.getVertices();
+      if (!vertices) continue;
+      const key = this.makeFaceKey(vertices);
+      if (!faceMap.has(key)) {
+        faceMap.set(key, []);
+      }
+      faceMap.get(key).push(face);
+    }
+    let duplicateCount = 0;
+    for (const [key, faces] of faceMap) {
+      if (faces.length > 1) {
+        this.duplicates.set(key, faces);
+        duplicateCount += faces.length - 1;
+      }
+    }
+    if (this.verbose && duplicateCount > 0) {
+      console.log(`Found ${duplicateCount} duplicate faces in ${this.duplicates.size} groups`);
+    }
+    return duplicateCount;
+  }
+  repair() {
+    let fixedCount = 0;
+    for (const faces of this.duplicates.values()) {
+      for (let i = 1; i < faces.length; i++) {
+        const face = faces[i];
+        if (!face) continue;
+        this.mesh.faces.delete(face.id);
+        const halfedges = face.getHalfedges();
+        if (!halfedges) continue;
+        for (const he of halfedges) {
+          this.mesh.halfedges.delete(he.id);
+          he.edge.allHalfedges = he.edge.allHalfedges.filter((h) => h.id !== he.id);
+        }
+        fixedCount++;
+      }
+    }
+    if (this.verbose && fixedCount > 0) {
+      console.log(`Removed ${fixedCount} duplicate faces`);
+    }
+    return fixedCount;
+  }
+  /**
+   * Create canonical key from sorted vertex IDs.
+   */
+  makeFaceKey(vertices) {
+    const ids = vertices.map((v) => v.id).sort((a, b) => a - b);
+    return ids.join(",");
+  }
+  getName() {
+    return "Remove Duplicate Faces";
+  }
+  canParallelize() {
+    return false;
+  }
+}
+class MeshRepairer {
+  constructor(meshOrGeometry, options) {
+    this.operations = [];
+    if (meshOrGeometry instanceof NonManifoldMesh) {
+      this.mesh = meshOrGeometry;
+    } else {
+      this.mesh = NonManifoldMesh.fromBufferGeometry(meshOrGeometry);
+    }
+    this.options = {
+      useWorkers: (options == null ? void 0 : options.useWorkers) ?? (typeof navigator !== "undefined" && this.mesh.faces.size > ((options == null ? void 0 : options.parallelThreshold) ?? 1e4)),
+      workerCount: (options == null ? void 0 : options.workerCount) ?? (typeof navigator !== "undefined" ? navigator.hardwareConcurrency || 4 : 4),
+      useAcceleration: (options == null ? void 0 : options.useAcceleration) ?? true,
+      parallelThreshold: (options == null ? void 0 : options.parallelThreshold) ?? 1e4,
+      verbose: (options == null ? void 0 : options.verbose) ?? false,
+      validateAfterEach: (options == null ? void 0 : options.validateAfterEach) ?? false
+    };
+    this.stats = {
+      input: {
+        vertices: this.mesh.vertices.size,
+        faces: this.mesh.faces.size,
+        edges: this.mesh.edges.size
+      },
+      output: {
+        vertices: this.mesh.vertices.size,
+        faces: this.mesh.faces.size,
+        edges: this.mesh.edges.size
+      },
+      operations: [],
+      totalTimeMs: 0,
+      success: true,
+      totalDefectsFound: 0,
+      totalDefectsFixed: 0
+    };
+  }
+  /**
+   * Remove isolated vertices (vertices with no faces).
+   * @returns this for chaining
+   */
+  removeIsolatedVertices() {
+    this.operations.push(new IsolatedVertexRepair(this.mesh, this.options.verbose));
+    return this;
+  }
+  /**
+   * Remove zero-area and degenerate triangles.
+   * @param areaThreshold - Minimum area threshold (default: 1e-10)
+   * @returns this for chaining
+   */
+  removeDegenerateFaces(areaThreshold) {
+    this.operations.push(new DegenerateFaceRepair(this.mesh, this.options.verbose, areaThreshold));
+    return this;
+  }
+  /**
+   * Remove duplicate faces with identical vertices.
+   * @returns this for chaining
+   */
+  removeDuplicateFaces() {
+    this.operations.push(new DuplicateFaceRepair(this.mesh, this.options.verbose));
+    return this;
+  }
+  /**
+   * Run all common repairs in optimal order.
+   * @returns this for chaining
+   */
+  repairAll() {
+    this.removeIsolatedVertices();
+    this.removeDuplicateFaces();
+    this.removeDegenerateFaces();
+    return this;
+  }
+  /**
+   * Execute all queued operations.
+   * @returns Repair statistics
+   */
+  execute() {
+    const startTime = performance.now();
+    this.stats.operations = [];
+    this.stats.totalDefectsFound = 0;
+    this.stats.totalDefectsFixed = 0;
+    this.stats.success = true;
+    for (const operation of this.operations) {
+      const opStats = operation.execute();
+      this.stats.operations.push(opStats);
+      this.stats.totalDefectsFound += opStats.defectsFound;
+      this.stats.totalDefectsFixed += opStats.defectsFixed;
+      if (!opStats.success) {
+        this.stats.success = false;
+      }
+      if (this.options.validateAfterEach) {
+        const validation = validateTopology(this.mesh);
+        if (!validation.isValid) {
+          const errors = [...validation.errors, ...validation.warnings];
+          console.warn(`Topology validation failed after ${opStats.operation}:`, errors);
+          this.stats.success = false;
+        }
+      }
+    }
+    this.stats.totalTimeMs = performance.now() - startTime;
+    this.stats.output = {
+      vertices: this.mesh.vertices.size,
+      faces: this.mesh.faces.size,
+      edges: this.mesh.edges.size
+    };
+    this.operations = [];
+    return this.stats;
+  }
+  /**
+   * Get current statistics.
+   */
+  getStats() {
+    return this.stats;
+  }
+  /**
+   * Get the repaired mesh.
+   */
+  getMesh() {
+    return this.mesh;
+  }
+  /**
+   * Export to BufferGeometry.
+   */
+  toBufferGeometry() {
+    return exportBufferGeometry(this.mesh);
+  }
+  /**
+   * Validate the mesh after repairs.
+   */
+  validate() {
+    const validation = validateTopology(this.mesh);
+    return {
+      isValid: validation.isValid,
+      errors: [
+        ...validation.errors.map((e) => e.message),
+        ...validation.warnings.map((w) => w.message)
+      ]
+    };
+  }
+}
+function repairMesh(geometry, options) {
+  const repairer = new MeshRepairer(geometry, options);
+  const stats = repairer.repairAll().execute();
+  return {
+    geometry: repairer.toBufferGeometry(),
+    stats
+  };
+}
+function removeIsolatedVertices(geometry, options) {
+  const repairer = new MeshRepairer(geometry, options);
+  const stats = repairer.removeIsolatedVertices().execute();
+  return {
+    geometry: repairer.toBufferGeometry(),
+    stats
+  };
+}
+function removeDegenerateFaces(geometry, options) {
+  const repairer = new MeshRepairer(geometry, options);
+  const stats = repairer.removeDegenerateFaces(options == null ? void 0 : options.areaThreshold).execute();
+  return {
+    geometry: repairer.toBufferGeometry(),
+    stats
+  };
+}
+function removeDuplicateFaces(geometry, options) {
+  const repairer = new MeshRepairer(geometry, options);
+  const stats = repairer.removeDuplicateFaces().execute();
+  return {
+    geometry: repairer.toBufferGeometry(),
+    stats
+  };
+}
 export {
   AdaptiveRemesher,
   BVH,
   BufferGeometryExporter,
   BufferGeometryImporter,
   DEFAULT_REMESH_OPTIONS,
+  DegenerateFaceRepair,
+  DuplicateFaceRepair,
   Edge,
   EdgeContractor,
   EdgeFlipper,
@@ -4254,9 +4610,12 @@ export {
   Face,
   FeatureSkeleton,
   Halfedge,
+  IsolatedVertexRepair,
   ManifoldAnalyzer,
+  MeshRepairer,
   NonManifoldMesh,
   QualityMetrics,
+  RepairOperation,
   SkeletonBuilder,
   SkeletonConstraints,
   SkeletonSegment,
@@ -4336,6 +4695,10 @@ export {
   reclassifyVertices,
   relocateVertex,
   remesh,
+  removeDegenerateFaces,
+  removeDuplicateFaces,
+  removeIsolatedVertices,
+  repairMesh,
   scale,
   smoothAllVertices,
   smoothVertex,