@meshioplusplus/wasm 10.6.0 → 10.14.0

package/index.d.ts

@@ -302,6 +302,19 @@ export type OpSpec =
       output?: string;
       component?: number;
     }
+  | {
+      /**
+       * The Hessian (second derivative) of a scalar `point_data` field --
+       * `gradient`'s companion one order further, for curvature-based
+       * adaptive refinement. A pure data step: geometry is untouched and
+       * one new (n,9) array is attached.
+       */
+      op: 'hessian';
+      array: string;
+      method?: GradientMethod;
+      location?: 'point' | 'cell';
+      output?: string;
+    }
   | {
       /**
        * The ZZ recovery-based error indicator of a `point_data` field, plus
@@ -391,6 +404,9 @@ export type ErrorMethod = 'zz';
 /** `estimateError`'s marking policy. See doc/error.md. */
 export type ErrorMarking = 'none' | 'absolute' | 'fraction' | 'dorfler';
 
+/** `remesh`'s clustering objective. See doc/remesh.md. */
+export type RemeshMetric = 'isotropic' | 'quadric' | 'anisotropic';
+
 /** One data array's location: `point_data`, `cell_data`, or `field_data`. */
 export type DataLocation = 'point' | 'cell' | 'field';
 
@@ -428,8 +444,11 @@ export type MergeDataPolicy = 'intersection' | 'fill';
 /** Element-representation conversion performed by `convertCells`. */
 export type ConvertCellsMode = 'linearize' | 'simplexify' | 'elevate';
 
-/** Smoothing operator applied by `smooth`. `'taubin'` is shrink-free. */
-export type SmoothMethod = 'laplacian' | 'taubin';
+/** Smoothing operator applied by `smooth`. `'taubin'` is shrink-free.
+ *  `'odt'` (optimal-Delaunay-triangulation smoothing) is tet-only and
+ *  moves each free interior vertex toward the volume-weighted average of
+ *  its incident tets' circumcenters. See doc/smooth.md. */
+export type SmoothMethod = 'laplacian' | 'taubin' | 'odt';
 
 /**
  * How `refine` resolves the hanging nodes a partial refinement leaves behind.
@@ -494,6 +513,10 @@ export type InterpolateMethod = 'nearest' | 'barycentric';
  *  target: throw, replace, or write to `name + '_interp'`. */
 export type InterpolateOnConflict = 'error' | 'overwrite' | 'suffix';
 
+/** What `conservativeInterpolate` does when a transferred name already
+ *  exists on the target: throw, replace, or write to `name + '_interp'`. */
+export type ConservativeInterpolateOnConflict = 'error' | 'overwrite' | 'suffix';
+
 /** Partitioning backend: SFC is always available; KaHIP is never compiled
  *  into the WASM build, so `'kahip'` always throws and `'auto'` = `'sfc'`. */
 export type PartitionMethod = 'sfc' | 'kahip' | 'auto';
@@ -527,6 +550,41 @@ export interface DataArrayInfo {
   inconsistentBlocks: boolean;
 }
 
+/** Cell-measure-weighted reduction of one array over one set of cells (the
+ *  whole mesh, or one named Cell region) -- see `dataIntegrate`. */
+export interface FieldIntegralRegion {
+  /** The region's name; absent on the whole-mesh `domain` entry. */
+  name?: string;
+  /** Cells with a computable measure. */
+  numCells: number;
+  /** Cells excluded: unmeasurable geometry (ragged, unsupported type, or
+   *  degenerate). */
+  numSkipped: number;
+  /** `sum(value * |measure|)` over cells finite in component k. */
+  totalPerComponent: number[];
+  /** `totalPerComponent[k] / domainMeasurePerComponent[k]`, or NaN when that
+   *  denominator is zero. */
+  meanPerComponent: number[];
+  /** `sum(|measure|)` over cells finite in component k. */
+  domainMeasurePerComponent: number[];
+  /** Measurable cells excluded from component k because its value was
+   *  non-finite there. */
+  numNanPerComponent: number[];
+}
+
+/** One array's field integral, returned by `dataIntegrate` --
+ *  `gradient`'s integration counterpart. See doc/field_integration.md. */
+export interface FieldIntegralArray {
+  name: string;
+  numComponents: number;
+  /** The whole-mesh reduction. */
+  domain: FieldIntegralRegion;
+  /** One independent entry per named Cell region present on the mesh -- a
+   *  cell in two regions contributes fully to both, one in none contributes
+   *  to neither. */
+  regions: FieldIntegralRegion[];
+}
+
 /** Heavy-data layout of a transient XDMF series. */
 export type XdmfDataFormat = 'HDF' | 'XML' | 'Binary';
 
@@ -1014,6 +1072,29 @@ export interface MeshioPlusPlusModule {
     onConflict?: InterpolateOnConflict,
   ): Mesh;
 
+  /**
+   * Mass-preserving cross-mesh field transfer: an exact overlap-measure
+   * weighted remap, so that over the region the two meshes share,
+   * sum(target value * target measure) equals sum(source value * source
+   * measure) — the property `interpolate`'s `'barycentric'` mode does not
+   * have. Both meshes are simplexified first (accepting ragged/polyhedron
+   * blocks for free, unlike a restricted cell-type scope). Unlike
+   * `interpolate`, an empty `arrays` transfers every source point_data AND
+   * cell_data array — there is one algorithm regardless of location. Output
+   * arrays are always Float64.
+   * @throws {Error} on an unknown onConflict, an unknown array name, a name
+   *   collision under `'error'`, mismatched maximum topological dimensions
+   *   between the two meshes, or no triangle/tetrahedron cells on either
+   *   side after simplexification.
+   */
+  conservativeInterpolate(
+    source: Mesh,
+    target: Mesh,
+    arrays?: string[],
+    defaultValue?: number,
+    onConflict?: ConservativeInterpolateOnConflict,
+  ): Mesh;
+
   /**
    * Green-element undo: restore `fine`'s transitional (closure-only) cells
    * back to their original parent, read verbatim from `coarse` — a lookup,
@@ -1248,6 +1329,41 @@ export interface MeshioPlusPlusModule {
     overwrite?: boolean,
   ): { mesh: Mesh; numSkipped: number; numFallback: number };
 
+  /**
+   * The Hessian (second derivative) of a **scalar** `point_data` field --
+   * `gradient`'s companion one order further, for curvature-based adaptive
+   * refinement.
+   *
+   * A composition of TWO `gradient` calls, not a new numerical kernel: the
+   * field is differentiated once (point location), then that `(n, 3)`
+   * gradient is differentiated again with the default gradient operator,
+   * producing `(n, 9)` -- the flattened row-major 3x3 Hessian, `H[i][j]` at
+   * index `i*3+j`. `method` is forwarded to BOTH internal passes. The width
+   * travels with the array in the returned mesh's `point_data_components` /
+   * `cell_data_components` maps, exactly as `gradient`'s own output does.
+   *
+   * A field that is at most LINEAR has an exactly zero Hessian everywhere --
+   * the one mesh-shape-independent guarantee. For a genuinely quadratic
+   * field the composition is exact on a structured/symmetric mesh away from
+   * its own boundary and a good, standard, but genuinely approximate
+   * curvature estimate on an irregular mesh (see doc/hessian.md).
+   *
+   * A curvature-driven refinement indicator needs no new API: `norm(...)`
+   * in `dataCalc` on the 9-component output is exactly its Frobenius norm,
+   * ready for `refine`'s `where` selector.
+   * @throws {Error} when `array` names a `cell_data` array (piecewise
+   *   constant, so it has no derivative), an unknown array, or an array
+   *   with more than one component (hessian is scalar-only).
+   */
+  hessian(
+    mesh: Mesh,
+    array: string,
+    method?: GradientMethod,
+    location?: 'point' | 'cell',
+    output?: string,
+    overwrite?: boolean,
+  ): { mesh: Mesh; numSkipped: number; numFallback: number };
+
   /**
    * The Zienkiewicz-Zhu (ZZ) recovery-based error indicator of a `point_data`
    * field, plus optional marking. A composition of `gradient` (Green-Gauss,
@@ -1283,6 +1399,134 @@ export interface MeshioPlusPlusModule {
     overwrite?: boolean,
   ): { mesh: Mesh; globalError: number; numSkipped: number; numMarked: number };
 
+  /**
+   * Remesh a surface by approximated centroidal Voronoi diagram (ACVD)
+   * clustering: replace its triangulation with a new, near-uniformly-sized,
+   * well-shaped one at `numClusters` vertices. Unlike every other
+   * resolution-changing operation, the output has NEW points and NEW
+   * connectivity with no correspondence to the input — `point_data`,
+   * `cell_data` and named regions are dropped, `field_data` is carried.
+   *
+   * `metric` is `"isotropic"` (default; area-weighted centroidal distance,
+   * fast, rounds sharp features), `"quadric"` (Garland-Heckbert quadric
+   * error, preserves sharp edges/corners at extra cost per candidate move),
+   * or `"anisotropic"` (clusters shaped by a local curvature tensor —
+   * elongated along low-curvature directions, compact across sharp ones —
+   * see `maxAnisotropy`). `subdivide` defaults to automatic (`-1`): the
+   * smallest count of uniform `refine` passes reaching `subsampleRatio`
+   * items per cluster, capped at `maxSubdivide`; `0` disables subdivision.
+   * `gradation` is the curvature-gradation exponent `gamma` in the item
+   * weight `area * kappa^gamma` (`0.0`, the default, disables gradation
+   * entirely and reproduces plain area weighting). `preserveBoundary`
+   * (default `true`) detects the input's open boundary (if any), seeds it
+   * before the interior, and emits a `line` dual cell along boundary edges
+   * whose endpoints land in different clusters — a no-op on a closed mesh.
+   * `maxAnisotropy` (default `4.0`, a measured value) is, under
+   * `metric = "anisotropic"`, the maximum ratio between the two in-plane
+   * target edge lengths a curvature tensor may request; `1.0` recovers the
+   * isotropic shape exactly. Must be at least `1.0`, and an error to set
+   * away from the default under any other metric.
+   * `numIsolatedClusters` and `numNonManifoldVertices` are two distinct
+   * causes of non-manifold output (disconnected clusters vs. "bowtie"
+   * vertices) that repair could not fully fix; check both rather than
+   * assuming.
+   * @throws {Error} on a cluster count below 4 or above the subdivided
+   *   input's vertex count, or on any block outside the surface scope (3D
+   *   volume cells, higher-order cells, ragged polygon/polyhedron blocks).
+   */
+  remesh(
+    mesh: Mesh,
+    numClusters: number,
+    subdivide?: number,
+    subsampleRatio?: number,
+    maxSubdivide?: number,
+    maxIterations?: number,
+    maxRepairPasses?: number,
+    metric?: RemeshMetric,
+    gradation?: number,
+    preserveBoundary?: boolean,
+    maxAnisotropy?: number,
+  ): {
+    mesh: Mesh;
+    numClusters: number;
+    numIterations: number;
+    subdivideApplied: number;
+    numIsolatedClusters: number;
+    numNonManifoldVertices: number;
+  };
+
+  /**
+   * Retetrahedralize a volume mesh (or a closed surface) at a caller-chosen
+   * resolution by isosurface stuffing — the volumetric sibling of `remesh`.
+   * Unlike `remesh`, this accepts a VOLUME mesh directly (its boundary is
+   * extracted internally) as well as a closed surface. Same
+   * no-correspondence-with-the-input output contract as `remesh`: new
+   * points, new connectivity, `point_data`/`cell_data`/named regions
+   * dropped, `field_data` carried.
+   *
+   * Exactly one of `resolution`/`cellSize` must be given, sizing a body-
+   * centered cubic (BCC) lattice whose uncut tets have dihedral angles from
+   * a fixed, mesh-size-independent set. `warpFraction` (default `0.35`)
+   * moves lattice vertices near the surface onto it, trading a small,
+   * measured chance of non-manifold boundary edges (reported as
+   * `numNonManifoldEdges`) for substantially better boundary tet quality;
+   * `0` disables warping and gives an exactly watertight but lower-quality
+   * boundary. See doc/remesh_volume.md for the measured tradeoff.
+   * @throws {Error} when neither or both of `resolution`/`cellSize` are
+   *   set, on a non-positive resolution/cell size, on a negative
+   *   `warpFraction`, when the root lattice would exceed `maxCells`, when
+   *   the cut output would exceed `maxTets`, and on any input the boundary
+   *   extraction itself refuses.
+   */
+  remeshVolume(
+    mesh: Mesh,
+    resolution?: number[] | null,
+    cellSize?: number,
+    bounds?: number[] | null,
+    padding?: number,
+    paddingRelative?: number,
+    maxCells?: number,
+    maxTets?: number,
+    warpFraction?: number,
+    sign?: SdfSign,
+    watertightCheck?: SdfWatertightCheck,
+  ): {
+    mesh: Mesh;
+    numTets: number;
+    numVerticesWarped: number;
+    numTetsRejected: number;
+    numNonManifoldEdges: number;
+  };
+
+  /**
+   * ODT-remesh a tetrahedral mesh: raise its worst element quality by
+   * relocating vertices AND flipping connectivity (2-3/3-2, predicate-free).
+   * The genuine "ODT remeshing" sibling of `remeshVolume` (which generates a
+   * fresh lattice mesh) and of `smooth` method `"odt"` (which only moves
+   * points on fixed connectivity). Tet-only. The point set is invariant, so
+   * point_data/field_data and Point regions carry; cell_data + Cell/Side
+   * regions are dropped. With `preserveBoundary` the boundary surface is
+   * exactly preserved. See doc/optimize_volume.md.
+   * @throws {Error} when the mesh contains a non-`tetra` block or no tetra.
+   */
+  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;
+  };
+
   /** Partition a mesh into submeshes by type, connected component, or tag. */
   split(mesh: Mesh, by: SplitBy, tagName?: string): { key: string; mesh: Mesh }[];
 
