@ortho-earth/voxel 0.0.0-stage → 0.4.0

package/dist/index.js

@@ -0,0 +1,289 @@
+import { prepareGrid, transferables, checkVoxelData, checkClip, buildColormap, thrOf, frameAt } from "./grid.js";
+export { prepare, checkVoxelData, checkClip, thrOf, buildColormap, colorStops, parseColor, quantize, toRgba8, valueRange, placeBox, placeRegion, unitAt, hprMat, enuBasis, ecefToLngLat, ecefEnuRows, inv3, mul3, rayBox, marchBlocks, COLORMAPS, COLORMAP_NAMES, SHELL_N, prepareGrid, maxOf, needsBricks, brickSpans, extract, parentIndex, frameValues, frameAt, BRICK, BRICK_LIMIT } from "./grid.js";
+// 描き手（worker）の URL＝入口（voxel-draw.js が兄弟を import）。字面は .js のまま＝npm の dist では実体・repo の中では Vite が .ts に読み替える
+const VOXEL_URL = new URL("./voxel-draw.js", import.meta.url).href;
+export const VERSION = "0.4.0";
+/** 楕円体表示の b/a（region の殻を本体と同じ形で作る） */
+const R_AX_ELL = 1 - 1 / 298.257223563;
+const rAxOf = (map) => { try {
+    return map.ellipsoidOn?.() ? R_AX_ELL : 1;
+}
+catch {
+    return 1;
+} };
+const shared = new WeakMap();
+/** 手綱が全部外れてからオーバーレイを片付けるまでの猶予（ms）＝場面の切り替え（remove → すぐ addData）で同じ名のオーバーレイを壊して作り直さない（render worker の片付けと新しい登録が競う） */
+export const OVERLAY_LINGER_MS = 250;
+function acquire(map, above, id, backend) {
+    let m = shared.get(map);
+    if (!m)
+        shared.set(map, (m = { ids: new Set() }));
+    if (m.ids.has(id))
+        throw new Error(`voxel: a layer with id "${id}" already exists`);
+    const k = above ? "above" : "below";
+    if (m[k]?.idle) {
+        clearTimeout(m[k].idle);
+        m[k].idle = null;
+    } // 片付けの猶予の中＝そのまま使う
+    if (!m[k]) {
+        const ov = map.overlay(VOXEL_URL, { name: above ? "voxel:above" : "voxel", above, opts: { depth: true, backend } });
+        const slot = { ov, refs: 0, backend: null, errors: new Map(), idle: null };
+        ov.onmessage = (d) => {
+            const e = d;
+            if (e?.type === "backend") {
+                slot.backend = e.backend ?? null;
+                if (e.error)
+                    console.error("[voxel] overlay failed:", e.error);
+            }
+            else if (e?.type === "error" && e.q != null) {
+                console.warn("[voxel]", e.q, e.error);
+                slot.errors.get(e.q)?.(e.error || "error");
+            }
+        };
+        m[k] = slot;
+    }
+    m[k].refs++;
+    m.ids.add(id);
+    return { ov: m[k].ov, slot: m[k], release() {
+            m.ids.delete(id);
+            const s = m[k];
+            if (!s || --s.refs > 0)
+                return;
+            s.idle = setTimeout(() => { if (s.refs > 0 || m[k] !== s)
+                return; s.ov.remove(); delete m[k]; }, OVERLAY_LINGER_MS); // 猶予の後に片付ける（その間に acquire が来れば続投）
+        } };
+}
+let reader = null, readerBroken = false, liveHandles = 0, readerIdle = null;
+function spawnReader() {
+    if (reader)
+        return reader;
+    if (readerBroken || typeof Worker === "undefined")
+        return null;
+    try {
+        const w = new Worker(new URL("./voxel-reader.js", import.meta.url), { type: "module", name: "voxel-reader" });
+        const r = { w, pending: new Map(), seq: 0 };
+        w.onmessage = ({ data: m }) => { const p = r.pending.get(m.seq); if (!p)
+            return; r.pending.delete(m.seq); if (m.ok) {
+            const { seq: _s, ok: _o, ...rest } = m;
+            p.res(rest);
+        }
+        else
+            p.rej(new Error(m.error)); };
+        w.onerror = (e) => {
+            readerBroken = true;
+            reader = null;
+            try {
+                w.terminate();
+            }
+            catch { /* 既に死んでいる */ }
+            const err = new Error(`voxel: reader worker failed (${e?.message || "error"})`);
+            err.fallback = true;
+            for (const p of r.pending.values())
+                p.rej(err);
+            r.pending.clear();
+            console.warn("[voxel] reader worker unavailable, preparing on the main thread:", e?.message || e);
+        };
+        return (reader = r);
+    }
+    catch (e) {
+        readerBroken = true;
+        console.warn("[voxel] reader worker unavailable, preparing on the main thread:", e?.message || e);
+        return null;
+    }
+}
+const readerUsed = () => { liveHandles++; if (readerIdle) {
+    clearTimeout(readerIdle);
+    readerIdle = null;
+} };
+const readerFree = () => { if (--liveHandles > 0 || !reader)
+    return; readerIdle = setTimeout(() => { readerIdle = null; if (liveHandles || !reader)
+    return; reader.w.terminate(); reader = null; }, 5000); };
+const isFileSource = (src) => typeof src === "string" || src instanceof URL || src instanceof ArrayBuffer || src instanceof Uint8Array;
+async function load(src, o, rAx) {
+    if (isFileSource(src))
+        throw new Error("voxel: file sources (.nc / .zarr / .vox / .npy) are not read yet (stage 5); pass VoxelData");
+    const d = checkVoxelData(src);
+    const popts = { colormap: o.colormap, range: o.range ?? null, alphaRamp: o.alphaRamp ?? null, threshold: o.threshold ?? null, rAx };
+    const r = spawnReader();
+    if (r) {
+        try {
+            const seq = ++r.seq, req = { seq, data: d, opts: popts };
+            const p = await new Promise((res, rej) => { r.pending.set(seq, { res, rej }); r.w.postMessage(req); }); // data は写し＝渡した人の配列は手放さない
+            return { ...p, reader: "worker" };
+        }
+        catch (e) {
+            if (!e?.fallback)
+                throw e;
+        }
+    }
+    return { ...prepareGrid(d, popts), reader: "main" };
+}
+const isVoxelHit = (id) => (t) => t.layer === id;
+const checkEnum = (v, allowed, name) => { if (!allowed.includes(v))
+    throw new RangeError(`voxel: ${name} must be ${allowed.map(a => JSON.stringify(a)).join(" | ")}`); };
+const MODE = { blocks: 0, volume: 1, iso: 2 };
+/** 格子を上げ直さずに変えられる opts（setProps はこれだけなら "style" を送る） */
+export const STYLE_KEYS = Object.freeze(["render", "opacity", "step", "threshold", "clip", "depthTest", "properties", "colormap", "alphaRamp", "time"]);
+function checkOpts(opts) {
+    if (opts.render != null)
+        checkEnum(opts.render, ["blocks", "volume", "iso"], "render");
+    if (opts.altitude != null)
+        checkEnum(opts.altitude, ["relative", "absolute"], "altitude");
+    if (opts.step != null && !(typeof opts.step === "number" && opts.step > 0))
+        throw new RangeError("voxel: step must be a positive number (cells)");
+    if (opts.opacity != null && !(typeof opts.opacity === "number" && opts.opacity >= 0 && opts.opacity <= 1))
+        throw new RangeError("voxel: opacity must be 0..1");
+    if (opts.threshold != null && !Number.isFinite(opts.threshold))
+        throw new TypeError("voxel: threshold must be a finite number (data units)");
+    checkClip(opts.clip);
+    if (opts.time != null && opts.time !== "clock" && !(typeof opts.time === "number" && Number.isFinite(opts.time)))
+        throw new TypeError("voxel: time must be \"clock\" or a time in ms");
+}
+let anonSeq = 0;
+/** map.addData(data, { kind: "voxel", … }) の実体 */
+export function createVoxel(map, data, opts = {}, { backend = "auto" } = {}) {
+    checkOpts(opts);
+    if (!isFileSource(data))
+        checkVoxelData(data); // 形の間違いは今・同期に投げる（worker へ送ってからでは遅い）
+    const id = opts.id ?? `voxel${++anonSeq}`;
+    const { ov, slot, release } = acquire(map, !!opts.above, id, backend);
+    try {
+        ov.addLayerId?.(id);
+    }
+    catch (e) {
+        release();
+        throw e;
+    }
+    readerUsed();
+    let cur = data, props = { ...opts }, removed = false, seq = 0, visible = true, values = null, comps = 1, baked = false;
+    let qs = []; // 描き手に送った層の名前（一枚＝id・ブリック＝id#0, id#1, …）
+    // 時間の次元＝見せるこま（opts.time＝"clock"（既定）は map.clock に付いて行く・数は固定）。こまの切り替えは "style" の frame だけ（上げ直さない）
+    let times = null, following = false;
+    const frameNow = () => { if (!times)
+        return 0; const t = props.time ?? "clock"; return frameAt(times, t === "clock" ? (map.clock?.time ?? Date.now()) : t); };
+    const showFrame = () => { const f = frameNow(); if (f === h.frame || removed)
+        return; h.frame = f; for (const q of qs)
+        ov.post({ type: "style", q, frame: f }); };
+    const onClock = () => showFrame();
+    const follow = (on) => { if (on === following || !map.clock)
+        return; following = on; if (on)
+        map.clock.on("tick", onClock).on("change", onClock);
+    else
+        map.clock.off("tick", onClock).off("change", onClock); };
+    const run = async (src, o) => {
+        const my = ++seq;
+        const p = await load(src, o, rAxOf(map));
+        if (removed || my !== seq)
+            return h;
+        h.dims = p.dims;
+        h.n = p.n;
+        h.anchor = p.anchor;
+        h.range = p.range;
+        h.reader = p.reader;
+        h.error = null;
+        h.shape = p.shape;
+        h.bricks = p.bricks?.length ?? 0;
+        times = h.times = p.times;
+        h.frame = frameNow();
+        follow(!!times && (o.time ?? "clock") === "clock");
+        cur = src;
+        values = src.values;
+        comps = p.comps;
+        baked = true;
+        const style = { mode: MODE[o.render ?? "volume"], thr: p.thr, step: o.step ?? 0.5, opacity: o.opacity ?? 1, clip: checkClip(o.clip), depthTest: o.depthTest !== false, properties: o.properties ?? null, range: p.range, on: visible, frame: h.frame, alt: o.altitude ?? (p.placed ? "absolute" : "relative") };
+        const next = p.bricks ? p.bricks.map((_, b) => `${id}#${b}`) : [id];
+        for (const q of qs)
+            if (!next.includes(q)) {
+                ov.post({ type: "remove", q });
+                slot.errors.delete(q);
+            } // 前の形の層（一枚 ↔ ブリック・ブリックの数）を片付ける
+        qs = next;
+        for (const q of qs)
+            slot.errors.set(q, e => { h.error = e; }); // 描き手の build の失敗（3D テクスチャの上限など）は非同期に届く＝warn と手綱の error（ready は解決する）
+        if (!p.bricks)
+            ov.post({ type: "layer", q: id, shape: p.shape, dims: p.dims, comps: p.comps, tex: p.tex, frames: p.frames, cmap: p.cmap, anchor: p.anchor, A: p.A, radius: p.radius, geo: p.geo, vmax: p.vmax, ...style }, transferables(p));
+        else
+            p.bricks.forEach((b, i) => ov.post({ type: "layer", q: qs[i], layer: id, shape: p.shape, dims: b.dims, comps: p.comps, tex: b.tex, frames: b.frames, cmap: i ? p.cmap.slice() : p.cmap, anchor: b.anchor, A: b.A, radius: b.radius, geo: b.geo, vmax: b.vmax, off: b.off, own: b.own, full: p.dims, ...style }, [b.tex.buffer, b.A.buffer, ...(b.geo ? [b.geo.shell.buffer] : []), ...(b.frames ?? []).map(f => f.buffer)].filter((x, k, a) => a.indexOf(x) === k)));
+        return h;
+    };
+    // 見た目だけの変更＝格子を上げ直さない（render・opacity・step・threshold・clip・depthTest・properties・colormap・alphaRamp）
+    const restyle = (p) => {
+        const s = {};
+        if ("render" in p)
+            s.mode = MODE[props.render ?? "volume"];
+        if ("opacity" in p)
+            s.opacity = props.opacity ?? 1;
+        if ("step" in p)
+            s.step = props.step ?? 0.5;
+        if ("threshold" in p)
+            s.thr = comps === 4 || !h.range ? 0 : thrOf(props.threshold, h.range);
+        if ("clip" in p)
+            s.clip = checkClip(props.clip);
+        if ("depthTest" in p)
+            s.depthTest = props.depthTest !== false;
+        if ("properties" in p)
+            s.properties = props.properties ?? null;
+        if ("time" in p && times) {
+            follow((props.time ?? "clock") === "clock");
+            const f = frameNow();
+            if (f !== h.frame) {
+                h.frame = f;
+                s.frame = f;
+            }
+        }
+        const cmap = "colormap" in p || "alphaRamp" in p ? buildColormap(props.colormap, props.alphaRamp ?? null) : null;
+        if (!Object.keys(s).length && !cmap)
+            return;
+        qs.forEach((q, i) => { const c = cmap && i < qs.length - 1 ? cmap.slice() : cmap; ov.post({ type: "style", q, ...s, ...(c ? { cmap: c } : {}) }, c ? [c.buffer] : []); });
+    };
+    // 当たりの value＝main が持つ元の値（worker の答えは番号だけ）
+    const withValue = (t) => { const k = t.index + (h.frame || 0) * (h.n || 0); if (values && comps === 1 && t.index >= 0 && k < values.length) {
+        const v = values[k];
+        t.value = v;
+        t.properties = { ...t.properties, value: v };
+    } return t; };
+    const h = {
+        id, kind: "voxel", overlay: ov, dims: null, n: 0, anchor: null, range: null, reader: null, error: null, shape: null, bricks: 0, times: null, frame: 0,
+        get backend() { return slot.backend; },
+        ready: undefined,
+        setData: (d) => { if (!isFileSource(d))
+            checkVoxelData(d); return (h.ready = run(d, props)); },
+        setProps: (p) => {
+            checkOpts(p);
+            props = { ...props, ...p };
+            if (baked && !removed && Object.keys(p).every(k => STYLE_KEYS.includes(k))) {
+                restyle(p);
+                return h.ready;
+            }
+            return (h.ready = run(cur, props));
+        },
+        setVisible: (on) => { visible = !!on; if (!removed)
+            for (const q of qs)
+                ov.post({ type: "vis", q, on: visible }); return h; },
+        pick: async (x, y, r = 4) => (await map.pickOverlays(x, y, { radius: r, names: [ov.name] })).filter(isVoxelHit(id)).map(withValue),
+        remove: () => { if (removed)
+            return; removed = true; follow(false); for (const q of qs) {
+            ov.post({ type: "remove", q });
+            slot.errors.delete(q);
+        } ov.removeLayerId?.(id); release(); readerFree(); },
+    };
+    h.ready = run(data, props);
+    return h;
+}
+/** map.use(voxelPlugin()) → map.addData(data, { kind: "voxel", render?, colormap?, range?, threshold?, alphaRamp?, step?, opacity?, altitude?, depthTest?, above?, properties? }) */
+export function voxelPlugin({ backend = "auto" } = {}) {
+    checkEnum(backend, ["auto", "webgpu", "webgl2"], "backend");
+    return {
+        name: "voxel",
+        version: VERSION,
+        provides: ["data.voxel"],
+        install(map) {
+            map.registry.dataKinds.add("voxel", { create: (m, data, o) => createVoxel(m, data, o, { backend }) });
+            return () => { try {
+                map.registry.dataKinds.remove("voxel");
+            }
+            catch { /* 既に外れた */ } };
+        },
+    };
+}
+export default voxelPlugin;

