@woosh/meep-engine 2.164.0 → 2.165.0

package/src/core/geom/3d/atlas/segment/atlas_compute_planar_regions.js

@@ -0,0 +1,77 @@
+import { uf_find, uf_init, uf_union } from "../../../../collection/union-find/union_find.js";
+import { NULL_POINTER } from "../../topology/struct/binary/BinaryTopology.js";
+import { EDGE_DIHEDRAL_BOUNDARY } from "../data/atlas_build_edge_dihedrals.js";
+
+/**
+ * How close to coplanar (adjacent-normal dot == 1) two faces must be to merge
+ * into the same planar region. xatlas uses a strict kEpsilon coplanarity test.
+ * @type {number}
+ */
+export const ATLAS_COPLANAR_TOLERANCE = 1e-4;
+
+/**
+ * Merge connected, (near-)coplanar faces into planar regions via union-find
+ * over interior edges (xatlas `computePlanarCharts` seeding). Two faces sharing
+ * an edge are unioned when the edge's adjacent-normal dot is >= 1 - tolerance.
+ * Boundary edges never merge across.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {Float32Array} edge_dihedrals from {@link atlas_build_edge_dihedrals}
+ * @param {number} [coplanar_tolerance]
+ * @returns {{region_of_face: Uint32Array, region_count: number}} `region_of_face`
+ *   maps each allocated face to a dense region id in [0, region_count);
+ *   unallocated faces map to {@link NULL_POINTER}.
+ */
+export function atlas_compute_planar_regions(mesh, edge_dihedrals, coplanar_tolerance = ATLAS_COPLANAR_TOLERANCE) {
+    const faces = mesh.faces;
+    const face_count = faces.size;
+
+    const parent = new Uint32Array(face_count);
+    uf_init(parent, face_count);
+
+    const edges = mesh.edges;
+    const edge_count = edges.size;
+    const threshold = 1 - coplanar_tolerance;
+
+    for (let e = 0; e < edge_count; e++) {
+        if (!edges.is_allocated(e)) {
+            continue;
+        }
+
+        const d = edge_dihedrals[e];
+        if (d === EDGE_DIHEDRAL_BOUNDARY || d < threshold) {
+            continue;
+        }
+
+        const l1 = mesh.edge_read_loop(e);
+        if (l1 === NULL_POINTER) {
+            continue;
+        }
+        const l2 = mesh.loop_read_radial_next(l1);
+        if (l2 === l1) {
+            continue;
+        }
+
+        uf_union(parent, mesh.loop_read_face(l1), mesh.loop_read_face(l2));
+    }
+
+    const region_of_face = new Uint32Array(face_count);
+    const remap = new Uint32Array(face_count).fill(NULL_POINTER);
+    let region_count = 0;
+
+    for (let f = 0; f < face_count; f++) {
+        if (!faces.is_allocated(f)) {
+            region_of_face[f] = NULL_POINTER;
+            continue;
+        }
+
+        const root = uf_find(parent, f);
+        if (remap[root] === NULL_POINTER) {
+            remap[root] = region_count;
+            region_count++;
+        }
+        region_of_face[f] = remap[root];
+    }
+
+    return { region_of_face, region_count };
+}

package/src/core/geom/3d/atlas/segment/atlas_merge_charts.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Greedily merge adjacent charts whose area-weighted proxy normals are nearly
+ * aligned (xatlas `mergeCharts`, conservative variant), reducing over-
+ * segmentation left by the greedy seed+grow. Union-find over chart ids; proxy
+ * accumulators are summed as charts merge, so each test is against the current
+ * merged normal. Interior edges are visited in ascending id order, and the
+ * smaller chart id is always chosen as the union root, so the relabelling is
+ * deterministic. Coverage is preserved (every face keeps a chart; ids densified).
+ *
+ * This does NOT re-parameterize — the driver re-extracts and parameterizes the
+ * merged charts. Zero-area charts (degenerate proxy) are never merged.
+ *
+ * @param {BinaryTopology} mesh face normals populated
+ * @param {Int32Array} face_chart face -> chart id (-1 if none)
+ * @param {number} chart_count
+ * @param {Float32Array} face_areas
+ * @param {object} [options]
+ * @param {number} [options.mergeMinDot] min proxy-normal dot to merge (default 0.9)
+ * @returns {{face_chart: Int32Array, chart_count: number}}
+ */
+export function atlas_merge_charts(mesh: BinaryTopology, face_chart: Int32Array, chart_count: number, face_areas: Float32Array, options?: {
+    mergeMinDot?: number;
+}): {
+    face_chart: Int32Array;
+    chart_count: number;
+};
+//# sourceMappingURL=atlas_merge_charts.d.ts.map

