@genome-spy/core 0.36.0 → 0.37.0

package/dist/src/scale/colorUtils.js

@@ -0,0 +1,184 @@
+import { color as d3color } from "d3-color";
+import { range } from "d3-array";
+import { scheme as vegaScheme, interpolateColors } from "vega-scale";
+import { isString, isArray, isFunction } from "vega-util";
+import { peek } from "../utils/arrayUtils";
+import { createOrUpdateTexture } from "../gl/webGLHelper";
+
+/**
+ * @param {string | import("../spec/scale").SchemeParams} schemeParams
+ * @param {WebGL2RenderingContext} gl
+ * @param {number} [count]
+ * @param {WebGLTexture} [existingTexture]
+ */
+export function createSchemeTexture(schemeParams, gl, count, existingTexture) {
+    const schemeName = isString(schemeParams)
+        ? schemeParams
+        : schemeParams.name;
+    const extent = (!isString(schemeParams) && schemeParams.extent) || [0, 1];
+
+    if (count === undefined && !isString(schemeParams)) {
+        count = schemeParams.count;
+    }
+
+    if (schemeName) {
+        const scheme = vegaScheme(schemeName);
+        if (isFunction(scheme)) {
+            // TODO: Reverse
+            const textureData = interpolatorToTextureData(scheme, {
+                extent,
+                count,
+            });
+            return createOrUpdateTexture(
+                gl,
+                {
+                    minMag: gl.LINEAR,
+                    format: gl.RGB,
+                    height: 1,
+                    wrap: gl.CLAMP_TO_EDGE,
+                },
+                textureData,
+                existingTexture
+            );
+        } else if (isArray(scheme)) {
+            return createDiscreteColorTexture(scheme, gl);
+        } else {
+            throw new Error("Unknown scheme: " + schemeName);
+        }
+    }
+}
+
+/**
+ * @param {string[]} colors
+ * @param {import("../spec/scale").ScaleInterpolate | import("../spec/scale").ScaleInterpolateParams} interpolateParams
+ * @param {WebGL2RenderingContext} gl
+ * @param {WebGLTexture} [existingTexture]
+ */
+export function createInterpolatedColorTexture(
+    colors,
+    interpolateParams = "rgb",
+    gl,
+    existingTexture
+) {
+    const interpolator = interpolateColors(
+        colors,
+        isString(interpolateParams)
+            ? interpolateParams
+            : interpolateParams.type,
+        isString(interpolateParams) ? undefined : interpolateParams.gamma
+    );
+
+    // TODO: Reverse
+    const textureData = interpolatorToTextureData(interpolator);
+    return createOrUpdateTexture(
+        gl,
+        {
+            minMag: gl.LINEAR,
+            format: gl.RGB,
+            height: 1,
+            wrap: gl.CLAMP_TO_EDGE,
+        },
+        textureData,
+        existingTexture
+    );
+}
+
+/**
+ * Creates a texture that maps integer indices to discrete 32bit floats.
+ * The range may represent point shapes, for example.
+ *
+ * @param {number[]} range
+ * @param {WebGL2RenderingContext} gl
+ * @param {number} [count]
+ * @param {WebGLTexture} [existingTexture]
+ */
+export function createDiscreteTexture(range, gl, count, existingTexture) {
+    const size = Math.max(range.length, count || 0);
+    const textureData = new Float32Array(size);
+
+    for (let i = 0; i < size; i++) {
+        textureData[i] = range[i % range.length];
+    }
+
+    return createOrUpdateTexture(
+        gl,
+        {
+            minMag: gl.NEAREST,
+            format: gl.RED,
+            internalFormat: gl.R32F,
+            height: 1,
+        },
+        textureData,
+        existingTexture
+    );
+}
+
+/**
+ * Creates a texture that maps integer indices to discrete RGB colors.
+ *
+ * @param {string[]} colors
+ * @param {WebGL2RenderingContext} gl
+ * @param {number} [count]
+ * @param {WebGLTexture} [existingTexture]
+ */
+export function createDiscreteColorTexture(colors, gl, count, existingTexture) {
+    const textureData = colorArrayToTextureData(colors, count);
+    return createOrUpdateTexture(
+        gl,
+        {
+            minMag: gl.NEAREST,
+            format: gl.RGB,
+            height: 1,
+        },
+        textureData,
+        existingTexture
+    );
+}
+
+/**
+ * Renders an interpolator to a texture, which can be used for mapping
+ * quantitative values to colors (sequential scale).
+ *
+ * @param {function(number):string} interpolator
+ * @param {object} options
+ * @param {number[]} [options.extent]
+ * @param {boolean} [options.reverse]
+ * @param {number} [options.count]
+ */
+function interpolatorToTextureData(
+    interpolator,
+    { extent = [0, 1], reverse = false, count = 256 } = {}
+) {
+    const start = extent[0];
+    const span = peek(extent) - start;
+
+    const steps = range(count)
+        .map((x) => x / (count - 1))
+        .map((x) => start + x / span)
+        .map(interpolator);
+
+    if (reverse) {
+        steps.reverse();
+    }
+
+    return colorArrayToTextureData(steps);
+}
+
+/**
+ * Renders a scheme (an array of colors) to a texture.
+ *
+ * @param {string[]} scheme
+ * @param {number} [count]
+ */
+function colorArrayToTextureData(scheme, count) {
+    const size = Math.max(scheme.length, count || 0);
+
+    const textureData = new Uint8Array(size * 3);
+    for (let i = 0; i < size; i++) {
+        const color = d3color(scheme[i % scheme.length]).rgb();
+        textureData[i * 3 + 0] = color.r;
+        textureData[i * 3 + 1] = color.g;
+        textureData[i * 3 + 2] = color.b;
+    }
+    return textureData;
+}

