react-cheminfo 0.8.0 → 0.10.0

package/lib/scatter/core/confidenceEllipse.js

@@ -0,0 +1,132 @@
+/**
+ * The outline that summarises where a group of samples sits on a scatter plot.
+ *
+ * Everything here is in data units. Turning one of these into something an SVG
+ * can draw is `projectEllipse`, which has to be a separate step because the two
+ * axes rarely carry the same number of pixels per unit.
+ */
+import { standardDeviationsForCoverage } from "./ellipseCoverage.js";
+/**
+ * A smaller eigenvalue below this share of the larger one is read as zero.
+ *
+ * A group whose spread across the major axis is under a millionth of its
+ * spread along it is collinear for any purpose a plot has, and the rounding of
+ * the covariance alone reaches that far: the nine points on a straight line
+ * used in the tests leave a residue of about 5e-17 where the exact answer is
+ * 0. Without the floor those points would draw a hairline ellipse on one
+ * machine and a segment on the next.
+ */
+const COLLINEAR_FLOOR = 1e-12;
+/**
+ * The outline that summarises a group of samples.
+ *
+ * Points that are not finite are skipped rather than poisoning the average, so
+ * a column with a few gaps still describes its group; `count` reports how many
+ * were actually used. The spread is measured with the `n - 1` divisor, which
+ * is what makes the outline an estimate of the group rather than a statement
+ * about the handful of samples that happen to have been measured.
+ * @param points - The group's samples, in data units.
+ * @param options - See {@link ConfidenceEllipseOptions}.
+ * @returns The outline, or `null` when the group is too small to have a shape, or when its coordinates are so large that squaring them overflows, or when the requested size is unbounded.
+ */
+export function confidenceEllipse(points, options = {}) {
+    const { size = { kind: 'coverage', probability: 0.95 }, minimumPoints = 3 } = options;
+    let count = 0;
+    let sumX = 0;
+    let sumY = 0;
+    for (const point of points) {
+        if (!Number.isFinite(point.x) || !Number.isFinite(point.y))
+            continue;
+        count++;
+        sumX += point.x;
+        sumY += point.y;
+    }
+    if (count < Math.max(2, minimumPoints))
+        return null;
+    const cx = sumX / count;
+    const cy = sumY / count;
+    let spreadX = 0;
+    let together = 0;
+    let spreadY = 0;
+    for (const point of points) {
+        if (!Number.isFinite(point.x) || !Number.isFinite(point.y))
+            continue;
+        const dx = point.x - cx;
+        const dy = point.y - cy;
+        spreadX += dx * dx;
+        together += dx * dy;
+        spreadY += dy * dy;
+    }
+    const divisor = count - 1;
+    const covariance = {
+        xx: spreadX / divisor,
+        xy: together / divisor,
+        yy: spreadY / divisor,
+    };
+    if (!Number.isFinite(cx) ||
+        !Number.isFinite(cy) ||
+        !Number.isFinite(covariance.xx) ||
+        !Number.isFinite(covariance.xy) ||
+        !Number.isFinite(covariance.yy)) {
+        return null;
+    }
+    const { rx, ry, angle } = ellipseAxes(covariance, ellipseStandardDeviations(size));
+    if (!Number.isFinite(rx) || !Number.isFinite(ry))
+        return null;
+    return { cx, cy, rx, ry, angle, count, covariance };
+}
+/**
+ * The semi-axes and the rotation that a covariance describes.
+ *
+ * The shape of an outline is the eigen-decomposition of a symmetric two by two
+ * matrix, which has a closed form and so never needs an iterative solver. It
+ * is public because the same three numbers are what turns any covariance into
+ * something drawable — one measured elsewhere, or one already mapped into
+ * pixels.
+ * @param covariance - How the cloud is spread.
+ * @param standardDeviations - How far out to measure. Defaults to `1`.
+ * @returns The two semi-axis lengths and the rotation of the major one, in radians, in `(-π/2, π/2]`. A collinear cloud gives `ry` of exactly `0`, and one with no spread at all gives an angle of `0` because it has no direction to report.
+ */
+export function ellipseAxes(covariance, standardDeviations = 1) {
+    const { xx, xy, yy } = covariance;
+    const middle = (xx + yy) / 2;
+    const half = (xx - yy) / 2;
+    const radius = Math.hypot(half, xy);
+    const major = middle + radius;
+    let minor = middle - radius;
+    if (!(minor > major * COLLINEAR_FLOOR))
+        minor = 0;
+    return {
+        rx: standardDeviations * Math.sqrt(major),
+        ry: standardDeviations * Math.sqrt(minor),
+        angle: majorAxisAngle(xx, xy, yy, major),
+    };
+}
+function majorAxisAngle(xx, xy, yy, major) {
+    // With no cross term the axes already are the eigenvectors, and asking
+    // `atan2` would only turn the exact answer into a rounded one.
+    if (xy === 0)
+        return xx >= yy ? 0 : Math.PI / 2;
+    // `major - xx` is never negative, so this lands in [0, π] and a negative
+    // cross term arrives half a turn away from the direction actually wanted.
+    const angle = Math.atan2(major - xx, xy);
+    return angle > Math.PI / 2 ? angle - Math.PI : angle;
+}
+/**
+ * How far out an outline of a given size is drawn.
+ *
+ * Public because a figure that measures its groups itself — a pair grid
+ * decomposing one shared block of covariances rather than calling
+ * {@link confidenceEllipse} per cell — still has to honour the same size the
+ * map was asked for, and a second reading of `EllipseSize` would be a second
+ * place for the two to drift apart.
+ * @param size - How large the outline was asked to be.
+ * @returns The number of standard deviations, never below zero.
+ */
+export function ellipseStandardDeviations(size) {
+    if (size.kind === 'standardDeviations') {
+        return Math.max(size.standardDeviations, 0);
+    }
+    return standardDeviationsForCoverage(size.probability);
+}
+//# sourceMappingURL=confidenceEllipse.js.map