package/src/core/geom/3d/atlas/segment/atlas_merge_charts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atlas_merge_charts.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/segment/atlas_merge_charts.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qEAPW,UAAU,eACV,MAAM,cACN,YAAY;IAEK,WAAW,GAA5B,MAAM;IACJ;IAAC,UAAU,EAAE,UAAU,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAC,CAkFzD"}

package/src/core/geom/3d/atlas/segment/atlas_merge_charts.js

@@ -0,0 +1,113 @@
+import { NULL_POINTER } from "../../topology/struct/binary/BinaryTopology.js";
+
+/**
+ * Default minimum proxy-normal dot for a merge. Conservative (~25°): only
+ * near-coplanar adjacent charts merge, so the merged chart stays flat enough to
+ * parameterize without new distortion. xatlas uses 0.5 (~60°) but pairs it with
+ * a per-merge ortho re-validation we deliberately leave to the downstream
+ * parameterization (an over-aggressive merge that can't flatten simply falls back
+ * to LSCM/piecewise — and the metrics A/B gate catches any regression).
+ */
+const DEFAULT_MERGE_MIN_DOT = 0.9;
+
+/**
+ * Greedily merge adjacent charts whose area-weighted proxy normals are nearly
+ * aligned (xatlas `mergeCharts`, conservative variant), reducing over-
+ * segmentation left by the greedy seed+grow. Union-find over chart ids; proxy
+ * accumulators are summed as charts merge, so each test is against the current
+ * merged normal. Interior edges are visited in ascending id order, and the
+ * smaller chart id is always chosen as the union root, so the relabelling is
+ * deterministic. Coverage is preserved (every face keeps a chart; ids densified).
+ *
+ * This does NOT re-parameterize — the driver re-extracts and parameterizes the
+ * merged charts. Zero-area charts (degenerate proxy) are never merged.
+ *
+ * @param {BinaryTopology} mesh face normals populated
+ * @param {Int32Array} face_chart face -> chart id (-1 if none)
+ * @param {number} chart_count
+ * @param {Float32Array} face_areas
+ * @param {object} [options]
+ * @param {number} [options.mergeMinDot] min proxy-normal dot to merge (default 0.9)
+ * @returns {{face_chart: Int32Array, chart_count: number}}
+ */
+export function atlas_merge_charts(mesh, face_chart, chart_count, face_areas, options = {}) {
+    const min_dot = options.mergeMinDot ?? DEFAULT_MERGE_MIN_DOT;
+    const faces = mesh.faces;
+    const face_count = faces.size;
+
+    // per-chart area-weighted (un-normalized) normal accumulator = the proxy
+    const proxy = new Float64Array(chart_count * 3);
+    const fn = new Float32Array(3);
+    for (let f = 0; f < face_count; f++) {
+        if (!faces.is_allocated(f)) continue;
+        const c = face_chart[f];
+        if (c < 0) continue;
+        const a = face_areas[f];
+        mesh.face_read_normal(fn, 0, f);
+        proxy[c * 3] += fn[0] * a;
+        proxy[c * 3 + 1] += fn[1] * a;
+        proxy[c * 3 + 2] += fn[2] * a;
+    }
+
+    const parent = new Int32Array(chart_count);
+    for (let c = 0; c < chart_count; c++) parent[c] = c;
+
+    /** @param {number} x @returns {number} root with path compression */
+    function find(x) {
+        while (parent[x] !== x) {
+            parent[x] = parent[parent[x]];
+            x = parent[x];
+        }
+        return x;
+    }
+
+    /** Whether two roots' proxy normals are within the merge cone. */
+    function aligned(a, b) {
+        const ax = proxy[a * 3], ay = proxy[a * 3 + 1], az = proxy[a * 3 + 2];
+        const bx = proxy[b * 3], by = proxy[b * 3 + 1], bz = proxy[b * 3 + 2];
+        const la = Math.sqrt(ax * ax + ay * ay + az * az);
+        const lb = Math.sqrt(bx * bx + by * by + bz * bz);
+        if (la === 0 || lb === 0) return false; // zero-area chart -> never merge
+        return (ax * bx + ay * by + az * bz) / (la * lb) >= min_dot;
+    }
+
+    const edges = mesh.edges;
+    const edge_count = edges.size;
+    for (let e = 0; e < edge_count; e++) {
+        if (!edges.is_allocated(e)) continue;
+        const l1 = mesh.edge_read_loop(e);
+        if (l1 === NULL_POINTER) continue;
+        const l2 = mesh.loop_read_radial_next(l1);
+        if (l2 === l1) continue; // mesh boundary edge
+
+        const c1 = face_chart[mesh.loop_read_face(l1)];
+        const c2 = face_chart[mesh.loop_read_face(l2)];
+        if (c1 < 0 || c2 < 0 || c1 === c2) continue;
+
+        const r1 = find(c1);
+        const r2 = find(c2);
+        if (r1 === r2 || !aligned(r1, r2)) continue;
+
+        const root = r1 < r2 ? r1 : r2;
+        const other = r1 < r2 ? r2 : r1;
+        parent[other] = root;
+        proxy[root * 3] += proxy[other * 3];
+        proxy[root * 3 + 1] += proxy[other * 3 + 1];
+        proxy[root * 3 + 2] += proxy[other * 3 + 2];
+    }
+
+    // densify root ids in ascending order
+    const dense = new Int32Array(chart_count).fill(-1);
+    let new_count = 0;
+    for (let c = 0; c < chart_count; c++) {
+        const r = find(c);
+        if (dense[r] === -1) dense[r] = new_count++;
+    }
+
+    const out = new Int32Array(face_count).fill(-1);
+    for (let f = 0; f < face_count; f++) {
+        const c = face_chart[f];
+        if (c >= 0) out[f] = dense[find(c)];
+    }
+    return { face_chart: out, chart_count: new_count };
+}

