Something went wrong. Try again.
svelte astro
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135// Pure data/math layer for the 3D scatter plot.//// Nothing in here knows Three.js or Svelte exist — these are plain// functions that can be read and tested in isolation. Everything the// component needs to "calculate" lives here; the component just consumes it.
import type { CSVData } from "./utils";
/** Converts a CSV cell (string, number, whatever) to a number. */function toNumber(value: unknown): number { return typeof value === "number" ? value : parseFloat(String(value));}
function isValidCell(row: string[], colIndex: number): boolean { // A missing column (-1, e.g. an optional field like bp_rp that isn't // present in this CSV) shouldn't disqualify a row — there's nothing to // check, so it's treated as valid and toNumber() will just produce NaN // for it below. if (colIndex < 0) return true; const cell = row[colIndex]; return cell !== undefined && cell.trim() !== "";}
/** * Extracts several columns of the CSV as numbers, filtered TOGETHER: a row * is dropped if ANY of the requested columns is empty for that row. * * This is the version to use whenever the resulting arrays need to line up * by index (e.g. x/y/z/color for the same set of points) — filtering each * column separately (as a naive per-column filter would) drops different * rows from each array, so index i silently stops referring to the same * row across arrays. That's what caused stars with no parallax to still * show up: they were dropped from the z (parallax) array but not from x/y, * shifting everything after them out of alignment. * * csv.rows is row-major (each row is an array indexed by column), so * "column N" is always obtained by walking the rows and reading row[N] — * never csv.rows[N] directly. That mix-up was the source of the real-unit * bug. */export function getColumns(csv: CSVData, colIndices: number[]): number[][] { const validRows = csv.rows.filter((row) => colIndices.every((c) => isValidCell(row, c)), ); return colIndices.map((c) => validRows.map((row) => (c < 0 ? NaN : toNumber(row[c]))), );}
/** Extracts one column of the CSV as numbers, dropping rows empty in that column. */export function getColumn(csv: CSVData, colIndex: number): number[] { return getColumns(csv, [colIndex])[0];}
/** * Linear min/max scale for a column. It's the bridge between that column's * real-world units and the normalized [-1, 1] space the 3D scene lives in. * toNormalized() and toReal() are inverses of each other, computed once * from the same min/max — by construction they can't drift apart. */export interface Scale { min: number; max: number; range: number; /** real value -> normalized [-1, 1] space */ toNormalized(value: number): number; /** normalized [-1, 1] space -> real value */ toReal(normalized: number): number;}
export function createScale(values: number[]): Scale { const valid = values.filter(Number.isFinite); const min = valid.length ? Math.min(...valid) : 0; const max = valid.length ? Math.max(...valid) : 0; const range = max - min;
return { min, max, range, toNormalized(value) { if (!Number.isFinite(value) || range === 0) return 0; return ((value - min) / range) * 2 - 1; }, toReal(normalized) { return ((normalized + 1) / 2) * range + min; }, };}
/** The three columns already normalized to [-1, 1], ready for a BufferGeometry. */export interface Points3D { xs: Float32Array; ys: Float32Array; zs: Float32Array;}
export function normalizePoints( xValues: number[], yValues: number[], zValues: number[], xScale: Scale, yScale: Scale, zScale: Scale,): Points3D { const n = xValues.length; const xs = new Float32Array(n); const ys = new Float32Array(n); const zs = new Float32Array(n); for (let i = 0; i < n; i++) { xs[i] = xScale.toNormalized(xValues[i]); ys[i] = yScale.toNormalized(yValues[i]); zs[i] = zScale.toNormalized(zValues[i]); } return { xs, ys, zs };}
/** * Points whose normalized Z falls within [center - halfWidth, center + halfWidth], * returned as [x, y] pairs ready for the SlicePlot. */export function sliceAt( points: Points3D, center: number, halfWidth: number,): [number, number][] { const result: [number, number][] = []; for (let i = 0; i < points.zs.length; i++) { if (Math.abs(points.zs[i] - center) <= halfWidth) { result.push([points.xs[i], points.ys[i]]); } } return result;}