package/lib/scatter/core/confidenceEllipse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"confidenceEllipse.js","sourceRoot":"","sources":["../../../src/scatter/core/confidenceEllipse.ts"],"names":[],"mappings":"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"}

package/lib/scatter/core/ellipseCoverage.d.ts

@@ -0,0 +1,33 @@
+/**
+ * How far out a group outline is drawn, and how much of the group it then
+ * holds.
+ *
+ * The two directions are exact inverses of one another, so a legend can quote
+ * a share and a control can offer standard deviations without either of them
+ * keeping a table of numbers that would drift apart.
+ */
+/**
+ * The share of a two-dimensional normal cloud that falls inside the ellipse
+ * drawn at a number of standard deviations.
+ *
+ * Not the 68, 95 and 99.7 percent that a single measurement is quoted with:
+ * those describe an interval on one axis, while an ellipse has to hold a point
+ * in both directions at once. One, two and three standard deviations therefore
+ * keep about 39, 86 and 99 percent of the cloud, and writing the
+ * one-dimensional figures beside a map is the usual way a scatter legend comes
+ * to promise more than its outlines contain.
+ * @param standardDeviations - How far out the ellipse is drawn.
+ * @returns The share, from 0 to 1. Zero for anything at or below zero, since an ellipse of no size holds nothing.
+ */
+export declare function coverageForStandardDeviations(standardDeviations: number): number;
+/**
+ * How far out to draw the ellipse that holds a share of a two-dimensional
+ * normal cloud.
+ *
+ * The inverse of {@link coverageForStandardDeviations}, which is what lets a
+ * control offer `95% of samples` and still hand the geometry a radius.
+ * @param coverage - The share of the cloud to enclose, from 0 to 1.
+ * @returns The number of standard deviations. Zero at or below zero, and infinite at or above one, because no finite ellipse holds every point of a cloud with unbounded tails.
+ */
+export declare function standardDeviationsForCoverage(coverage: number): number;
+//# sourceMappingURL=ellipseCoverage.d.ts.map

package/lib/scatter/core/ellipseCoverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ellipseCoverage.d.ts","sourceRoot":"","sources":["../../../src/scatter/core/ellipseCoverage.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;;;;;;;GAYG;AACH,wBAAgB,6BAA6B,CAC3C,kBAAkB,EAAE,MAAM,GACzB,MAAM,CAMR;AAED;;;;;;;;GAQG;AACH,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAItE"}

