velo-plot 1.11.1

package/dist/plugins/3d/Impulse3DRenderer.d.ts

@@ -0,0 +1,130 @@
+import { OrbitCamera, OrbitCameraOptions } from './camera/OrbitCamera';
+import { OrbitControllerOptions } from './controls/OrbitController';
+import { Axes3DOptions } from './Axes3D';
+import { Tooltip3DOptions } from './Tooltip3D';
+import { Renderer3DOptions, RenderStats3D, Renderer3DEventCallback } from './types';
+import { CustomThemeOptions } from './colorThemes';
+
+export interface ImpulseSeriesData {
+    /** X coordinates */
+    x: Float32Array;
+    /** Y coordinates (top of stems) */
+    y: Float32Array;
+    /** Z coordinates */
+    z: Float32Array;
+    /** Base Y value (default: 0) */
+    baseY?: number;
+    /** Color per point (RGB) */
+    colors?: Float32Array;
+    /** Single color for all stems */
+    color?: [number, number, number];
+}
+export interface Impulse3DRendererOptions extends Renderer3DOptions {
+    camera?: OrbitCameraOptions;
+    controls?: OrbitControllerOptions;
+    axes?: Axes3DOptions;
+    showAxes?: boolean;
+    /** Stem thickness (default: 0.03) */
+    stemWidth?: number;
+    /** Number of sides for cylinder (default: 6) */
+    stemSides?: number;
+    /** Show marker at top of stem (default: true) */
+    showMarkers?: boolean;
+    /** Marker size multiplier (default: 2) */
+    markerSize?: number;
+    /** Enable tooltips (default: true) */
+    enableTooltip?: boolean;
+    tooltip?: Tooltip3DOptions;
+    /** Color theme options */
+    theme?: CustomThemeOptions;
+}
+export declare class Impulse3DRenderer {
+    private canvas;
+    private gl;
+    private dpr;
+    private programs;
+    private camera;
+    private controller;
+    private axes;
+    private stemVao;
+    private stemPositionBuffer;
+    private stemNormalBuffer;
+    private stemColorBuffer;
+    private stemIndexBuffer;
+    private stemIndexCount;
+    private markerVao;
+    private markerPositionBuffer;
+    private markerNormalBuffer;
+    private markerColorBuffer;
+    private markerIndexBuffer;
+    private markerIndexCount;
+    private backgroundColor;
+    private showAxes;
+    private stemWidth;
+    private stemSides;
+    private showMarkers;
+    private markerSize;
+    private impulseData;
+    private bounds;
+    private animationFrameId;
+    private needsRender;
+    private eventListeners;
+    private tooltip;
+    private enableTooltip;
+    private lastHitIndex;
+    private boundHandleMouseMove?;
+    private boundHandleMouseLeave?;
+    private lastFrameTime;
+    private frameCount;
+    private fps;
+    private lastFpsUpdate;
+    private colorTheme;
+    constructor(options: Impulse3DRendererOptions);
+    private handleMouseMove;
+    private handleMouseLeave;
+    pickAtScreen(screenX: number, screenY: number): {
+        index: number;
+        distance: number;
+        point: [number, number, number];
+    } | null;
+    private initBuffers;
+    private handleResize;
+    resize(): void;
+    /**
+     * Set impulse data
+     */
+    setData(data: ImpulseSeriesData): void;
+    private buildGeometry;
+    private buildStemGeometry;
+    private buildMarkerGeometry;
+    private calculateBounds;
+    /**
+     * Fit camera to show all data
+     */
+    fitToData(): void;
+    getCanvasSize(): {
+        width: number;
+        height: number;
+    };
+    /**
+     * Render a single frame
+     */
+    render(): void;
+    private renderBuffers;
+    startRenderLoop(): void;
+    stopRenderLoop(): void;
+    getStats(): RenderStats3D;
+    getCamera(): OrbitCamera;
+    getAxisLabels(): import('./Axes3D').AxisLabel3D[];
+    getViewProjectionMatrix(): Float32Array;
+    projectToScreen(worldPos: [number, number, number]): {
+        x: number;
+        y: number;
+        visible: boolean;
+    };
+    exportImage(format?: 'png' | 'jpeg' | 'webp', quality?: number, transparent?: boolean): string;
+    on(event: string, callback: Renderer3DEventCallback): void;
+    off(event: string, callback: Renderer3DEventCallback): void;
+    private emitEvent;
+    destroy(): void;
+}

package/dist/plugins/3d/Line3DRenderer.d.ts

