napari-js 0.1.0

package/dist/layers/layer.d.ts

@@ -0,0 +1,32 @@
+import { Emitter } from '../scene/events';
+export type BlendMode = 'opaque' | 'translucent' | 'additive' | 'minimum';
+/**
+ * Base layer: identity + the display properties shared by every layer kind (opacity,
+ * blending, visibility, and a data→world affine via `scale`/`translate`). Mutating any
+ * property emits {@link changed} so the renderer can schedule a redraw — the napari
+ * evented-layer model, GPU-side.
+ */
+export declare abstract class Layer {
+    readonly id: string;
+    readonly changed: Emitter<Layer>;
+    abstract readonly kind: string;
+    name: string;
+    /** Data→world scale (e.g. physical pixel size). */
+    scale: [number, number];
+    /** Data→world translation. */
+    translate: [number, number];
+    protected _opacity: number;
+    protected _visible: boolean;
+    protected _blending: BlendMode;
+    protected constructor(opts?: {
+        name?: string;
+        scale?: [number, number];
+        translate?: [number, number];
+    });
+    get opacity(): number;
+    set opacity(value: number);
+    get visible(): boolean;
+    set visible(value: boolean);
+    get blending(): BlendMode;
+    set blending(value: BlendMode);
+}

package/dist/layers/points-layer.d.ts

@@ -0,0 +1,59 @@
+import { Layer, BlendMode } from './layer';
+export type PointSymbol = 'disc' | 'ring' | 'square';
+export type RGBA = [number, number, number, number];
+/** Per-point or broadcast scalar/color inputs. */
+type SizeInput = number | number[] | Float32Array;
+type ColorInput = RGBA | RGBA[];
+export interface PointsLayerOptions {
+    name?: string;
+    /** Marker diameter in data units (single value or per-point). */
+    size?: SizeInput;
+    /** Fill color (single RGBA 0..1 or per-point). */
+    faceColor?: ColorInput;
+    /** Border color (single or per-point). */
+    borderColor?: ColorInput;
+    /** Border thickness in data units. */
+    borderWidth?: number;
+    symbol?: PointSymbol;
+    opacity?: number;
+    blending?: BlendMode;
+    visible?: boolean;
+    scale?: [number, number];
+    translate?: [number, number];
+}
+/**
+ * A scatter layer of point markers (the napari Points layer analog). Positions are `[x, y]`
+ * pairs in data coordinates; size/colors may be uniform or per-point. Marker shape is one of
+ * {@link PointSymbol}. Mutating display props emits `changed`; structural changes
+ * (positions/size/colors) also bump {@link dataVersion} so the visual rebuilds its instance
+ * buffer.
+ */
+export declare class PointsLayer extends Layer {
+    readonly kind = "points";
+    readonly count: number;
+    positions: Float32Array;
+    dataVersion: number;
+    private _size;
+    private _faceColor;
+    private _borderColor;
+    private _borderWidth;
+    private _symbol;
+    constructor(positions: Float32Array | number[][], opts?: PointsLayerOptions);
+    get size(): SizeInput;
+    set size(value: SizeInput);
+    get faceColor(): ColorInput;
+    set faceColor(value: ColorInput);
+    get borderColor(): ColorInput;
+    set borderColor(value: ColorInput);
+    get borderWidth(): number;
+    set borderWidth(value: number);
+    get symbol(): PointSymbol;
+    set symbol(value: PointSymbol);
+    symbolCode(): number;
+    /** Per-point size at index `i`. */
+    sizeAt(i: number): number;
+    /** Build the interleaved instance buffer (count × 12 floats) for the GPU. */
+    buildInstanceData(): Float32Array<ArrayBuffer>;
+}
+export declare const POINTS_INSTANCE_STRIDE = 12;
+export {};

package/dist/layers/volume-layer.d.ts

@@ -0,0 +1,46 @@
+import { Layer, BlendMode } from './layer';
+import { Colormap } from '../color/colormap';
+export type VolumeRendering = 'mip' | 'translucent' | 'iso';
+export interface VolumeLayerOptions {
+    name?: string;
+    colormap?: Colormap | string;
+    /** Normalization window in source-data units (default [0,255] for uint8). */
+    contrastLimits?: [number, number];
+    gamma?: number;
+    rendering?: VolumeRendering;
+    /** Iso threshold as a windowed value 0..1 (iso mode). */
+    isoThreshold?: number;
+    opacity?: number;
+    blending?: BlendMode;
+    visible?: boolean;
+}
+/**
+ * A 3D scalar volume (the napari Image-in-3D / volume analog), rendered by fragment
+ * raymarching. `data` is an 8-bit scalar field of size `width*height*depth` in x-fastest
+ * order. uint16/float volumes are a follow-up. Rendered only when `dims.ndisplay === 3`.
+ */
+export declare class VolumeLayer extends Layer {
+    readonly kind = "volume";
+    readonly width: number;
+    readonly height: number;
+    readonly depth: number;
+    readonly data: Uint8Array;
+    colormapVersion: number;
+    private _colormap;
+    private _contrastLimits;
+    private _gamma;
+    private _rendering;
+    private _isoThreshold;
+    constructor(data: Uint8Array, width: number, height: number, depth: number, opts?: VolumeLayerOptions);
+    get colormap(): Colormap;
+    set colormap(value: Colormap | string);
+    get contrastLimits(): [number, number];
+    set contrastLimits(value: readonly [number, number]);
+    get gamma(): number;
+    set gamma(value: number);
+    get rendering(): VolumeRendering;
+    set rendering(value: VolumeRendering);
+    renderingCode(): number;
+    get isoThreshold(): number;
+    set isoThreshold(value: number);
+}

package/dist/math/mat4.d.ts

@@ -0,0 +1,22 @@
+/** Column-major 4×4 matrix (WGSL `mat4x4<f32>` layout): element at row r, col c is `m[c*4 + r]`. */
+export type Mat4 = Float32Array;
+export declare function identity(): Mat4;
+/** Return `a * b` (apply `b` first, then `a`). */
+export declare function multiply(a: Mat4, b: Mat4): Mat4;
+/** Affine map `(x, y) → (sx·x + tx, sy·y + ty)` in homogeneous form (data → world). */
+export declare function scaleTranslate2d(sx: number, sy: number, tx: number, ty: number): Mat4;
+/**
+ * Orthographic 2D view-projection: world → clip space, centered on `center`, scaled by
+ * `zoom` (canvas px per world unit), for a `vw`×`vh` viewport. The Y axis is flipped so that
+ * increasing world/data Y points downward on screen (image convention).
+ */
+export type Vec3 = readonly [number, number, number];
+export declare function scale3d(sx: number, sy: number, sz: number): Mat4;
+export declare function translate3d(tx: number, ty: number, tz: number): Mat4;
+/** WebGPU-style perspective (clip z in [0,1]). `fovy` in radians. */
+export declare function perspective(fovy: number, aspect: number, near: number, far: number): Mat4;
+/** Right-handed view matrix looking from `eye` toward `center` (column-major). */
+export declare function lookAt(eye: Vec3, center: Vec3, up: Vec3): Mat4;
+/** Inverse of a 4×4 matrix (column-major). Returns the identity if singular. */
+export declare function invert(a: Mat4): Mat4;
+export declare function ortho2d(center: readonly [number, number], zoom: number, vw: number, vh: number): Mat4;