package/dist/src/scale/glslScaleGenerator.d.ts

@@ -0,0 +1,45 @@
+/**
+ *
+ * @param {Channel} channel
+ * @param {number | number[] | string | boolean} value
+ */
+export function generateValueGlsl(channel: Channel, value: number | number[] | string | boolean): string;
+/**
+ *
+ * @param {Channel} channel
+ * @param {any} scale TODO: typing
+ * @param {import("../spec/channel").ChannelDef} channelDef
+ */
+export function generateScaleGlsl(channel: Channel, scale: any, channelDef: import("../spec/channel").ChannelDef): {
+    glsl: string;
+    domainUniform: string;
+};
+/**
+ *
+ * @param {string} type
+ */
+export function isHighPrecisionScale(type: string): boolean;
+/**
+ * @param {number} x Must be an integer
+ * @param {number[]} [arr]
+ */
+export function splitHighPrecision(x: number, arr?: number[]): number[];
+/**
+ * @param {number[]} domain
+ */
+export function toHighPrecisionDomainUniform(domain: number[]): number[];
+export const ATTRIBUTE_PREFIX: "attr_";
+export const DOMAIN_PREFIX: "uDomain_";
+export const RANGE_PREFIX: "range_";
+export const SCALE_FUNCTION_PREFIX: "scale_";
+export const SCALED_FUNCTION_PREFIX: "getScaled_";
+export const RANGE_TEXTURE_PREFIX: "uRangeTexture_";
+export type Channel = import("../spec/channel").Channel;
+/**
+ * Turns a number or number array to float or vec[234] string.
+ */
+export type VectorizedValue = string & {
+    type: string;
+    numComponents: number;
+};
+//# sourceMappingURL=glslScaleGenerator.d.ts.map

package/dist/src/scale/glslScaleGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glslScaleGenerator.d.ts","sourceRoot":"","sources":["../../../src/scale/glslScaleGenerator.js"],"names":[],"mappings":"AAiDA;;;;GAIG;AACH,2CAHW,OAAO,SACP,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,GAAG,OAAO,UAsC9C;AAED;;;;;GAKG;AAEH,2CALW,OAAO,SACP,GAAG,cACH,OAAO,iBAAiB,EAAE,UAAU;;;EA8Q9C;AA+FD;;;GAGG;AACH,2CAFW,MAAM,WAIhB;AAOD;;;GAGG;AACH,sCAHW,MAAM,QACN,MAAM,EAAE,YAYlB;AAYD;;GAEG;AACH,qDAFW,MAAM,EAAE,YAIlB;AAteD,uCAAwC;AACxC,uCAAwC;AACxC,oCAAqC;AACrC,6CAA8C;AAC9C,kDAAmD;AACnD,oDAAqD;sBAMxC,OAAO,iBAAiB,EAAE,OAAO;;;;8BAgXjC,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE"}