@@ -0,0 +1,118 @@
+import { OrbitCamera, OrbitCameraOptions } from './camera/OrbitCamera';
+import { OrbitControllerOptions } from './controls/OrbitController';
+import { Axes3DOptions } from './Axes3D';
+import { Tooltip3DOptions } from './Tooltip3D';
+import { Renderer3DOptions, RenderStats3D, Renderer3DEventCallback } from './types';
+
+export interface Line3DData {
+    /** X coordinates */
+    x: Float32Array;
+    /** Y coordinates */
+    y: Float32Array;
+    /** Z coordinates */
+    z: Float32Array;
+    /** Color per vertex (optional, RGB) */
+    colors?: Float32Array;
+    /** Single line color [r, g, b] (used if colors not provided) */
+    color?: [number, number, number];
+}
+export interface Line3DRendererOptions extends Renderer3DOptions {
+    camera?: OrbitCameraOptions;
+    controls?: OrbitControllerOptions;
+    axes?: Axes3DOptions;
+    showAxes?: boolean;
+    /** Line thickness in world units (default: 0.05) */
+    lineWidth?: number;
+    /** Number of segments around the tube (default: 8) */
+    tubeSides?: number;
+    /** Enable tooltips (default: true) */
+    enableTooltip?: boolean;
+    tooltip?: Tooltip3DOptions;
+}
+export declare class Line3DRenderer {
+    private canvas;
+    private gl;
+    private dpr;
+    private programs;
+    private camera;
+    private controller;
+    private axes;
+    private vao;
+    private positionBuffer;
+    private normalBuffer;
+    private colorBuffer;
+    private indexBuffer;
+    private indexCount;
+    private backgroundColor;
+    private showAxes;
+    private lineWidth;
+    private tubeSides;
+    private lines;
+    private bounds;
+    private animationFrameId;
+    private needsRender;
+    private eventListeners;
+    private tooltip;
+    private enableTooltip;
+    private lastHitIndex;
+    private boundHandleMouseMove?;
+    private boundHandleMouseLeave?;
+    private lastFrameTime;
+    private frameCount;
+    private fps;
+    private lastFpsUpdate;
+    constructor(options: Line3DRendererOptions);
+    private handleMouseMove;
+    private handleMouseLeave;
+    pickAtScreen(screenX: number, screenY: number): {
+        seriesIndex: number;
+        pointIndex: number;
+        distance: number;
+        point: [number, number, number];
+    } | null;
+    private initBuffers;
+    private handleResize;
+    resize(): void;
+    /**
+     * Set line data (single line or array of lines)
+     */
+    setData(lines: Line3DData | Line3DData[]): void;
+    /**
+     * Add a single line
+     */
+    addLine(line: Line3DData): void;
+    /**
+     * Clear all lines
+     */
+    clearLines(): void;
+    private buildTubeGeometry;
+    private calculateBounds;
+    /**
+     * Fit camera to show all data
+     */
+    fitToData(): void;
+    getCanvasSize(): {
+        width: number;
+        height: number;
+    };
+    /**
+     * Render a single frame
+     */
+    render(): void;
+    startRenderLoop(): void;
+    stopRenderLoop(): void;
+    getStats(): RenderStats3D;
+    getCamera(): OrbitCamera;
+    getAxisLabels(): import('./Axes3D').AxisLabel3D[];
+    getViewProjectionMatrix(): Float32Array;
+    projectToScreen(worldPos: [number, number, number]): {
+        x: number;
+        y: number;
+        visible: boolean;
+    };
+    exportImage(format?: 'png' | 'jpeg' | 'webp', quality?: number, transparent?: boolean): string;
+    on(event: string, callback: Renderer3DEventCallback): void;
+    off(event: string, callback: Renderer3DEventCallback): void;
+    private emitEvent;
+    destroy(): void;
+}

package/dist/plugins/3d/PointCloud3DRenderer.d.ts