package/lib/scatter/core/ellipseCoverage.js

@@ -0,0 +1,46 @@
+/**
+ * How far out a group outline is drawn, and how much of the group it then
+ * holds.
+ *
+ * The two directions are exact inverses of one another, so a legend can quote
+ * a share and a control can offer standard deviations without either of them
+ * keeping a table of numbers that would drift apart.
+ */
+/**
+ * The share of a two-dimensional normal cloud that falls inside the ellipse
+ * drawn at a number of standard deviations.
+ *
+ * Not the 68, 95 and 99.7 percent that a single measurement is quoted with:
+ * those describe an interval on one axis, while an ellipse has to hold a point
+ * in both directions at once. One, two and three standard deviations therefore
+ * keep about 39, 86 and 99 percent of the cloud, and writing the
+ * one-dimensional figures beside a map is the usual way a scatter legend comes
+ * to promise more than its outlines contain.
+ * @param standardDeviations - How far out the ellipse is drawn.
+ * @returns The share, from 0 to 1. Zero for anything at or below zero, since an ellipse of no size holds nothing.
+ */
+export function coverageForStandardDeviations(standardDeviations) {
+    if (!Number.isFinite(standardDeviations)) {
+        return standardDeviations > 0 ? 1 : 0;
+    }
+    if (standardDeviations <= 0)
+        return 0;
+    return 1 - Math.exp(-(standardDeviations * standardDeviations) / 2);
+}
+/**
+ * How far out to draw the ellipse that holds a share of a two-dimensional
+ * normal cloud.
+ *
+ * The inverse of {@link coverageForStandardDeviations}, which is what lets a
+ * control offer `95% of samples` and still hand the geometry a radius.
+ * @param coverage - The share of the cloud to enclose, from 0 to 1.
+ * @returns The number of standard deviations. Zero at or below zero, and infinite at or above one, because no finite ellipse holds every point of a cloud with unbounded tails.
+ */
+export function standardDeviationsForCoverage(coverage) {
+    if (!Number.isFinite(coverage) || coverage <= 0)
+        return 0;
+    if (coverage >= 1)
+        return Number.POSITIVE_INFINITY;
+    return Math.sqrt(-2 * Math.log(1 - coverage));
+}
+//# sourceMappingURL=ellipseCoverage.js.map

package/lib/scatter/core/ellipseCoverage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ellipseCoverage.js","sourceRoot":"","sources":["../../../src/scatter/core/ellipseCoverage.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,6BAA6B,CAC3C,kBAA0B;IAE1B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,CAAC;QACzC,OAAO,kBAAkB,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACxC,CAAC;IACD,IAAI,kBAAkB,IAAI,CAAC;QAAE,OAAO,CAAC,CAAC;IACtC,OAAO,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,kBAAkB,GAAG,kBAAkB,CAAC,GAAG,CAAC,CAAC,CAAC;AACtE,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,6BAA6B,CAAC,QAAgB;IAC5D,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,QAAQ,IAAI,CAAC;QAAE,OAAO,CAAC,CAAC;IAC1D,IAAI,QAAQ,IAAI,CAAC;QAAE,OAAO,MAAM,CAAC,iBAAiB,CAAC;IACnD,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC;AAChD,CAAC"}

