@genome-spy/core 0.14.0

package/src/data/transforms/clone.js

@@ -0,0 +1,40 @@
+import createCloner from "../../utils/cloner";
+import FlowNode, { BEHAVIOR_CLONES, isFileBatch } from "../flowNode";
+
+/**
+ * Clones the data objects that pass through.
+ */
+export default class CloneTransform extends FlowNode {
+    get behavior() {
+        return BEHAVIOR_CLONES;
+    }
+
+    constructor() {
+        super();
+
+        /** @param {any} datum */
+        const setupCloner = (datum) => {
+            const clone = createCloner(datum);
+
+            /** @param {any} datum */
+            this.handle = (datum) => this._propagate(clone(datum));
+
+            this.handle(datum);
+        };
+
+        this.handle = setupCloner;
+
+        /**
+         * Signals that a new batch of data will be propagated.
+         *
+         * @param {import("../flowNode").FlowBatch} [flowBatch]
+         */
+        this.beginBatch = (flowBatch) => {
+            if (isFileBatch(flowBatch)) {
+                // TODO: Only create new cloner if the props change
+                this.handle = setupCloner;
+            }
+            super.beginBatch(flowBatch);
+        };
+    }
+}

package/src/data/transforms/clone.test.js

@@ -0,0 +1,10 @@
+import { processData } from "../flowTestUtils";
+import CloneTransform from "./clone";
+
+test("CloneTransform clones the data objects", () => {
+    const data = [{ x: 1 }, { x: 2 }];
+    const clonedData = processData(new CloneTransform(), data);
+
+    expect(clonedData).toEqual(data);
+    expect(clonedData[0]).not.toBe(data[0]);
+});

package/src/data/transforms/coverage.js