@@ -0,0 +1,84 @@
+import { OrbitCameraOptions } from './camera/OrbitCamera';
+import { OrbitControllerOptions } from './controls/OrbitController';
+import { Axes3DOptions } from './Axes3D';
+import { Renderer3DOptions, Renderer3DEventCallback } from './types';
+import { CustomThemeOptions } from './colorThemes';
+
+export interface PointCloudData {
+    /** Positions [x0, y0, z0, x1, y1, z1, ...] */
+    positions: Float32Array;
+    /** Colors per point [r0, g0, b0, ...] (optional) */
+    colors?: Float32Array;
+    /** Sizes per point (optional) */
+    sizes?: Float32Array;
+}
+export interface PointCloud3DRendererOptions extends Renderer3DOptions {
+    camera?: OrbitCameraOptions;
+    controls?: OrbitControllerOptions;
+    axes?: Axes3DOptions;
+    showAxes?: boolean;
+    /** Global point size multiplier (default: 2.0) */
+    pointSize?: number;
+    /** Use circular points instead of squares (default: true) */
+    circular?: boolean;
+    /** Global opacity (default: 1.0) */
+    opacity?: number;
+    /** Color theme options */
+    theme?: CustomThemeOptions;
+    /** Enable tooltips */
+    enableTooltip?: boolean;
+}
+export declare class PointCloud3DRenderer {
+    private canvas;
+    private gl;
+    private dpr;
+    private programs;
+    private camera;
+    private controller;
+    private axes;
+    private vao;
+    private positionBuffer;
+    private colorBuffer;
+    private sizeBuffer;
+    private pointCount;
+    private backgroundColor;
+    private globalPointSize;
+    private circular;
+    private opacity;
+    private positions;
+    private bounds;
+    private animationFrameId;
+    private needsRender;
+    private eventListeners;
+    private tooltip;
+    private lastHitIndex;
+    private boundHandleMouseMove?;
+    private boundHandleMouseLeave?;
+    private colorTheme;
+    constructor(options: PointCloud3DRendererOptions);
+    private initBuffers;
+    setData(data: PointCloudData): void;
+    private updateBounds;
+    private generateThemeColors;
+    render(): void;
+    private startRenderLoop;
+    fitToData(): void;
+    private handleMouseMove;
+    private handleMouseLeave;
+    private handleResize;
+    private resize;
+    getCanvasSize(): {
+        width: number;
+        height: number;
+    };
+    getAxisLabels(): import('./Axes3D').AxisLabel3D[];
+    getViewProjectionMatrix(): import('./math').Mat4Type;
+    projectToScreen(worldPos: [number, number, number]): {
+        x: number;
+        y: number;
+        visible: boolean;
+    };
+    on(event: string, callback: Renderer3DEventCallback): void;
+    private emitEvent;
+    destroy(): void;
+}

package/dist/plugins/3d/Raycaster3D.d.ts

