@genome-spy/core 0.71.0 → 0.72.0

package/dist/src/gl/hashTable.js

@@ -0,0 +1,164 @@
+/** Sentinel key that marks an empty hash slot. */
+export const HASH_EMPTY_KEY = 0xffff_ffff;
+
+/** Default maximum load factor for table sizing. */
+export const DEFAULT_MAX_LOAD_FACTOR = 0.6;
+
+const MAX_U32 = 0xffff_ffff;
+
+/**
+ * Build-time options for sizing the hash table.
+ *
+ * @typedef {object} HashTableBuildOptions
+ * @property {number} [capacity] Power-of-two table size override.
+ * @property {number} [maxLoadFactor] Maximum load factor before resizing.
+ */
+
+/**
+ * Packed table payload ready for WebGL texture upload.
+ *
+ * @typedef {object} HashTableBuildResult
+ * @property {Uint32Array} table Hash table slots that contain keys.
+ * @property {number} capacity Table capacity (number of slots).
+ * @property {number} size Number of stored keys.
+ */
+
+/**
+ * 32-bit integer hash for u32 keys. Keep in sync with GLSL hash32.
+ *
+ * @param {number} value
+ * @returns {number}
+ */
+export function hash32(value) {
+    let v = value >>> 0;
+    v ^= v >>> 16;
+    v = Math.imul(v, 0x7feb352d);
+    v ^= v >>> 15;
+    v = Math.imul(v, 0x846ca68b);
+    v ^= v >>> 16;
+    return v >>> 0;
+}
+
+/**
+ * Build a hash table for set membership checks.
+ *
+ * @param {Iterable<number>} keys
+ * @param {HashTableBuildOptions} [options]
+ * @returns {HashTableBuildResult}
+ */
+export function buildHashTableSet(keys, options = {}) {
+    const normalized = Array.from(keys, (key) => normalizeU32(key, "key"));
+    const size = normalized.length;
+    const maxLoadFactor = options.maxLoadFactor ?? DEFAULT_MAX_LOAD_FACTOR;
+    if (!(maxLoadFactor > 0 && maxLoadFactor < 1)) {
+        throw new Error("maxLoadFactor must be between 0 and 1.");
+    }
+
+    const capacity =
+        options.capacity ?? nextPow2(Math.ceil(size / maxLoadFactor));
+    if (!Number.isSafeInteger(capacity) || capacity < 1) {
+        throw new Error("capacity must be a positive power of two.");
+    }
+    if ((capacity & (capacity - 1)) !== 0) {
+        throw new Error("capacity must be a power of two.");
+    }
+
+    const table = new Uint32Array(capacity);
+    table.fill(HASH_EMPTY_KEY);
+
+    const mask = capacity - 1;
+    for (const key of normalized) {
+        if (key === HASH_EMPTY_KEY) {
+            throw new Error(
+                "Hash table keys must not equal the empty sentinel (0xffffffff)."
+            );
+        }
+        let index = hash32(key) & mask;
+        let inserted = false;
+
+        for (let probe = 0; probe < capacity; probe += 1) {
+            const existingKey = table[index];
+            if (existingKey === HASH_EMPTY_KEY || existingKey === key) {
+                table[index] = key;
+                inserted = true;
+                break;
+            }
+            index = (index + 1) & mask;
+        }
+
+        if (!inserted) {
+            throw new Error(
+                "Hash table insertion failed. Increase capacity or lower load factor."
+            );
+        }
+    }
+
+    return { table, capacity, size };
+}
+
+/**
+ * Computes a 2D texture layout for a power-of-two hash table capacity.
+ *
+ * The returned dimensions satisfy `width * height === capacity`.
+ *
+ * @param {number} capacity
+ * @param {number} maxTextureSize
+ * @returns {{ width: number, height: number }}
+ */
+export function computeHashTextureDimensions(capacity, maxTextureSize) {
+    if (!Number.isSafeInteger(capacity) || capacity < 1) {
+        throw new Error("capacity must be a positive integer.");
+    }
+    if ((capacity & (capacity - 1)) !== 0) {
+        throw new Error("capacity must be a power of two.");
+    }
+    if (!Number.isSafeInteger(maxTextureSize) || maxTextureSize < 1) {
+        throw new Error("maxTextureSize must be a positive integer.");
+    }
+
+    const maxSlots = maxTextureSize * maxTextureSize;
+    if (capacity > maxSlots) {
+        throw new Error(
+            "Selection hash table exceeds maximum texture capacity."
+        );
+    }
+
+    const maxPow2Width = 1 << Math.floor(Math.log2(maxTextureSize));
+    const width = Math.min(capacity, maxPow2Width);
+    const height = capacity / width;
+
+    if (height > maxTextureSize) {
+        throw new Error(
+            "Selection hash table dimensions exceed maximum texture size."
+        );
+    }
+
+    return { width, height };
+}
+
+/**
+ * @param {number} value
+ * @param {string} label
+ * @returns {number}
+ */
+function normalizeU32(value, label) {
+    if (!Number.isSafeInteger(value) || value < 0 || value > MAX_U32) {
+        throw new Error(label + " must be a non-negative u32.");
+    }
+    return value >>> 0;
+}
+
+/**
+ * @param {number} value
+ * @returns {number}
+ */
+function nextPow2(value) {
+    let v = Math.max(1, value);
+    v -= 1;
+    v |= v >>> 1;
+    v |= v >>> 2;
+    v |= v >>> 4;
+    v |= v >>> 8;
+    v |= v >>> 16;
+    return v + 1;
+}