@@ -1472,6 +1716,14 @@ export interface MeshioPlusPlusModule {
   /** Read-only per-array summary of every data array the mesh carries. */
   dataInfo(mesh: Mesh): DataArrayInfo[];
 
+  /**
+   * Cell-measure-weighted total/mean of one or more cell_data arrays --
+   * gradient's integration counterpart. `arrays` empty/undefined means
+   * every cell_data array. A point_data-only name throws naming
+   * dataPointToCell as the fix. See doc/field_integration.md.
+   */
+  dataIntegrate(mesh: Mesh, arrays?: string[]): FieldIntegralArray[];
+
   /**
    * Open a transient (time-series) XDMF writer on the virtual filesystem --
    * the one stateful object in this API. See {@link XdmfTimeSeriesWriter} for

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meshioplusplus/wasm",
-  "version": "10.6.0",
+  "version": "10.14.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

@@ -160,7 +160,11 @@ function resolveVariant(variant) {
  *   distanceToSurface: (query: Mesh, surface: Mesh, sign?: string, location?: string, band?: number, recordInside?: boolean, watertightCheck?: string) => {mesh: Mesh, numBanded: number, quality: object},
  *   computeSdf: (surface: Mesh, structure?: string, resolution?: number[], cellSize?: number, bounds?: number[], padding?: number, paddingRelative?: number, rootResolution?: number, maxDepth?: number, bandCells?: number, recordLevels?: boolean, maxCells?: number, sign?: string, location?: string, band?: number, watertightCheck?: string) => {mesh: Mesh, dims: number[], origin: number[], spacing: number[], maxDepth: number, numBanded: number, quality: object},
  *   gradient: (mesh: Mesh, array: string, operator?: string, method?: string, location?: string, output?: string, component?: number, overwrite?: boolean) => {mesh: Mesh, numSkipped: number, numFallback: number},
+ *   hessian: (mesh: Mesh, array: string, method?: string, location?: string, output?: string, overwrite?: boolean) => {mesh: Mesh, numSkipped: number, numFallback: number},
  *   estimateError: (mesh: Mesh, array: string, method?: string, marking?: string, markingValue?: number, output?: string, marked?: string, overwrite?: boolean) => {mesh: Mesh, globalError: number, numSkipped: number, numMarked: number},
+ *   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},
  *   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,
@@ -177,6 +181,7 @@ function resolveVariant(variant) {
  *   dataCalc: (mesh: Mesh, expression: string, location: string, outputName: string, overwrite?: boolean) => Mesh,
  *   dataCondition: (mesh: Mesh, location: string, names?: string[], mode?: string, lo?: number, hi?: number, scope?: string, nanPolicy?: string, nanReplacement?: number, suffix?: string) => Mesh,
  *   dataInfo: (mesh: Mesh) => object[],
+ *   dataIntegrate: (mesh: Mesh, arrays?: string[]) => object[],
  *   createXdmfTimeSeriesWriter: (path: string, options?: {dataFormat?: string, gzipLevel?: number, mode?: 'truncate'|'append', autoFlush?: boolean}) => XdmfTimeSeriesWriter,
  * }>}
  */
@@ -355,6 +360,23 @@ export async function loadMeshioPlusPlus(moduleOverrides = {}, { variant = 'auto
                 defaultValue,
                 onConflict,
             ),
+        // Mass-preserving cross-mesh field transfer: an exact overlap-measure
+        // weighted remap (unlike interpolate's pointwise sampling). An empty
+        // `arrays` = every source point_data AND cell_data array.
+        conservativeInterpolate: (
+            source,
+            target,
+            arrays = [],
+            defaultValue = 0,
+            onConflict = 'error',
+        ) =>
+            Module.conservativeInterpolate(
+                source,
+                target,
+                arrays,
+                defaultValue,
+                onConflict,
+            ),
         // Restore `fine`'s transitional (green) cells to their coarse parent,
         // read verbatim from `coarse` (a lookup, not a reconstruction).
         undoGreen: (coarse, fine) => Module.undoGreen(coarse, fine),
@@ -437,6 +459,14 @@ export async function loadMeshioPlusPlus(moduleOverrides = {}, { variant = 'auto
             overwrite = false,
         ) =>
             Module.gradient(mesh, array, operator, method, location, output, component, overwrite),
+        hessian: (
+            mesh,
+            array,
+            method = 'green-gauss',
+            location = 'cell',
+            output = '',
+            overwrite = false,
+        ) => Module.hessian(mesh, array, method, location, output, overwrite),
         estimateError: (
             mesh,
             array,
@@ -457,6 +487,57 @@ export async function loadMeshioPlusPlus(moduleOverrides = {}, { variant = 'auto
                 marked,
                 overwrite,
             ),
+        remesh: (
+            mesh,
+            numClusters,
+            subdivide = -1,
+            subsampleRatio = 10.0,
+            maxSubdivide = 4,
+            maxIterations = 100,
+            maxRepairPasses = 10,
+            metric = 'isotropic',
+            gradation = 0.0,
+            preserveBoundary = true,
+            maxAnisotropy = 4.0,
+        ) =>
+            Module.remesh(
+                mesh,
+                numClusters,
+                subdivide,
+                subsampleRatio,
+                maxSubdivide,
+                maxIterations,
+                maxRepairPasses,
+                metric,
+                gradation,
+                preserveBoundary,
+                maxAnisotropy,
+            ),
+        remeshVolume: (
+            mesh,
+            resolution = null,
+            cellSize = 0,
+            bounds = null,
+            padding = 0,
+            paddingRelative = 0.1,
+            maxCells = 20000000,
+            maxTets = 20000000,
+            warpFraction = 0.35,
+            sign = 'pseudonormal',
+            watertightCheck = 'warn',
+        ) =>
+            Module.remeshVolume(mesh, resolution, cellSize, bounds, padding, paddingRelative,
+                maxCells, maxTets, warpFraction, sign, watertightCheck),
+        optimizeVolume: (
+            mesh,
+            maxIterations = 10,
+            relocate = true,
+            flip = true,
+            preserveBoundary = true,
+            minImprovement = 1e-6,
+        ) =>
+            Module.optimizeVolume(mesh, maxIterations, relocate, flip, preserveBoundary,
+                minImprovement),
         split: (mesh, by, tagName = '') => Module.split(mesh, by, tagName),
         convertCells: (mesh, mode = 'linearize', recordParentIds = false) =>
             Module.convertCells(mesh, mode, recordParentIds),
@@ -547,6 +628,7 @@ export async function loadMeshioPlusPlus(moduleOverrides = {}, { variant = 'auto
                 mesh, location, names, mode, lo, hi, scope, nanPolicy, nanReplacement, suffix,
             ),
         dataInfo: (mesh) => Module.dataInfo(mesh),
+        dataIntegrate: (mesh, arrays = []) => Module.dataIntegrate(mesh, arrays),
         // Transient (time-series) XDMF -- the one *stateful* thing in this API.
         // The raw binding is an opaque integer handle plus seven free
         // functions (see bindings/wasm/js_bindings.cpp for why it is not an