@@ -0,0 +1,137 @@
+/**
+ * 3D Raycasting utilities for picking/selection.
+ * Implements ray-sphere intersection for bubble selection.
+ */
+export interface Ray3D {
+    origin: [number, number, number];
+    direction: [number, number, number];
+}
+export interface HitResult {
+    index: number;
+    distance: number;
+    point: [number, number, number];
+}
+/**
+ * Creates a ray from screen coordinates through the scene.
+ * @param screenX Screen X coordinate (pixels from left)
+ * @param screenY Screen Y coordinate (pixels from top)
+ * @param canvasWidth Canvas width in pixels
+ * @param canvasHeight Canvas height in pixels
+ * @param viewProjectionMatrix Combined view-projection matrix
+ * @returns Ray in world space
+ */
+export declare function createRayFromScreen(screenX: number, screenY: number, canvasWidth: number, canvasHeight: number, viewProjectionMatrix: Float32Array): Ray3D;
+/**
+ * Test ray-sphere intersection.
+ * @param ray The ray to test
+ * @param center Sphere center
+ * @param radius Sphere radius
+ * @returns Distance to intersection, or null if no hit
+ */
+export declare function raySphereIntersection(ray: Ray3D, center: [number, number, number], radius: number): number | null;
+/**
+ * Find the closest bubble hit by a ray.
+ * @param ray The ray to test
+ * @param positions Float32Array of positions (x,y,z interleaved)
+ * @param scales Float32Array of scales (radii)
+ * @param baseRadius Base radius multiplier
+ * @returns Hit result or null if no hit
+ */
+export declare function pickBubble(ray: Ray3D, positions: Float32Array, scales: Float32Array, baseRadius?: number): HitResult | null;
+/**
+ * Batch pick bubbles - returns all bubbles within a tolerance of the ray.
+ * More efficient for hover detection.
+ */
+export declare function pickBubblesInRange(ray: Ray3D, positions: Float32Array, scales: Float32Array, baseRadius?: number, maxResults?: number): HitResult[];
+/**
+ * Calculate distance from a point to a ray (for approximate/fast picking).
+ */
+export declare function pointToRayDistance(ray: Ray3D, point: [number, number, number]): number;
+/**
+ * Result of a surface mesh hit test
+ */
+export interface SurfaceHitResult {
+    /** Distance from ray origin to hit point */
+    distance: number;
+    /** Hit point in world coordinates */
+    point: [number, number, number];
+    /** Grid row and column indices */
+    row: number;
+    col: number;
+    /** Interpolated Y value at hit point */
+    yValue: number;
+    /** Barycentric coordinates for interpolation */
+    baryU: number;
+    baryV: number;
+}
+/**
+ * Ray-triangle intersection using Möller-Trumbore algorithm.
+ * Returns distance to intersection or null if no hit.
+ */
+export declare function rayTriangleIntersection(ray: Ray3D, v0: [number, number, number], v1: [number, number, number], v2: [number, number, number]): {
+    distance: number;
+    u: number;
+    v: number;
+} | null;
+/**
+ * Pick a point on a surface mesh grid.
+ * Tests ray against all triangles in the grid.
+ *
+ * @param ray The picking ray
+ * @param xValues X coordinates array (columns)
+ * @param zValues Z coordinates array (rows)
+ * @param yValues Y values array (row-major: row * cols + col)
+ * @returns Hit result or null if no intersection
+ */
+export declare function pickSurfaceMesh(ray: Ray3D, xValues: Float32Array, zValues: Float32Array, yValues: Float32Array): SurfaceHitResult | null;
+/**
+ * Calculate the shortest distance between a ray and a line segment.
+ * Useful for picking lines and thin tubes.
+ */
+export declare function raySegmentDistance(ray: Ray3D, p0: [number, number, number], p1: [number, number, number]): {
+    distance: number;
+    pointOnRay: [number, number, number];
+    pointOnSegment: [number, number, number];
+    t: number;
+};
+/**
+ * Pick a series index and point index from a 3D line.
+ */
+export declare function pickLine(ray: Ray3D, lines: {
+    x: Float32Array;
+    y: Float32Array;
+    z: Float32Array;
+}[], threshold?: number): {
+    seriesIndex: number;
+    pointIndex: number;
+    distance: number;
+    point: [number, number, number];
+} | null;
+/**
+ * Pick a point from an impulse/stem series.
+ */
+export declare function pickImpulse(ray: Ray3D, data: {
+    x: Float32Array;
+    y: Float32Array;
+    z: Float32Array;
+    baseY?: number;
+}, threshold?: number): {
+    index: number;
+    distance: number;
+    point: [number, number, number];
+} | null;
+/**
+ * Pick a series index and point index from a 3D area (curtain).
+ * Checks the top line of the area.
+ */
+export declare function pickArea(ray: Ray3D, areas: {
+    x: Float32Array;
+    y: Float32Array;
+    z: Float32Array;
+    baseY?: number;
+}[], threshold?: number): {
+    seriesIndex: number;
+    pointIndex: number;
+    distance: number;
+    point: [number, number, number];
+} | null;

package/dist/plugins/3d/Ribbon3DRenderer.d.ts

@@ -0,0 +1,83 @@
+import { OrbitCameraOptions } from './camera/OrbitCamera';
+import { OrbitControllerOptions } from './controls/OrbitController';
+import { Axes3DOptions } from './Axes3D';
+import { Renderer3DOptions, Renderer3DEventCallback } from './types';
+import { CustomThemeOptions } from './colorThemes';
+
+export interface RibbonSeriesData {
+    /** X coordinates */
+    xValues: Float32Array;
+    /** Y coordinates */
+    yValues: Float32Array;
+    /** Z center coordinate of this ribbon */
+    z: number;
+    /** Width of the ribbon along the Z axis (default 0.5) */
+    width?: number;
+    /** Color of the ribbon (default: [0.3, 0.8, 1.0]) */
+    color?: [number, number, number];
+}
+export interface Ribbon3DRendererOptions extends Renderer3DOptions {
+    camera?: OrbitCameraOptions;
+    controls?: OrbitControllerOptions;
+    axes?: Axes3DOptions;
+    showAxes?: boolean;
+    /** Global opacity (default: 0.9) */
+    opacity?: number;
+    /** Enable tooltips */
+    enableTooltip?: boolean;
+    /** Color theme options */
+    theme?: CustomThemeOptions;
+}
+export declare class Ribbon3DRenderer {
+    private canvas;
+    private gl;
+    private dpr;
+    private programs;
+    private camera;
+    private controller;
+    private axes;
+    private vao;
+    private positionBuffer;
+    private normalBuffer;
+    private colorBuffer;
+    private indexBuffer;
+    private indexCount;
+    private backgroundColor;
+    private opacity;
+    private series;
+    private bounds;
+    private animationFrameId;
+    private needsRender;
+    private eventListeners;
+    private hoveredSeriesIndex;
+    private colorTheme;
+    private tooltip;
+    private lastHitIndex;
+    private boundHandleMouseMove?;
+    private boundHandleMouseLeave?;
+    constructor(options: Ribbon3DRendererOptions);
+    setData(series: RibbonSeriesData[]): void;
+    private updateBounds;
+    private updateGeometry;
+    render(): void;
+    private startRenderLoop;
+    fitToData(): void;
+    private handleMouseMove;
+    private handleMouseLeave;
+    private handleResize;
+    private resize;
+    getCanvasSize(): {
+        width: number;
+        height: number;
+    };
+    getAxisLabels(): import('./Axes3D').AxisLabel3D[];
+    getViewProjectionMatrix(): import('./math').Mat4Type;
+    projectToScreen(worldPos: [number, number, number]): {
+        x: number;
+        y: number;
+        visible: boolean;
+    };
+    on(event: string, callback: Renderer3DEventCallback): void;
+    private emitEvent;
+    destroy(): void;
+}

