@meshioplusplus/wasm 17.7.0 → 17.9.0

package/index.d.ts

@@ -902,6 +902,36 @@ export type OpSpec =
       maxCells?: number;
       sign?: SdfSign;
     }
+  | {
+      /**
+       * An octree (quadtree for a planar `line` skin) around the mesh: leaves
+       * are fine only where the skin is. Like `voxelize` it replaces the
+       * geometry; the result carries `octree:level`/`octree:cut` cell data and
+       * `octree:hanging` point data.
+       */
+      op: 'octree';
+      rootCells?: number[];
+      minLevel?: number;
+      maxLevel?: number;
+      bounds?: number[];
+      padding?: number;
+      paddingRelative?: number;
+      dimension?: number;
+      sampleDistance?: number;
+      balance?: OctreeBalance;
+      fill?: VoxelFill;
+      attachDistance?: boolean;
+      evenOdd?: boolean;
+      maxCells?: number;
+      sign?: SdfSign;
+      transition?: OctreeTransition;
+      snap?: boolean;
+      surfaceLevel?: number;
+      curvatureThreshold?: number;
+      featureAngle?: number;
+      sizeArray?: string;
+      plane?: PlanarPlane;
+    }
   | {
       /**
        * A signed distance field: a grid over the mesh's surface, filled. Like
@@ -971,6 +1001,15 @@ export type GradientOperator = 'gradient' | 'divergence' | 'curl';
 /** Which cells `voxelize` keeps. See doc/voxelize.md. */
 export type VoxelFill = 'all' | 'surface' | 'inside';
 
+/** How strictly `octree` keeps neighbouring leaves the same size. See doc/octree.md. */
+export type OctreeBalance = 'none' | 'face' | 'full';
+
+/** What `octree` emits where a fine leaf meets a coarse one. See doc/octree.md. */
+export type OctreeTransition = 'hanging' | 'polyhedra' | 'templates';
+
+/** The plane of a 2-D skin. */
+export type PlanarPlane = 'auto' | 'xy' | 'xz' | 'yz';
+
 /** How a signed distance decides which side of the surface a point is on. */
 export type SdfSign = 'unsigned' | 'pseudonormal' | 'winding-number';
 
@@ -1105,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). */
@@ -1704,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;
 
@@ -2046,6 +2094,51 @@ export interface MeshioPlusPlusModule {
     numOccupied: number;
   };
 
+  /**
+   * Build an octree (a quadtree for a planar `line` skin) around a mesh: leaves
+   * are fine only where the skin is. `balance` keeps neighbours within 2:1;
+   * `fill` is as for `voxelize`. Pass `null` for `rootCells`/`bounds` to take the
+   * defaults.
+   * @throws {Error} on an empty or oversized level range, an unknown
+   *   `balance`/`fill`/`sign`, an open polyline with `fill: 'inside'`, or when
+   *   the tree exceeds `maxCells`.
+   */
+  octree(
+    mesh: Mesh,
+    rootCells?: number[] | null,
+    minLevel?: number,
+    maxLevel?: number,
+    bounds?: number[] | null,
+    padding?: number,
+    paddingRelative?: number,
+    dimension?: number,
+    sampleDistance?: number,
+    balance?: OctreeBalance,
+    fill?: VoxelFill,
+    sign?: SdfSign,
+    attachDistance?: boolean,
+    evenOdd?: boolean,
+    maxCells?: number,
+    watertightCheck?: SdfWatertightCheck,
+    transition?: OctreeTransition,
+    snap?: boolean,
+    surfaceLevel?: number,
+    curvatureThreshold?: number,
+    featureAngle?: number,
+    sizeArray?: string,
+    plane?: PlanarPlane,
+  ): {
+    mesh: Mesh;
+    dimension: number;
+    numLeaves: number;
+    numHanging: number;
+    finestLevel: number;
+    origin: number[];
+    rootSize: number;
+    numSnapped: number;
+    numRefused: number;
+  };
+
   /** What is wrong with a surface, in numbers rather than a bare flag. */
   surfaceWatertightCheck(mesh: Mesh): {
     boundaryEdges: number;
@@ -2499,7 +2592,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(
@@ -2510,6 +2606,8 @@ export interface MeshioPlusPlusModule {
     minPatchCells?: number,
     region?: string,
     prefix?: string,
+    method?: 'angle' | 'primitive',
+    tolerance?: number,
   ): {
     mesh: Mesh;
     numPatches: number;
@@ -2551,10 +2649,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;
 
@@ -3045,9 +3145,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,
@@ -3290,6 +3390,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. */
@@ -3333,6 +3437,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.7.0",
+  "version": "17.9.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,
@@ -276,6 +277,7 @@ export class MeshioPlusPlusLoadError extends Error {
  *   isosurface: (mesh: Mesh, array: string, isovalues: number|number[], component?: number, recordParentIds?: boolean) => Mesh,
  *   grid: (dims: number[], origin?: number[], spacing?: number[], maxCells?: number) => 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},
  *   sampleDistance: (surface: Mesh, points: number[], sign?: string, band?: number, watertightCheck?: string) => Float64Array,
  *   distanceToSurface: (query: Mesh, surface: Mesh, sign?: string, location?: string, band?: number, recordInside?: boolean, watertightCheck?: string) => {mesh: Mesh, numBanded: number, quality: object},
@@ -290,12 +292,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,
@@ -600,9 +602,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(),
@@ -755,6 +758,35 @@ export async function loadMeshioPlusPlus(
         ) =>
             Module.voxelize(mesh, resolution, cellSize, bounds, padding, paddingRelative,
                 fill, sign, attachOccupancy, maxCells, watertightCheck),
+        octree: (
+            mesh,
+            rootCells = null,
+            minLevel = 0,
+            maxLevel = 4,
+            bounds = null,
+            padding = 0,
+            paddingRelative = 0,
+            dimension = 0,
+            sampleDistance = 0,
+            balance = 'face',
+            fill = 'all',
+            sign = 'pseudonormal',
+            attachDistance = false,
+            evenOdd = false,
+            maxCells = 20000000,
+            watertightCheck = 'warn',
+            transition = 'hanging',
+            snap = false,
+            surfaceLevel = -1,
+            curvatureThreshold = 0,
+            featureAngle = 0,
+            sizeArray = '',
+            plane = 'auto',
+        ) =>
+            Module.octree(mesh, rootCells, minLevel, maxLevel, bounds, padding, paddingRelative,
+                dimension, sampleDistance, balance, fill, sign, attachDistance, evenOdd, maxCells,
+                watertightCheck, transition, snap, surfaceLevel, curvatureThreshold, featureAngle,
+                sizeArray, plane),
         surfaceWatertightCheck: (mesh) => Module.surfaceWatertightCheck(mesh),
         sampleDistance: (surface, points, sign = 'pseudonormal', band = 0, watertightCheck = 'warn') =>
             Module.sampleDistance(surface, points, sign, band, watertightCheck),
@@ -932,9 +964,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',