package/dist/src/gl/includes/common.glsl.js

@@ -1,2 +1,2 @@
-const shader = "#define PI 3.141593\nuniform View{mediump vec2 uViewOffset;mediump vec2 uViewScale;mediump vec2 uViewportSize;lowp float uDevicePixelRatio;lowp float uViewOpacity;bool uPickingEnabled;};/***Maps a coordinate on the unit scale to a normalized device coordinate.*(0,0)is at the bottom left corner.*/vec4 unitToNdc(vec2 coord){return vec4((coord*uViewScale+uViewOffset)*2.0-1.0,0.0,1.0);}vec4 unitToNdc(float x,float y){return unitToNdc(vec2(x,y));}vec4 pixelsToNdc(vec2 coord){return unitToNdc(coord/uViewportSize);}vec4 pixelsToNdc(float x,float y){return pixelsToNdc(vec2(x,y));}float linearstep(float edge0,float edge1,float x){return clamp((x-edge0)/(edge1-edge0),0.0,1.0);}bool isEmptyBinarySearchTexture(highp usampler2D s){return textureSize(s,0).x==1&&texelFetch(s,ivec2(0,0),0).r==0u;}bool binarySearchTexture(highp usampler2D s,uint value){int texSize=textureSize(s,0).x;if(texSize==1&&texelFetch(s,ivec2(0,0),0).r==0u){return false;}int left=0;int right=texSize-1;while(left<=right){int mid=left+(right-left)/2;uint midValue=texelFetch(s,ivec2(mid,0),0).r;if(midValue==value){return true;}if(midValue<value){left=mid+1;}else{right=mid-1;}}return false;}/***Calculates a gamma for antialiasing opacity based on the color.*/float getGammaForColor(vec3 rgb){return mix(1.25,0.75,smoothstep(0.0,1.0,dot(rgb,vec3(0.299,0.587,0.114))));}/***Specialized linearstep for doing antialiasing*/float distanceToRatio(float d){return clamp(d*uDevicePixelRatio+0.5,0.0,1.0);}vec4 distanceToColor(float d,vec4 fill,vec4 stroke,vec4 background,float halfStrokeWidth){if(halfStrokeWidth>0.0){float sd=abs(d)-halfStrokeWidth;return mix(stroke,d<=0.0 ? fill : background,distanceToRatio(sd));}else{return mix(background,fill,distanceToRatio(-d));}}";
+const shader = "#define PI 3.141593\nuniform View{mediump vec2 uViewOffset;mediump vec2 uViewScale;mediump vec2 uViewportSize;lowp float uDevicePixelRatio;lowp float uViewOpacity;bool uPickingEnabled;};/***Maps a coordinate on the unit scale to a normalized device coordinate.*(0,0)is at the bottom left corner.*/vec4 unitToNdc(vec2 coord){return vec4((coord*uViewScale+uViewOffset)*2.0-1.0,0.0,1.0);}vec4 unitToNdc(float x,float y){return unitToNdc(vec2(x,y));}vec4 pixelsToNdc(vec2 coord){return unitToNdc(coord/uViewportSize);}vec4 pixelsToNdc(float x,float y){return pixelsToNdc(vec2(x,y));}float linearstep(float edge0,float edge1,float x){return clamp((x-edge0)/(edge1-edge0),0.0,1.0);}const highp uint HASH_EMPTY_KEY=0xffffffffu;highp uint hash32(highp uint key){highp uint v=key;v ^=v>>16u;v*=0x7feb352du;v ^=v>>15u;v*=0x846ca68bu;v ^=v>>16u;return v;}bool isEmptyHashTexture(highp usampler2D s){ivec2 texSize=textureSize(s,0);return texSize.x==1&&texSize.y==1&&texelFetch(s,ivec2(0,0),0).r==HASH_EMPTY_KEY;}bool hashContainsTexture(highp usampler2D s,highp uint value){ivec2 texSize=textureSize(s,0);highp uint width=uint(texSize.x);highp uint size=width*uint(texSize.y);highp uint mask=size-1u;highp uint index=hash32(value)&mask;for(highp uint probe=0u;probe<size;probe+=1u){ivec2 coord=ivec2(int(index % width),int(index/width));highp uint entry=texelFetch(s,coord,0).r;if(entry==value){return true;}if(entry==HASH_EMPTY_KEY){return false;}index=(index+1u)&mask;}return false;}/***Calculates a gamma for antialiasing opacity based on the color.*/float getGammaForColor(vec3 rgb){return mix(1.25,0.75,smoothstep(0.0,1.0,dot(rgb,vec3(0.299,0.587,0.114))));}/***Specialized linearstep for doing antialiasing*/float distanceToRatio(float d){return clamp(d*uDevicePixelRatio+0.5,0.0,1.0);}vec4 distanceToColor(float d,vec4 fill,vec4 stroke,vec4 background,float halfStrokeWidth){if(halfStrokeWidth>0.0){float sd=abs(d)-halfStrokeWidth;return mix(stroke,d<=0.0 ? fill : background,distanceToRatio(sd));}else{return mix(background,fill,distanceToRatio(-d));}}";
 export default shader;