package/src/core/geom/3d/atlas/segment/atlas_segment_charts.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Greedy chart segmentation (xatlas `Atlas::computeCharts`, region-growing core).
+ * Charts are grown one at a time from the lowest-id unassigned face; each chart
+ * absorbs its cheapest edge-adjacent neighbour until the cheapest candidate's
+ * cost exceeds `maxCost`, then a new chart is seeded. Coverage is total — every
+ * allocated face ends in exactly one chart.
+ *
+ * The cost of adding a face is `normalDeviationWeight·N + normalSeamWeight·NS +
+ * roundnessWeight·R`, where N is the deviation of the face normal from the
+ * chart's running area-weighted normal, NS is the length-weighted normal
+ * discontinuity across the shared edges, and R is the relative isoperimetric
+ * (roundness) change. The candidate queue is a min-heap with lazy
+ * re-evaluation: a popped entry whose cost drifted is re-queued at its fresh
+ * cost before any face is committed, so commits always act on the true minimum.
+ *
+ * Determinism: seed order is ascending face id, the heap and cost are
+ * deterministic, and there is no wall-clock exit — the labelling is
+ * reproducible.
+ *
+ * Note: segmentation here is face-granular. xatlas grows whole coplanar regions
+ * atomically; that is a quality/perf refinement layered on the same cost and is
+ * a deferred follow-up.
+ *
+ * @param {BinaryTopology} mesh face normals must be populated
+ * @param {Float32Array} face_areas from atlas_build_face_areas
+ * @param {Float32Array} edge_lengths from atlas_build_edge_lengths
+ * @param {Float32Array} edge_dihedrals from atlas_build_edge_dihedrals
+ * @param {object} [options] overrides of {@link ATLAS_SEGMENT_DEFAULTS}
+ * @returns {{face_chart: Int32Array, chart_count: number}} `face_chart[f]` is the
+ *   chart id of face f, or -1 for unallocated faces.
+ */
+export function atlas_segment_charts(mesh: BinaryTopology, face_areas: Float32Array, edge_lengths: Float32Array, edge_dihedrals: Float32Array, options?: object): {
+    face_chart: Int32Array;
+    chart_count: number;
+};
+export namespace ATLAS_SEGMENT_DEFAULTS {
+    let maxCost: number;
+    let normalDeviationWeight: number;
+    let normalSeamWeight: number;
+    let roundnessWeight: number;
+    let maxChartArea: number;
+    let maxBoundaryLength: number;
+}
+//# sourceMappingURL=atlas_segment_charts.d.ts.map