@@ -0,0 +1,187 @@
+import FlatQueue from "flatqueue";
+
+import { field } from "../../utils/field";
+import FlowNode, { BEHAVIOR_CLONES } from "../flowNode";
+
+/**
+ * @typedef {import("../../spec/transform").CoverageParams} CoverageParams
+ */
+
+/**
+ * Computes coverage for sorted segments
+ *
+ * TODO: Binned coverage
+ */
+export default class CoverageTransform extends FlowNode {
+    get behavior() {
+        return BEHAVIOR_CLONES;
+    }
+
+    /**
+     * @param {CoverageParams} params
+     */
+    constructor(params) {
+        super();
+        this.params = params;
+
+        this.startAccessor = field(params.start);
+        this.endAccessor = field(params.end);
+
+        /** @type {function(any):string} */
+        this.chromAccessor = params.chrom
+            ? field(params.chrom)
+            : (d) => undefined;
+        /** @type {function(any):number} */
+        this.weightAccessor = params.weight ? field(params.weight) : (d) => 1;
+
+        this.as = {
+            coverage: params.as || "coverage",
+            start: params.asStart || params.start,
+            end: params.asEnd || params.end,
+            chrom: params.asChrom || params.chrom,
+        };
+
+        // eslint-disable-next-line no-new-func
+        this.createSegment = /** @type {function} */ (
+            new Function(
+                "start",
+                "end",
+                "coverage",
+                "chrom",
+                "return {" +
+                    Object.entries(this.as)
+                        .filter(([param, prop]) => prop)
+                        .map(
+                            ([param, prop]) =>
+                                `${JSON.stringify(prop)}: ${param}`
+                        )
+                        .join(", ") +
+                    "};"
+            )
+        );
+
+        // End pos as priority, weight as value
+        this.ends = new FlatQueue();
+    }
+
+    reset() {
+        super.reset();
+        this.initialize();
+    }
+
+    initialize() {
+        const asCoverage = this.as.coverage;
+        const asEnd = this.as.end;
+        const asChrom = this.as.chrom;
+
+        const startAccessor = this.startAccessor;
+        const endAccessor = this.endAccessor;
+        const chromAccessor = this.chromAccessor;
+        const weightAccessor = this.weightAccessor;
+
+        /** @type {Record<string, number|string>} used for merging adjacent segment */
+        let bufferedSegment;
+
+        /** @type {string} */
+        let prevChrom;
+
+        /** @type {string} */
+        let chrom;
+
+        // TODO: Whattabout cumulative error when float weights are used?
+        // Howabout https://github.com/d3/d3-array#fsum ?
+        let coverage = 0;
+
+        /** @type {number} */
+        let prevEdge;
+
+        // End pos as priority, weight as value
+        const ends = this.ends;
+        ends.clear();
+
+        /**
+         * @param {number} start
+         * @param {number} end
+         * @param {number} coverage
+         */
+        const pushSegment = (start, end, coverage) => {
+            if (start == end) {
+                return;
+            }
+
+            let extended = false;
+            if (bufferedSegment) {
+                if (bufferedSegment[asCoverage] === coverage) {
+                    // Extend it
+                    bufferedSegment[asEnd] = end;
+                    extended = true;
+                } else if (bufferedSegment[asCoverage] != 0) {
+                    this._propagate(bufferedSegment);
+                }
+            }
+
+            if (!extended) {
+                bufferedSegment = this.createSegment(
+                    start,
+                    end,
+                    coverage,
+                    chrom
+                );
+            }
+        };
+
+        const flushQueue = () => {
+            // Flush queue
+            /** @type {number} */
+            let edge;
+            while ((edge = ends.peekValue()) !== undefined) {
+                pushSegment(prevEdge, edge, coverage);
+                prevEdge = edge;
+                coverage -= ends.pop();
+            }
+            prevEdge = undefined;
+
+            if (bufferedSegment) {
+                this._propagate(bufferedSegment);
+                bufferedSegment = undefined;
+            }
+        };
+
+        /** @param {Record<string, any>} datum */
+        this.handle = (datum) => {
+            const start = startAccessor(datum);
+
+            /** @type {number} */
+            let edge;
+            while ((edge = ends.peekValue()) !== undefined && edge < start) {
+                pushSegment(prevEdge, edge, coverage);
+                prevEdge = edge;
+                coverage -= ends.pop();
+            }
+
+            if (asChrom) {
+                let newChrom = chromAccessor(datum);
+                if (newChrom !== prevChrom) {
+                    flushQueue();
+                    chrom = newChrom;
+                    prevChrom = chrom;
+                }
+            }
+
+            if (prevEdge !== undefined) {
+                pushSegment(prevEdge, start, coverage);
+            }
+            prevEdge = start;
+
+            const weight = weightAccessor(datum);
+            coverage += weight;
+
+            ends.push(weight, endAccessor(datum));
+        };
+
+        this.complete = () => {
+            flushQueue();
+            super.complete();
+        };
+    }
+}

package/src/data/transforms/coverage.test.js

