@meshioplusplus/wasm 16.21.0 → 16.25.0

package/index.d.ts

@@ -20,6 +20,40 @@ export interface SurfaceQualityInfo {
   watertight: boolean;
 }
 
+/** Names one region: its name plus, optionally, its kind, dimension and tag. */
+export interface RegionSelector {
+  name: string;
+  kind?: 'point' | 'cell' | 'side';
+  dim?: number;
+  tag?: number;
+}
+
+/** One `editRegions` edit. */
+export interface RegionEdit {
+  op: 'union' | 'intersection' | 'difference' | 'rename' | 'retag' | 'delete';
+  inputs: Array<string | RegionSelector>;
+  output?: string;
+  dim?: number;
+  tag?: number;
+  keepInputs?: boolean;
+}
+
+/** `agglomerate`'s options (see doc/agglomerate.md). */
+export interface AgglomerateOptions {
+  mergeCoplanarFaces?: boolean;
+  coplanarAngle?: number;
+  minSphericity?: number;
+}
+
+/** `resampleSequence`'s options: the settings document's `Resample` object. */
+export interface ResampleOptions {
+  Times?: number[] | { Start: number; Stop: number; Step: number };
+  TimesFrom?: string;
+  Method?: 'linear' | 'nearest' | 'previous';
+  Extrapolate?: 'error' | 'clamp';
+  BlendPoints?: boolean;
+}
+
 /**
  * A `point_data`/`cell_data`/`field_data` array's JS type: it carries its
  * source dtype crossing the WASM boundary instead of always widening to
@@ -1192,6 +1226,34 @@ export interface MeshioPlusPlusModule {
    *
    * @returns the number of steps written.
    */