package/lib/scatter/core/ellipseProjection.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Putting a data-space outline on the screen.
+ *
+ * Kept apart from `confidenceEllipse` because the measurement is a property of
+ * the samples and the projection is a property of the plot: the same outline
+ * is drawn again at every zoom and every resize, and only this half has to be
+ * redone.
+ */
+import type { ChartScale } from '../../chart/core/chartScale.ts';
+import type { ConfidenceEllipse, EllipsePoint } from './confidenceEllipse.ts';
+/** An ellipse ready to be handed to an SVG `<ellipse>` element. */
+export interface PixelEllipse {
+    /** Centre of the ellipse, in pixels. */
+    cx: number;
+    /** Centre of the ellipse, in pixels. */
+    cy: number;
+    /** Semi-major axis length, in pixels. */
+    rx: number;
+    /** Semi-minor axis length, in pixels; `0` for a perfectly collinear group. */
+    ry: number;
+    /** Rotation of the major axis, in degrees, for `transform="rotate(...)"`. */
+    angleDegrees: number;
+}
+/**
+ * Map a data-space ellipse onto the plot, keeping it exact when the two axes
+ * carry different numbers of pixels per data unit.
+ *
+ * Scaling `rx` and `ry` and reusing the data-space angle is wrong: an
+ * anisotropic map turns the ellipse by a different amount and changes the
+ * ratio of its axes — on a 640 by 400 plot of one measured cloud the naive
+ * route was 47 pixels out. The covariance is therefore transformed first and
+ * only then decomposed, which is exact for any linear axis and lets the
+ * browser draw a real curve at any zoom. Drawing a data-space ellipse inside a
+ * scaled `<g>` would be geometrically right and visually wrong, because SVG
+ * scales the stroke with the group.
+ * @param ellipse - An ellipse in data units.
+ * @param x - The plot's horizontal data-to-pixel mapping.
+ * @param y - Its vertical mapping, whose `factor` is negative.
+ * @returns The ellipse in pixels, or `null` when the mapping overflows.
+ */
+export declare function projectEllipse(ellipse: ConfidenceEllipse, x: ChartScale, y: ChartScale): PixelEllipse | null;
+/**
+ * Sample the outline of a data-space ellipse, for a plot whose axes are not
+ * linear and where the shape is therefore no longer an ellipse on screen.
+ *
+ * Prefer {@link projectEllipse} on linear axes: it is exact, it is constant
+ * time, and the browser draws a curve rather than a polygon.
+ * @param ellipse - An ellipse in data units.
+ * @param steps - Points around the outline, at least three. Sixty-four keeps the flat sides under a third of a pixel on a 640 by 400 plot. Defaults to `64`.
+ * @returns The outline in data units, the first point not repeated at the end.
+ */
+export declare function ellipsePolygon(ellipse: ConfidenceEllipse, steps?: number): EllipsePoint[];
+//# sourceMappingURL=ellipseProjection.d.ts.map

package/lib/scatter/core/ellipseProjection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ellipseProjection.d.ts","sourceRoot":"","sources":["../../../src/scatter/core/ellipseProjection.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAEjE,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAO9E,mEAAmE;AACnE,MAAM,WAAW,YAAY;IAC3B,wCAAwC;IACxC,EAAE,EAAE,MAAM,CAAC;IACX,wCAAwC;IACxC,EAAE,EAAE,MAAM,CAAC;IACX,yCAAyC;IACzC,EAAE,EAAE,MAAM,CAAC;IACX,8EAA8E;IAC9E,EAAE,EAAE,MAAM,CAAC;IACX,6EAA6E;IAC7E,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,iBAAiB,EAC1B,CAAC,EAAE,UAAU,EACb,CAAC,EAAE,UAAU,GACZ,YAAY,GAAG,IAAI,CAwCrB;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,iBAAiB,EAC1B,KAAK,SAAgB,GACpB,YAAY,EAAE,CAiBhB"}

package/lib/scatter/core/ellipseProjection.js