package/dist/plugins/3d/SurfaceBar3DRenderer.d.ts

@@ -0,0 +1,92 @@
+import { OrbitCameraOptions } from './camera/OrbitCamera';
+import { OrbitControllerOptions } from './controls/OrbitController';
+import { Axes3DOptions } from './Axes3D';
+import { Renderer3DOptions, Renderer3DEventCallback } from './types';
+import { CustomThemeOptions } from './colorThemes';
+
+export interface SurfaceBarData {
+    /** Number of rows in the grid (Z axis) */
+    rows: number;
+    /** Number of columns in the grid (X axis) */
+    cols: number;
+    /** Height values for each bar [v_0_0, v_0_1, ..., v_r-1_c-1] */
+    heights: Float32Array;
+    /** Colors per bar [r0, g0, b0, ...] (optional) */
+    colors?: Float32Array;
+    /** Origin point of the grid [x, y, z] (default [0,0,0]) */
+    origin?: [number, number, number];
+    /** Spacing between bars [dx, dz] (default [1,1]) */
+    spacing?: [number, number];
+}
+export interface SurfaceBar3DRendererOptions extends Renderer3DOptions {
+    camera?: OrbitCameraOptions;
+    controls?: OrbitControllerOptions;
+    axes?: Axes3DOptions;
+    showAxes?: boolean;
+    /** Opacity (default: 1.0) */
+    opacity?: number;
+    /** Bar scale (default: 1.0) */
+    barScale?: number;
+    /** Color theme options */
+    theme?: CustomThemeOptions;
+    /** Enable tooltips */
+    enableTooltip?: boolean;
+}
+export declare class SurfaceBar3DRenderer {
+    private canvas;
+    private gl;
+    private dpr;
+    private programs;
+    private camera;
+    private controller;
+    private axes;
+    private vao;
+    private positionBuffer;
+    private indexBuffer;
+    private indexCount;
+    private instancePosBuffer;
+    private heightBuffer;
+    private colorBuffer;
+    private barCount;
+    private backgroundColor;
+    private barWidth;
+    private barDepth;
+    private barScale;
+    private opacity;
+    private data;
+    private bounds;
+    private animationFrameId;
+    private needsRender;
+    private eventListeners;
+    private tooltip;
+    private lastHitIndex;
+    private boundHandleMouseMove?;
+    private boundHandleMouseLeave?;
+    private colorTheme;
+    constructor(options: SurfaceBar3DRendererOptions);
+    private initBuffers;
+    setData(data: SurfaceBarData): void;
+    private updateBounds;
+    private generateThemeColors;
+    render(): void;
+    private startRenderLoop;
+    fitToData(): void;
+    private handleMouseMove;
+    private handleMouseLeave;
+    private handleResize;
+    private resize;
+    getCanvasSize(): {
+        width: number;
+        height: number;
+    };
+    getAxisLabels(): import('./Axes3D').AxisLabel3D[];
+    getViewProjectionMatrix(): import('./math').Mat4Type;
+    projectToScreen(worldPos: [number, number, number]): {
+        x: number;
+        y: number;
+        visible: boolean;
+    };
+    on(event: string, callback: Renderer3DEventCallback): void;
+    private emitEvent;
+    destroy(): void;
+}