@meshioplusplus/wasm 16.41.0 → 17.0.0

package/index.d.ts

@@ -202,7 +202,8 @@ export type MeshInfo =
   | UnvInfo
   | GmshInfo
   | ExodusInfo
-  | MfemInfo;
+  | MfemInfo
+  | CadJsonInfo;
 
 /** OpenFOAM's side channel: `readMeshSelective`'s cell_tags/patch-type map, reshaped per patch. */
 export interface OpenFoamInfo {
@@ -306,6 +307,92 @@ export interface GmshInfo {
   periodic?: { entity: number[]; affine: number[]; nodePairs: BigInt64Array | number[] }[];
 }
 
+/** One NURBS curve of a B-rep: a trimming curve in a face's (u, v), or an edge's 3-D curve. */
+export interface BrepCurve {
+  degree: number;
+  /** The full knot vector (`n + degree + 1` knots). */
+  knots: number[];
+  /** Whether the file wrote Kratos's reduced form (without the outer knots). */
+  reducedKnots: boolean;
+  rational: boolean;
+  /** (points, 3) control points; a trimming curve's are (u, v, 0). */
+  controlPoints: Float64Array;
+  weights: Float64Array;
+  /** The control points' ids (Kratos node ids), empty when the file gives none. */
+  ids: BigInt64Array | number[];
+  /** `[t0, t1]`, or empty. */
+  activeRange: number[];
+  /** Members not modelled, as compact JSON object text. */
+  extra: string;
+}
+
+/** A trimming curve of a loop, or an embedded edge of a face. */
+export interface BrepTrim {
+  /** -1 when the file gives none. */
+  trimIndex: number;
+  direction: boolean;
+  curve: BrepCurve;
+  extra: string;
+}
+
+/** A topology entry: the face (and trim) an edge or vertex lies on. */
+export interface BrepRef {
+  /** -1 when the entity is named instead. */
+  id: number;
+  name: string;
+  /** -1 when absent. */
+  trimIndex: number;
+  /** 1 true, 0 false, -1 absent. */
+  relativeDirection: number;
+  localCoordinates: number[];
+  extra: string;
+}
+
+/**
+ * Kratos CAD JSON's side channel: the NURBS boundary representation (C++
+ * `BrepInfo`) the mesh was sampled from -- trimmed faces, their loops, edges
+ * and vertices, as Kratos's `CadJsonInput` reads them. Every index is 0-based;
+ * ids are -1 where an entity is named by `name` instead. `writeMesh` writes it
+ * back as CAD JSON.
+ */
+/** Sampling options of `igaRefine` / `igaSample`. */
+export interface IgaOptions {
+  /** Cells per knot span and direction of the sampling; 0 is automatic. */
+  sampleSubdivisions?: number;
+  /** B-rep: points per knot span a trimming curve is sampled at (2..4096). */
+  trimSamples?: number;
+  /** B-rep: sample the edges that have a 3-D curve. */
+  edges?: boolean;
+  /** B-rep: keep only the cells inside the trimming loops. */
+  trim?: boolean;
+}
+
+export interface CadJsonInfo {
+  format: 'cad_json';
+  /** The face surfaces: two degrees, two full knot vectors, (points, 3) control net (u fastest). */
+  patches: { degrees: number[]; knots: number[][]; controlPoints: Float64Array; weights: Float64Array }[];
+  breps: { id: number; name: string; faces: number[]; edges: number[]; vertices: number[]; extra: string }[];
+  faces: {
+    id: number;
+    name: string;
+    /** Index into `patches`. */
+    patch: number;
+    swappedNormal: boolean;
+    trimmed: boolean;
+    rational: boolean;
+    reducedKnots: boolean;
+    controlPointIds: BigInt64Array | number[];
+    loops: { type: string; trims: BrepTrim[]; extra: string }[];
+    embeddedEdges: BrepTrim[];
+    surfaceExtra: string;
+    extra: string;
+  }[];
+  edges: { id: number; name: string; curve: BrepCurve | null; topology: BrepRef[]; extra: string }[];
+  vertices: { id: number; name: string; topology: BrepRef[]; extra: string }[];
+  /** The file's other top-level members (Kratos: tolerances, version_number). */
+  extra: string;
+}
+
 /**
  * MFEM's side channel (v16.40.0): the NURBS patches an `MFEM NURBS mesh` was
  * sampled from (C++ `NurbsInfo`). Arrays are flat, their widths given beside
@@ -2429,6 +2516,91 @@ export interface MeshioPlusPlusModule {
     numUnfitted: number;
   };
 
+  /**
+   * Refine every patch (every face surface of a B-rep) of a NURBS model
+   * exactly: degree elevation by `elevate`, then knot insertion splitting each
+   * knot span in `subdivisions` parts (a number, or one per direction; an
+   * `mfem` model refines every direction alike). `info` is the side channel
+   * of `readMeshSelective(path, {info: true})` for an MFEM NURBS mesh or a
+   * CAD JSON file. Returns the refined model sampled (`sampleSubdivisions`
+   * cells per span, 0 automatic) and the refined model, which `writeMesh`
+   * writes back with the mesh. The geometry, the fields and a trimmed face's
+   * trimming loops do not change. See doc/iga.md.
+   * @throws {Error} on a bad option, a non-NURBS info or an inconsistent model.
+   */
+  igaRefine(
+    info: MfemInfo | CadJsonInfo,
+    options?: IgaOptions & {
+      subdivisions?: number | number[];
+      elevate?: number | number[];
+    },
+  ): { mesh: Mesh; info: MfemInfo | CadJsonInfo };
+
+  /** Sample a NURBS model into Lagrange cells; see `igaRefine`. */
+  igaSample(
+    info: MfemInfo | CadJsonInfo,
+    options?: IgaOptions,
+  ): { mesh: Mesh; info: MfemInfo | CadJsonInfo };
+
+  /**
+   * Evaluate patch `patch` (0-based; the face of a B-rep) at `params`, a flat
+   * array with the parametric dimension's worth of numbers per point.
+   * `derivatives: 1` adds the first derivatives (`(N, d, spaceDim)`) and the
+   * unit normals of a surface in 3-D; a B-rep face also reports `inside`
+   * (1 where its trimming loops contain the point).
+   */
+  igaEvaluate(
+    info: MfemInfo | CadJsonInfo,
+    patch: number,
+    params: ArrayLike<number>,
+    options?: { derivatives?: 0 | 1; trimSamples?: number },
+  ): {
+    spaceDim: number;
+    points: Float64Array;
+    fields: Float64Array[];
+    fieldComponents: number[];
+    derivatives?: Float64Array;
+    normals?: Float64Array;
+    inside?: Uint8Array;
+  };
+
+  /**
+   * Isoparametric tessellation of curved (quadratic) cells: every
+   * `triangle6`, `quad8`, `quad9`, `tetra10` and `hexahedron27` cell is sampled
+   * on a reference lattice and mapped through its own shape functions, curved
+   * surface cells becoming one `triangle` block and curved volume cells one
+   * `tetra` block; every other cell passes through unchanged. `levels` is
+   * divisions per axis for `quad8`/`quad9`/`hexahedron27` and recursive splits
+   * (`2^levels` divisions per edge) for `triangle6`/`tetra10`; `curved = false`
+   * passes every cell through. The output carries `tessellate:source_point`
+   * (point data, -1 for a new point), `tessellate:source_cell` and
+   * `tessellate:sub_index` (cell data); `fields` interpolates point data and
+   * copies cell data onto the children, and `recordStencil` adds
+   * `tessellate:stencil`/`tessellate:weights` (`(P, 27)` point data). Facet
+   * counts are over the output `tetra` block: `numFacetsWithBadCount` is 0
+   * for a conforming tessellation. See doc/tessellation.md.
+   * @throws {Error} on `levels` outside 0..20 or not an integer, or a point
+   *   data array whose row count is not the number of points.
+   */
+  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;
+  };
+
   /**
    * The (sampled) Hausdorff distance between the surfaces of two meshes; a
    * volume mesh contributes its skin. `faceSamples = s > 0` also samples the

package/package.json

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

package/src/index.mjs

@@ -256,7 +256,11 @@ export class MeshioPlusPlusLoadError extends Error {
  *   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},
+ *   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},
+ *   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,
  *   renderPng: (mesh: Mesh, options?: RenderOptions, compress?: number) => Uint8Array,
@@ -858,6 +862,12 @@ export async function loadMeshioPlusPlus(moduleOverrides = {}, { variant = 'auto
         ) =>
             Module.fitPrimitives(mesh, patchData, tolerance, relative, minInlierFraction,
                 Array.isArray(types) ? types : [types], maxIterations),
+        igaRefine: (info, options = {}) => Module.igaRefine(info, options),
+        igaSample: (info, options = {}) => Module.igaSample(info, options),
+        igaEvaluate: (info, patch, params, options = {}) =>
+            Module.igaEvaluate(info, patch, params, options),
+        tessellate: (mesh, levels = 2, curved = true, fields = true, recordStencil = false) =>
+            Module.tessellate(mesh, levels, curved, fields, recordStencil),
         render: (mesh, options = {}) => Module.render(mesh, options),
         renderText: (mesh, options = {}, text = {}) => Module.renderText(mesh, options, text),
         renderPng: (mesh, options = {}, compress = 0) => Module.renderPng(mesh, options, compress),