@@ -0,0 +1,94 @@
+/**
+ * Putting a data-space outline on the screen.
+ *
+ * Kept apart from `confidenceEllipse` because the measurement is a property of
+ * the samples and the projection is a property of the plot: the same outline
+ * is drawn again at every zoom and every resize, and only this half has to be
+ * redone.
+ */
+import { ellipseAxes } from "./confidenceEllipse.js";
+const HALF_TURN_DEGREES = 180;
+const DEFAULT_STEPS = 64;
+const MINIMUM_STEPS = 3;
+/**
+ * Map a data-space ellipse onto the plot, keeping it exact when the two axes
+ * carry different numbers of pixels per data unit.
+ *
+ * Scaling `rx` and `ry` and reusing the data-space angle is wrong: an
+ * anisotropic map turns the ellipse by a different amount and changes the
+ * ratio of its axes — on a 640 by 400 plot of one measured cloud the naive
+ * route was 47 pixels out. The covariance is therefore transformed first and
+ * only then decomposed, which is exact for any linear axis and lets the
+ * browser draw a real curve at any zoom. Drawing a data-space ellipse inside a
+ * scaled `<g>` would be geometrically right and visually wrong, because SVG
+ * scales the stroke with the group.
+ * @param ellipse - An ellipse in data units.
+ * @param x - The plot's horizontal data-to-pixel mapping.
+ * @param y - Its vertical mapping, whose `factor` is negative.
+ * @returns The ellipse in pixels, or `null` when the mapping overflows.
+ */
+export function projectEllipse(ellipse, x, y) {
+    const cosine = Math.cos(ellipse.angle);
+    const sine = Math.sin(ellipse.angle);
+    const along = ellipse.rx * ellipse.rx;
+    const across = ellipse.ry * ellipse.ry;
+    // The quadratic form of the drawn ellipse, which shares its shape with a
+    // covariance and so decomposes the same way.
+    const xx = along * cosine * cosine + across * sine * sine;
+    const xy = (along - across) * cosine * sine;
+    const yy = along * sine * sine + across * cosine * cosine;
+    // Only the linear part of the mapping changes the shape; the offsets move
+    // the centre and nothing else. A negative vertical factor flips the cross
+    // term, which is what turns a counter-clockwise data angle into the
+    // clockwise one SVG rotates by.
+    const factors = x.factor * y.factor;
+    const projected = ellipseAxes({
+        xx: x.factor * x.factor * xx,
+        xy: factors * xy,
+        yy: y.factor * y.factor * yy,
+    });
+    const result = {
+        cx: x.offset + ellipse.cx * x.factor,
+        cy: y.offset + ellipse.cy * y.factor,
+        rx: projected.rx,
+        ry: projected.ry,
+        angleDegrees: (projected.angle * HALF_TURN_DEGREES) / Math.PI,
+    };
+    if (!Number.isFinite(result.cx) ||
+        !Number.isFinite(result.cy) ||
+        !Number.isFinite(result.rx) ||
+        !Number.isFinite(result.ry) ||
+        !Number.isFinite(result.angleDegrees)) {
+        return null;
+    }
+    return result;
+}
+/**
+ * Sample the outline of a data-space ellipse, for a plot whose axes are not
+ * linear and where the shape is therefore no longer an ellipse on screen.
+ *
+ * Prefer {@link projectEllipse} on linear axes: it is exact, it is constant
+ * time, and the browser draws a curve rather than a polygon.
+ * @param ellipse - An ellipse in data units.
+ * @param steps - Points around the outline, at least three. Sixty-four keeps the flat sides under a third of a pixel on a 640 by 400 plot. Defaults to `64`.
+ * @returns The outline in data units, the first point not repeated at the end.
+ */
+export function ellipsePolygon(ellipse, steps = DEFAULT_STEPS) {
+    const total = Number.isFinite(steps)
+        ? Math.max(MINIMUM_STEPS, Math.floor(steps))
+        : DEFAULT_STEPS;
+    const cosine = Math.cos(ellipse.angle);
+    const sine = Math.sin(ellipse.angle);
+    const outline = new Array(total);
+    for (let index = 0; index < total; index++) {
+        const turn = (2 * Math.PI * index) / total;
+        const along = ellipse.rx * Math.cos(turn);
+        const across = ellipse.ry * Math.sin(turn);
+        outline[index] = {
+            x: ellipse.cx + along * cosine - across * sine,
+            y: ellipse.cy + along * sine + across * cosine,
+        };
+    }
+    return outline;
+}
+//# sourceMappingURL=ellipseProjection.js.map

package/lib/scatter/core/ellipseProjection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ellipseProjection.js","sourceRoot":"","sources":["../../../src/scatter/core/ellipseProjection.ts"],"names":[],"mappings":"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"}