@@ -0,0 +1,122 @@
+import CoverageTransform from "./coverage";
+import { processData } from "../flowTestUtils";
+
+/**
+ * @typedef {import("../../spec/transform").CoverageParams} CoverageParams
+ */
+
+/**
+ * @param {CoverageParams} params
+ * @param {any[]} data
+ */
+function transform(params, data) {
+    const t = new CoverageTransform(params);
+    t.initialize();
+    return processData(t, data);
+}
+
+test("Coverage transform produces correct coverage segments", () => {
+    const reads = [
+        [0, 4],
+        [1, 3],
+        [2, 6],
+        [4, 8],
+        [8, 10],
+        [11, 14],
+        [11, 13],
+        [11, 12],
+        [15, 18],
+        [16, 18],
+        [17, 18],
+    ].map((d) => ({
+        start: d[0],
+        end: d[1],
+    }));
+
+    const coverageSegments = [
+        [0, 1, 1],
+        [1, 2, 2],
+        [2, 3, 3],
+        [3, 6, 2],
+        [6, 10, 1],
+        [11, 12, 3],
+        [12, 13, 2],
+        [13, 14, 1],
+        [15, 16, 1],
+        [16, 17, 2],
+        [17, 18, 3],
+    ].map((d) => ({
+        start: d[0],
+        end: d[1],
+        coverage: d[2],
+    }));
+
+    /** @type {CoverageParams} */
+    const coverageConfig = {
+        type: "coverage",
+        start: "start",
+        end: "end",
+    };
+    expect(transform(coverageConfig, reads)).toEqual(coverageSegments);
+});
+
+test("Coverage transform handles chromosomes", () => {
+    const reads = [
+        { chrom: "chr1", start: 0, end: 1 },
+        { chrom: "chr2", start: 0, end: 1 },
+        { chrom: "chr3", start: 1, end: 3 },
+    ];
+
+    const coverageSegments = [
+        { chrom: "chr1", start: 0, end: 1, coverage: 1 },
+        { chrom: "chr2", start: 0, end: 1, coverage: 1 },
+        { chrom: "chr3", start: 1, end: 3, coverage: 1 },
+    ];
+
+    /** @type {CoverageParams} */
+    const coverageConfig = {
+        type: "coverage",
+        chrom: "chrom",
+        start: "start",
+        end: "end",
+    };
+
+    expect(transform(coverageConfig, reads)).toEqual(coverageSegments);
+});
+
+test("Coverage transform handles weights", () => {
+    const reads = [
+        [0, 4, 1],
+        [1, 3, 2],
+        [2, 6, 3],
+        [8, 10, -1],
+    ].map((d) => ({
+        start: d[0],
+        end: d[1],
+        weight: d[2],
+    }));
+
+    const coverageSegments = [
+        [0, 1, 1],
+        [1, 2, 3],
+        [2, 3, 6],
+        [3, 4, 4],
+        [4, 6, 3],
+        [8, 10, -1],
+    ].map((d) => ({
+        start: d[0],
+        end: d[1],
+        coverage: d[2],
+    }));
+
+    /** @type {CoverageParams} */
+    const coverageConfig = {
+        type: "coverage",
+        chrom: "chrom",
+        start: "start",
+        end: "end",
+        weight: "weight",
+    };
+
+    expect(transform(coverageConfig, reads)).toEqual(coverageSegments);
+});

package/src/data/transforms/filter.js

@@ -0,0 +1,37 @@
+import createFunction from "../../utils/expression";
+import FlowNode from "../flowNode";
+
+/**
+ * @typedef {import("../../spec/transform").FilterParams} FilterParams
+ */
+
+export default class FilterTransform extends FlowNode {
+    /**
+     *
+     * @param {FilterParams} params
+     */
+    constructor(params) {
+        super();
+        this.params = params;
+
+        /** @type {(datum: any) => boolean} */
+        this.predicate = undefined;
+    }
+
+    initialize() {
+        this.predicate = createFunction(
+            this.params.expr,
+            this.getGlobalObject()
+        );
+    }
+
+    /**
+     *
+     * @param {import("../flowNode").Datum} datum
+     */
+    handle(datum) {
+        if (this.predicate(datum)) {
+            this._propagate(datum);
+        }
+    }
+}

package/src/data/transforms/filter.test.js

@@ -0,0 +1,17 @@
+import { processData } from "../flowTestUtils";
+import FilterTransform from "./filter";
+
+test("FilterTransform filter rows", () => {
+    const data = [1, 2, 3, 4, 5, 6].map((x) => ({ x }));
+
+    /** @type {import("../../spec/transform").FilterParams} */
+    const filterParams = {
+        type: "filter",
+        expr: "datum.x > 3 && datum.x != 5",
+    };
+
+    const t = new FilterTransform(filterParams);
+    t.initialize();
+
+    expect(processData(t, data)).toEqual([4, 6].map((x) => ({ x })));
+});

package/src/data/transforms/filterScoredLabels.js

