@genome-spy/core 0.23.0 → 0.24.2

package/package.json

@@ -7,7 +7,7 @@
   },
   "contributors": [],
   "license": "BSD-2-Clause",
-  "version": "0.23.0",
+  "version": "0.24.2",
   "main": "dist/index.js",
   "module": "src/index.js",
   "exports": {
@@ -53,5 +53,5 @@
     "vega-scale": "^7.1.1",
     "vega-util": "^1.16.0"
   },
-  "gitHead": "7420b51a4344e39985db59396ddf873eb3002143"
+  "gitHead": "587ef91161457b17a039f82111d15df339e1e9f5"
 }

package/src/gl/dataToVertices.js

@@ -131,13 +131,18 @@ export class GeometryBuilder {
      * @param {number} [hi]
      */
     prepareXIndexer(data, lo = 0, hi = lo + data.length) {
-        if (!data.length || hi - lo < 0) {
+        const disable = () => {
             /**
              * @param {import("../data/flowNode").Datum} datum
              */
             this.addToXIndex = (datum) => {
                 // nop
             };
+            this.xIndexer = undefined;
+        };
+
+        if (!data.length || hi - lo < 0) {
+            disable();
             return;
         }
 
@@ -152,31 +157,33 @@ export class GeometryBuilder {
             const xa = xe.accessor;
             const x2a = x2e ? x2e.accessor : xa;
 
-            this.xIndexer = createBinningRangeIndexer(
-                50,
-                [xa(data[lo]), x2a(data[hi - 1])],
-                xa,
-                x2a
-            );
-
-            let lastVertexCount = this.variableBuilder.vertexCount;
-
-            /**
-             * @param {any} datum
-             */
-            this.addToXIndex = (datum) => {
-                let currentVertexCount = this.variableBuilder.vertexCount;
-                this.xIndexer(datum, lastVertexCount, currentVertexCount);
-                lastVertexCount = currentVertexCount;
-            };
+            /** @type {[number, number]} */
+            const dataDomain = [xa(data[lo]), x2a(data[hi - 1])];
+
+            // No indexer for point domains that have zero extent
+            if (dataDomain[1] > dataDomain[0]) {
+                this.xIndexer = createBinningRangeIndexer(
+                    50,
+                    dataDomain,
+                    xa,
+                    x2a
+                );
+
+                let lastVertexCount = this.variableBuilder.vertexCount;
+
+                /**
+                 * @param {any} datum
+                 */
+                this.addToXIndex = (datum) => {
+                    let currentVertexCount = this.variableBuilder.vertexCount;
+                    this.xIndexer(datum, lastVertexCount, currentVertexCount);
+                    lastVertexCount = currentVertexCount;
+                };
+            } else {
+                disable();
+            }
         } else {
-            this.xIndexer = undefined;
-            /**
-             * @param {import("../data/flowNode").Datum} datum
-             */
-            this.addToXIndex = (datum) => {
-                // nop
-            };
+            disable();
         }
     }
 

package/src/marks/link.js

@@ -140,7 +140,11 @@ export default class LinkMark extends Mark {
                 this.bufferInfo.attribs
             )) {
                 const [attribute, attribInfo] = attribInfoObject;
-                if (attribInfo.buffer && this.arrays[attribute].numComponents) {
+                if (
+                    attribInfo.buffer &&
+                    attribInfo.numComponents &&
+                    attribInfo.divisor
+                ) {
                     attribInfo.offset =
                         offset * this.arrays[attribute].numComponents * 4; // gl.FLOAT in bytes
                 }

package/src/node_modules/.vitest/results.json

@@ -0,0 +1 @@
+{"version":"0.23.1","results":[["/genome/genome.test.js",{"duration":17,"failed":false}],["/scale/scale.test.js",{"duration":27,"failed":false}],["/utils/layout/flexLayout.test.js",{"duration":41,"failed":false}],["/data/flowOptimizer.test.js",{"duration":12,"failed":false}],["/utils/layout/rectangle.test.js",{"duration":10,"failed":false}],["/utils/domainArray.test.js",{"duration":11,"failed":false}],["/data/transforms/regexFold.test.js",{"duration":9,"failed":false}],["/view/scaleResolution.test.js",{"duration":169,"failed":false}],["/view/view.test.js",{"duration":161,"failed":false}],["/view/axisResolution.test.js",{"duration":22,"failed":false}],["/view/flowBuilder.test.js",{"duration":11,"failed":false}],["/encoder/encoder.test.js",{"duration":15,"failed":false}],["/data/transforms/stack.test.js",{"duration":11,"failed":false}],["/data/transforms/identifier.test.js",{"duration":84,"failed":false}],["/data/transforms/coverage.test.js",{"duration":10,"failed":false}],["/data/transforms/flattenDelimited.test.js",{"duration":16,"failed":false}],["/genome/scaleIndex.test.js",{"duration":11,"failed":false}],["/utils/layout/grid.test.js",{"duration":7,"failed":false}],["/utils/topK.test.js",{"duration":95,"failed":false}],["/utils/binnedIndex.test.js",{"duration":6,"failed":false}],["/data/collector.test.js",{"duration":11,"failed":false}],["/data/flow.test.js",{"duration":11,"failed":false}],["/utils/propertyCacher.test.js",{"duration":8,"failed":false}],["/data/transforms/regexExtract.test.js",{"duration":10,"failed":false}],["/data/transforms/pileup.test.js",{"duration":7,"failed":false}],["/utils/indexer.test.js",{"duration":6,"failed":false}],["/encoder/accessor.test.js",{"duration":10,"failed":false}],["/data/sources/sequenceSource.test.js",{"duration":8,"failed":false}],["/data/sources/inlineSource.test.js",{"duration":10,"failed":false}],["/utils/mergeObjects.test.js",{"duration":13,"failed":false}],["/data/flowNode.test.js",{"duration":6,"failed":false}],["/scale/ticks.test.js",{"duration":10,"failed":false}],["/data/formats/fasta.test.js",{"duration":10,"failed":false}],["/data/transforms/flattenSequence.test.js",{"duration":10,"failed":false}],["/utils/addBaseUrl.test.js",{"duration":5,"failed":false}],["/data/transforms/project.test.js",{"duration":10,"failed":false}],["/utils/iterateNestedMaps.test.js",{"duration":5,"failed":false}],["/utils/reservationMap.test.js",{"duration":6,"failed":false}],["/utils/kWayMerge.test.js",{"duration":5,"failed":false}],["/data/transforms/sample.test.js",{"duration":326,"failed":false}],["/utils/propertyCoalescer.test.js",{"duration":5,"failed":false}],["/utils/coalesce.test.js",{"duration":4,"failed":false}],["/data/transforms/filter.test.js",{"duration":6,"failed":false}],["/utils/cloner.test.js",{"duration":6,"failed":false}],["/utils/variableTools.test.js",{"duration":6,"failed":false}],["/view/viewFactory.test.js",{"duration":4,"failed":false}],["/data/transforms/formula.test.js",{"duration":8,"failed":false}],["/utils/concatIterables.test.js",{"duration":18,"failed":false}],["/utils/numberExtractor.test.js",{"duration":30,"failed":false}],["/data/transforms/clone.test.js",{"duration":8,"failed":false}],["/genome/scaleLocus.test.js",{"duration":0,"failed":false}],["/data/dataFlow.test.js",{"duration":0,"failed":false}]]}

package/src/utils/binnedIndex.js

@@ -13,11 +13,12 @@ const MIN_INTEGER = -(2 ** 31);
 
 /**
  * A binned index for (overlapping) ranges that are sorted by their start position.
+ * Each indexed range is associated with respective vertex indices.
  *
  * @param {number} size Number of bins
- * @param {[number, number]} domain
- * @param {(datum: T) => number} accessor
- * @param {(datum: T) => number} [accessor2]
+ * @param {[number, number]} domain Domain of positions
+ * @param {(datum: T) => number} accessor Accessor for range's start position
+ * @param {(datum: T) => number} [accessor2] Accessor for range's end position
  * @template T
  */
 export function createBinningRangeIndexer(
@@ -38,19 +39,32 @@ export function createBinningRangeIndexer(
     const domainLength = domain[1] - domain[0];
     const divisor = domainLength / size;
 
-    /** @param {number} pos */
-    const getBin = (pos) =>
-        clamp(Math.floor((pos - start) / divisor), 0, size - 1);
+    /**
+     * @param {number} pos
+     * @param {boolean} end
+     */
+    const getBin = (pos, end) => {
+        const unfloored = (pos - start) / divisor;
+        const floored = Math.floor(unfloored);
+
+        // Special handling for the end coordinate because we are using half-open ranges.
+        return clamp(
+            end && floored == unfloored ? floored - 1 : floored,
+            0,
+            size - 1
+        );
+    };
 
     /**
+     * Indexer for point items. Those have just a single coordinate.
      *
      * @param {T} datum
-     * @param {number} startIndex
-     * @param {number} endIndex
+     * @param {number} startVertexIndex
+     * @param {number} endVertexIndex
      */
-    function binningIndexer(datum, startIndex, endIndex) {
-        if (startIndex > lastIndex) {
-            lastIndex = startIndex;
+    function binningIndexer(datum, startVertexIndex, endVertexIndex) {
+        if (startVertexIndex > lastIndex) {
+            lastIndex = startVertexIndex;
         } else if (!unordered) {
             unordered = true;
             // TODO: Contextual info like view path
@@ -60,26 +74,27 @@ export function createBinningRangeIndexer(
         }
 
         const value = accessor(datum);
-        const bin = getBin(value);
+        const bin = getBin(value, false);
 
-        if (startIndices[bin] > startIndex) {
-            startIndices[bin] = startIndex;
+        if (startIndices[bin] > startVertexIndex) {
+            startIndices[bin] = startVertexIndex;
         }
 
-        if (endIndices[bin] < endIndex) {
-            endIndices[bin] = endIndex;
+        if (endIndices[bin] < endVertexIndex) {
+            endIndices[bin] = endVertexIndex;
         }
     }
 
     /**
+     * Indexer for ranged items. Those have both start and end coordinates.
      *
      * @param {T} datum
-     * @param {number} startIndex
-     * @param {number} endIndex
+     * @param {number} startVertexIndex
+     * @param {number} endVertexIndex
      */
-    function binningRangeIndexer(datum, startIndex, endIndex) {
-        if (startIndex > lastIndex) {
-            lastIndex = startIndex;
+    function binningRangeIndexer(datum, startVertexIndex, endVertexIndex) {
+        if (startVertexIndex > lastIndex) {
+            lastIndex = startVertexIndex;
         } else if (!unordered) {
             unordered = true;
             // TODO: Contextual info like view path
@@ -90,18 +105,18 @@ export function createBinningRangeIndexer(
 
         const start = accessor(datum);
         const end = accessor2(datum);
-        const startBin = getBin(start);
-        const endBin = getBin(end);
+        const startBin = getBin(start, false);
+        const endBin = getBin(end, true);
 
         // TODO: This loop could probably be done as a more efficient post processing
         // step.
         for (let bin = startBin; bin <= endBin; bin++) {
-            if (startIndices[bin] > startIndex) {
-                startIndices[bin] = startIndex;
+            if (startIndices[bin] > startVertexIndex) {
+                startIndices[bin] = startVertexIndex;
             }
 
-            if (endIndices[bin] < endIndex) {
-                endIndices[bin] = endIndex;
+            if (endIndices[bin] < endVertexIndex) {
+                endIndices[bin] = endVertexIndex;
             }
         }
     }
@@ -110,8 +125,13 @@ export function createBinningRangeIndexer(
      * @type {Lookup}
      */
     const lookup = (start, end, arr = [0, 0]) => {
-        arr[0] = startIndices[getBin(start)];
-        arr[1] = Math.max(endIndices[getBin(end)], arr[0]);
+        const startBin = getBin(start, false);
+        const endBin = getBin(end, true);
+        const startIndex = startIndices[startBin];
+        const endIndex = Math.max(endIndices[endBin], startIndex);
+
+        arr[0] = startIndex;
+        arr[1] = endIndex;
         return arr;
     };
 

package/src/utils/binnedIndex.test.js

@@ -2,29 +2,60 @@ import { describe, expect, test } from "vitest";
 import { createBinningRangeIndexer } from "./binnedIndex.js";
 
 describe("Binning Indexer", () => {
-    test("Points are binned correctly", () => {
-        const items = [0, 1, 4, 10, 35, 36, 80];
+    test("Single point is binned correctly", () => {
+        const items = [25];
         const indexer = createBinningRangeIndexer(10, [0, 100], (x) => x);
 
-        items.forEach((i) => indexer(i, i, i + 1));
+        // Each item uses two vertices
+        items.forEach((x, i) => indexer(x, i * 2, (i + 1) * 2));
 
         const index = indexer.getIndex();
 
-        expect(index(0, 1)).toEqual([0, 5]);
-        expect(index(1, 2)).toEqual([0, 5]);
-        expect(index(1, 15)).toEqual([0, 11]);
-        expect(index(10, 15)).toEqual([10, 11]);
-        expect(index(11, 38)).toEqual([10, 37]);
-        expect(index(11, 45)).toEqual([10, 37]);
-        expect(index(40, 85)).toEqual([80, 81]);
-        expect(index(90, 100)).toEqual([81, 81]);
+        expect(index(1, 4)).toEqual([0, 0]);
+        expect(index(23, 27)).toEqual([0, 2]);
+        expect(index(13, 37)).toEqual([0, 2]);
+        // TODO: MAX_INT could be replaced with the actual maximum vertex number
+        expect(index(40, 42)).toEqual([2147483647, 2147483647]);
+    });
+
+    test("Multiple points are binned correctly", () => {
+        const items = [0, 1, 4, 10, 35, 35, 36, 80];
+        const indexer = createBinningRangeIndexer(10, [0, 100], (x) => x);
+
+        // Each item uses two vertices
+        items.forEach((x, i) => indexer(x, i * 2, (i + 1) * 2));
+
+        const index = indexer.getIndex();
+
+        expect(index(0, 0)).toEqual([0, 6]);
+        expect(index(0, 1)).toEqual([0, 6]);
+        expect(index(1, 2)).toEqual([0, 6]);
+        expect(index(1, 15)).toEqual([0, 8]);
+        expect(index(3, 6)).toEqual([0, 6]);
+        expect(index(10, 15)).toEqual([6, 8]);
+        expect(index(11, 38)).toEqual([6, 14]);
+        expect(index(11, 45)).toEqual([6, 14]);
+        expect(index(34, 36)).toEqual([8, 14]);
+        expect(index(35.5, 36.5)).toEqual([8, 14]);
+        expect(index(40, 50)).toEqual([14, 14]);
+        expect(index(40, 85)).toEqual([14, 16]);
+        expect(index(90, 100)).toEqual([16, 16]);
+
+        expect(index(0, 100)).toEqual([0, 16]);
+        expect(index(-1, 100)).toEqual([0, 16]);
+        expect(index(0, 101)).toEqual([0, 16]);
     });
 
     test("Non-overlapping ranges are binned correctly", () => {
         const items = [
             [0, 5],
-            [25, 50],
+            [25, 48],
             [50, 55],
+            [64, 67],
+            [72, 75],
+            [75, 78],
+            [86, 90],
+            [90, 93],
         ];
         const indexer = createBinningRangeIndexer(
             10,
@@ -33,41 +64,92 @@ describe("Binning Indexer", () => {
             (x) => x[1]
         );
 
-        items.forEach((x) => indexer(x, x[0], x[1]));
+        // Each item uses two vertices
+        items.forEach((x, i) => indexer(x, i * 2, (i + 1) * 2));
+
+        const index = indexer.getIndex();
+
+        expect(index(0, 1)).toEqual([0, 2]);
+        expect(index(3, 40)).toEqual([0, 4]);
+        expect(index(6, 40)).toEqual([0, 4]);
+        expect(index(15, 30)).toEqual([2, 4]);
+        expect(index(50, 57)).toEqual([4, 6]);
+        expect(index(62, 69)).toEqual([6, 8]);
+        expect(index(69, 71)).toEqual([6, 12]);
+        expect(index(69, 79)).toEqual([6, 12]);
+
+        expect(index(80, 90)).toEqual([12, 14]);
+        expect(index(90, 100)).toEqual([14, 16]);
+
+        expect(index(0, 99)).toEqual([0, 16]);
+        expect(index(0, 100)).toEqual([0, 16]);
+    });
+
+    test("Overlapping ranges with the same start coordinate are binned correctly", () => {
+        const items = [
+            // Increasing lengths
+            [0, 5],
+            [0, 64],
+            [0, 80],
+            // Decreasing lengths
+            [100, 191],
+            [100, 167],
+            [100, 123],
+        ];
+        const indexer = createBinningRangeIndexer(
+            100,
+            [0, 1000],
+            (x) => x[0],
+            (x) => x[1]
+        );
+
+        // Each item uses two vertices
+        items.forEach((x, i) => indexer(x, i * 2, (i + 1) * 2));
 
         const index = indexer.getIndex();
 
-        // TODO: More tests. Doesn't work 100%
+        expect(index(0, 1)).toEqual([0, 6]);
+        expect(index(3, 40)).toEqual([0, 6]);
+        expect(index(0, 100)).toEqual([0, 6]);
+        expect(index(77, 78)).toEqual([4, 6]);
 
-        expect(index(0, 1)).toEqual([0, 5]);
-        expect(index(3, 40)).toEqual([0, 50]);
-        expect(index(6, 40)).toEqual([0, 50]);
-        // fails: expect(index(50, 57)).toEqual([50, 55]);
+        expect(index(90, 205)).toEqual([6, 12]);
+        expect(index(111, 115)).toEqual([6, 12]);
+        // Not optimal. Should be [6, 8], but [6, 12] is not wrong
+        expect(index(180, 190)).toEqual([6, 12]);
     });
 
     test("Overlapping ranges are binned correctly", () => {
         const items = [
             [10, 30],
             [25, 50],
+
+            [102, 129],
+            [112, 139],
+            [121, 149],
         ];
         const indexer = createBinningRangeIndexer(
-            10,
-            [0, 100],
+            100,
+            [0, 1000],
             (x) => x[0],
             (x) => x[1]
         );
 
-        items.forEach((x) => indexer(x, x[0], x[1]));
+        items.forEach((x, i) => indexer(x, i * 2, (i + 1) * 2));
 
         const index = indexer.getIndex();
 
-        // TODO: More tests. Doesn't work 100%
+        // TODO: More tests
+
+        expect(index(0, 5)).toEqual([0, 0]);
+        expect(index(0, 15)).toEqual([0, 2]);
+        expect(index(27, 40)).toEqual([0, 4]);
+        expect(index(40, 50)).toEqual([2, 4]);
+        expect(index(40, 80)).toEqual([2, 4]);
+        expect(index(10, 29)).toEqual([0, 4]);
 
-        expect(index(0, 5)).toEqual([10, 10]);
-        expect(index(0, 15)).toEqual([10, 30]);
-        expect(index(27, 40)).toEqual([10, 50]);
-        expect(index(40, 50)).toEqual([25, 50]);
-        expect(index(40, 80)).toEqual([25, 50]);
-        expect(index(10, 29)).toEqual([10, 50]);
+        expect(index(90, 160)).toEqual([4, 10]);
+        expect(index(115, 116)).toEqual([4, 8]);
+        expect(index(135, 145)).toEqual([6, 10]);
     });
 });