@genome-spy/core 0.29.0 → 0.30.0

package/package.json

@@ -7,7 +7,7 @@
   },
   "contributors": [],
   "license": "MIT",
-  "version": "0.29.0",
+  "version": "0.30.0",
   "main": "dist/index.js",
   "module": "src/index.js",
   "exports": {
@@ -53,5 +53,5 @@
     "vega-scale": "^7.1.1",
     "vega-util": "^1.16.0"
   },
-  "gitHead": "465004bcc575262ef7cee3932502a3bfee1da4e1"
+  "gitHead": "c8fe26f3421a1bec7323428f0bd7da46cda34dba"
 }

package/src/genomeSpy.js

@@ -378,6 +378,7 @@ export default class GenomeSpy {
         // Now that all data have been loaded, the domains may need adjusting
         this.viewRoot.visit((view) => {
             for (const resolution of Object.values(view.resolutions.scale)) {
+                // TODO: Don't reconfigure multiple times
                 // IMPORTANT TODO: Check that discrete domains and indexers match!!!!!!!!!
                 resolution.reconfigure();
             }

package/src/gl/webGLHelper.js

@@ -9,7 +9,12 @@ import {
 } from "twgl.js";
 import { isArray, isString } from "vega-util";
 
-import { isDiscrete, isDiscretizing, isInterpolating } from "vega-scale";
+import {
+    isContinuous,
+    isDiscrete,
+    isDiscretizing,
+    isInterpolating,
+} from "vega-scale";
 import {
     createDiscreteColorTexture,
     createDiscreteTexture,
@@ -321,43 +326,53 @@ export default class WebGLHelper {
             const props = resolution.getScaleProps();
 
             const scale = resolution.getScale();
+            const range = /** @type {any[]} */ (scale.range());
 
             /** @type {WebGLTexture} */
             let texture;
 
             if (props.scheme) {
-                let count = isString(props.scheme)
-                    ? undefined
-                    : props.scheme.count;
-
-                count = fixCount(count, scale);
-
-                texture = createSchemeTexture(
-                    props.scheme,
-                    this.gl,
-                    count,
-                    existingTexture
-                );
-            } else {
-                // No scheme, assume that colors are specified in the range
-
-                const range = /** @type {any[]} */ (scale.range());
-
-                if (isInterpolating(scale.type)) {
-                    texture = createInterpolatedColorTexture(
+                if (scale.type == "threshold" && range) {
+                    // Scale initialization may have configured the range. Let's use it.
+                    texture = createDiscreteColorTexture(
                         range,
-                        props.interpolate,
                         this.gl,
+                        scale.domain().length,
                         existingTexture
                     );
                 } else {
-                    texture = createDiscreteColorTexture(
-                        range,
+                    let count = isString(props.scheme)
+                        ? undefined
+                        : props.scheme.count;
+
+                    count = fixCount(count, scale);
+
+                    texture = createSchemeTexture(
+                        props.scheme,
                         this.gl,
-                        scale.domain().length,
+                        count,
                         existingTexture
                     );
                 }
+            } else if (
+                // Interpolating
+                isInterpolating(scale.type) ||
+                // Or piecewise
+                (isContinuous(scale.type) && range.length > 2)
+            ) {
+                texture = createInterpolatedColorTexture(
+                    range,
+                    props.interpolate,
+                    this.gl,
+                    existingTexture
+                );
+            } else {
+                texture = createDiscreteColorTexture(
+                    range,
+                    this.gl,
+                    scale.domain().length,
+                    existingTexture
+                );
             }
 
             this.rangeTextures.set(resolution, texture);

package/src/scale/glslScaleGenerator.js

@@ -314,7 +314,7 @@ export function generateScaleGlsl(channel, scale, channelDef) {
         if (piecewise) {
             // TODO: Handle range correctly. Now this assumes unit range.
             scaleBody.push(
-                `transformed = (float(slot) + transformed) / (float(${name}.length()) - 1.0);`
+                `transformed = (float(slot) + transformed) / (float(${name}.length() - 1));`
             );
         }
     } else {
@@ -463,26 +463,40 @@ export function isHighPrecisionScale(type) {
     return type == "index" || type == "locus";
 }
 
+// Maximum precise index number is 2^(23 + 11) ~ 17G
+// Higher number increases precision but makes zooming unstable
+const BS = 2 ** 11;
+const BM = BS - 1;
+
 /**
- * @param {number} x
+ * @param {number} x Must be an integer
  * @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 ??= [];
+export function splitHighPrecision(x, arr = []) {
+    // Using a bitmask is MUCH faster than using modulo (at least on Chrome 112)
+    // https://www.wikiwand.com/en/Modulo#Performance_issues
+    const lo = x & BM;
+    const hi = x - lo;
+
     arr[0] = hi;
     arr[1] = lo;
+
     return arr;
 }
 
+/**
+ * @param {number} x
+ */
+function exactSplitHighPrecision(x) {
+    const lo = x % BS;
+    const hi = x - lo;
+
+    return [hi, lo];
+}
+
 /**
  * @param {number[]} domain
  */
 export function toHighPrecisionDomainUniform(domain) {
-    return [...splitHighPrecision(domain[0]), domain[1] - domain[0]];
+    return [...exactSplitHighPrecision(domain[0]), domain[1] - domain[0]];
 }

package/src/view/scaleResolution.js

@@ -220,6 +220,12 @@ export default class ScaleResolution {
                 props.domain = domain;
             } else if (isDiscrete(props.type)) {
                 props.domain = new NominalDomain();
+            } else if (props.scheme) {
+                // An initial domain is required when using a scheme.
+                // Otherwise configureScale() does something weird when the domain is set later,
+                // resulting in an interpolator between just two colors.
+                // TODO: Fix configureScale().
+                props.domain = [0, 1];
             }
 
             if (!props.domain && props.domainMid !== undefined) {

package/src/view/zoom.js

@@ -30,10 +30,10 @@ export default function interactionToZoom(event, coords, handleZoom, hover) {
 
         if (hover) {
             const e = hover.mark.encoders;
-            if (e.x && !e.x2) {
+            if (e.x && !e.x2 && !e.x.constantValue) {
                 x = +e.x(hover.datum) * coords.width + coords.x;
             }
-            if (e.y && !e.y2) {
+            if (e.y && !e.y2 && !e.y.constantValue) {
                 y = (1 - +e.y(hover.datum)) * coords.height + coords.y;
             }
         }