package/src/core/geom/3d/atlas/segment/atlas_segment_charts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atlas_segment_charts.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/segment/atlas_segment_charts.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,uEAPW,YAAY,gBACZ,YAAY,kBACZ,YAAY,YACZ,MAAM;gBACS,UAAU;iBAAe,MAAM;EA+MxD"}

package/src/core/geom/3d/atlas/segment/atlas_segment_charts.js

@@ -0,0 +1,275 @@
+import { IndexedFloatMinHeap } from "../../../../collection/heap/IndexedFloatMinHeap.js";
+import { v3_dot } from "../../../vec3/v3_dot.js";
+import { EDGE_DIHEDRAL_BOUNDARY } from "../data/atlas_build_edge_dihedrals.js";
+
+/**
+ * Cost returned for a face that must not join the chart (hard reject). Never
+ * inserted into the heap.
+ * @type {number}
+ */
+const REJECT = Infinity;
+
+/**
+ * Hard reject when the normal-deviation term reaches this — `1 - dot >= 0.707`
+ * is roughly a 73 degree fold away from the chart's running normal. Matches
+ * xatlas's `computeCost` hard cutoff.
+ * @type {number}
+ */
+const NORMAL_DEVIATION_REJECT = 0.707;
+
+/**
+ * A heap entry is considered stale (recomputed against a drifted chart normal)
+ * when its fresh cost differs from the stored cost by more than this.
+ * @type {number}
+ */
+const STALE_EPSILON = 1e-6;
+
+/**
+ * Default segmentation weights/limits (xatlas `ChartOptions`). The texture-seam
+ * term is intentionally absent: this port never ingests authored UVs.
+ */
+export const ATLAS_SEGMENT_DEFAULTS = {
+    maxCost: 2,
+    normalDeviationWeight: 2,
+    normalSeamWeight: 4,
+    roundnessWeight: 0.01,
+    maxChartArea: 0,
+    maxBoundaryLength: 0,
+};
+
+/**
+ * Greedy chart segmentation (xatlas `Atlas::computeCharts`, region-growing core).
+ * Charts are grown one at a time from the lowest-id unassigned face; each chart
+ * absorbs its cheapest edge-adjacent neighbour until the cheapest candidate's
+ * cost exceeds `maxCost`, then a new chart is seeded. Coverage is total — every
+ * allocated face ends in exactly one chart.
+ *
+ * The cost of adding a face is `normalDeviationWeight·N + normalSeamWeight·NS +
+ * roundnessWeight·R`, where N is the deviation of the face normal from the
+ * chart's running area-weighted normal, NS is the length-weighted normal
+ * discontinuity across the shared edges, and R is the relative isoperimetric
+ * (roundness) change. The candidate queue is a min-heap with lazy
+ * re-evaluation: a popped entry whose cost drifted is re-queued at its fresh
+ * cost before any face is committed, so commits always act on the true minimum.
+ *
+ * Determinism: seed order is ascending face id, the heap and cost are
+ * deterministic, and there is no wall-clock exit — the labelling is
+ * reproducible.
+ *
+ * Note: segmentation here is face-granular. xatlas grows whole coplanar regions
+ * atomically; that is a quality/perf refinement layered on the same cost and is
+ * a deferred follow-up.
+ *
+ * @param {BinaryTopology} mesh face normals must be populated
+ * @param {Float32Array} face_areas from atlas_build_face_areas
+ * @param {Float32Array} edge_lengths from atlas_build_edge_lengths
+ * @param {Float32Array} edge_dihedrals from atlas_build_edge_dihedrals
+ * @param {object} [options] overrides of {@link ATLAS_SEGMENT_DEFAULTS}
+ * @returns {{face_chart: Int32Array, chart_count: number}} `face_chart[f]` is the
+ *   chart id of face f, or -1 for unallocated faces.
+ */
+export function atlas_segment_charts(mesh, face_areas, edge_lengths, edge_dihedrals, options = {}) {
+    const opt = { ...ATLAS_SEGMENT_DEFAULTS, ...options };
+
+    const faces = mesh.faces;
+    const face_count = faces.size;
+
+    const face_chart = new Int32Array(face_count).fill(-1);
+    const face_cost = new Float32Array(face_count);
+    const heap = new IndexedFloatMinHeap(face_count);
+
+    const fn = new Float32Array(3);
+    const cn = new Float32Array(3);
+
+    // Mutable state of the chart currently being grown.
+    let chart_id = 0;
+    let chart_area = 0;
+    let chart_boundary = 0;
+    let accum_x = 0, accum_y = 0, accum_z = 0;
+
+    // Output of the last evaluate() call, to avoid per-candidate allocation.
+    let out_area = 0;
+    let out_boundary = 0;
+
+    /**
+     * Normalize the chart's running area-weighted normal accumulator into `cn`.
+     */
+    function chart_unit_normal() {
+        const len = Math.sqrt(accum_x * accum_x + accum_y * accum_y + accum_z * accum_z) || 1;
+        cn[0] = accum_x / len;
+        cn[1] = accum_y / len;
+        cn[2] = accum_z / len;
+    }
+
+    /**
+     * Sum of edge lengths around face f (its perimeter).
+     * @param {number} f face id
+     * @returns {number}
+     */
+    function face_perimeter(f) {
+        let p = 0;
+        let l = mesh.face_read_loop(f);
+        const start = l;
+        do {
+            p += edge_lengths[mesh.loop_read_edge(l)];
+            l = mesh.loop_read_next(l);
+        } while (l !== start);
+        return p;
+    }
+
+    /**
+     * Cost of adding face g to the current chart, or REJECT. Side effect: sets
+     * out_area / out_boundary for the caller to commit.
+     * @param {number} g face id
+     * @returns {number}
+     */
+    function evaluate(g) {
+        mesh.face_read_normal(fn, 0, g);
+        chart_unit_normal();
+
+        const dot = v3_dot(cn[0], cn[1], cn[2], fn[0], fn[1], fn[2]);
+        const N = Math.min(1 - dot, 1);
+        if (N >= NORMAL_DEVIATION_REJECT) {
+            return REJECT;
+        }
+
+        const new_area = chart_area + face_areas[g];
+        if (opt.maxChartArea > 0 && new_area > opt.maxChartArea) {
+            return REJECT;
+        }
+
+        let shared_len = 0;
+        let shared_seam = 0;
+        let boundary_delta = 0;
+
+        let l = mesh.face_read_loop(g);
+        const start = l;
+        do {
+            const e = mesh.loop_read_edge(l);
+            const len = edge_lengths[e];
+            const opp = mesh.loop_read_radial_next(l);
+            const opp_face = opp === l ? -1 : mesh.loop_read_face(opp);
+
+            if (opp_face !== -1 && face_chart[opp_face] === chart_id) {
+                shared_len += len;
+                const dih = edge_dihedrals[e];
+                const dd = dih === EDGE_DIHEDRAL_BOUNDARY ? 1 : dih;
+                shared_seam += len * (1 - dd);
+                boundary_delta -= len;
+            } else {
+                boundary_delta += len;
+            }
+
+            l = mesh.loop_read_next(l);
+        } while (l !== start);
+
+        const new_boundary = chart_boundary + boundary_delta;
+        if (opt.maxBoundaryLength > 0 && new_boundary > opt.maxBoundaryLength) {
+            return REJECT;
+        }
+
+        const NS = shared_len > 0 ? shared_seam / shared_len : 0;
+
+        let R = 0;
+        if (chart_area > 0 && chart_boundary > 0 && new_boundary > 0) {
+            const old_ratio = (chart_boundary * chart_boundary) / chart_area;
+            const new_ratio = (new_boundary * new_boundary) / new_area;
+            R = 1 - old_ratio / new_ratio;
+        }
+
+        out_area = new_area;
+        out_boundary = new_boundary;
+
+        return opt.normalDeviationWeight * N + opt.normalSeamWeight * NS + opt.roundnessWeight * R;
+    }
+
+    /**
+     * (Re-)evaluate and (re-)queue every unallocated face edge-adjacent to f,
+     * caching each candidate's cost in `face_cost`.
+     * @param {number} f face id just committed to the current chart
+     */
+    function push_neighbours(f) {
+        let l = mesh.face_read_loop(f);
+        const start = l;
+        do {
+            const opp = mesh.loop_read_radial_next(l);
+            if (opp !== l) {
+                const h = mesh.loop_read_face(opp);
+                if (faces.is_allocated(h) && face_chart[h] === -1) {
+                    const c = evaluate(h);
+                    if (c !== REJECT) {
+                        if (heap.contains(h)) {
+                            heap.update(h, c);
+                        } else {
+                            heap.insert(h, c);
+                        }
+                        face_cost[h] = c;
+                    }
+                }
+            }
+            l = mesh.loop_read_next(l);
+        } while (l !== start);
+    }
+
+    let chart_count = 0;
+
+    for (let seed = 0; seed < face_count; seed++) {
+        if (!faces.is_allocated(seed) || face_chart[seed] !== -1) {
+            continue;
+        }
+
+        chart_id = chart_count;
+        chart_count++;
+        heap.clear();
+
+        face_chart[seed] = chart_id;
+        mesh.face_read_normal(fn, 0, seed);
+        const seed_area = face_areas[seed];
+        accum_x = fn[0] * seed_area;
+        accum_y = fn[1] * seed_area;
+        accum_z = fn[2] * seed_area;
+        chart_area = seed_area;
+        chart_boundary = face_perimeter(seed);
+
+        push_neighbours(seed);
+
+        for (;;) {
+            const g = heap.pop_min();
+            if (g === -1) {
+                break;
+            }
+            if (face_chart[g] !== -1) {
+                continue;
+            }
+
+            const stored = face_cost[g];
+            const fresh = evaluate(g);
+
+            if (fresh === REJECT) {
+                continue;
+            }
+            if (Math.abs(fresh - stored) > STALE_EPSILON) {
+                // Cost drifted with the chart normal — re-queue at the true value.
+                face_cost[g] = fresh;
+                heap.insert(g, fresh);
+                continue;
+            }
+            if (fresh > opt.maxCost) {
+                break;
+            }
+
+            face_chart[g] = chart_id;
+            chart_area = out_area;
+            chart_boundary = out_boundary;
+            mesh.face_read_normal(fn, 0, g);
+            const ga = face_areas[g];
+            accum_x += fn[0] * ga;
+            accum_y += fn[1] * ga;
+            accum_z += fn[2] * ga;
+
+            push_neighbours(g);
+        }
+    }
+
+    return { face_chart, chart_count };
+}