@@ -0,0 +1,134 @@
+import { bisector } from "d3-array";
+import FlowNode from "../flowNode";
+import { topKSlice } from "../../utils/topK";
+import ReservationMap from "../../utils/reservationMap";
+import { field } from "../../utils/field";
+
+/**
+ * @typedef {import("../../spec/transform").FilterScoredLabelsParams} Params
+ * @typedef {import("../../view/view").default} View
+ */
+export default class FilterScoredLabelsTransform extends FlowNode {
+    /**
+     *
+     * @param {Params} params
+     * @param {View} view
+     */
+    constructor(params, view) {
+        super();
+
+        this.params = params;
+
+        /** @type {any[]} */
+        this._data = [];
+
+        this.channel = params.channel ?? "x";
+
+        if (!["x", "y"].includes(this.channel)) {
+            throw new Error("Invalid channel: " + this.channel);
+        }
+
+        this.posAccessor = field(this.params.pos);
+        this.posBisector = bisector(this.posAccessor);
+        this.scoreAccessor = field(this.params.score);
+        this.widthAccessor = field(this.params.width);
+        /** @type {function(any):any} */
+        this.laneAccessor = this.params.lane
+            ? field(this.params.lane)
+            : (d) => 0;
+        this.padding = this.params.padding ?? 0;
+
+        /** @type {Map<any, ReservationMap>} */
+        this.reservationMaps = new Map();
+
+        this.resolution = view.getScaleResolution(this.channel);
+
+        // Synchronize propagation with rendering because we need both the domain and the range (length of the axis).
+        const callback = () => this._filterAndPropagate();
+        this.schedule = () => view.context.animator.requestTransition(callback);
+
+        // Propagate when the domain changes
+        this.resolution.addEventListener("domain", (scale) => this.schedule());
+
+        // Propagate when layout changes. Abusing a "private" method.
+        // TODO: Provide another attachment point, in view context for example
+        view._addBroadcastHandler("layoutComputed", () => this.schedule());
+
+        // TODO: Remove observers when this FlowNode is thrown away.
+    }
+
+    complete() {
+        const posAccessor = this.posAccessor;
+        this._data.sort((a, b) => posAccessor(a) - posAccessor(b));
+
+        this._scores = this._data.map(this.scoreAccessor);
+
+        for (const lane of new Set(this._data.map(this.laneAccessor))) {
+            this.reservationMaps.set(lane, new ReservationMap(200));
+        }
+
+        this.schedule();
+
+        super.complete();
+    }
+
+    _filterAndPropagate() {
+        super.reset();
+
+        const scale = this.resolution.getScale();
+        const rangeSpan =
+            this.resolution.members[0].view.coords?.[
+                this.channel == "x" ? "width" : "height"
+            ];
+        if (!rangeSpan) {
+            // The view size is not (yet) available
+            return;
+        }
+
+        for (const reservationMap of this.reservationMaps.values()) {
+            reservationMap.reset();
+        }
+
+        const domain = scale.domain();
+        const k = 70; // TODO: Configurable
+
+        // Find the maximum of k elements from the visible domain in priority order
+        const topIndices = topKSlice(
+            this._scores,
+            k,
+            this.posBisector.left(this._data, domain[0]),
+            this.posBisector.right(this._data, domain[1])
+        );
+
+        // Try to fit the elements on the available lanes and propagate if there was room
+        for (const i of topIndices) {
+            const datum = this._data[i];
+            const pos = scale(this.posAccessor(datum)) * rangeSpan;
+            const halfWidth = this.widthAccessor(datum) / 2 + this.padding;
+
+            if (
+                this.reservationMaps
+                    .get(this.laneAccessor(datum))
+                    .reserve(pos - halfWidth, pos + halfWidth)
+            ) {
+                this._propagate(datum);
+            }
+        }
+
+        super.complete();
+    }
+
+    reset() {
+        super.reset();
+        this._data = [];
+        this.groups = new Map();
+    }
+
+    /**
+     *
+     * @param {import("../flowNode").Datum} datum
+     */
+    handle(datum) {
+        this._data.push(datum);
+    }
+}

package/src/data/transforms/flattenCompressedExons.js