+  /**
+   * Resample `source` onto new times and write it to `outPath`: one file per
+   * target time when it carries `{step}`/`{index}`, else one series file.
+   * `resample` is the settings document's `Resample` object. At most two
+   * source meshes are alive at once. See doc/sequences.md.
+   *
+   * @returns the number of target times written.
+   */
+  resampleSequence(
+    source: string | string[],
+    outPath: string,
+    resample: ResampleOptions,
+    outFormat?: string,
+    options?: {
+      format?: string;
+      times?: number[];
+      timeFrom?: 'auto' | 'file' | 'filename' | 'index';
+      sort?: boolean;
+    },
+  ): number;
+
+  /**
+   * `a` with every floating-point data array replaced by `(1 - w) a + w b`
+   * (integer data from the nearer step); both steps must share a topology.
+   * `blendPoints` blends the coordinates too.
+   */
+  blendSteps(a: Mesh, b: Mesh, w: number, blendPoints?: boolean): Mesh;
+
   sequenceToTimeseries(
     source: string | string[],
     outPath: string,
@@ -1942,6 +2004,125 @@ export interface MeshioPlusPlusModule {
     quality: SurfaceQualityInfo;
   };
 
+  /**
+   * Quality gate: score every cell and test the `require` thresholds (text
+   * such as `'scaled_jacobian >= 0.2; aspect_ratio <= 5 @ 1%'`) plus the
+   * inverted and degenerate cell counts (`maxInverted`/`maxDegenerate`,
+   * default 0, negative disables). `summary` is the text both CLIs print. See
+   * doc/mesh_quality.md.
+   * @throws {Error} on a malformed specification or an unknown metric.
+   */
+  checkQuality(
+    mesh: Mesh,
+    require?: string,
+    maxInverted?: number,
+    maxDegenerate?: number,
+  ): {
+    passed: boolean;
+    numCells: number;
+    numInverted: number;
+    numDegenerate: number;
+    checks: Array<{
+      name: string;
+      metric: string;
+      min: number;
+      max: number;
+      maxFraction: number;
+      evaluated: number;
+      violations: number;
+      fraction: number;
+      worst: number;
+      worstCell: number;
+      passed: boolean;
+    }>;
+    summary: string;
+  };
+
+  /**
+   * The sharp, open, non-manifold and inconsistently wound edges of a surface
+   * (or of a volume mesh's skin) as a mesh of `line` cells over the input's
+   * points, with cell data `feature:kind` (1 feature, 2 boundary,
+   * 3 non-manifold, 4 inconsistent) and `feature:angle` (degrees). The counts
+   * cover the whole surface, selected or not. See doc/feature_edges.md.
+   * @throws {Error} on an angle outside [0, 180] or an unknown region.
+   */
+  featureEdges(
+    mesh: Mesh,
+    featureAngle?: number,
+    feature?: boolean,
+    boundary?: boolean,
+    nonManifold?: boolean,
+    inconsistent?: boolean,
+    region?: string,
+  ): {
+    mesh: Mesh;
+    numFeature: number;
+    numBoundary: number;
+    numNonManifold: number;
+    numInconsistent: number;
+  };
+
+  /**
+   * The (sampled) Hausdorff distance between the surfaces of two meshes; a
+   * volume mesh contributes its skin. `faceSamples = s > 0` also samples the
+   * centroids of the `s*s` sub-triangles of every triangle (vertices alone
+   * give a lower bound). See doc/hausdorff.md.
+   * @throws {Error} when a mesh has no surface triangles.
+   */
+  hausdorffDistance(
+    a: Mesh,
+    b: Mesh,
+    faceSamples?: number,
+    regionA?: string,
+    regionB?: string,
+  ): {
+    distance: number;
+    aToB: number;
+    bToA: number;
+    meanAToB: number;
+    rmsAToB: number;
+    meanBToA: number;
+    rmsBToA: number;
+    numSamplesA: number;
+    numSamplesB: number;
+    worstPointA: Float64Array;
+    worstPointB: Float64Array;
+  };
+
+  /**
+   * Apply region edits, in order, to a copy of `mesh` (points, cells and data
+   * untouched): `union`, `intersection`, `difference` (two or more inputs of
+   * one kind, result named `output`), `rename`, `retag` (`tag`/`dim`) and
+   * `delete`. An input names exactly one region; pin `kind`/`dim`/`tag` when a
+   * name is shared. See doc/regions.md.
+   * @throws {Error} on a missing or ambiguous region, mixed kinds, or a result
+   *   that would replace an unrelated region.
+   */
+  editRegions(mesh: Mesh, edits: RegionEdit | RegionEdit[]): Mesh;
+
+  /**
+   * The master node each node of the `slave` region maps onto under the
+   * row-major 4x4 affine `matrix` (16 numbers), within `atol`. `slave` is
+   * ascending and `master` aligned with it (0-based point ids). See
+   * doc/periodic.md.
+   * @throws {Error} on a master claimed twice or, with `requireComplete`, an
+   *   unmatched slave node.
+   */
+  matchPeriodicNodes(
+    mesh: Mesh,
+    slave: string | RegionSelector,
+    master: string | RegionSelector,
+    matrix: ArrayLike<number>,
+    atol?: number,
+    requireComplete?: boolean,
+  ): {
+    slave: Int32Array;
+    master: Int32Array;
+    unmatched: Int32Array;
+    numFixed: number;
+    maxResidual: number;
+  };
+
   /**
    * Surface repair beyond `clean`: weld (opt-in) -> triangulate -> split
    * bowties -> orient by the topological half-edge rule per connected
@@ -2090,10 +2271,26 @@ export interface MeshioPlusPlusModule {
    *
    * With `returnMaps: true`, returns `{mesh, cellMap}` instead of a bare
    * mesh -- a single FLAT array (global input cell index -> global output
-   * cell index), unlike the other ops' per-block `cellMaps`.
+   * cell index), unlike the other ops' per-block `cellMaps` -- plus
+   * `numFacesMerged` and `numRejected` for the `options` below.
+   *
+   * `options.mergeCoplanarFaces` fuses coplanar shared and boundary faces
+   * (within `coplanarAngle` degrees, default 1) into one polygon;
+   * `options.minSphericity` (0 = off) refuses an absorption that would drop a
+   * group's sphericity below it. See doc/agglomerate.md.
    */
-  agglomerate(mesh: Mesh, targetGroupSize?: number, returnMaps?: false): Mesh;
-  agglomerate(mesh: Mesh, targetGroupSize?: number, returnMaps?: true): { mesh: Mesh; cellMap: Int32Array };
+  agglomerate(
+    mesh: Mesh,
+    targetGroupSize?: number,
+    returnMaps?: false,
+    options?: AgglomerateOptions,
+  ): Mesh;
+  agglomerate(
+    mesh: Mesh,
+    targetGroupSize: number | undefined,
+    returnMaps: true,
+    options?: AgglomerateOptions,
+  ): { mesh: Mesh; cellMap: Int32Array; numFacesMerged: number; numRejected: number };
 
   /**
    * Refine a mesh, subdividing cells into same-type children (`line` → 2,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@meshioplusplus/wasm",
-  "version": "16.21.0",
-  "description": "meshio++ mesh I/O compiled to WebAssembly: read 46 and write 49 mesh formats (incl. MED, CGNS, Exodus) in the browser or Node.js",
+  "version": "16.25.0",
+  "description": "meshio++ mesh I/O compiled to WebAssembly: read 76 and write 68 mesh formats (incl. MED, CGNS, Exodus) in the browser or Node.js",
   "type": "module",
   "main": "./src/index.mjs",
   "module": "./src/index.mjs",

package/src/index.mjs

@@ -210,6 +210,8 @@ export class MeshioPlusPlusLoadError extends Error {
  *   sequenceEntries: (source: string|string[], options?: object) => object[],
  *   sequenceToTimeseries: (source: string|string[], outPath: string, outFormat?: string, options?: object) => number,
  *   timeseriesToSequence: (inPath: string, outPattern: string, inFormat?: string, outFormat?: string) => string[],
+ *   resampleSequence: (source: string|string[], outPath: string, resample: object, outFormat?: string, options?: object) => number,
+ *   blendSteps: (a: Mesh, b: Mesh, w: number, blendPoints?: boolean) => Mesh,
  *   numNodesPerCell: () => Object<string, number>,
  *   topologicalDimension: () => Object<string, number>,
  *   meshBackend: () => string,
@@ -250,13 +252,18 @@ export class MeshioPlusPlusLoadError extends Error {
  *   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}},
  *   computeNormals: (mesh: Mesh, pointNormals?: boolean, cellNormals?: boolean, weight?: string, splitAngle?: number, recordParentIds?: boolean, region?: string) => {mesh: Mesh, numIsolated: number, numUndefined: number, numDegenerate: number, numSplitPoints: number, numAddedPoints: number, quality: {boundaryEdges: number, nonManifoldEdges: number, inconsistentPairs: number, degenerateTriangles: number, watertight: boolean}},
+ *   checkQuality: (mesh: Mesh, require?: string, maxInverted?: number, maxDegenerate?: number) => {passed: boolean, numCells: number, numInverted: number, numDegenerate: number, checks: Array<object>, summary: string},
+ *   featureEdges: (mesh: Mesh, featureAngle?: number, feature?: boolean, boundary?: boolean, nonManifold?: boolean, inconsistent?: boolean, region?: string) => {mesh: Mesh, numFeature: number, numBoundary: number, numNonManifold: number, numInconsistent: number},
+ *   hausdorffDistance: (a: Mesh, b: Mesh, faceSamples?: number, regionA?: string, regionB?: string) => {distance: number, aToB: number, bToA: number, meanAToB: number, rmsAToB: number, meanBToA: number, rmsBToA: number, numSamplesA: number, numSamplesB: number, worstPointA: Float64Array, worstPointB: Float64Array},
+ *   editRegions: (mesh: Mesh, edits: Array<{op: string, inputs: Array<string | {name: string, kind?: string, dim?: number, tag?: number}>, output?: string, dim?: number, tag?: number, keepInputs?: boolean}>) => Mesh,
+ *   matchPeriodicNodes: (mesh: Mesh, slave: string | {name: string, kind?: string, dim?: number, tag?: number}, master: string | {name: string, kind?: string, dim?: number, tag?: number}, matrix: ArrayLike<number>, atol?: number, requireComplete?: boolean) => {slave: Int32Array, master: Int32Array, unmatched: Int32Array, numFixed: number, maxResidual: number},
  *   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, returnMaps?: boolean) => {key: string, mesh: Mesh, pointMap?: Int32Array, cellMaps?: Int32Array[]}[],
  *   convertCells: (mesh: Mesh, mode?: string, recordParentIds?: boolean, returnMaps?: boolean) => Mesh | {mesh: Mesh, pointMap: Int32Array, cellMaps: Int32Array[]},
  *   subdivide: (mesh: Mesh, recordParentIds?: boolean, returnMaps?: boolean) => Mesh | {mesh: Mesh, cellMaps: Int32Array[]},
- *   agglomerate: (mesh: Mesh, targetGroupSize?: number, returnMaps?: boolean) => Mesh | {mesh: Mesh, cellMap: Int32Array},
+ *   agglomerate: (mesh: Mesh, targetGroupSize?: number, returnMaps?: boolean, options?: {mergeCoplanarFaces?: boolean, coplanarAngle?: number, minSphericity?: number}) => Mesh | {mesh: Mesh, cellMap: Int32Array, numFacesMerged: number, numRejected: number},
  *   refine: (mesh: Mesh, levels?: number, recordParentIds?: boolean,
  *            options?: object, returnMaps?: boolean) => Mesh | {mesh: Mesh, pointMap: Int32Array, cellMaps: Int32Array[]},
  *   decimate: (mesh: Mesh, ratio?: number, targetFaces?: number, maxError?: number, placement?: string, preserveBoundary?: boolean, preserveFeatures?: boolean, featureAngle?: number, frozen?: number[]|Int32Array|null, returnMaps?: boolean) => {mesh: Mesh, facesRemoved: number, pointsRemoved: number, collapsesRejected: number, maxErrorApplied: number, pointMap?: Int32Array, cellMaps?: Int32Array[]},
@@ -460,6 +467,12 @@ export async function loadMeshioPlusPlus(moduleOverrides = {}, { variant = 'auto
         // Streams -- one mesh alive at a time, whatever the step count.
         sequenceToTimeseries: (source, outPath, outFormat = '', options = undefined) =>
             Module.sequenceToTimeseries(source, outPath, outFormat, options),
+        // Resample onto new times: `resample` is {Times | TimesFrom, Method,
+        // Extrapolate, BlendPoints}. At most two meshes alive at a time.
+        resampleSequence: (source, outPath, resample, outFormat = '', options = undefined) =>
+            Module.resampleSequence(source, outPath, resample, outFormat, options),
+        // `a` with its float data blended to (1 - w) a + w b; same topology.
+        blendSteps: (a, b, w, blendPoints = false) => Module.blendSteps(a, b, w, blendPoints),
         // Fan-out: one multi-step file -> one file per step. `outPattern` must
         // contain '{step}' or '{index}'; returns the MEMFS paths written.
         timeseriesToSequence: (inPath, outPattern, inFormat = '', outFormat = '') =>
@@ -775,6 +788,26 @@ export async function loadMeshioPlusPlus(moduleOverrides = {}, { variant = 'auto
         ) =>
             Module.computeNormals(mesh, pointNormals, cellNormals, weight, splitAngle,
                 recordParentIds, region),
+        checkQuality: (mesh, require = '', maxInverted = 0, maxDegenerate = 0) =>
+            Module.checkQuality(mesh, require, maxInverted, maxDegenerate),
+        featureEdges: (
+            mesh,
+            featureAngle = 30,
+            feature = true,
+            boundary = true,
+            nonManifold = true,
+            inconsistent = true,
+            region = '',
+        ) =>
+            Module.featureEdges(mesh, featureAngle, feature, boundary, nonManifold,
+                inconsistent, region),
+        hausdorffDistance: (a, b, faceSamples = 0, regionA = '', regionB = '') =>
+            Module.hausdorffDistance(a, b, faceSamples, regionA, regionB),
+        editRegions: (mesh, edits) =>
+            Module.editRegions(mesh, Array.isArray(edits) ? edits : [edits]),
+        matchPeriodicNodes: (mesh, slave, master, matrix, atol = 1e-8, requireComplete = true) =>
+            Module.matchPeriodicNodes(mesh, slave, master, Array.from(matrix), atol,
+                requireComplete),
         repair: (
             mesh,
             fixOrientation = true,
@@ -828,8 +861,9 @@ export async function loadMeshioPlusPlus(moduleOverrides = {}, { variant = 'auto
         // `returnMaps` (default false): when true, returns `{mesh, cellMap}`
         // instead of a bare mesh -- a single FLAT array (global cell index ->
         // global cell index), unlike the other ops' per-block `cellMaps`.
-        agglomerate: (mesh, targetGroupSize = 8, returnMaps = false) =>
-            Module.agglomerate(mesh, targetGroupSize, returnMaps),
+        // `options`: {mergeCoplanarFaces, coplanarAngle, minSphericity}.
+        agglomerate: (mesh, targetGroupSize = 8, returnMaps = false, options = undefined) =>
+            Module.agglomerate(mesh, targetGroupSize, returnMaps, options),
         // `returnMaps` (default false): when true, returns
         // `{mesh, pointMap, cellMaps}` instead of a bare mesh.
         refine: (mesh, levels = 1, recordParentIds = false, options = undefined,