package/dist/voxel-draw.d.ts

@@ -0,0 +1,16 @@
+import type { VoxelMessage, VoxelPickResult, CamState, VoxelApi, PickContext, OverlayHost } from "./voxel-gl.js";
+export type VoxelBackend = "webgpu" | "webgl2";
+export interface VoxelDrawOpts {
+    depth?: boolean;
+    backend?: VoxelBackend | "auto";
+}
+export declare function init(canvas: OffscreenCanvas, opts?: VoxelDrawOpts, h?: OverlayHost | null): {
+    depth: true;
+} | undefined;
+export declare function message(d: VoxelMessage): void;
+export declare function frame(cam: unknown, s: CamState, size: {
+    w: number;
+    h: number;
+}, api: VoxelApi): boolean;
+export declare function pick(x: number, y: number, r: number, ctx: PickContext | null | undefined): VoxelPickResult | null | Promise<VoxelPickResult | null>;
+export declare function destroy(): void;

package/dist/voxel-draw.js

@@ -0,0 +1,77 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+// render worker はオーバーレイの名前ごとに一つのモジュール実体（URL の ?ov=名前）＝全部外して同じ名前で立て直すと、この実体がそのまま使い回される。
+// ＝init で状態を戻し、古い init の非同期は世代（gen）で捨てる（以前は dead が true のまま残り、立て直したオーバーレイが何も描かず probe も答えなかった）
+let impl = null, queue = [], gen = 0;
+const withQuery = (u) => { u.search = new URL(import.meta.url).search; return u.href; };
+const GPU_URL = () => withQuery(new URL("./voxel-gpu.js", import.meta.url)), GL_URL = () => withQuery(new URL("./voxel-gl.js", import.meta.url));
+const hasGpu = () => !!globalThis.navigator?.gpu;
+export function init(canvas, opts = {}, h = null) {
+    const my = ++gen, dead = () => my !== gen;
+    impl?.m.destroy();
+    impl = null;
+    queue = [];
+    const pref = opts.backend ?? "auto", want = opts.depth !== false, t0 = performance.now();
+    (async () => {
+        try {
+            const tryGpu = pref === "webgpu" ? hasGpu() : pref === "auto" && hasGpu() && !!h?.gpuDevice?.(); // auto＝本体の device がある時だけ
+            if (tryGpu) {
+                try {
+                    const mod = await import(__rewriteRelativeImportExtension(/* @vite-ignore */ GPU_URL()));
+                    if (dead())
+                        return;
+                    const m = mod.create();
+                    await m.init(canvas, { depth: want }, h);
+                    if (dead()) {
+                        m.destroy();
+                        return;
+                    }
+                    impl = { kind: "webgpu", m };
+                }
+                catch (e) {
+                    if (pref === "webgpu")
+                        throw e;
+                    console.warn("[voxel] WebGPU unavailable, drawing with WebGL2:", e?.message || e);
+                }
+            }
+            else if (pref === "webgpu")
+                throw new Error("WebGPU is not available (navigator.gpu)");
+            if (!impl) {
+                const m = await import(__rewriteRelativeImportExtension(/* @vite-ignore */ GL_URL()));
+                if (dead())
+                    return;
+                m.init(canvas, { depth: want }, h);
+                impl = { kind: "webgl2", m };
+            }
+            for (const d of queue)
+                impl.m.message(d);
+            queue = [];
+            console.info(`[voxel] backend=${impl.kind}${impl.kind === "webgpu" && impl.m.shared ? " (map's device)" : ""} in ${Math.round(performance.now() - t0)}ms`);
+            h?.post?.({ type: "backend", backend: impl.kind, shared: impl.kind === "webgpu" && impl.m.shared });
+            h?.requestDraw?.();
+        }
+        catch (e) {
+            const error = String(e?.message || e);
+            console.error("[voxel] overlay failed", e);
+            h?.post?.({ type: "backend", backend: null, error });
+            for (const d of queue)
+                if (d.type === "probe")
+                    h?.post?.({ type: "pixels", id: d.id, error }); // 検定の probe を宙吊りにしない
+            queue = [];
+        }
+    })();
+    return want ? { depth: true } : undefined;
+}
+export function message(d) { if (impl)
+    impl.m.message(d);
+else
+    queue.push(d); }
+export function frame(cam, s, size, api) { return impl ? impl.m.frame(cam, s, size, api) : false; }
+export function pick(x, y, r, ctx) { return impl ? impl.m.pick(x, y, r, ctx) : null; }
+export function destroy() { gen++; impl?.m.destroy(); impl = null; queue = []; }