@@ -0,0 +1,57 @@
+import { field } from "../../utils/field";
+import numberExtractor from "../../utils/numberExtractor";
+import FlowNode, { BEHAVIOR_CLONES } from "../flowNode";
+
+/**
+ * @typedef {import("../../spec/transform").FlattenCompressedExonsParams} FlattenCompressedExonsParams
+ */
+
+/**
+ * Flattens "run-length encoded" exons. The transforms inputs the start
+ * coordinate of the gene body and a comma-delimited string of alternating
+ * intron and exon lengths. A new datum is created for each exon.
+ */
+export default class FlattenCompressedExonsTransform extends FlowNode {
+    get behavior() {
+        return BEHAVIOR_CLONES;
+    }
+
+    /**
+     *
+     * @param {FlattenCompressedExonsParams} params
+     */
+    constructor(params) {
+        super();
+
+        const exonsAccessor = field(params.exons ?? "exons");
+        const startAccessor = field(params.start ?? "start");
+        const [exonStart, exonEnd] = params.as || ["exonStart", "exonEnd"];
+
+        /**
+         *
+         * @param {any} datum
+         */
+        this.handle = (datum) => {
+            let upper = startAccessor(datum);
+            let lower = upper;
+
+            let inExon = true;
+            const exons = exonsAccessor(datum);
+            for (const token of numberExtractor(exons)) {
+                if (inExon) {
+                    lower = upper + token;
+                } else {
+                    upper = lower + token;
+
+                    const newRow = Object.assign({}, datum);
+                    newRow[exonStart] = lower;
+                    newRow[exonEnd] = upper;
+
+                    this._propagate(newRow);
+                }
+
+                inExon = !inExon;
+            }
+        };
+    }
+}

package/src/data/transforms/flattenDelimited.js

@@ -0,0 +1,68 @@
+import { asArray } from "../../utils/arrayUtils";
+import { field } from "../../utils/field";
+import FlowNode, { BEHAVIOR_CLONES } from "../flowNode";
+
+/**
+ * @typedef {import("../../spec/transform").FlattenDelimitedParams} FlattenDelimitedParams
+ * @prop {string[]} separators
+ * @prop {string[]} fields
+ * @prop {string[]} [as]
+ */
+
+export default class FlattenDelimitedTransform extends FlowNode {
+    get behavior() {
+        return BEHAVIOR_CLONES;
+    }
+
+    /**
+     *
+     * @param {FlattenDelimitedParams} params
+     */
+    constructor(params) {
+        super();
+
+        // TODO: Validate config. string elements, etc...
+
+        const accessors = asArray(params.field).map((f) => field(f));
+        const separators = asArray(params.separator);
+        const as = asArray(params.as || params.field);
+
+        if (
+            accessors.length !== separators.length ||
+            accessors.length !== as.length
+        ) {
+            throw new Error(
+                `Lengths of "separator" (${separators.length}), "fields" (${accessors.length}), and "as" (${as.length}) do not match!`
+            );
+        }
+
+        /** @param {any[]} datum */
+        this.handle = (datum) => {
+            if (accessors.some((a) => !a(datum))) return;
+
+            const splitFields = accessors.map((accessor, i) =>
+                accessor(datum).split(separators[i])
+            );
+            validateSplit(splitFields, datum);
+            const flatLen = splitFields[0].length;
+
+            for (let ri = 0; ri < flatLen; ri++) {
+                const newRow = Object.assign({}, datum);
+                for (let fi = 0; fi < accessors.length; fi++) {
+                    newRow[as[fi]] = splitFields[fi][ri];
+                }
+                this._propagate(newRow);
+            }
+        };
+    }
+}
+
+function validateSplit(splitFields, row) {
+    const splitLengths = splitFields.map((f) => f.length);
+    if (!splitLengths.every((x) => x == splitLengths[0])) {
+        throw new Error(
+            "Mismatching number of elements in the fields to be split: " +
+                JSON.stringify(row)
+        );
+    }
+}