package/lib/scatter/core/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * What a scatter plot has to work out before it can draw: which point the
+ * pointer is nearest, which points a lasso caught, and the outline that holds
+ * a given share of a group.
+ *
+ * The ellipse is the part worth reading twice. A group's outline is computed
+ * in the data's own units and drawn in pixels, and because the two axes rarely
+ * carry the same number of units per pixel, the rotation is not the same in
+ * both — which is why the outline is projected rather than handed to an SVG
+ * `<ellipse>` with a data-space angle.
+ */
+export type { ConfidenceEllipse, ConfidenceEllipseOptions, EllipseCovariance, EllipseCoverageSize, EllipsePoint, EllipseSize, EllipseStandardDeviationSize, } from './confidenceEllipse.ts';
+export { confidenceEllipse, ellipseAxes, ellipseStandardDeviations, } from './confidenceEllipse.ts';
+export { coverageForStandardDeviations, standardDeviationsForCoverage, } from './ellipseCoverage.ts';
+export type { PixelEllipse } from './ellipseProjection.ts';
+export { ellipsePolygon, projectEllipse } from './ellipseProjection.ts';
+export type { LassoPath } from './lassoPath.ts';
+export { appendLassoPoint, createLassoPath, lassoPathData, resetLassoPath, } from './lassoPath.ts';
+export { pointInPolygon, pointsInPolygon, polygonBounds } from './polygon.ts';
+export type { ScatterSelectionMode } from './scatterSelection.ts';
+export { mergeScatterSelection, scatterSelectedIndices, scatterSelectionMask, } from './scatterSelection.ts';
+export type { PixelBounds, ScreenPoints } from './screenPoints.ts';
+export { nearestPointIndex, pointsWithinBounds } from './screenPoints.ts';
+//# sourceMappingURL=index.d.ts.map

package/lib/scatter/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/scatter/core/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,YAAY,EACV,iBAAiB,EACjB,wBAAwB,EACxB,iBAAiB,EACjB,mBAAmB,EACnB,YAAY,EACZ,WAAW,EACX,4BAA4B,GAC7B,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,iBAAiB,EACjB,WAAW,EACX,yBAAyB,GAC1B,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,6BAA6B,EAC7B,6BAA6B,GAC9B,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACxE,YAAY,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EACL,gBAAgB,EAChB,eAAe,EACf,aAAa,EACb,cAAc,GACf,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC9E,YAAY,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,EACL,qBAAqB,EACrB,sBAAsB,EACtB,oBAAoB,GACrB,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACnE,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC"}

package/lib/scatter/core/index.js

@@ -0,0 +1,19 @@
+/**
+ * What a scatter plot has to work out before it can draw: which point the
+ * pointer is nearest, which points a lasso caught, and the outline that holds
+ * a given share of a group.
+ *
+ * The ellipse is the part worth reading twice. A group's outline is computed
+ * in the data's own units and drawn in pixels, and because the two axes rarely
+ * carry the same number of units per pixel, the rotation is not the same in
+ * both — which is why the outline is projected rather than handed to an SVG
+ * `<ellipse>` with a data-space angle.
+ */
+export { confidenceEllipse, ellipseAxes, ellipseStandardDeviations, } from "./confidenceEllipse.js";
+export { coverageForStandardDeviations, standardDeviationsForCoverage, } from "./ellipseCoverage.js";
+export { ellipsePolygon, projectEllipse } from "./ellipseProjection.js";
+export { appendLassoPoint, createLassoPath, lassoPathData, resetLassoPath, } from "./lassoPath.js";
+export { pointInPolygon, pointsInPolygon, polygonBounds } from "./polygon.js";
+export { mergeScatterSelection, scatterSelectedIndices, scatterSelectionMask, } from "./scatterSelection.js";
+export { nearestPointIndex, pointsWithinBounds } from "./screenPoints.js";
+//# sourceMappingURL=index.js.map

package/lib/scatter/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/scatter/core/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAWH,OAAO,EACL,iBAAiB,EACjB,WAAW,EACX,yBAAyB,GAC1B,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,6BAA6B,EAC7B,6BAA6B,GAC9B,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAExE,OAAO,EACL,gBAAgB,EAChB,eAAe,EACf,aAAa,EACb,cAAc,GACf,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAE9E,OAAO,EACL,qBAAqB,EACrB,sBAAsB,EACtB,oBAAoB,GACrB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC"}