package/dist/voxel-gl.d.ts

@@ -0,0 +1,184 @@
+import type { OverlayFrameApi } from "@ortho-earth/globe";
+import type { GeoGrid, Clip } from "./grid.js";
+export interface OverlayHost {
+    depthGLSL?: string | null;
+    requestDraw?(): void;
+    post?(d: unknown): void;
+    gpuDevice?(): GPUDevice | null;
+}
+export interface CamState {
+    mvp: ArrayLike<number>;
+    eye?: ArrayLike<number> | null;
+}
+export type VoxelApi = Pick<OverlayFrameApi, "rAx" | "elevM" | "liftScale"> & {
+    depth?: OverlayFrameApi["depth"];
+};
+export interface PickContext {
+    s: CamState;
+    api: VoxelApi;
+    size: {
+        w: number;
+        h: number;
+    };
+}
+export type VoxelAltitude = "relative" | "absolute";
+export interface VoxelStyle {
+    frame?: number;
+    mode?: 0 | 1 | 2;
+    thr?: number;
+    step?: number;
+    opacity?: number;
+    clip?: Clip | null;
+    depthTest?: boolean;
+    cmap?: Uint8Array;
+    properties?: Record<string, unknown> | null;
+}
+export interface VoxelLayerBody extends VoxelStyle {
+    layer?: string; /** ブリック＝テクスチャの 0 番のセルの親での位置・描く範囲・親の dims */
+    off?: [number, number, number];
+    own?: [number, number, number, number, number, number];
+    full?: [number, number, number]; /** 最大値（R8・RGBA は α）＝閾より下なら描かない */
+    vmax?: number; /** 時間の次元＝こまごとのテクスチャ（frames[0]＝tex）。style の frame で選ぶ（上げ直さない） */
+    frames?: Uint8Array[] | null;
+    shape: "box" | "region";
+    dims: [number, number, number];
+    comps: 1 | 4;
+    tex: Uint8Array;
+    cmap: Uint8Array;
+    anchor: [number, number, number];
+    alt?: VoxelAltitude;
+    A: Float64Array | ArrayLike<number>;
+    radius: number;
+    geo?: GeoGrid | null;
+    mode: 0 | 1 | 2;
+    thr: number;
+    step: number;
+    opacity: number;
+    range: [number, number];
+    on?: boolean;
+}
+export type VoxelMessage = ({
+    type: "layer";
+    q: string;
+} & VoxelLayerBody) | ({
+    type: "style";
+    q: string;
+} & VoxelStyle) | {
+    type: "remove";
+    q: string;
+} | {
+    type: "vis";
+    q: string;
+    on: boolean;
+} | {
+    type: "clear";
+} | {
+    type: "probe";
+    id: unknown;
+};
+export interface VoxelPickResult {
+    id: number;
+    q: string;
+    layer: string;
+    index: number;
+    cell: [number, number, number];
+    value: number | null;
+    distance: number;
+    lngLat: [number, number];
+    properties: Record<string, unknown> & {
+        index: number;
+        cell: [number, number, number];
+        value: number | null;
+    };
+}
+export interface EnuBasis {
+    E: number[];
+    N: number[];
+    U: number[];
+    u: number[];
+}
+export declare const BOX: Float32Array<ArrayBufferLike>;
+export declare function init(canvas: OffscreenCanvas, opts?: {
+    depth?: boolean;
+}, h?: OverlayHost | null): {
+    depth: true;
+} | undefined;
+/** 錨の東北上 m → 単位球（列＝東・北・上×1/R） */
+export declare function enuBasis(lon: number, lat: number, rAx?: number): EnuBasis;
+/** 法線の行列（セルの軸 → 東北上の単位ベクトル・列優先）と勾配の行列（A⁻ᵀ・列優先） */
+export declare function normalMats(A: Float64Array, Ainv: Float64Array): {
+    nrm: Float32Array;
+    gradM: Float32Array;
+};
+export declare function message(d: VoxelMessage): void;
+/** 刻み（box＝セル・region＝m）と最大の歩数（光線の空間で） */
+export declare function stepsOf(L: {
+    shape: "box" | "region";
+    dims: [number, number, number];
+    mode: number;
+    step: number;
+    geo: GeoGrid | null;
+}): {
+    step: number;
+    maxSteps: number;
+};
+/** 断面 → セル空間の範囲 */
+export declare const clipBounds: (dims: [number, number, number], clip: Clip | null) => {
+    lo: number[];
+    hi: number[];
+};
+type BrickLike = {
+    dims: [number, number, number];
+    clip: Clip | null;
+    off: [number, number, number] | null;
+    own: [number, number, number, number, number, number] | null;
+    full: [number, number, number] | null;
+};
+/** 描く範囲（テクスチャのセル座標）＝断面（親の割合）と持ち分の交わり。空なら null（そのブリックは描かない） */
+export declare function drawBounds(L: BrickLike): {
+    lo: number[];
+    hi: number[];
+} | null;
+/** 閾より下しか無い層（ブリック）＝描かない（vmax＝R8 の 0〜255。RGBA は α 0 の時だけ） */
+export declare const isEmpty: (L: {
+    vmax: number;
+    thr: number;
+    comps: 1 | 4;
+}) => boolean;
+/** 目（東北上 m）から層の中心まで＝奥から描く順（同じ大きさの箱が並ぶブリックは中心の遠い順で正しく重なる） */
+export declare function centerDist(L: {
+    dims: [number, number, number];
+    A: ArrayLike<number>;
+    off: [number, number, number] | null;
+    geo: GeoGrid | null;
+}, enu: number[]): number;
+/** 当たり（層の中の番号）→ 親の層の id・番号・セル（ブリックは off と full で戻す） */
+export declare function pickedCell(q: string, L: {
+    layer: string | null;
+    dims: [number, number, number];
+    off: [number, number, number] | null;
+    full: [number, number, number] | null;
+}, index: number): {
+    layer: string;
+    index: number;
+    cell: [number, number, number];
+};
+export declare function frame(cam: unknown, s: CamState, { w, h }: {
+    w: number;
+    h: number;
+}, api: VoxelApi): boolean;
+/** 当たりの番号 → セル・経緯度（セルの中心＝box は A で・region は経緯度の枠で） */
+export declare function hitOf(L: {
+    dims: [number, number, number];
+    A: Float64Array;
+    anchor: [number, number, number];
+    geo: GeoGrid | null;
+    properties: Record<string, unknown> | null;
+    off?: [number, number, number] | null;
+}, index: number): {
+    cell: [number, number, number];
+    lngLat: [number, number];
+};
+export declare function pick(x: number, y: number, r: number, ctx: PickContext | null | undefined): VoxelPickResult | null;
+export declare function destroy(): void;
+export {};