@genome-spy/core 0.18.0 → 0.19.1

package/src/scale/glslScaleGenerator.js

@@ -109,8 +109,8 @@ export function generateScaleGlsl(channel, scale, channelDef) {
     const domainUniformName = DOMAIN_PREFIX + primary;
     const rangeName = RANGE_PREFIX + primary;
 
-    const fp64 = !!scale.fp64;
-    const attributeType = fp64 ? "vec2" : "float";
+    const hp = isHighPrecisionScale(scale.type);
+    const attributeType = hp ? "vec2" : "float";
 
     const domainLength = scale.domain ? scale.domain().length : undefined;
 
@@ -127,9 +127,6 @@ export function generateScaleGlsl(channel, scale, channelDef) {
     glsl.push("");
 
     glsl.push(`#define ${channel}_DEFINED`);
-    if (fp64) {
-        glsl.push(`#define ${channel}_FP64`);
-    }
 
     const { transform } = splitScaleType(scale.type);
 
@@ -139,11 +136,7 @@ export function generateScaleGlsl(channel, scale, channelDef) {
      */
     const makeScaleCall = (name, ...args) =>
         // eslint-disable-next-line no-useless-call
-        makeFunctionCall.apply(null, [
-            name + (fp64 ? "Fp64" : ""),
-            "value",
-            ...args,
-        ]);
+        makeFunctionCall.apply(null, [name, "value", ...args]);
 
     let functionCall;
     switch (transform) {
@@ -181,6 +174,17 @@ export function generateScaleGlsl(channel, scale, channelDef) {
 
         case "index":
         case "locus":
+            functionCall = makeScaleCall(
+                "scaleBandHp",
+                "domain",
+                rangeName,
+                scale.paddingInner(),
+                scale.paddingOuter(),
+                scale.align(),
+                // @ts-expect-error TODO: fix typing
+                channelDef.band ?? 0.5
+            );
+            break;
         case "point":
         case "band":
             functionCall = makeScaleCall(
@@ -296,10 +300,13 @@ export function generateScaleGlsl(channel, scale, channelDef) {
     if (functionCall) {
         const name = domainUniformName;
         if (usesDomain) {
-            const dtype = fp64 ? "vec4" : "vec2";
-            scaleBody.push(
-                `${dtype} domain = ${dtype}(${name}[slot], ${name}[slot + 1]);`
-            );
+            if (hp) {
+                scaleBody.push(`vec3 domain = ${name};`);
+            } else {
+                scaleBody.push(
+                    `vec2 domain = vec2(${name}[slot], ${name}[slot + 1]);`
+                );
+            }
         }
 
         scaleBody.push(`float transformed = ${functionCall};`);
@@ -344,9 +351,9 @@ ${returnType} ${SCALED_FUNCTION_PREFIX}${channel}() {
             isContinuous(scale.type) || isDiscretizing(scale.type)
                 ? domainLength
                 : 2;
-        domainUniform = `${
-            fp64 ? "vec2" : "float"
-        } ${domainUniformName}[${length}];`;
+        domainUniform = hp
+            ? `highp vec3 ${domainUniformName};`
+            : `mediump float ${domainUniformName}[${length}];`;
     }
 
     return {
@@ -447,3 +454,35 @@ function makeFunctionCall(name, ...args) {
 
     return `${name}(${fixedArgs.join(", ")})`;
 }
+
+/**
+ *
+ * @param {string} type
+ */
+export function isHighPrecisionScale(type) {
+    return type == "index" || type == "locus";
+}
+
+/**
+ * @param {number} x
+ * @param {number[]} [arr]
+ */
+export function splitHighPrecision(x, arr) {
+    // Maximum precise index number is 2^(23 + 11) ~ 17G
+    // Higher number increases precision but makes zooming unstable
+    const bs = 2 ** 11;
+
+    const lo = x % bs;
+    const hi = Math.round(x - lo);
+    arr ??= [];
+    arr[0] = hi;
+    arr[1] = lo;
+    return arr;
+}
+
+/**
+ * @param {number[]} domain
+ */
+export function toHighPrecisionDomainUniform(domain) {
+    return [...splitHighPrecision(domain[0]), domain[1] - domain[0]];
+}

package/src/scale/scale.test.js

@@ -1,3 +1,4 @@
+import { expect, test } from "vitest";
 /*!
  * Adapted from vega-encode:
  * https://github.com/vega/vega/blob/master/packages/vega-encode/test/scale-test.js

package/src/scale/ticks.test.js

@@ -1,3 +1,4 @@
+import { expect, test } from "vitest";
 /*!
  * Adapted from vega-encode:
  * https://github.com/vega/vega/blob/master/packages/vega-encode/test/scale-test.js

package/src/spec/scale.d.ts

@@ -221,15 +221,6 @@ export interface Scale {
      * If `true` and the scale is used on a positional channel, it can bee zoomed and translated interactively.
      */
     zoom?: boolean | ZoomParams;
-
-    /**
-     * Use emulated 64bit floating points on the GPU to increase precision.
-     *
-     * Emulation has a performance cost when compared to the native 32bit processing, but the effect is negligible in the most cases.
-     *
-     * __Default value:__ `true` for `"locus"` scale, `false` for others.
-     */
-    fp64?: boolean;
 }
 
 export interface SchemeParams {

package/src/utils/addBaseUrl.test.js

@@ -1,3 +1,4 @@
+import { expect, test } from "vitest";
 import addBaseUrl from "./addBaseUrl";
 
 test("addBaseUrl adds baseUrl when needed", () => {

package/src/utils/cloner.test.js

@@ -1,3 +1,4 @@
+import { expect, test } from "vitest";
 import createCloner from "./cloner";
 
 const template = {

package/src/utils/coalesce.test.js

@@ -1,3 +1,4 @@
+import { expect, test } from "vitest";
 import coalesce from "./coalesce";
 
 test("Coalesce returns first defined value", () => {

package/src/utils/concatIterables.test.js

@@ -1,3 +1,4 @@
+import { expect, test } from "vitest";
 import concatIterables from "./concatIterables";
 
 test("ConcatIterables yields all elements in the correct order", () => {

package/src/utils/domainArray.test.js

@@ -1,3 +1,4 @@
+import { describe, expect, test } from "vitest";
 import createDomain, {
     toRegularArray as r,
     PiecewiseDomain,

package/src/utils/indexer.test.js

@@ -1,3 +1,4 @@
+import { expect, test } from "vitest";
 import createIndexer from "./indexer";
 
 test("Index values one by one", () => {

package/src/utils/iterateNestedMaps.test.js

@@ -1,3 +1,4 @@
+import { expect, test } from "vitest";
 import { group } from "d3-array";
 import iterateNestedMaps from "./iterateNestedMaps";
 

package/src/utils/kWayMerge.test.js

@@ -1,3 +1,4 @@
+import { expect, test } from "vitest";
 import kWayMerge from "./kWayMerge";
 
 test("k-way merge merges multiple sorted arrays", () => {

package/src/utils/layout/flexLayout.test.js

@@ -1,3 +1,4 @@
+import { describe, expect, test } from "vitest";
 import {
     mapToPixelCoords,
     getMinimumSize,

package/src/utils/layout/rectangle.test.js

@@ -1,3 +1,4 @@
+import { expect, test } from "vitest";
 import Rectangle from "./rectangle";
 import Padding from "./padding";
 

package/src/utils/mergeObjects.test.js

@@ -1,3 +1,4 @@
+import { expect, test } from "vitest";
 import mergeObjects from "./mergeObjects";
 
 test("Merges non-conflicting properties", () => {

package/src/utils/numberExtractor.test.js

@@ -1,3 +1,4 @@
+import { expect, test } from "vitest";
 import numberExtractor from "./numberExtractor";
 
 test("NumberExtractor parses delimited integers", () => {

package/src/utils/propertyCacher.test.js

@@ -1,3 +1,4 @@
+import { expect, test } from "vitest";
 import { getCachedOrCall, invalidate, invalidateAll } from "./propertyCacher";
 
 class TestClass {

package/src/utils/propertyCoalescer.test.js

@@ -1,3 +1,4 @@
+import { expect, test } from "vitest";
 import coalesceProperties from "./propertyCoalescer";
 
 test("CoalesceProperties works as expected", () => {

package/src/utils/reservationMap.test.js

@@ -1,3 +1,4 @@
+import { expect, test } from "vitest";
 import ReservationMap from "./reservationMap";
 
 test("ReservationMap works correctly", () => {

package/src/utils/topK.test.js

@@ -1,3 +1,4 @@
+import { expect, test } from "vitest";
 import { range } from "d3-array";
 import { topK, topKSlice } from "./topK";
 

package/src/utils/variableTools.test.js

@@ -1,3 +1,4 @@
+import { expect, test } from "vitest";
 import * as vt from "./variableTools";
 
 test("InferNumerality", () => {

package/src/view/axisResolution.test.js

@@ -1,3 +1,4 @@
+import { describe, expect, test } from "vitest";
 import { createAndInitialize } from "./testUtils";
 import UnitView from "./unitView";
 import View from "./view";

package/src/view/flowBuilder.test.js

@@ -1,3 +1,4 @@
+import { expect, test } from "vitest";
 import Collector from "../data/collector";
 import FlowNode from "../data/flowNode";
 import FilterTransform from "../data/transforms/filter";

package/src/view/scaleResolution.js

@@ -228,11 +228,6 @@ export default class ScaleResolution {
                 props.domain = [props.domainMin ?? 0, props.domainMax ?? 1];
             }
 
-            // Genomic coordinates need higher precision
-            if (props.type == LOCUS && !("fp64" in props)) {
-                props.fp64 = true;
-            }
-
             // Reverse discrete y axis
             if (
                 this.channel == "y" &&
@@ -331,11 +326,6 @@ export default class ScaleResolution {
             scale.genome(this.getGenome());
         }
 
-        // Tag the scale and inform encoders and shaders that emulated
-        // 64bit floats should be used.
-        // N.B. the tag is lost upon scale.clone().
-        scale.fp64 = !!props.fp64;
-
         if (isContinuous(scale.type)) {
             this._zoomExtent = this._getZoomExtent();
         }
@@ -405,12 +395,16 @@ export default class ScaleResolution {
         let newDomain = [...oldDomain];
 
         // @ts-expect-error
-        const anchor = scale.invert(scaleAnchor);
+        let anchor = scale.invert(scaleAnchor);
 
         if (this.getScaleProps().reverse) {
             pan = -pan;
         }
 
+        if ("align" in scale) {
+            anchor += scale.align();
+        }
+
         // TODO: symlog
         switch (scale.type) {
             case "linear":

package/src/view/scaleResolution.test.js

@@ -1,3 +1,4 @@
+import { describe, expect, test } from "vitest";
 import { createAndInitialize } from "./testUtils";
 import createDomain, { toRegularArray as r } from "../utils/domainArray";
 import LayerView from "./layerView";

package/src/view/unitView.js

@@ -17,6 +17,7 @@ import {
 import createDomain from "../utils/domainArray";
 import AxisResolution from "./axisResolution";
 import { isAggregateSamplesSpec } from "./viewFactory";
+import { peek } from "../utils/arrayUtils";
 
 /**
  *
@@ -337,10 +338,13 @@ export default class UnitView extends ContainerView {
         if (isAggregateSamplesSpec(this.spec)) {
             // TODO: Support multiple
             for (const sumSpec of this.spec.aggregateSamples) {
-                sumSpec.transform = [
-                    ...(sumSpec.transform ?? []),
-                    { type: "mergeFacets" },
-                ];
+                const transform = sumSpec.transform ?? [];
+                if (transform.length && peek(transform).type != "collect") {
+                    // MergeFacets must be a direct child of Collector
+                    transform.push({ type: "collect" });
+                }
+                transform.push({ type: "mergeFacets" });
+                sumSpec.transform = transform;
 
                 sumSpec.encoding = {
                     ...(sumSpec.encoding ?? {}),

package/src/view/view.test.js

@@ -1,3 +1,4 @@
+import { describe, expect, test } from "vitest";
 import UnitView from "./unitView";
 import LayerView from "./layerView";
 

package/src/view/viewFactory.test.js

@@ -1,3 +1,4 @@
+import { expect, test } from "vitest";
 import { ViewFactory } from "./viewFactory";
 
 test("isViewSpec", () => {

package/src/gl/includes/fp64-arithmetic.glsl

@@ -1,187 +0,0 @@
-// Adapted from luma.gl - https://github.com/uber/luma.gl
-
-// Copyright (c) 2015 - 2017 Uber Technologies, Inc.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-uniform float ONE;
-
-/*
-About LUMA_FP64_CODE_ELIMINATION_WORKAROUND
-
-The purpose of this workaround is to prevent shader compilers from
-optimizing away necessary arithmetic operations by swapping their sequences
-or transform the equation to some 'equivalent' from.
-
-The method is to multiply an artifical variable, ONE, which will be known to
-the compiler to be 1 only at runtime. The whole expression is then represented
-as a polynomial with respective to ONE. In the coefficients of all terms, only one a
-and one b should appear
-
-err = (a + b) * ONE^6 - a * ONE^5 - (a + b) * ONE^4 + a * ONE^3 - b - (a + b) * ONE^2 + a * ONE
-*/
-
-// Divide float number to high and low floats to extend fraction bits
-vec2 split(float a) {
-  const float SPLIT = 4097.0;
-  float t = a * SPLIT;
-#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  float a_hi = t * ONE - (t - a);
-  float a_lo = a * ONE - a_hi;
-#else
-  float a_hi = t - (t - a);
-  float a_lo = a - a_hi;
-#endif
-  return vec2(a_hi, a_lo);
-}
-
-// Divide float number again when high float uses too many fraction bits
-vec2 split2(vec2 a) {
-  vec2 b = split(a.x);
-  b.y += a.y;
-  return b;
-}
-
-// Special sum operation when a > b
-vec2 quickTwoSum(float a, float b) {
-#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  float sum = (a + b) * ONE;
-  float err = b - (sum - a) * ONE;
-#else
-  float sum = a + b;
-  float err = b - (sum - a);
-#endif
-  return vec2(sum, err);
-}
-
-// General sum operation
-vec2 twoSum(float a, float b) {
-  float s = (a + b);
-#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  float v = (s * ONE - a) * ONE;
-  float err = (a - (s - v) * ONE) * ONE * ONE * ONE + (b - v);
-#else
-  float v = s - a;
-  float err = (a - (s - v)) + (b - v);
-#endif
-  return vec2(s, err);
-}
-
-vec2 twoSub(float a, float b) {
-  float s = (a - b);
-#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  float v = (s * ONE - a) * ONE;
-  float err = (a - (s - v) * ONE) * ONE * ONE * ONE - (b + v);
-#else
-  float v = s - a;
-  float err = (a - (s - v)) - (b + v);
-#endif
-  return vec2(s, err);
-}
-
-vec2 twoSqr(float a) {
-  float prod = a * a;
-  vec2 a_fp64 = split(a);
-#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  float err = ((a_fp64.x * a_fp64.x - prod) * ONE + 2.0 * a_fp64.x *
-    a_fp64.y * ONE * ONE) + a_fp64.y * a_fp64.y * ONE * ONE * ONE;
-#else
-  float err = ((a_fp64.x * a_fp64.x - prod) + 2.0 * a_fp64.x * a_fp64.y) + a_fp64.y * a_fp64.y;
-#endif
-  return vec2(prod, err);
-}
-
-vec2 twoProd(float a, float b) {
-  float prod = a * b;
-  vec2 a_fp64 = split(a);
-  vec2 b_fp64 = split(b);
-  float err = ((a_fp64.x * b_fp64.x - prod) + a_fp64.x * b_fp64.y +
-    a_fp64.y * b_fp64.x) + a_fp64.y * b_fp64.y;
-  return vec2(prod, err);
-}
-
-vec2 sum_fp64(vec2 a, vec2 b) {
-  vec2 s, t;
-  s = twoSum(a.x, b.x);
-  t = twoSum(a.y, b.y);
-  s.y += t.x;
-  s = quickTwoSum(s.x, s.y);
-  s.y += t.y;
-  s = quickTwoSum(s.x, s.y);
-  return s;
-}
-
-vec2 sub_fp64(vec2 a, vec2 b) {
-  vec2 s, t;
-  s = twoSub(a.x, b.x);
-  t = twoSub(a.y, b.y);
-  s.y += t.x;
-  s = quickTwoSum(s.x, s.y);
-  s.y += t.y;
-  s = quickTwoSum(s.x, s.y);
-  return s;
-}
-
-vec2 mul_fp64(vec2 a, vec2 b) {
-  vec2 prod = twoProd(a.x, b.x);
-  // y component is for the error
-  prod.y += a.x * b.y;
-#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
-  prod = split2(prod);
-#endif
-  prod = quickTwoSum(prod.x, prod.y);
-  prod.y += a.y * b.x;
-#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
-  prod = split2(prod);
-#endif
-  prod = quickTwoSum(prod.x, prod.y);
-  return prod;
-}
-
-vec2 div_fp64(vec2 a, vec2 b) {
-  float xn = 1.0 / b.x;
-#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
-  vec2 yn = mul_fp64(a, vec2(xn, 0));
-#else
-  vec2 yn = a * xn;
-#endif
-  float diff = (sub_fp64(a, mul_fp64(b, yn))).x;
-  vec2 prod = twoProd(xn, diff);
-  return sum_fp64(yn, prod);
-}
-
-vec2 sqrt_fp64(vec2 a) {
-  if (a.x == 0.0 && a.y == 0.0) return vec2(0.0, 0.0);
-  if (a.x < 0.0) return vec2(0.0 / 0.0, 0.0 / 0.0);
-
-  float x = 1.0 / sqrt(a.x);
-  float yn = a.x * x;
-#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  vec2 yn_sqr = twoSqr(yn) * ONE;
-#else
-  vec2 yn_sqr = twoSqr(yn);
-#endif
-  float diff = sub_fp64(a, yn_sqr).x;
-  vec2 prod = twoProd(x * 0.5, diff);
-#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
-  return sum_fp64(split(yn), prod);
-#else
-  return sum_fp64(vec2(yn, 0.0), prod);
-#endif
-}