@solid-labs/fab-one-widget 0.1.7 → 0.1.8

package/dist/geo_wasm.d.ts

@@ -0,0 +1,529 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Result of the align-to-origin transform.
+ */
+export class AlignResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    details(): string;
+    mpt(): Float32Array;
+    origin(): Float32Array;
+    positions(): Float32Array;
+    /**
+     * Returns [ox, oy, oz, r00, r01, r02, r10, r11, r12, r20, r21, r22]
+     * To transform a point p: rotated = R * (p - [ox,oy,oz])
+     */
+    transform(): Float32Array;
+}
+
+/**
+ * Result of batch cross-sections along a line.
+ */
+export class BatchCrossSectionResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    all_loop_points(): Float32Array;
+    circumferences(): Float32Array;
+    count(): number;
+    details(): string;
+    offsets(): Uint32Array;
+}
+
+/**
+ * Result of cross-section detection.
+ */
+export class CrossSectionResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    circumference(): number;
+    details(): string;
+    is_closed(): boolean;
+    loop_points(): Float32Array;
+    plane_normal(): Float32Array;
+}
+
+/**
+ * Result of inner shell extraction via ray-casting from interior point.
+ */
+export class ExtractInnerShellResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    details(): string;
+    indices(): Uint32Array;
+    inner_count(): number;
+    interior_point(): Float32Array;
+    positions(): Float32Array;
+    total_count(): number;
+}
+
+/**
+ * Result of fill_small_holes.
+ */
+export class FillHolesResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    details(): string;
+    holes_filled(): number;
+    indices(): Uint32Array;
+    positions(): Float32Array;
+}
+
+/**
+ * Result of weld_and_keep_largest: holds positions + indices.
+ * Access via getters since wasm_bindgen can't return tuples.
+ */
+export class MeshResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    indices(): Uint32Array;
+    positions(): Float32Array;
+    stats(): string;
+}
+
+/**
+ * Stage 1 result: fully preprocessed mesh ready for interactive steps.
+ *
+ * Chains four operations in a single WASM call (no JS round-trips):
+ *   1. Unit detection & conversion (m → mm)
+ *   2. AABB center → origin
+ *   3. Vertex welding + largest-component extraction
+ *   4. Small-hole filling
+ */
+export class PreprocessResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    bbox_size(): Float32Array;
+    detected_unit(): string;
+    holes_filled(): number;
+    indices(): Uint32Array;
+    log(): string;
+    max_dimension(): number;
+    positions(): Float32Array;
+    unit_converted(): boolean;
+    weld_stats(): string;
+}
+
+/**
+ * Result of centroid-based alignment refinement.
+ */
+export class RefineAlignmentResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    centroid_axis(): Float32Array;
+    correction_angle(): number;
+    details(): string;
+    mpt(): Float32Array;
+    origin(): Float32Array;
+    positions(): Float32Array;
+    rotation(): Float32Array;
+}
+
+/**
+ * Result of secondary PCA alignment.
+ */
+export class SecondaryPcaResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    details(): string;
+    mpt(): Float32Array;
+    origin(): Float32Array;
+    positions(): Float32Array;
+    transform(): Float32Array;
+}
+
+/**
+ * Result of shell detection at MPT.
+ */
+export class ShellDetectResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    avg_thickness(): number;
+    details(): string;
+    double_hit_count(): number;
+    hit_points(): Float32Array;
+    hit_ray_lines(): Float32Array;
+    is_double_shell(): boolean;
+    max_thickness(): number;
+    min_thickness(): number;
+    miss_ray_lines(): Float32Array;
+    ray_count(): number;
+    surface_normal(): Float32Array;
+    thickness(): number;
+}
+
+/**
+ * Result of subdividing the origin→projection line into ~1" spaced points.
+ */
+export class SubdivideLineResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    count(): number;
+    points(): Float32Array;
+    spacing(): number;
+    total_distance(): number;
+}
+
+/**
+ * Result of detect_and_convert_units: holds positions + detection info.
+ */
+export class UnitConversionResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    converted(): boolean;
+    detected_unit(): string;
+    max_dimension(): number;
+    positions(): Float32Array;
+}
+
+/**
+ * Translate geometry so `origin_pt` maps to (0,0,0), then rotate so the
+ * vector from `origin_pt` to its projection on the cross-section plane
+ * aligns with the +Y axis.
+ *
+ * `positions`: flat [x,y,z,...] vertex positions
+ * `origin_pt`: [x,y,z] the origin point (will become 0,0,0)
+ * `mpt`: [x,y,z] the MPT point on the surface
+ * `plane_normal`: [nx,ny,nz] the cross-section plane normal
+ */
+export function align_to_origin(positions: Float32Array, origin_pt: Float32Array, mpt: Float32Array, plane_normal: Float32Array): AlignResult;
+
+/**
+ * Slice the mesh at each Y height from the given points.
+ *
+ * After PCA alignment (step 7), the mesh is Y-aligned: origin at (0,0,0),
+ * MPT along +Y. Cross-sections are horizontal planes (normal = Y axis)
+ * at each subdivision point's Y coordinate.
+ *
+ * `positions`: flat [x,y,z,...] indexed mesh positions (PCA-aligned)
+ * `indices`: flat [i0,i1,i2,...] triangle indices
+ * `y_values`: Y coordinates to slice at
+ * `max_gap`: maximum gap to bridge when chaining segments (mm)
+ */
+export function batch_cross_sections_y(positions: Float32Array, indices: Uint32Array, y_values: Float32Array, max_gap: number): BatchCrossSectionResult;
+
+/**
+ * Same as `batch_cross_sections_y` but picks the **inner** (smallest substantial)
+ * loop at each height. For double-shell meshes this selects the inner wall.
+ *
+ * Uses a tight chaining tolerance (no gap bridging) to prevent inner+outer
+ * wall segments from merging into one figure-8 loop.
+ *
+ * "Substantial" = circumference >= 30% of the largest loop at that height.
+ * Among substantial loops, picks the one with the smallest circumference.
+ */
+export function batch_cross_sections_y_inner(positions: Float32Array, indices: Uint32Array, y_values: Float32Array, _max_gap: number): BatchCrossSectionResult;
+
+/**
+ * Compute bounding box from a flat f32 position array [x,y,z, x,y,z, ...]
+ * Returns [min_x, min_y, min_z, max_x, max_y, max_z]
+ */
+export function bounding_box(positions: Float32Array): Float32Array;
+
+/**
+ * Translate positions so their AABB center is at origin.
+ * Takes flat [x,y,z,...], returns new flat [x,y,z,...].
+ */
+export function center_to_origin(positions: Float32Array): Float32Array;
+
+/**
+ * Detect if positions are in meters or millimeters based on bounding box size.
+ * If max AABB dimension < `meter_threshold` (default: 10), assumes meters and scales to mm (*1000).
+ * Otherwise assumes already in mm and passes through.
+ */
+export function detect_and_convert_units(positions: Float32Array, meter_threshold: number): UnitConversionResult;
+
+/**
+ * Detect if the surface at `mpt` is single or double shell.
+ *
+ * Strategy: compute the surface normal at `mpt` (from the closest triangle),
+ * then cast rays in a cone of directions around that normal (both sides).
+ * For each ray, count surface intersections. If we consistently find pairs
+ * of hits with small gaps, it's a double shell.
+ *
+ * `positions`: flat [x,y,z,...] indexed geometry positions
+ * `indices`: flat [i0,i1,i2,...] triangle indices
+ * `mpt`: [x,y,z] the MPT point on the surface
+ * `max_thickness`: maximum expected wall thickness — hits farther than this are ignored
+ */
+export function detect_shell(positions: Float32Array, indices: Uint32Array, mpt: Float32Array, max_thickness: number): ShellDetectResult;
+
+/**
+ * Step 5a: Extract the inner shell from a double-walled mesh.
+ *
+ * Strategy: multi-point face-visibility.
+ *   1. Use `hit_points` (outer wall hits from detect_shell) to compute the cavity
+ *      direction: vector from mean-outer-hit toward MPT = inward = cavity direction.
+ *   2. Generate a cluster of probe points at multiple depths inside the cavity,
+ *      spread laterally for concave-socket robustness.
+ *   3. For every triangle, cast a ray from each probe toward the face centroid;
+ *      if the FIRST hit is that triangle from ANY probe → inner shell.
+ *
+ * `mpt`:        user-placed point on the inner surface
+ * `wall_thickness`: median wall thickness from detect_shell
+ * `hit_points`: outer-wall hit points from detect_shell [x,y,z,...] (may be empty)
+ */
+export function extract_inner_shell(positions: Float32Array, indices: Uint32Array, mpt: Float32Array, wall_thickness: number, hit_points: Float32Array): ExtractInnerShellResult;
+
+/**
+ * Find and fill small boundary holes in an indexed mesh.
+ *
+ * A "hole" is a closed boundary loop of edges that each appear in exactly one triangle.
+ * Loops whose total perimeter is < `max_perimeter` are filled via fan triangulation
+ * from the loop centroid.
+ *
+ * `positions`: flat [x,y,z,...] vertex positions
+ * `indices`: flat [i0,i1,i2,...] triangle indices
+ * `max_perimeter`: maximum hole perimeter in mm to close (e.g. 40.0)
+ */
+export function fill_small_holes(positions: Float32Array, indices: Uint32Array, max_perimeter: number): FillHolesResult;
+
+/**
+ * Find the cross-section plane through `mpt` that gives the smallest circumference.
+ *
+ * Strategy:
+ *   1. Build rotation axes: the surface normal + 8 perturbed axes (±5° tilts)
+ *   2. For each axis, coarse scan 90 plane orientations (2° steps)
+ *   3. Refine: ±2° around best at 0.1° steps
+ *   4. Score loops by circumference × closedness × proximity to MPT
+ *
+ * `positions`: flat [x,y,z,...] indexed geometry positions
+ * `indices`: flat [i0,i1,i2,...] triangle indices
+ * `mpt`: [x,y,z] the MPT point on the surface
+ * `surface_normal`: [nx,ny,nz] surface normal at MPT
+ * `max_gap`: maximum gap to bridge when chaining segments into loops (mm)
+ */
+export function find_min_cross_section(positions: Float32Array, indices: Uint32Array, mpt: Float32Array, surface_normal: Float32Array, max_gap: number): CrossSectionResult;
+
+/**
+ * Initialize panic hook for better WASM error messages in the browser console.
+ * Called automatically on WASM module init.
+ */
+export function init(): void;
+
+/**
+ * Stage 1: preprocess a raw mesh in one shot.
+ *
+ * Accepts raw geometry (positions + optional indices) and runs all four
+ * automatic preprocessing steps without crossing the WASM boundary in between.
+ *
+ * **Parameters**
+ * - `positions`: flat `[x,y,z, …]` vertex positions
+ * - `indices`:   flat `[i0,i1,i2, …]` triangle indices (pass empty array for non-indexed)
+ * - `meter_threshold`: max AABB dimension (in model units) below which the
+ *   geometry is assumed to be in meters and scaled ×1000 to mm (default: `10.0`)
+ * - `weld_tolerance`: distance within which vertices are merged (default: `1e-4`)
+ * - `max_hole_perimeter`: boundary loops shorter than this (mm) are fan-filled (default: `300.0`)
+ */
+export function preprocess_mesh(positions: Float32Array, indices: Uint32Array, meter_threshold: number, weld_tolerance: number, max_hole_perimeter: number): PreprocessResult;
+
+/**
+ * Build a BVH from flat triangle positions and ray-cast against it.
+ * `positions`: flat [x,y,z, ...] with every 9 floats = 1 triangle
+ * `ray_origin`: [ox, oy, oz]
+ * `ray_dir`: [dx, dy, dz]
+ * Returns indices of triangles whose AABBs the ray intersects.
+ */
+export function ray_cast_bvh(positions: Float32Array, ray_origin: Float32Array, ray_dir: Float32Array): Uint32Array;
+
+/**
+ * Step 9: Refine alignment using cross-section centroids.
+ *
+ * Computes PCA on the centroids of cross-section loops to find the "true"
+ * limb axis, then rotates the mesh so this axis aligns with +Y.
+ *
+ * `centroids`: flat [x,y,z,...] centroid of each cross-section loop
+ * `all_positions`: flat [x,y,z,...] full mesh positions
+ * `origin_pt`: [x,y,z]
+ * `mpt`: [x,y,z]
+ */
+export function refine_alignment(centroids: Float32Array, all_positions: Float32Array, origin_pt: Float32Array, mpt: Float32Array): RefineAlignmentResult;
+
+/**
+ * Compute PCA on `selected_positions` (the region of interest),
+ * then apply the resulting rotation to `all_positions` (full mesh).
+ *
+ * The principal axis (longest variance) aligns with +Y.
+ * Ensures `origin_pt.y < mpt.y` after rotation (origin below MPT).
+ *
+ * `selected_positions`: flat [x,y,z,...] of selected region vertices
+ * `all_positions`: flat [x,y,z,...] of full mesh
+ * `origin_pt`: [x,y,z]
+ * `mpt`: [x,y,z]
+ */
+export function secondary_pca(selected_positions: Float32Array, all_positions: Float32Array, origin_pt: Float32Array, mpt: Float32Array): SecondaryPcaResult;
+
+/**
+ * Step 8: Subdivide the line from `origin_pt` to its projection onto the
+ * cross-section plane into points spaced roughly 1 inch (25.4 mm) apart.
+ *
+ * `origin_pt`: [x,y,z] the origin point
+ * `mpt`: [x,y,z] a point on the cross-section plane
+ * `plane_normal`: [nx,ny,nz] the cross-section plane normal
+ *
+ * Returns the series of evenly-spaced points along the line (both endpoints included).
+ */
+export function subdivide_origin_to_plane(origin_pt: Float32Array, mpt: Float32Array, plane_normal: Float32Array): SubdivideLineResult;
+
+/**
+ * Weld close vertices, find connected components, keep only the largest mesh.
+ *
+ * `positions`: flat [x,y,z,...] — non-indexed (every 9 floats = 1 triangle)
+ * `tolerance`: distance within which vertices are merged
+ *
+ * For indexed input, use `weld_and_keep_largest_indexed`.
+ */
+export function weld_and_keep_largest(positions: Float32Array, tolerance: number): MeshResult;
+
+/**
+ * Same as above but for indexed geometry.
+ * `positions`: flat [x,y,z,...]
+ * `indices`: flat [i0,i1,i2, ...] triangle indices
+ * `tolerance`: weld distance
+ */
+export function weld_and_keep_largest_indexed(positions: Float32Array, indices: Uint32Array, tolerance: number): MeshResult;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_crosssectionresult_free: (a: number, b: number) => void;
+    readonly crosssectionresult_loop_points: (a: number) => [number, number];
+    readonly crosssectionresult_plane_normal: (a: number) => [number, number];
+    readonly crosssectionresult_circumference: (a: number) => number;
+    readonly crosssectionresult_is_closed: (a: number) => number;
+    readonly crosssectionresult_details: (a: number) => [number, number];
+    readonly find_min_cross_section: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => number;
+    readonly __wbg_batchcrosssectionresult_free: (a: number, b: number) => void;
+    readonly batchcrosssectionresult_all_loop_points: (a: number) => [number, number];
+    readonly batchcrosssectionresult_offsets: (a: number) => [number, number];
+    readonly batchcrosssectionresult_circumferences: (a: number) => [number, number];
+    readonly batchcrosssectionresult_count: (a: number) => number;
+    readonly batchcrosssectionresult_details: (a: number) => [number, number];
+    readonly batch_cross_sections_y: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+    readonly batch_cross_sections_y_inner: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+    readonly __wbg_unitconversionresult_free: (a: number, b: number) => void;
+    readonly unitconversionresult_positions: (a: number) => [number, number];
+    readonly unitconversionresult_detected_unit: (a: number) => [number, number];
+    readonly unitconversionresult_converted: (a: number) => number;
+    readonly unitconversionresult_max_dimension: (a: number) => number;
+    readonly detect_and_convert_units: (a: number, b: number, c: number) => number;
+    readonly center_to_origin: (a: number, b: number) => [number, number];
+    readonly __wbg_meshresult_free: (a: number, b: number) => void;
+    readonly meshresult_positions: (a: number) => [number, number];
+    readonly meshresult_indices: (a: number) => [number, number];
+    readonly meshresult_stats: (a: number) => [number, number];
+    readonly weld_and_keep_largest: (a: number, b: number, c: number) => number;
+    readonly weld_and_keep_largest_indexed: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly __wbg_alignresult_free: (a: number, b: number) => void;
+    readonly alignresult_positions: (a: number) => [number, number];
+    readonly alignresult_mpt: (a: number) => [number, number];
+    readonly alignresult_origin: (a: number) => [number, number];
+    readonly alignresult_transform: (a: number) => [number, number];
+    readonly alignresult_details: (a: number) => [number, number];
+    readonly align_to_origin: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
+    readonly __wbg_secondarypcaresult_free: (a: number, b: number) => void;
+    readonly secondarypcaresult_positions: (a: number) => [number, number];
+    readonly secondarypcaresult_mpt: (a: number) => [number, number];
+    readonly secondarypcaresult_origin: (a: number) => [number, number];
+    readonly secondarypcaresult_transform: (a: number) => [number, number];
+    readonly secondarypcaresult_details: (a: number) => [number, number];
+    readonly secondary_pca: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
+    readonly __wbg_refinealignmentresult_free: (a: number, b: number) => void;
+    readonly refinealignmentresult_positions: (a: number) => [number, number];
+    readonly refinealignmentresult_mpt: (a: number) => [number, number];
+    readonly refinealignmentresult_origin: (a: number) => [number, number];
+    readonly refinealignmentresult_rotation: (a: number) => [number, number];
+    readonly refinealignmentresult_centroid_axis: (a: number) => [number, number];
+    readonly refinealignmentresult_correction_angle: (a: number) => number;
+    readonly refinealignmentresult_details: (a: number) => [number, number];
+    readonly refine_alignment: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
+    readonly __wbg_subdividelineresult_free: (a: number, b: number) => void;
+    readonly subdividelineresult_points: (a: number) => [number, number];
+    readonly subdividelineresult_count: (a: number) => number;
+    readonly subdividelineresult_spacing: (a: number) => number;
+    readonly subdividelineresult_total_distance: (a: number) => number;
+    readonly subdivide_origin_to_plane: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+    readonly __wbg_fillholesresult_free: (a: number, b: number) => void;
+    readonly fillholesresult_positions: (a: number) => [number, number];
+    readonly fillholesresult_indices: (a: number) => [number, number];
+    readonly fillholesresult_holes_filled: (a: number) => number;
+    readonly fillholesresult_details: (a: number) => [number, number];
+    readonly fill_small_holes: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly __wbg_shelldetectresult_free: (a: number, b: number) => void;
+    readonly shelldetectresult_is_double_shell: (a: number) => number;
+    readonly shelldetectresult_thickness: (a: number) => number;
+    readonly shelldetectresult_ray_count: (a: number) => number;
+    readonly shelldetectresult_double_hit_count: (a: number) => number;
+    readonly shelldetectresult_avg_thickness: (a: number) => number;
+    readonly shelldetectresult_min_thickness: (a: number) => number;
+    readonly shelldetectresult_max_thickness: (a: number) => number;
+    readonly shelldetectresult_details: (a: number) => [number, number];
+    readonly shelldetectresult_hit_ray_lines: (a: number) => [number, number];
+    readonly shelldetectresult_miss_ray_lines: (a: number) => [number, number];
+    readonly shelldetectresult_hit_points: (a: number) => [number, number];
+    readonly shelldetectresult_surface_normal: (a: number) => [number, number];
+    readonly detect_shell: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+    readonly __wbg_extractinnershellresult_free: (a: number, b: number) => void;
+    readonly extractinnershellresult_positions: (a: number) => [number, number];
+    readonly extractinnershellresult_indices: (a: number) => [number, number];
+    readonly extractinnershellresult_interior_point: (a: number) => [number, number];
+    readonly extractinnershellresult_inner_count: (a: number) => number;
+    readonly extractinnershellresult_total_count: (a: number) => number;
+    readonly extractinnershellresult_details: (a: number) => [number, number];
+    readonly extract_inner_shell: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => number;
+    readonly ray_cast_bvh: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+    readonly __wbg_preprocessresult_free: (a: number, b: number) => void;
+    readonly preprocessresult_positions: (a: number) => [number, number];
+    readonly preprocessresult_indices: (a: number) => [number, number];
+    readonly preprocessresult_bbox_size: (a: number) => [number, number];
+    readonly preprocessresult_detected_unit: (a: number) => [number, number];
+    readonly preprocessresult_unit_converted: (a: number) => number;
+    readonly preprocessresult_max_dimension: (a: number) => number;
+    readonly preprocessresult_weld_stats: (a: number) => [number, number];
+    readonly preprocessresult_holes_filled: (a: number) => number;
+    readonly preprocessresult_log: (a: number) => [number, number];
+    readonly preprocess_mesh: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+    readonly init: () => void;
+    readonly bounding_box: (a: number, b: number) => [number, number];
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;