package/src/core/geom/3d/atlas/segment/atlas_segment_charts_atomic.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Region-atomic chart segmentation (xatlas grows whole coplanar regions as
+ * units). Identical greedy structure and cost to {@link atlas_segment_charts},
+ * but the growth nodes are planar regions from {@link atlas_build_region_graph}
+ * rather than individual triangles: a chart absorbs an entire region at a time.
+ * This keeps coplanar faces together (no seam through a flat surface) and is
+ * far cheaper on flat-heavy meshes (the heap holds regions, not triangles).
+ *
+ * Cost = `normalDeviationWeight·N + normalSeamWeight·NS + roundnessWeight·R`,
+ * with the same 73-degree hard reject and optional area/boundary caps. The
+ * candidate queue uses the same lazy re-evaluation. Deterministic.
+ *
+ * @param {RegionGraph} region_graph from atlas_build_region_graph
+ * @param {Uint32Array} region_of_face face -> region id (NULL_POINTER if unallocated)
+ * @param {object} [options] overrides of ATLAS_SEGMENT_DEFAULTS
+ * @returns {{face_chart: Int32Array, chart_count: number}}
+ */
+export function atlas_segment_charts_atomic(region_graph: RegionGraph, region_of_face: Uint32Array, options?: object): {
+    face_chart: Int32Array;
+    chart_count: number;
+};
+//# sourceMappingURL=atlas_segment_charts_atomic.d.ts.map

package/src/core/geom/3d/atlas/segment/atlas_segment_charts_atomic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atlas_segment_charts_atomic.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/segment/atlas_segment_charts_atomic.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;GAgBG;AACH,uFAJW,WAAW,YACX,MAAM;gBACS,UAAU;iBAAe,MAAM;EA6KxD"}