package/lib/scatter/core/lassoPath.d.ts

@@ -0,0 +1,60 @@
+/**
+ * The outline a pointer has drawn, as a buffer that is only partly in use.
+ *
+ * The two arrays are grown by doubling and never shrunk, and `length` says how
+ * much of them is the path. A drag emits a pointer move every frame or more
+ * often; growing the buffer on each one would put a fresh pair of typed arrays
+ * in front of the collector sixty times a second, during the one interaction
+ * where a dropped frame is visible as a kink in the line the user is drawing.
+ */
+export interface LassoPath {
+    /** Horizontal position of each vertex; only the first `length` are in use. */
+    xs: Float64Array;
+    /** Vertical position of each vertex; only the first `length` are in use. */
+    ys: Float64Array;
+    /** How many vertices have been kept. */
+    length: number;
+}
+/**
+ * An empty path, with room to grow.
+ * @param capacity - How many vertices to make room for before the first growth; at least one, and rounded down. Defaults to 256, which is a couple of seconds of dragging.
+ * @returns The path, holding no vertex yet.
+ */
+export declare function createLassoPath(capacity?: number): LassoPath;
+/**
+ * Empty a path without giving up the room it has claimed.
+ *
+ * The buffers are kept, so the second lasso of a session and the fiftieth cost
+ * nothing to start. Whatever is left past `length` is never read.
+ * @param path - The path to empty.
+ */
+export declare function resetLassoPath(path: LassoPath): void;
+/**
+ * Add a vertex, unless it is too near the last one kept.
+ *
+ * The distance is measured from the last vertex that was kept, not from the
+ * last position the pointer reported, so consecutive vertices are always at
+ * least `minDistance` apart however slowly the pointer is moving. Measuring
+ * from the raw sample instead would let a slow drag across the whole plot keep
+ * a single vertex, and the outline would close as a straight line between
+ * where the drag started and where it ended.
+ * @param path - The path to add to; its buffers are doubled when full.
+ * @param x - Horizontal position of the vertex, in pixels.
+ * @param y - Vertical position of the vertex, in pixels.
+ * @param minDistance - How far the pointer has to have moved for the vertex to be worth keeping, in pixels. Nothing is dropped when it is zero, negative, or not finite.
+ * @returns Whether the vertex was kept. A position that is not finite never is.
+ */
+export declare function appendLassoPoint(path: LassoPath, x: number, y: number, minDistance: number): boolean;
+/**
+ * The path as an SVG `d` attribute.
+ *
+ * Coordinates are rounded to a tenth of a pixel. A lasso is drawn at a
+ * resolution the eye cannot resolve past that, and the full doubles would put
+ * seventeen characters per vertex into an attribute that is rewritten on every
+ * frame of the drag.
+ * @param path - The path to write out.
+ * @param close - Whether to close the ring with a `Z`, which is what turns the drawn line into the shape that is about to be tested.
+ * @returns The `d` attribute, or an empty string when the path holds no vertex.
+ */
+export declare function lassoPathData(path: LassoPath, close: boolean): string;
+//# sourceMappingURL=lassoPath.d.ts.map

package/lib/scatter/core/lassoPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lassoPath.d.ts","sourceRoot":"","sources":["../../../src/scatter/core/lassoPath.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,MAAM,WAAW,SAAS;IACxB,8EAA8E;IAC9E,EAAE,EAAE,YAAY,CAAC;IACjB,4EAA4E;IAC5E,EAAE,EAAE,YAAY,CAAC;IACjB,wCAAwC;IACxC,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,QAAQ,SAAmB,GAAG,SAAS,CAKtE;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,CAEpD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,SAAS,EACf,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,WAAW,EAAE,MAAM,GAClB,OAAO,CAwBT;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,GAAG,MAAM,CAWrE"}

package/lib/scatter/core/lassoPath.js

