@dtour/scatter 0.1.0

package/dist/selection.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Bit-pack an array of selected point indices into a Uint32Array mask.
+ * Each bit represents one point; bit i is set if index i appears in the input.
+ *
+ * @param indices - selected point indices (array, Int32Array, etc.)
+ * @param numPoints - total number of points in the dataset
+ * @returns Uint32Array of length ceil(numPoints / 32)
+ */
+export declare const bitPackIndices: (indices: ArrayLike<number>, numPoints: number) => Uint32Array;
+//# sourceMappingURL=selection.d.ts.map

package/dist/selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../src/selection.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,GACzB,SAAS,SAAS,CAAC,MAAM,CAAC,EAC1B,WAAW,MAAM,KAChB,WAUF,CAAC"}

package/dist/tour/arc-length.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Compute cumulative arc-length table for a cyclic sequence of basis matrices.
+ * The last basis connects back to the first (closed loop).
+ *
+ * Because interpolation follows a Catmull-Rom spline (not a geodesic),
+ * we sample multiple points along each cubic segment and sum the
+ * geodesic distances between consecutive samples.
+ *
+ * Returns a Float32Array of length bases.length + 1:
+ *   [0, d01, d01+d12, ..., total]
+ * Normalized to [0, 1] so the slider maps directly.
+ *
+ * @param bases - array of p×2 column-major basis matrices
+ * @param p     - number of dimensions
+ */
+export declare const computeArcLengths: (bases: Float32Array[], p: number) => Float32Array;
+export type ResolvedPosition = {
+    segment: number;
+    localT: number;
+};
+/**
+ * Given a normalized position t in [0, 1] along the total arc,
+ * find which segment it falls in and the local interpolation parameter.
+ *
+ * Uses binary search for O(log n) lookup.
+ */
+export declare const resolvePosition: (arcLengths: Float32Array, t: number) => ResolvedPosition;
+/**
+ * Convenience: resolve position and compute the interpolated basis in one call.
+ */
+export declare const interpolateAtPosition: (out: Float32Array, bases: Float32Array[], arcLengths: Float32Array, p: number, t: number) => Float32Array;
+//# sourceMappingURL=arc-length.d.ts.map

package/dist/tour/arc-length.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arc-length.d.ts","sourceRoot":"","sources":["../../src/tour/arc-length.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,YAAY,EAAE,EAAE,GAAG,MAAM,KAAG,YAuCpE,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,eAAe,GAAI,YAAY,YAAY,EAAE,GAAG,MAAM,KAAG,gBAsBrE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,qBAAqB,GAChC,KAAK,YAAY,EACjB,OAAO,YAAY,EAAE,EACrB,YAAY,YAAY,EACxB,GAAG,MAAM,EACT,GAAG,MAAM,KACR,YAQF,CAAC"}

package/dist/tour/geodesic.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Interpolate through four p×2 basis matrices using Catmull-Rom spline
+ * + Gram-Schmidt orthonormalization.
+ *
+ * CR(t) = 0.5 * ((2*P1) + (-P0+P2)*t + (2*P0-5*P1+4*P2-P3)*t² + (-P0+3*P1-3*P2+P3)*t³)
+ *
+ * The spline passes exactly through P1 (at t=0) and P2 (at t=1), with
+ * C1-continuous tangents derived from neighbors P0 and P3. After the
+ * cubic blend, Gram-Schmidt restores orthonormality.
+ *
+ * All basis matrices are column-major: [x0, x1, ..., xp-1, y0, y1, ..., yp-1]
+ *
+ * @param out - pre-allocated output (2p floats, column-major)
+ * @param P0  - previous basis (neighbor before start)
+ * @param P1  - start basis
+ * @param P2  - end basis
+ * @param P3  - next basis (neighbor after end)
+ * @param p   - number of dimensions
+ * @param t   - interpolation parameter [0, 1]
+ */
+export declare const interpolateBases: (out: Float32Array, P0: Float32Array, P1: Float32Array, P2: Float32Array, P3: Float32Array, p: number, t: number) => Float32Array;
+/**
+ * Geodesic distance between two p×2 basis matrices.
+ * Distance = sqrt(tau_0^2 + tau_1^2) where tau_i are principal angles.
+ */
+export declare const geodesicDistance: (Fa: Float32Array, Fz: Float32Array, p: number) => number;
+//# sourceMappingURL=geodesic.d.ts.map

package/dist/tour/geodesic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geodesic.d.ts","sourceRoot":"","sources":["../../src/tour/geodesic.ts"],"names":[],"mappings":"AAyCA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,gBAAgB,GAC3B,KAAK,YAAY,EACjB,IAAI,YAAY,EAChB,IAAI,YAAY,EAChB,IAAI,YAAY,EAChB,IAAI,YAAY,EAChB,GAAG,MAAM,EACT,GAAG,MAAM,KACR,YAkBF,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GAAI,IAAI,YAAY,EAAE,IAAI,YAAY,EAAE,GAAG,MAAM,KAAG,MAkBhF,CAAC"}

package/dist/tour/svd2x2.d.ts

@@ -0,0 +1,13 @@
+export type SVD2x2Result = {
+    U: Float32Array;
+    S: Float32Array;
+    V: Float32Array;
+};
+/**
+ * Analytical SVD of a 2x2 matrix.
+ *
+ * Input A is row-major: A = [[A[0], A[1]], [A[2], A[3]]].
+ * Returns U, S, V such that A ≈ U * diag(S) * V^T.
+ */
+export declare const svd2x2: (A: Float32Array) => SVD2x2Result;
+//# sourceMappingURL=svd2x2.d.ts.map

package/dist/tour/svd2x2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"svd2x2.d.ts","sourceRoot":"","sources":["../../src/tour/svd2x2.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GAAG;IACzB,CAAC,EAAE,YAAY,CAAC;IAChB,CAAC,EAAE,YAAY,CAAC;IAChB,CAAC,EAAE,YAAY,CAAC;CACjB,CAAC;AAIF;;;;;GAKG;AACH,eAAO,MAAM,MAAM,GAAI,GAAG,YAAY,KAAG,YAyExC,CAAC"}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@dtour/scatter",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/scatter.js",
+  "module": "./dist/scatter.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/scatter.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "vite build && tsc --emitDeclarationOnly --declaration --outDir dist",
+    "dev": "vite build --watch"
+  },
+  "dependencies": {
+    "@uwdata/flechette": "catalog:",
+    "hyparquet": "^1.25.0",
+    "hyparquet-compressors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@webgpu/types": "^0.1.54",
+    "vite": "catalog:"
+  }
+}