@meshioplusplus/wasm 17.8.0 → 17.10.0

package/index.d.ts

@@ -1144,8 +1144,9 @@ export type InterpolateOnConflict = 'error' | 'overwrite' | 'suffix';
  *  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'`. */
+/** Partitioning backend: SFC is always available; KaHIP is linked only in
+ *  the full artifact, so `'kahip'` throws there outside it and `'auto'`
+ *  resolves to SFC. */
 export type PartitionMethod = 'sfc' | 'kahip' | 'auto';
 
 /** KaHIP preconfiguration (ignored by the SFC method). */
@@ -1743,10 +1744,18 @@ export interface MeshioPlusPlusModule {
 
   /**
    * Whether OpenCASCADE is linked in, so `step` and `iges` read and `fitCad`
-   * runs: true in the full artifact (`{full: true}`), false in the lean one.
+   * has its OpenCASCADE backend: true in the full artifact (`{full: true}`),
+   * false in the lean one (where `fitCad` runs the native backend).
    */
   hasOcct(): boolean;
 
+  /**
+   * Whether the KaHIP kaffpa partitioner is linked in, so `partition` with
+   * `method: 'kahip'` runs: true in the full artifact (`{full: true}`),
+   * false in the lean one.
+   */
+  hasKahip(): boolean;
+
   /** Whether the VTK XML zstd block codec is linked in (the full artifact). */
   hasZstd(): boolean;
 
@@ -2058,6 +2067,47 @@ export interface MeshioPlusPlusModule {
   grid(dims: number[], origin?: number[] | null, spacing?: number[] | null,
        maxCells?: number): Mesh;
 
+  /**
+   * A regular 2-D grid of quads or triangles at `z = origin[2]`, points x
+   * fastest. `split` (`'zigzag'`, `'up'`, `'down'`, `'center'`) lays out the
+   * triangles; `order: 2` gives `quad8` / `triangle6` cells on the exact
+   * geometry. Side regions `xmin`, `xmax`, `ymin`, `ymax`.
+   * @throws {Error} on a bad count, size, cell type, split or order, or a mesh
+   *   above `maxCells`.
+   */
+  rectangle(dims?: number[] | null, size?: number[] | null, origin?: number[] | null,
+            cellType?: string, split?: string, order?: number, maxCells?: number): Mesh;
+
+  /** A regular 3-D grid of `'hexahedron'`, `'tetra'` (six Kuhn tetrahedra per
+   * cell) or `'wedge'` cells. Side regions `xmin` ... `zmax`. */
+  box(dims?: number[] | null, size?: number[] | null, origin?: number[] | null,
+      cellType?: string, order?: number, maxCells?: number): Mesh;
+
+  /** A disk of `n x n` quads (squircle map) or `n` rings of triangles. Side
+   * region `rim`. */
+  disk(radius?: number, n?: number, center?: number[] | null, cellType?: string,
+       order?: number, maxCells?: number): Mesh;
+
+  /** A latitude / longitude sphere surface, oriented outward; `cellType: 'quad'`
+   * gives quads between the rings and triangle caps. */
+  uvSphere(radius?: number, nu?: number, nv?: number, center?: number[] | null,
+           cellType?: string, order?: number, maxCells?: number): Mesh;
+
+  /** A sphere surface of `20 * 4^subdivisions` triangles, oriented outward. */
+  icosaSphere(radius?: number, subdivisions?: number, center?: number[] | null,
+              order?: number, maxCells?: number): Mesh;
+
+  /** A solid cylinder along z, `'hexahedron'` or `'wedge'` cells. Side regions
+   * `side`, `top`, `bottom`. */
+  cylinder(radius?: number, height?: number, nxy?: number, nz?: number,
+           center?: number[] | null, cellType?: string, order?: number,
+           maxCells?: number): Mesh;
+
+  /** One cell of each requested meshio type in its reference coordinates, side
+   * by side (every supported type when `types` is omitted); `pairs` gives two
+   * cells sharing a facet, for linear types. */
+  referenceCells(types?: string[] | null, pairs?: boolean): Mesh;
+
   /**
    * Build a regular grid around a mesh. Give exactly one of `resolution` and
    * `cellSize`; `fill` selects the whole bounding box, only the cells a triangle
@@ -2583,7 +2633,10 @@ export interface MeshioPlusPlusModule {
    * feature edges. The mesh comes back unchanged plus cell data
    * `segment:patch` (-1 off the surface), field data `segment:adjacency`
    * (rows `[a, b, sharedEdges]`) and one cell region per patch,
-   * `<prefix>:<k>`. See doc/segment.md.
+   * `<prefix>:<k>`. `method: 'primitive'` (v17.9.0) ends a patch where the
+   * surface its facets lie on changes, at `tolerance` (relative to the
+   * diagonal), so a fillet comes apart from its tangent planes. See
+   * doc/segment.md.
    * @throws {Error} on an option out of range, an unknown region or a volume block.
    */
   segment(
@@ -2594,6 +2647,8 @@ export interface MeshioPlusPlusModule {
     minPatchCells?: number,
     region?: string,
     prefix?: string,
+    method?: 'angle' | 'primitive',
+    tolerance?: number,
   ): {
     mesh: Mesh;
     numPatches: number;
@@ -2635,10 +2690,12 @@ export interface MeshioPlusPlusModule {
    * output of `segment` then `fitPrimitives`): planes, spheres, cylinders,
    * cones and tori, fillets and blends, threads and freeform B-spline faces,
    * sewn and checked by OpenCASCADE, optionally written as STEP to
-   * `stepPath` on the virtual FS. Needs OpenCASCADE: the full artifact only.
-   * See doc/fit_cad.md.
-   * @throws {Error} in the lean artifact (naming `{full: true}`), on a bad
-   *   option, or on a skin that is not closed.
+   * `stepPath` on the virtual FS. The lean artifact (and `backend: 'native'`)
+   * runs the kernel-free backend instead (v17.9.0): the fitted patches become
+   * analytic STEP faces, the rest coplanar polygons, and `mesh` is the skin
+   * itself. See doc/fit_cad.md.
+   * @throws {Error} with `backend: 'occt'` in the lean artifact (naming
+   *   `{full: true}`), on a bad option, or on a skin that is not closed.
    */
   fitCad(mesh: Mesh, options?: FitCadOptions): FitCadResult;
 
@@ -3129,9 +3186,9 @@ export interface MeshioPlusPlusModule {
    * scalar `cell_data` array of per-cell weights. `ghostLayers > 0` grows
    * each piece by that many shared-node BFS layers of other parts' cells (a
    * halo), tagged `partition:ghost`.
-   * @throws {Error} on `method: 'kahip'` (KaHIP is never part of the WASM
-   *   build; the message names `MESHIOPLUSPLUS_WITH_KAHIP`), `nparts < 1`,
-   *   `ghostLayers < 0`, or a bad weights array.
+   * @throws {Error} on `method: 'kahip'` outside the full artifact (KaHIP
+   *   is linked only there; the message names `MESHIOPLUSPLUS_WITH_KAHIP`),
+   *   `nparts < 1`, `ghostLayers < 0`, or a bad weights array.
    */
   partition(
     mesh: Mesh,
@@ -3374,6 +3431,10 @@ export interface FitCadOptions {
   fillets?: boolean;
   /** Try thread faces, tapered and of varying pitch included (default true). */
   threads?: boolean;
+  /** Merge faces on one surface once the solid is built (default true; v17.9.0). */
+  mergeFaces?: boolean;
+  /** The engine: OpenCASCADE when linked in (`'auto'`, the default), or none (v17.9.0). */
+  backend?: 'auto' | 'occt' | 'native';
 }
 
 /** What {@link MeshioPlusPlusModule.fitCad} built. */
@@ -3417,6 +3478,8 @@ export interface FitCadResult {
   numTaperedThread: number;
   /** Thread flanks whose pitch varies along the axis. */
   numVariablePitchThread: number;
+  /** The engine that built the solid (v17.9.0). */
+  backend: 'occt' | 'native';
   /** The solid's B-rep, for `writeMesh(path, mesh, 'cad_json', {info})`. */
   info: CadJsonInfo;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meshioplusplus/wasm",
-  "version": "17.8.0",
+  "version": "17.10.0",
   "description": "meshio++ mesh I/O compiled to WebAssembly: read 80 and write 75 mesh formats (incl. MED, CGNS, Exodus; STEP and IGES in the full build) in the browser or Node.js",
   "type": "module",
   "main": "./src/index.mjs",

package/src/index.mjs

@@ -32,7 +32,7 @@
 //
 // Beside that lean pair the package ships the FULL pair (roadmap 6.2),
 // meshioplusplus_wasm_full and meshioplusplus_wasm_full_mt: the same API, with
-// OpenCASCADE (STEP/IGES reading, fitCad), zstd, lz4 and bzip2 linked in, and
+// OpenCASCADE (STEP/IGES reading, fitCad's OpenCASCADE backend), zstd, lz4 and bzip2 linked in, and
 // a mixed licence (OpenCASCADE is LGPL-2.1 with its exception; see
 // THIRD_PARTY_NOTICES.md). `{ full: true }` loads it, with the same variant
 // choice. Its import() is deliberately NOT literal: a bundler that saw it would
@@ -249,6 +249,7 @@ export class MeshioPlusPlusLoadError extends Error {
  *   parallelBackend: () => string,
  *   hasCgnslib: () => boolean,
  *   hasOcct: () => boolean,
+ *   hasKahip: () => boolean,
  *   hasZstd: () => boolean,
  *   hasLz4: () => boolean,
  *   hasBzip2: () => boolean,
@@ -275,6 +276,13 @@ export class MeshioPlusPlusLoadError extends Error {
  *   slice: (mesh: Mesh, origin: number[], normal: number[], recordParentIds?: boolean) => Mesh,
  *   isosurface: (mesh: Mesh, array: string, isovalues: number|number[], component?: number, recordParentIds?: boolean) => Mesh,
  *   grid: (dims: number[], origin?: number[], spacing?: number[], maxCells?: number) => Mesh,
+ *   rectangle: (dims?: number[], size?: number[], origin?: number[], cellType?: string, split?: string, order?: number, maxCells?: number) => Mesh,
+ *   box: (dims?: number[], size?: number[], origin?: number[], cellType?: string, order?: number, maxCells?: number) => Mesh,
+ *   disk: (radius?: number, n?: number, center?: number[], cellType?: string, order?: number, maxCells?: number) => Mesh,
+ *   uvSphere: (radius?: number, nu?: number, nv?: number, center?: number[], cellType?: string, order?: number, maxCells?: number) => Mesh,
+ *   icosaSphere: (radius?: number, subdivisions?: number, center?: number[], order?: number, maxCells?: number) => Mesh,
+ *   cylinder: (radius?: number, height?: number, nxy?: number, nz?: number, center?: number[], cellType?: string, order?: number, maxCells?: number) => Mesh,
+ *   referenceCells: (types?: string[], pairs?: boolean) => Mesh,
  *   voxelize: (mesh: Mesh, resolution?: number[], cellSize?: number, bounds?: number[], padding?: number, paddingRelative?: number, fill?: string, sign?: string, attachOccupancy?: boolean, maxCells?: number, watertightCheck?: string) => {mesh: Mesh, dims: number[], origin: number[], spacing: number[], numOccupied: number},
  *   octree: (mesh: Mesh, rootCells?: number[], minLevel?: number, maxLevel?: number, bounds?: number[], padding?: number, paddingRelative?: number, dimension?: number, sampleDistance?: number, balance?: string, fill?: string, sign?: string, attachDistance?: boolean, evenOdd?: boolean, maxCells?: number, watertightCheck?: string, transition?: string, snap?: boolean, surfaceLevel?: number, curvatureThreshold?: number, featureAngle?: number, sizeArray?: string, plane?: string) => {mesh: Mesh, dimension: number, numLeaves: number, numHanging: number, finestLevel: number, origin: number[], rootSize: number, numSnapped: number, numRefused: number},
  *   surfaceWatertightCheck: (mesh: Mesh) => {boundaryEdges: number, nonManifoldEdges: number, inconsistentPairs: number, degenerateTriangles: number, watertight: boolean},
@@ -291,12 +299,12 @@ export class MeshioPlusPlusLoadError extends Error {
  *   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},
- *   segment: (mesh: Mesh, featureAngle?: number, normalTolerance?: number, curvatureTolerance?: number, minPatchCells?: number, region?: string, prefix?: string) => {mesh: Mesh, numPatches: number, numMerged: number, numFeatureEdges: number, numBoundaryEdges: number, numNonManifoldEdges: number},
+ *   segment: (mesh: Mesh, featureAngle?: number, normalTolerance?: number, curvatureTolerance?: number, minPatchCells?: number, region?: string, prefix?: string, method?: 'angle' | 'primitive', tolerance?: number) => {mesh: Mesh, numPatches: number, numMerged: number, numFeatureEdges: number, numBoundaryEdges: number, numNonManifoldEdges: number},
  *   igaRefine: (info: object, options?: {subdivisions?: number | number[], elevate?: number | number[], sampleSubdivisions?: number, trimSamples?: number, edges?: boolean, trim?: boolean}) => {mesh: Mesh, info: object},
  *   igaSample: (info: object, options?: {sampleSubdivisions?: number, trimSamples?: number, edges?: boolean, trim?: boolean}) => {mesh: Mesh, info: object},
  *   igaEvaluate: (info: object, patch: number, params: ArrayLike<number>, options?: {derivatives?: 0 | 1, trimSamples?: number}) => object,
  *   fitPrimitives: (mesh: Mesh, patchData?: string, tolerance?: number, relative?: boolean, minInlierFraction?: number, types?: string[], maxIterations?: number) => {mesh: Mesh, numPatches: number, numPlane: number, numSphere: number, numCylinder: number, numCone: number, numTorus: number, numUnfitted: number},
- *   fitCad: (mesh: Mesh, options?: {stepPath?: string, tolerance?: number, exactEdges?: boolean, types?: string[], meshDeflection?: number, maxDemotionRounds?: number, freeform?: boolean, freeformDegree?: number, freeformMaxControl?: number, freeformSplit?: boolean, fillets?: boolean, threads?: boolean}) => object,
+ *   fitCad: (mesh: Mesh, options?: {stepPath?: string, tolerance?: number, exactEdges?: boolean, types?: string[], meshDeflection?: number, maxDemotionRounds?: number, freeform?: boolean, freeformDegree?: number, freeformMaxControl?: number, freeformSplit?: boolean, fillets?: boolean, threads?: boolean, mergeFaces?: boolean, backend?: 'auto' | 'occt' | 'native'}) => object,
  *   tessellate: (mesh: Mesh, levels?: number, curved?: boolean, fields?: boolean, recordStencil?: boolean) => {mesh: Mesh, numSourcePoints: number, numSourceCells: number, numCurvedSourceCells: number, numPassThroughSourceCells: number, numPoints: number, numCells: number, numBoundaryFacets: number, numInteriorFacets: number, numFacetsWithBadCount: number},
  *   render: (mesh: Mesh, options?: RenderOptions) => RenderedFrame,
  *   renderText: (mesh: Mesh, options?: RenderOptions, text?: RenderTextOptions) => string,
@@ -601,9 +609,10 @@ export async function loadMeshioPlusPlus(
         // meshioplusplus_wasm_mt one -- which of the two this instance loaded.
         parallelBackend: () => Module.parallelBackend(),
         hasCgnslib: () => Module.hasCgnslib(),
-        // The full artifact's libraries (roadmap 6.2): all four are true there
+        // The full artifact's libraries (roadmap 6.2): all five are true there
         // and false in the lean one. buildFlavour() names which loaded.
         hasOcct: () => Module.hasOcct(),
+        hasKahip: () => Module.hasKahip(),
         hasZstd: () => Module.hasZstd(),
         hasLz4: () => Module.hasLz4(),
         hasBzip2: () => Module.hasBzip2(),
@@ -741,6 +750,28 @@ export async function loadMeshioPlusPlus(
             Module.slice(mesh, origin, normal, recordParentIds),
         grid: (dims, origin = null, spacing = null, maxCells = 20000000) =>
             Module.grid(dims, origin, spacing, maxCells),
+        rectangle: (
+            dims = null, size = null, origin = null, cellType = 'quad', split = 'zigzag',
+            order = 1, maxCells = 20000000,
+        ) => Module.rectangle(dims, size, origin, cellType, split, order, maxCells),
+        box: (
+            dims = null, size = null, origin = null, cellType = 'hexahedron', order = 1,
+            maxCells = 20000000,
+        ) => Module.box(dims, size, origin, cellType, order, maxCells),
+        disk: (
+            radius = 1, n = 8, center = null, cellType = 'quad', order = 1, maxCells = 20000000,
+        ) => Module.disk(radius, n, center, cellType, order, maxCells),
+        uvSphere: (
+            radius = 1, nu = 16, nv = 8, center = null, cellType = 'triangle', order = 1,
+            maxCells = 20000000,
+        ) => Module.uvSphere(radius, nu, nv, center, cellType, order, maxCells),
+        icosaSphere: (radius = 1, subdivisions = 2, center = null, order = 1, maxCells = 20000000) =>
+            Module.icosaSphere(radius, subdivisions, center, order, maxCells),
+        cylinder: (
+            radius = 1, height = 1, nxy = 8, nz = 8, center = null, cellType = 'hexahedron',
+            order = 1, maxCells = 20000000,
+        ) => Module.cylinder(radius, height, nxy, nz, center, cellType, order, maxCells),
+        referenceCells: (types = null, pairs = false) => Module.referenceCells(types, pairs),
         voxelize: (
             mesh,
             resolution = null,
@@ -962,9 +993,11 @@ export async function loadMeshioPlusPlus(
             minPatchCells = 1,
             region = '',
             prefix = 'patch',
+            method = 'angle',
+            tolerance = 1e-3,
         ) =>
             Module.segment(mesh, featureAngle, normalTolerance, curvatureTolerance,
-                minPatchCells, region, prefix),
+                minPatchCells, region, prefix, method, tolerance),
         fitPrimitives: (
             mesh,
             patchData = 'segment:patch',