@meshioplusplus/wasm 10.20.2 → 11.0.0

package/index.d.ts

@@ -7,6 +7,19 @@
  * A rectangular (uniform node count) group of cells, all the same meshio++
  * cell type.
  */
+/**
+ * What is wrong with a surface, in numbers rather than a bare flag -- the four
+ * counts `surfaceWatertightCheck`, `computeCurvature`, `repair` and
+ * `shrinkwrap` all report.
+ */
+export interface SurfaceQualityInfo {
+  boundaryEdges: number;
+  nonManifoldEdges: number;
+  inconsistentPairs: number;
+  degenerateTriangles: number;
+  watertight: boolean;
+}
+
 export interface RectangularCellBlock {
   /** meshio++ cell type name, e.g. "triangle", "tetra10", "hexahedron". */
   type: string;
@@ -1527,6 +1540,137 @@ export interface MeshioPlusPlusModule {
     minQualityAfter: number;
   };
 
+  /**
+   * Per-vertex mean (H) and Gaussian (K) curvature of a surface mesh -- the
+   * signed distance's natural companion as a node feature. K is the angle
+   * defect, H the cotangent Laplace-Beltrami operator. Writes
+   * `curvature:mean`/`curvature:gaussian` point data, optionally
+   * `curvature:area` and `curvature:principal`. `totalAngleDefect` is the
+   * Gauss-Bonnet oracle: `2*pi*chi` exactly for a CLOSED surface (`4*pi` for
+   * anything sphere-like), whatever the tessellation and whichever
+   * `dualArea`. H's sign is orientation-dependent and K's is not, so check
+   * `quality.inconsistentPairs` before trusting a sign. Never repairs its
+   * input. See doc/curvature.md.
+   * @throws {Error} on a non-surface input or an unknown region.
+   */
+  computeCurvature(
+    mesh: Mesh,
+    mean?: boolean,
+    gaussian?: boolean,
+    dualArea?: 'mixed-voronoi' | 'barycentric',
+    includeBoundary?: boolean,
+    recordArea?: boolean,
+    recordPrincipal?: boolean,
+    region?: string,
+  ): {
+    mesh: Mesh;
+    numBoundary: number;
+    numIsolated: number;
+    numDegenerate: number;
+    totalAngleDefect: number;
+    quality: {
+      boundaryEdges: number;
+      nonManifoldEdges: number;
+      inconsistentPairs: number;
+      degenerateTriangles: number;
+      watertight: boolean;
+    };
+  };
+
+  /**
+   * Surface repair beyond `clean`: weld (opt-in) -> triangulate -> split
+   * bowties -> orient by the topological half-edge rule per connected
+   * component -> fan-fill boundary loops of at most `maxHoleEdges` edges,
+   * wound to agree with the surrounding surface -> orient closed components
+   * outward. Lower-dimensional blocks ride along; fill triangles land in one
+   * trailing `triangle` block. Non-manifold EDGES are counted, never split.
+   * See doc/repair.md.
+   * @throws {Error} on a volume or higher-order input (naming the fix).
+   */
+  repair(
+    mesh: Mesh,
+    fixOrientation?: boolean,
+    orientOutward?: boolean,
+    fillHoles?: boolean,
+    splitNonManifold?: boolean,
+    maxHoleEdges?: number,
+    weldTolerance?: number,
+    recordProvenance?: boolean,
+  ): {
+    mesh: Mesh;
+    qualityBefore: SurfaceQualityInfo;
+    qualityAfter: SurfaceQualityInfo;
+    numFlipped: number;
+    numComponents: number;
+    largestComponent: number;
+    numOrientedOutward: number;
+    numUnorientable: number;
+    numVerticesSplit: number;
+    numHolesDetected: number;
+    numHolesFilled: number;
+    numHolesSkipped: number;
+    numFacesAdded: number;
+    numPointsAdded: number;
+    pointsWelded: number;
+  };
+
+  /**
+   * Project every (selected) point of `mesh` onto the surface of `target`:
+   * `x' = x + w (p + offset n - x)`, one projection, no iteration. Every
+   * point of the source moves whatever cells it carries; only the target must
+   * be a surface. The offset goes along the hit FEATURE's pseudonormal (the
+   * bisector at a crease), not the selected triangle's normal. `weights`
+   * names a point-data array on the source. See doc/shrinkwrap.md.
+   * @throws {Error} on an unusable target, region or weights array.
+   */
+  shrinkwrap(
+    mesh: Mesh,
+    target: Mesh,
+    offset?: number,
+    maxDistance?: number,
+    weights?: string,
+    targetRegion?: string,
+    normalWeight?: 'angle' | 'area',
+    recordDistance?: boolean,
+    recordClosestCell?: boolean,
+  ): {
+    mesh: Mesh;
+    quality: SurfaceQualityInfo;
+    numProjected: number;
+    numMissed: number;
+    numSkipped: number;
+    maxDisplacement: number;
+  };
+
+  /**
+   * Sobolev (Helmholtz-filtered) deformation: solve `(M + l^2 K) u = M d`
+   * over the mesh's own P1 operators and move the points by `u` -- a
+   * screened-Poisson low-pass filter of the raw displacement whose cutoff
+   * wavelength is `lengthScale`. Every top-dimensional block must be a linear
+   * simplex; lower-dimensional blocks ride along. Nothing is pinned by
+   * default. Non-convergence sets `converged` false and returns the last
+   * iterate. See doc/sobolev_deform.md.
+   * @throws {Error} on a missing array or a non-simplex block (naming the fix).
+   */
+  sobolevDeform(
+    mesh: Mesh,
+    array: string,
+    lengthScale: number,
+    fixedPointsArray?: string,
+    fixBoundary?: boolean,
+    recordFiltered?: boolean,
+    maxIterations?: number,
+    tolerance?: number,
+  ): {
+    mesh: Mesh;
+    numIterations: number;
+    residual: number;
+    converged: boolean;
+    numFixed: number;
+    numIsolated: number;
+    maxDisplacement: number;
+  };
+
   /** Partition a mesh into submeshes by type, connected component, or tag. */
   split(mesh: Mesh, by: SplitBy, tagName?: string): { key: string; mesh: Mesh }[];
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meshioplusplus/wasm",
-  "version": "10.20.2",
+  "version": "11.0.0",
   "description": "meshio++ mesh I/O compiled to WebAssembly: read/write 41 mesh formats (incl. MED, CGNS, Exodus) in the browser or Node.js",
   "type": "module",
   "main": "./src/index.mjs",

package/src/index.mjs

@@ -165,6 +165,10 @@ function resolveVariant(variant) {
  *   remesh: (mesh: Mesh, numClusters: number, subdivide?: number, subsampleRatio?: number, maxSubdivide?: number, maxIterations?: number, maxRepairPasses?: number, metric?: string, gradation?: number, preserveBoundary?: boolean, maxAnisotropy?: number) => {mesh: Mesh, numClusters: number, numIterations: number, subdivideApplied: number, numIsolatedClusters: number, numNonManifoldVertices: number},
  *   remeshVolume: (mesh: Mesh, resolution?: number[], cellSize?: number, bounds?: number[], padding?: number, paddingRelative?: number, maxCells?: number, maxTets?: number, warpFraction?: number, sign?: string, watertightCheck?: string) => {mesh: Mesh, numTets: number, numVerticesWarped: number, numTetsRejected: number, numNonManifoldEdges: number},
  *   optimizeVolume: (mesh: Mesh, maxIterations?: number, relocate?: boolean, flip?: boolean, preserveBoundary?: boolean, minImprovement?: number) => {mesh: Mesh, numFlips: number, num23Flips: number, num32Flips: number, numVerticesMoved: number, numTets: number, minQualityBefore: number, minQualityAfter: number},
+ *   computeCurvature: (mesh: Mesh, mean?: boolean, gaussian?: boolean, dualArea?: string, includeBoundary?: boolean, recordArea?: boolean, recordPrincipal?: boolean, region?: string) => {mesh: Mesh, numBoundary: number, numIsolated: number, numDegenerate: number, totalAngleDefect: number, quality: {boundaryEdges: number, nonManifoldEdges: number, inconsistentPairs: number, degenerateTriangles: number, watertight: boolean}},
+ *   repair: (mesh: Mesh, fixOrientation?: boolean, orientOutward?: boolean, fillHoles?: boolean, splitNonManifold?: boolean, maxHoleEdges?: number, weldTolerance?: number, recordProvenance?: boolean) => {mesh: Mesh, qualityBefore: object, qualityAfter: object, numFlipped: number, numComponents: number, largestComponent: number, numOrientedOutward: number, numUnorientable: number, numVerticesSplit: number, numHolesDetected: number, numHolesFilled: number, numHolesSkipped: number, numFacesAdded: number, numPointsAdded: number, pointsWelded: number},
+ *   shrinkwrap: (mesh: Mesh, target: Mesh, offset?: number, maxDistance?: number, weights?: string, targetRegion?: string, normalWeight?: string, recordDistance?: boolean, recordClosestCell?: boolean) => {mesh: Mesh, quality: object, numProjected: number, numMissed: number, numSkipped: number, maxDisplacement: number},
+ *   sobolevDeform: (mesh: Mesh, array: string, lengthScale: number, fixedPointsArray?: string, fixBoundary?: boolean, recordFiltered?: boolean, maxIterations?: number, tolerance?: number) => {mesh: Mesh, numIterations: number, residual: number, converged: boolean, numFixed: number, numIsolated: number, maxDisplacement: number},
  *   split: (mesh: Mesh, by: string, tagName?: string) => {key: string, mesh: Mesh}[],
  *   convertCells: (mesh: Mesh, mode?: string, recordParentIds?: boolean) => Mesh,
  *   subdivide: (mesh: Mesh, recordParentIds?: boolean) => Mesh,
@@ -545,6 +549,55 @@ export async function loadMeshioPlusPlus(moduleOverrides = {}, { variant = 'auto
         ) =>
             Module.optimizeVolume(mesh, maxIterations, relocate, flip, preserveBoundary,
                 minImprovement),
+        computeCurvature: (
+            mesh,
+            mean = true,
+            gaussian = true,
+            dualArea = 'mixed-voronoi',
+            includeBoundary = false,
+            recordArea = false,
+            recordPrincipal = false,
+            region = '',
+        ) =>
+            Module.computeCurvature(mesh, mean, gaussian, dualArea, includeBoundary,
+                recordArea, recordPrincipal, region),
+        repair: (
+            mesh,
+            fixOrientation = true,
+            orientOutward = true,
+            fillHoles = true,
+            splitNonManifold = true,
+            maxHoleEdges = 10,
+            weldTolerance = 0,
+            recordProvenance = false,
+        ) =>
+            Module.repair(mesh, fixOrientation, orientOutward, fillHoles, splitNonManifold,
+                maxHoleEdges, weldTolerance, recordProvenance),
+        shrinkwrap: (
+            mesh,
+            target,
+            offset = 0,
+            maxDistance = 0,
+            weights = '',
+            targetRegion = '',
+            normalWeight = 'angle',
+            recordDistance = false,
+            recordClosestCell = false,
+        ) =>
+            Module.shrinkwrap(mesh, target, offset, maxDistance, weights, targetRegion,
+                normalWeight, recordDistance, recordClosestCell),
+        sobolevDeform: (
+            mesh,
+            array,
+            lengthScale,
+            fixedPointsArray = '',
+            fixBoundary = false,
+            recordFiltered = false,
+            maxIterations = 128,
+            tolerance = 1e-10,
+        ) =>
+            Module.sobolevDeform(mesh, array, lengthScale, fixedPointsArray, fixBoundary,
+                recordFiltered, maxIterations, tolerance),
         split: (mesh, by, tagName = '') => Module.split(mesh, by, tagName),
         convertCells: (mesh, mode = 'linearize', recordParentIds = false) =>
             Module.convertCells(mesh, mode, recordParentIds),