package/dist/src/gl/webGLHelper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webGLHelper.d.ts","sourceRoot":"","sources":["../../../src/gl/webGLHelper.js"],"names":[],"mappings":"AAyZA;;;;GAIG;AACH,kCAJW,sBAAsB,gBACtB,WAAW,kBACX,WAAW;;;;;;EA8CrB;AAED;;;;;GAKG;AACH,0CALW,qBAAqB,WACrB,IAAI,CAAC,OAAO,SAAS,EAAE,cAAc,EAAE,KAAK,CAAC,OAC7C,MAAM,EAAE,GAAG,eAAe,YAC1B,YAAY,gBAYtB;AAED;;;;;;GAMG;AACH,qCALW,sBAAsB,mBACtB,OAAO,SAAS,EAAE,eAAe,KACjC,MAAM,KACN,MAAM,2BAWhB;AAED;;;;;GAKG;AACH,yCAJW,sBAAsB,mBACtB,OAAO,SAAS,EAAE,eAAe,SACjC,MAAM,UA4BhB;AAlfD;IACI;;;;;;;OAOG;IACH,uBANW,WAAW,eACX,MAAM;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,2BAGrC,sBAAsB,EAsFhC;IAnFG,wBAA2B;IAC3B;;;MAKO;IAEP,uCAAuC;IACvC,cADW,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CACN;IAE7B,6EAA6E;IAC7E,eADW,OAAO,CAAC,OAAO,qBAAqB,EAAE,SAAS,EAAE,YAAY,CAAC,CACvC;IAElC;;OAEG;IACH,mBAFU,OAAO,CAAC,OAAO,4BAA4B,EAAE,mBAAmB,EAAE,YAAY,CAAC,CAEnD;IA8CtC,0BAAoB;IACpB,2BAAY;IAGZ,oDAAoD;IACpD,2BADW,OAAO,SAAS,EAAE,iBAAiB,EAAE,CAQ/C;IACD,sDAGC;IAML,uBAGC;IAFG;;;MAAmC;IAIvC;;;;;OAKG;IACH,oBAHW,MAAM,QACN,MAAM,GAAG,MAAM,EAAE,eA2B3B;IAED,iBAcC;IAED,iBAEC;IAED;;;;OAIG;IACH,oCAFW;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE;;;MAS3C;IAED;;;OAGG;IACH;;;MAuBC;IAED;;;;;;;;;OASG;IACH,+BAHW,OAAO,8BAA8B,EAAE,OAAO,WAC9C,OAAO,QA2GjB;IAED;;OAEG;IACH,kCAFW,OAAO,4BAA4B,EAAE,mBAAmB,0BA+BlE;CACJ"}
+{"version":3,"file":"webGLHelper.d.ts","sourceRoot":"","sources":["../../../src/gl/webGLHelper.js"],"names":[],"mappings":"AA+ZA;;;;GAIG;AACH,kCAJW,sBAAsB,gBACtB,WAAW,kBACX,WAAW;;;;;;EA8CrB;AAED;;;;;GAKG;AACH,0CALW,qBAAqB,WACrB,IAAI,CAAC,OAAO,SAAS,EAAE,cAAc,EAAE,KAAK,CAAC,OAC7C,MAAM,EAAE,GAAG,eAAe,YAC1B,YAAY,gBAYtB;AAED;;;;;;GAMG;AACH,qCALW,sBAAsB,mBACtB,OAAO,SAAS,EAAE,eAAe,KACjC,MAAM,KACN,MAAM,2BAWhB;AAED;;;;;GAKG;AACH,yCAJW,sBAAsB,mBACtB,OAAO,SAAS,EAAE,eAAe,SACjC,MAAM,UA4BhB;AApfD;IACI;;;;;;;OAOG;IACH,uBANW,WAAW,eACX,MAAM;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,2BAGrC,sBAAsB,EAsFhC;IAnFG,wBAA2B;IAC3B;;;MAKO;IAEP,uCAAuC;IACvC,cADW,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CACN;IAE7B,6EAA6E;IAC7E,eADW,OAAO,CAAC,OAAO,qBAAqB,EAAE,SAAS,EAAE,YAAY,CAAC,CACvC;IAElC;;OAEG;IACH,mBAFU,OAAO,CAAC,OAAO,4BAA4B,EAAE,mBAAmB,EAAE,YAAY,CAAC,CAEnD;IA8CtC,0BAAoB;IACpB,2BAAY;IAGZ,oDAAoD;IACpD,2BADW,OAAO,SAAS,EAAE,iBAAiB,EAAE,CAQ/C;IACD,sDAGC;IAML,uBAGC;IAFG;;;MAAmC;IAIvC;;;;;OAKG;IACH,oBAHW,MAAM,QACN,MAAM,GAAG,MAAM,EAAE,eA2B3B;IAED,iBAcC;IAED,iBAEC;IAED;;;;OAIG;IACH,oCAFW;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE;;;MAS3C;IAED;;;OAGG;IACH;;;MAuBC;IAED;;;;;;;;;OASG;IACH,+BAHW,OAAO,8BAA8B,EAAE,OAAO,WAC9C,OAAO,QA2GjB;IAED;;OAEG;IACH,kCAFW,OAAO,4BAA4B,EAAE,mBAAmB,0BAiClE;CACJ"}