@@ -0,0 +1,101 @@
+const DEFAULT_CAPACITY = 256;
+/**
+ * An empty path, with room to grow.
+ * @param capacity - How many vertices to make room for before the first growth; at least one, and rounded down. Defaults to 256, which is a couple of seconds of dragging.
+ * @returns The path, holding no vertex yet.
+ */
+export function createLassoPath(capacity = DEFAULT_CAPACITY) {
+    const size = Number.isFinite(capacity)
+        ? Math.max(1, Math.floor(capacity))
+        : DEFAULT_CAPACITY;
+    return { xs: new Float64Array(size), ys: new Float64Array(size), length: 0 };
+}
+/**
+ * Empty a path without giving up the room it has claimed.
+ *
+ * The buffers are kept, so the second lasso of a session and the fiftieth cost
+ * nothing to start. Whatever is left past `length` is never read.
+ * @param path - The path to empty.
+ */
+export function resetLassoPath(path) {
+    path.length = 0;
+}
+/**
+ * Add a vertex, unless it is too near the last one kept.
+ *
+ * The distance is measured from the last vertex that was kept, not from the
+ * last position the pointer reported, so consecutive vertices are always at
+ * least `minDistance` apart however slowly the pointer is moving. Measuring
+ * from the raw sample instead would let a slow drag across the whole plot keep
+ * a single vertex, and the outline would close as a straight line between
+ * where the drag started and where it ended.
+ * @param path - The path to add to; its buffers are doubled when full.
+ * @param x - Horizontal position of the vertex, in pixels.
+ * @param y - Vertical position of the vertex, in pixels.
+ * @param minDistance - How far the pointer has to have moved for the vertex to be worth keeping, in pixels. Nothing is dropped when it is zero, negative, or not finite.
+ * @returns Whether the vertex was kept. A position that is not finite never is.
+ */
+export function appendLassoPoint(path, x, y, minDistance) {
+    if (!Number.isFinite(x) || !Number.isFinite(y))
+        return false;
+    if (path.length > 0) {
+        const lastX = path.xs[path.length - 1];
+        const lastY = path.ys[path.length - 1];
+        if (lastX !== undefined && lastY !== undefined) {
+            const gate = Number.isFinite(minDistance) && minDistance > 0
+                ? minDistance * minDistance
+                : 0;
+            const deltaX = x - lastX;
+            const deltaY = y - lastY;
+            if (deltaX * deltaX + deltaY * deltaY < gate)
+                return false;
+        }
+    }
+    if (path.length >= path.xs.length || path.length >= path.ys.length) {
+        growLassoPath(path);
+    }
+    path.xs[path.length] = x;
+    path.ys[path.length] = y;
+    path.length += 1;
+    return true;
+}
+/**
+ * The path as an SVG `d` attribute.
+ *
+ * Coordinates are rounded to a tenth of a pixel. A lasso is drawn at a
+ * resolution the eye cannot resolve past that, and the full doubles would put
+ * seventeen characters per vertex into an attribute that is rewritten on every
+ * frame of the drag.
+ * @param path - The path to write out.
+ * @param close - Whether to close the ring with a `Z`, which is what turns the drawn line into the shape that is about to be tested.
+ * @returns The `d` attribute, or an empty string when the path holds no vertex.
+ */
+export function lassoPathData(path, close) {
+    const count = Math.min(path.length, path.xs.length, path.ys.length);
+    let data = '';
+    for (let index = 0; index < count; index++) {
+        const x = path.xs[index];
+        const y = path.ys[index];
+        if (x === undefined || y === undefined)
+            break;
+        data += `${index === 0 ? 'M' : ' L'}${roundToTenth(x)},${roundToTenth(y)}`;
+    }
+    if (data.length === 0)
+        return '';
+    return close ? `${data}Z` : data;
+}
+function growLassoPath(path) {
+    const capacity = Math.max(1, Math.min(path.xs.length, path.ys.length)) * 2;
+    const xs = new Float64Array(capacity);
+    const ys = new Float64Array(capacity);
+    xs.set(path.xs);
+    ys.set(path.ys);
+    path.xs = xs;
+    path.ys = ys;
+}
+function roundToTenth(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    return Math.round(value * 10) / 10;
+}
+//# sourceMappingURL=lassoPath.js.map

package/lib/scatter/core/lassoPath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lassoPath.js","sourceRoot":"","sources":["../../../src/scatter/core/lassoPath.ts"],"names":[],"mappings":"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"}