package/dist/src/gl/webGLHelper.js

@@ -27,6 +27,10 @@ import {
     isDiscreteChannel,
 } from "../encoder/encoder.js";
 import { isMultiPointSelection } from "../selection/selection.js";
+import {
+    buildHashTableSet,
+    computeHashTextureDimensions,
+} from "./hashTable.js";
 
 export default class WebGLHelper {
     /**
@@ -351,9 +355,11 @@ export default class WebGLHelper {
             );
         }
 
-        const keys = Array.from(selection.data.keys());
-        // Zero is a special value for no selection. The minimum texture size is 1.
-        const uniqueIds = keys.length > 0 ? keys.sort((a, b) => a - b) : [0];
+        const { table, capacity } = buildHashTableSet(selection.data.keys());
+        const { width, height } = computeHashTextureDimensions(
+            capacity,
+            this.gl.getParameter(this.gl.MAX_TEXTURE_SIZE)
+        );
 
         const existingTexture = this.selectionTextures.get(selection);
 
@@ -365,10 +371,10 @@ export default class WebGLHelper {
                 minMag: gl.NEAREST,
                 format: gl.RED_INTEGER,
                 internalFormat: gl.R32UI,
-                height: 1,
-                width: uniqueIds.length,
+                width,
+                height,
             },
-            new Uint32Array(uniqueIds),
+            table,
             update ? existingTexture : false
         );
 

package/dist/src/marks/mark.d.ts

@@ -137,7 +137,7 @@ export default class Mark<P extends import("../spec/mark.js").MarkProps = import
      */
     get encoding(): import("../spec/channel.js").Encoding;
     getContext(): import("../types/viewContext.js").default;
-    getType(): "link" | "rect" | "text" | "point" | "rule";
+    getType(): "link" | "point" | "text" | "rect" | "rule";
     initializeData(): void;
     /**
      * Initialize encoders that encode fields of the data (or constants) to

package/dist/src/marks/mark.d.ts.map

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

package/dist/src/marks/mark.js

@@ -528,8 +528,7 @@ export default class Mark {
                 }
             } else if (isMultiPointSelection(selection)) {
                 // We need a texture for each multi-selection parameter.
-                // The texture contains the uniqueIds of the selected data objects sorted
-                // in ascending order, which allows for binary search.
+                // The texture stores an open-addressing hash table of selected uniqueIds.
                 if (!selectionParameterUniforms.has(param)) {
                     selectionParameterUniforms.set(param, "multi");
 
@@ -560,7 +559,7 @@ export default class Mark {
                     const texName = SELECTION_TEXTURE_PREFIX + param;
                     scaleCode.push(
                         `bool ${SELECTION_CHECKER_PREFIX}${param}(bool empty) {\n` +
-                            `   return binarySearchTexture(${texName}, ${uniqueIdAttr}) || (empty && isEmptyBinarySearchTexture(${texName}));\n` +
+                            `   return hashContainsTexture(${texName}, ${uniqueIdAttr}) || (empty && isEmptyHashTexture(${texName}));\n` +
                             `}`
                     );
 

package/dist/src/utils/radixSort.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"radixSort.d.ts","sourceRoot":"","sources":["../../../src/utils/radixSort.js"],"names":[],"mappings":"AAKA;;GAEG;AACH,uCAFW,MAAM,EAAE,YAyDlB;AAaD;;GAEG;AACH,8CAFW,MAAM,EAAE,YAoDlB"}
+{"version":3,"file":"radixSort.d.ts","sourceRoot":"","sources":["../../../src/utils/radixSort.js"],"names":[],"mappings":"AAiBA;;GAEG;AACH,uCAFW,MAAM,EAAE,YA8DlB;AAeD;;GAEG;AACH,8CAFW,MAAM,EAAE,YA0DlB"}

package/dist/src/utils/radixSort.js

@@ -3,12 +3,29 @@ const MAX_INTEGER_DIGIT = getDigits([MAX_INTEGER]);
 
 // TODO: Optimize more! Some ideas: https://travisdowns.github.io/blog/2019/05/22/sorting.html
 
+/**
+ * @param {number[]} arr An array of unsigned integers
+ */
+function checkIfSorted(arr) {
+    for (let i = 1; i < arr.length; i++) {
+        if (arr[i] < arr[i - 1]) {
+            return false;
+        }
+    }
+    return true;
+}
+
 /**
  * @param {number[]} arr An array of unsigned integers
  */
 export default function radixSort(arr) {
     const maxDigits = getDigits(arr);
 
+    // Early exit if already sorted
+    if (checkIfSorted(arr)) {
+        return arr;
+    }
+
     let buffer = new Array(arr.length);
     let bufferPtr = buffer;
     const counts = new Array(16);
@@ -69,7 +86,9 @@ export default function radixSort(arr) {
 function getDigits(arr) {
     let max = 0;
     for (let i = 0, n = arr.length; i < n; i++) {
-        max = Math.max(max, arr[i]);
+        if (arr[i] > max) {
+            max = arr[i];
+        }
     }
     return Math.floor(Math.log2(max) / 4) + 1;
 }
@@ -80,6 +99,12 @@ function getDigits(arr) {
 export function radixSortIntoLookupArray(arr) {
     const maxDigits = getDigits(arr);
     let indexes = Array.from({ length: arr.length }, (_, i) => i);
+
+    // Early exit if already sorted
+    if (checkIfSorted(arr)) {
+        return indexes;
+    }
+
     let buffer = new Array(arr.length);
     const counts = new Array(16);
 

package/dist/src/view/facetView.d.ts

@@ -48,7 +48,7 @@ export default class FacetView extends ContainerView<import("../spec/view.js").C
     getAccessor(channel: "row" | "column"): any;
     updateFacets(): void;
     updateLabels(): void;
-    getFacetGroups(): string[] | number[] | boolean[];
+    getFacetGroups(): number[] | boolean[] | string[];
     /**
      * @param {import("./renderingContext/viewRenderingContext.js").default} context
      * @param {import("./layout/rectangle.js").default} coords

package/dist/src/view/unitView.d.ts

@@ -21,7 +21,7 @@ export default class UnitView<TSpec extends import("../spec/view.js").UnitSpec =
     constructor(spec: TSpec, context: import("../types/viewContext.js").default, layoutParent: import("./containerView.js").default, dataParent: import("./view.js").default, name: string, options?: import("./view.js").ViewOptions);
     /** @type {import("../marks/mark.js").default} */
     mark: import("../marks/mark.js").default;
-    getMarkType(): "link" | "rect" | "text" | "point" | "rule";
+    getMarkType(): "link" | "point" | "text" | "rect" | "rule";
     /**
      * Pulls scales and axes up in the view hierarcy according to the resolution rules, using dataParents.
      * TODO: legends

package/package.json

@@ -7,7 +7,7 @@
   },
   "contributors": [],
   "license": "MIT",
-  "version": "0.71.0",
+  "version": "0.72.0",
   "jsdelivr": "dist/bundle/index.js",
   "unpkg": "dist/bundle/index.js",
   "browser": "dist/bundle/index.js",
@@ -56,6 +56,7 @@
     "flatqueue": "^3.0.0",
     "generic-filehandle2": "^2.0.14",
     "gff-nostream": "^2.0.0",
+    "hyparquet": "^1.25.0",
     "internmap": "^2.0.3",
     "lit": "^3.3.0",
     "twgl.js": "^4.19.1",
@@ -67,5 +68,5 @@
   "devDependencies": {
     "@types/long": "^4.0.1"
   },
-  "gitHead": "ee14df5ba7218882d48a1674916304ac6f0a4549"
+  "gitHead": "504e1d0f7c45c2324bb6b0ff7b9230829d60518e"
 }