@vitessce/gl 2.0.0-beta.0

package/dist/glsl/index.js

@@ -0,0 +1,340 @@
+export const colormaps = `#define GLSLIFY 1
+vec4 plasma (float x_4) {
+  const float e0 = 0.0;
+  const vec4 v0 = vec4(0.050980392156862744,0.03137254901960784,0.5294117647058824,1);
+  const float e1 = 0.13;
+  const vec4 v1 = vec4(0.29411764705882354,0.011764705882352941,0.6313725490196078,1);
+  const float e2 = 0.25;
+  const vec4 v2 = vec4(0.49019607843137253,0.011764705882352941,0.6588235294117647,1);
+  const float e3 = 0.38;
+  const vec4 v3 = vec4(0.6588235294117647,0.13333333333333333,0.5882352941176471,1);
+  const float e4 = 0.5;
+  const vec4 v4 = vec4(0.796078431372549,0.27450980392156865,0.4745098039215686,1);
+  const float e5 = 0.63;
+  const vec4 v5 = vec4(0.8980392156862745,0.4196078431372549,0.36470588235294116,1);
+  const float e6 = 0.75;
+  const vec4 v6 = vec4(0.9725490196078431,0.5803921568627451,0.2549019607843137,1);
+  const float e7 = 0.88;
+  const vec4 v7 = vec4(0.9921568627450981,0.7647058823529411,0.1568627450980392,1);
+  const float e8 = 1.0;
+  const vec4 v8 = vec4(0.9411764705882353,0.9764705882352941,0.12941176470588237,1);
+  float a0 = smoothstep(e0,e1,x_4);
+  float a1 = smoothstep(e1,e2,x_4);
+  float a2 = smoothstep(e2,e3,x_4);
+  float a3 = smoothstep(e3,e4,x_4);
+  float a4 = smoothstep(e4,e5,x_4);
+  float a5 = smoothstep(e5,e6,x_4);
+  float a6 = smoothstep(e6,e7,x_4);
+  float a7 = smoothstep(e7,e8,x_4);
+  return max(mix(v0,v1,a0)*step(e0,x_4)*step(x_4,e1),
+    max(mix(v1,v2,a1)*step(e1,x_4)*step(x_4,e2),
+    max(mix(v2,v3,a2)*step(e2,x_4)*step(x_4,e3),
+    max(mix(v3,v4,a3)*step(e3,x_4)*step(x_4,e4),
+    max(mix(v4,v5,a4)*step(e4,x_4)*step(x_4,e5),
+    max(mix(v5,v6,a5)*step(e5,x_4)*step(x_4,e6),
+    max(mix(v6,v7,a6)*step(e6,x_4)*step(x_4,e7),mix(v7,v8,a7)*step(e7,x_4)*step(x_4,e8)
+  )))))));
+}
+
+vec4 viridis (float x_1) {
+  const float e0 = 0.0;
+  const vec4 v0 = vec4(0.26666666666666666,0.00392156862745098,0.32941176470588235,1);
+  const float e1 = 0.13;
+  const vec4 v1 = vec4(0.2784313725490196,0.17254901960784313,0.47843137254901963,1);
+  const float e2 = 0.25;
+  const vec4 v2 = vec4(0.23137254901960785,0.3176470588235294,0.5450980392156862,1);
+  const float e3 = 0.38;
+  const vec4 v3 = vec4(0.17254901960784313,0.44313725490196076,0.5568627450980392,1);
+  const float e4 = 0.5;
+  const vec4 v4 = vec4(0.12941176470588237,0.5647058823529412,0.5529411764705883,1);
+  const float e5 = 0.63;
+  const vec4 v5 = vec4(0.15294117647058825,0.6784313725490196,0.5058823529411764,1);
+  const float e6 = 0.75;
+  const vec4 v6 = vec4(0.3607843137254902,0.7843137254901961,0.38823529411764707,1);
+  const float e7 = 0.88;
+  const vec4 v7 = vec4(0.6666666666666666,0.8627450980392157,0.19607843137254902,1);
+  const float e8 = 1.0;
+  const vec4 v8 = vec4(0.9921568627450981,0.9058823529411765,0.1450980392156863,1);
+  float a0 = smoothstep(e0,e1,x_1);
+  float a1 = smoothstep(e1,e2,x_1);
+  float a2 = smoothstep(e2,e3,x_1);
+  float a3 = smoothstep(e3,e4,x_1);
+  float a4 = smoothstep(e4,e5,x_1);
+  float a5 = smoothstep(e5,e6,x_1);
+  float a6 = smoothstep(e6,e7,x_1);
+  float a7 = smoothstep(e7,e8,x_1);
+  return max(mix(v0,v1,a0)*step(e0,x_1)*step(x_1,e1),
+    max(mix(v1,v2,a1)*step(e1,x_1)*step(x_1,e2),
+    max(mix(v2,v3,a2)*step(e2,x_1)*step(x_1,e3),
+    max(mix(v3,v4,a3)*step(e3,x_1)*step(x_1,e4),
+    max(mix(v4,v5,a4)*step(e4,x_1)*step(x_1,e5),
+    max(mix(v5,v6,a5)*step(e5,x_1)*step(x_1,e6),
+    max(mix(v6,v7,a6)*step(e6,x_1)*step(x_1,e7),mix(v7,v8,a7)*step(e7,x_1)*step(x_1,e8)
+  )))))));
+}
+
+vec4 greys (float x_10) {
+  const float e0 = 0.0;
+  const vec4 v0 = vec4(0,0,0,1);
+  const float e1 = 1.0;
+  const vec4 v1 = vec4(1,1,1,1);
+  float a0 = smoothstep(e0,e1,x_10);
+  return mix(v0,v1,a0)*step(e0,x_10)*step(x_10,e1);
+}
+
+vec4 magma (float x_7) {
+  const float e0 = 0.0;
+  const vec4 v0 = vec4(0,0,0.01568627450980392,1);
+  const float e1 = 0.13;
+  const vec4 v1 = vec4(0.10980392156862745,0.06274509803921569,0.26666666666666666,1);
+  const float e2 = 0.25;
+  const vec4 v2 = vec4(0.30980392156862746,0.07058823529411765,0.4823529411764706,1);
+  const float e3 = 0.38;
+  const vec4 v3 = vec4(0.5058823529411764,0.1450980392156863,0.5058823529411764,1);
+  const float e4 = 0.5;
+  const vec4 v4 = vec4(0.7098039215686275,0.21176470588235294,0.47843137254901963,1);
+  const float e5 = 0.63;
+  const vec4 v5 = vec4(0.8980392156862745,0.3137254901960784,0.39215686274509803,1);
+  const float e6 = 0.75;
+  const vec4 v6 = vec4(0.984313725490196,0.5294117647058824,0.3803921568627451,1);
+  const float e7 = 0.88;
+  const vec4 v7 = vec4(0.996078431372549,0.7607843137254902,0.5294117647058824,1);
+  const float e8 = 1.0;
+  const vec4 v8 = vec4(0.9882352941176471,0.9921568627450981,0.7490196078431373,1);
+  float a0 = smoothstep(e0,e1,x_7);
+  float a1 = smoothstep(e1,e2,x_7);
+  float a2 = smoothstep(e2,e3,x_7);
+  float a3 = smoothstep(e3,e4,x_7);
+  float a4 = smoothstep(e4,e5,x_7);
+  float a5 = smoothstep(e5,e6,x_7);
+  float a6 = smoothstep(e6,e7,x_7);
+  float a7 = smoothstep(e7,e8,x_7);
+  return max(mix(v0,v1,a0)*step(e0,x_7)*step(x_7,e1),
+    max(mix(v1,v2,a1)*step(e1,x_7)*step(x_7,e2),
+    max(mix(v2,v3,a2)*step(e2,x_7)*step(x_7,e3),
+    max(mix(v3,v4,a3)*step(e3,x_7)*step(x_7,e4),
+    max(mix(v4,v5,a4)*step(e4,x_7)*step(x_7,e5),
+    max(mix(v5,v6,a5)*step(e5,x_7)*step(x_7,e6),
+    max(mix(v6,v7,a6)*step(e6,x_7)*step(x_7,e7),mix(v7,v8,a7)*step(e7,x_7)*step(x_7,e8)
+  )))))));
+}
+
+vec4 jet (float x_8) {
+  const float e0 = 0.0;
+  const vec4 v0 = vec4(0,0,0.5137254901960784,1);
+  const float e1 = 0.125;
+  const vec4 v1 = vec4(0,0.23529411764705882,0.6666666666666666,1);
+  const float e2 = 0.375;
+  const vec4 v2 = vec4(0.0196078431372549,1,1,1);
+  const float e3 = 0.625;
+  const vec4 v3 = vec4(1,1,0,1);
+  const float e4 = 0.875;
+  const vec4 v4 = vec4(0.9803921568627451,0,0,1);
+  const float e5 = 1.0;
+  const vec4 v5 = vec4(0.5019607843137255,0,0,1);
+  float a0 = smoothstep(e0,e1,x_8);
+  float a1 = smoothstep(e1,e2,x_8);
+  float a2 = smoothstep(e2,e3,x_8);
+  float a3 = smoothstep(e3,e4,x_8);
+  float a4 = smoothstep(e4,e5,x_8);
+  return max(mix(v0,v1,a0)*step(e0,x_8)*step(x_8,e1),
+    max(mix(v1,v2,a1)*step(e1,x_8)*step(x_8,e2),
+    max(mix(v2,v3,a2)*step(e2,x_8)*step(x_8,e3),
+    max(mix(v3,v4,a3)*step(e3,x_8)*step(x_8,e4),mix(v4,v5,a4)*step(e4,x_8)*step(x_8,e5)
+  ))));
+}
+
+vec4 bone (float x_11) {
+  const float e0 = 0.0;
+  const vec4 v0 = vec4(0,0,0,1);
+  const float e1 = 0.376;
+  const vec4 v1 = vec4(0.32941176470588235,0.32941176470588235,0.4549019607843137,1);
+  const float e2 = 0.753;
+  const vec4 v2 = vec4(0.6627450980392157,0.7843137254901961,0.7843137254901961,1);
+  const float e3 = 1.0;
+  const vec4 v3 = vec4(1,1,1,1);
+  float a0 = smoothstep(e0,e1,x_11);
+  float a1 = smoothstep(e1,e2,x_11);
+  float a2 = smoothstep(e2,e3,x_11);
+  return max(mix(v0,v1,a0)*step(e0,x_11)*step(x_11,e1),
+    max(mix(v1,v2,a1)*step(e1,x_11)*step(x_11,e2),mix(v2,v3,a2)*step(e2,x_11)*step(x_11,e3)
+  ));
+}
+
+vec4 copper (float x_6) {
+  const float e0 = 0.0;
+  const vec4 v0 = vec4(0,0,0,1);
+  const float e1 = 0.804;
+  const vec4 v1 = vec4(1,0.6274509803921569,0.4,1);
+  const float e2 = 1.0;
+  const vec4 v2 = vec4(1,0.7803921568627451,0.4980392156862745,1);
+  float a0 = smoothstep(e0,e1,x_6);
+  float a1 = smoothstep(e1,e2,x_6);
+  return max(mix(v0,v1,a0)*step(e0,x_6)*step(x_6,e1),mix(v1,v2,a1)*step(e1,x_6)*step(x_6,e2)
+  );
+}
+
+vec4 density (float x_5) {
+  const float e0 = 0.0;
+  const vec4 v0 = vec4(0.21176470588235294,0.054901960784313725,0.1411764705882353,1);
+  const float e1 = 0.13;
+  const vec4 v1 = vec4(0.34901960784313724,0.09019607843137255,0.3137254901960784,1);
+  const float e2 = 0.25;
+  const vec4 v2 = vec4(0.43137254901960786,0.17647058823529413,0.5176470588235295,1);
+  const float e3 = 0.38;
+  const vec4 v3 = vec4(0.47058823529411764,0.30196078431372547,0.6980392156862745,1);
+  const float e4 = 0.5;
+  const vec4 v4 = vec4(0.47058823529411764,0.44313725490196076,0.8352941176470589,1);
+  const float e5 = 0.63;
+  const vec4 v5 = vec4(0.45098039215686275,0.592156862745098,0.8941176470588236,1);
+  const float e6 = 0.75;
+  const vec4 v6 = vec4(0.5254901960784314,0.7254901960784313,0.8901960784313725,1);
+  const float e7 = 0.88;
+  const vec4 v7 = vec4(0.6941176470588235,0.8392156862745098,0.8901960784313725,1);
+  const float e8 = 1.0;
+  const vec4 v8 = vec4(0.9019607843137255,0.9450980392156862,0.9450980392156862,1);
+  float a0 = smoothstep(e0,e1,x_5);
+  float a1 = smoothstep(e1,e2,x_5);
+  float a2 = smoothstep(e2,e3,x_5);
+  float a3 = smoothstep(e3,e4,x_5);
+  float a4 = smoothstep(e4,e5,x_5);
+  float a5 = smoothstep(e5,e6,x_5);
+  float a6 = smoothstep(e6,e7,x_5);
+  float a7 = smoothstep(e7,e8,x_5);
+  return max(mix(v0,v1,a0)*step(e0,x_5)*step(x_5,e1),
+    max(mix(v1,v2,a1)*step(e1,x_5)*step(x_5,e2),
+    max(mix(v2,v3,a2)*step(e2,x_5)*step(x_5,e3),
+    max(mix(v3,v4,a3)*step(e3,x_5)*step(x_5,e4),
+    max(mix(v4,v5,a4)*step(e4,x_5)*step(x_5,e5),
+    max(mix(v5,v6,a5)*step(e5,x_5)*step(x_5,e6),
+    max(mix(v6,v7,a6)*step(e6,x_5)*step(x_5,e7),mix(v7,v8,a7)*step(e7,x_5)*step(x_5,e8)
+  )))))));
+}
+
+vec4 inferno (float x_3) {
+  const float e0 = 0.0;
+  const vec4 v0 = vec4(0,0,0.01568627450980392,1);
+  const float e1 = 0.13;
+  const vec4 v1 = vec4(0.12156862745098039,0.047058823529411764,0.2823529411764706,1);
+  const float e2 = 0.25;
+  const vec4 v2 = vec4(0.3333333333333333,0.058823529411764705,0.42745098039215684,1);
+  const float e3 = 0.38;
+  const vec4 v3 = vec4(0.5333333333333333,0.13333333333333333,0.41568627450980394,1);
+  const float e4 = 0.5;
+  const vec4 v4 = vec4(0.7294117647058823,0.21176470588235294,0.3333333333333333,1);
+  const float e5 = 0.63;
+  const vec4 v5 = vec4(0.8901960784313725,0.34901960784313724,0.2,1);
+  const float e6 = 0.75;
+  const vec4 v6 = vec4(0.9764705882352941,0.5490196078431373,0.0392156862745098,1);
+  const float e7 = 0.88;
+  const vec4 v7 = vec4(0.9764705882352941,0.788235294117647,0.19607843137254902,1);
+  const float e8 = 1.0;
+  const vec4 v8 = vec4(0.9882352941176471,1,0.6431372549019608,1);
+  float a0 = smoothstep(e0,e1,x_3);
+  float a1 = smoothstep(e1,e2,x_3);
+  float a2 = smoothstep(e2,e3,x_3);
+  float a3 = smoothstep(e3,e4,x_3);
+  float a4 = smoothstep(e4,e5,x_3);
+  float a5 = smoothstep(e5,e6,x_3);
+  float a6 = smoothstep(e6,e7,x_3);
+  float a7 = smoothstep(e7,e8,x_3);
+  return max(mix(v0,v1,a0)*step(e0,x_3)*step(x_3,e1),
+    max(mix(v1,v2,a1)*step(e1,x_3)*step(x_3,e2),
+    max(mix(v2,v3,a2)*step(e2,x_3)*step(x_3,e3),
+    max(mix(v3,v4,a3)*step(e3,x_3)*step(x_3,e4),
+    max(mix(v4,v5,a4)*step(e4,x_3)*step(x_3,e5),
+    max(mix(v5,v6,a5)*step(e5,x_3)*step(x_3,e6),
+    max(mix(v6,v7,a6)*step(e6,x_3)*step(x_3,e7),mix(v7,v8,a7)*step(e7,x_3)*step(x_3,e8)
+  )))))));
+}
+
+vec4 cool (float x_2) {
+  const float e0 = 0.0;
+  const vec4 v0 = vec4(0.49019607843137253,0,0.7019607843137254,1);
+  const float e1 = 0.13;
+  const vec4 v1 = vec4(0.4549019607843137,0,0.8549019607843137,1);
+  const float e2 = 0.25;
+  const vec4 v2 = vec4(0.3843137254901961,0.2901960784313726,0.9294117647058824,1);
+  const float e3 = 0.38;
+  const vec4 v3 = vec4(0.26666666666666666,0.5725490196078431,0.9058823529411765,1);
+  const float e4 = 0.5;
+  const vec4 v4 = vec4(0,0.8,0.7725490196078432,1);
+  const float e5 = 0.63;
+  const vec4 v5 = vec4(0,0.9686274509803922,0.5725490196078431,1);
+  const float e6 = 0.75;
+  const vec4 v6 = vec4(0,1,0.34509803921568627,1);
+  const float e7 = 0.88;
+  const vec4 v7 = vec4(0.1568627450980392,1,0.03137254901960784,1);
+  const float e8 = 1.0;
+  const vec4 v8 = vec4(0.5764705882352941,1,0,1);
+  float a0 = smoothstep(e0,e1,x_2);
+  float a1 = smoothstep(e1,e2,x_2);
+  float a2 = smoothstep(e2,e3,x_2);
+  float a3 = smoothstep(e3,e4,x_2);
+  float a4 = smoothstep(e4,e5,x_2);
+  float a5 = smoothstep(e5,e6,x_2);
+  float a6 = smoothstep(e6,e7,x_2);
+  float a7 = smoothstep(e7,e8,x_2);
+  return max(mix(v0,v1,a0)*step(e0,x_2)*step(x_2,e1),
+    max(mix(v1,v2,a1)*step(e1,x_2)*step(x_2,e2),
+    max(mix(v2,v3,a2)*step(e2,x_2)*step(x_2,e3),
+    max(mix(v3,v4,a3)*step(e3,x_2)*step(x_2,e4),
+    max(mix(v4,v5,a4)*step(e4,x_2)*step(x_2,e5),
+    max(mix(v5,v6,a5)*step(e5,x_2)*step(x_2,e6),
+    max(mix(v6,v7,a6)*step(e6,x_2)*step(x_2,e7),mix(v7,v8,a7)*step(e7,x_2)*step(x_2,e8)
+  )))))));
+}
+
+vec4 hot (float x_0) {
+  const float e0 = 0.0;
+  const vec4 v0 = vec4(0,0,0,1);
+  const float e1 = 0.3;
+  const vec4 v1 = vec4(0.9019607843137255,0,0,1);
+  const float e2 = 0.6;
+  const vec4 v2 = vec4(1,0.8235294117647058,0,1);
+  const float e3 = 1.0;
+  const vec4 v3 = vec4(1,1,1,1);
+  float a0 = smoothstep(e0,e1,x_0);
+  float a1 = smoothstep(e1,e2,x_0);
+  float a2 = smoothstep(e2,e3,x_0);
+  return max(mix(v0,v1,a0)*step(e0,x_0)*step(x_0,e1),
+    max(mix(v1,v2,a1)*step(e1,x_0)*step(x_0,e2),mix(v2,v3,a2)*step(e2,x_0)*step(x_0,e3)
+  ));
+}
+
+vec4 spring (float x_14) {
+  const float e0 = 0.0;
+  const vec4 v0 = vec4(1,0,1,1);
+  const float e1 = 1.0;
+  const vec4 v1 = vec4(1,1,0,1);
+  float a0 = smoothstep(e0,e1,x_14);
+  return mix(v0,v1,a0)*step(e0,x_14)*step(x_14,e1);
+}
+
+vec4 summer (float x_9) {
+  const float e0 = 0.0;
+  const vec4 v0 = vec4(0,0.5019607843137255,0.4,1);
+  const float e1 = 1.0;
+  const vec4 v1 = vec4(1,1,0.4,1);
+  float a0 = smoothstep(e0,e1,x_9);
+  return mix(v0,v1,a0)*step(e0,x_9)*step(x_9,e1);
+}
+
+vec4 autumn (float x_13) {
+  const float e0 = 0.0;
+  const vec4 v0 = vec4(1,0,0,1);
+  const float e1 = 1.0;
+  const vec4 v1 = vec4(1,1,0,1);
+  float a0 = smoothstep(e0,e1,x_13);
+  return mix(v0,v1,a0)*step(e0,x_13)*step(x_13,e1);
+}
+
+vec4 winter (float x_12) {
+  const float e0 = 0.0;
+  const vec4 v0 = vec4(0,0,1,1);
+  const float e1 = 1.0;
+  const vec4 v1 = vec4(0,1,0.5019607843137255,1);
+  float a0 = smoothstep(e0,e1,x_12);
+  return mix(v0,v1,a0)*step(e0,x_12)*step(x_12,e1);
+}
+`;

package/dist/heatmap-bitmap-layer-shaders.js

@@ -0,0 +1,109 @@
+import { colormaps } from './glsl';
+/**
+ * No change to the vertex shader from the base BitmapLayer.
+ * Reference: https://github.com/visgl/deck.gl/blob/8.2-release/modules/layers/src/bitmap-layer/bitmap-layer-vertex.js
+ */
+export const vertexShader = `
+#define SHADER_NAME heatmap-bitmap-layer-vertex-shader
+
+attribute vec2 texCoords;
+attribute vec3 positions;
+attribute vec3 positions64Low;
+
+varying vec2 vTexCoord;
+
+const vec3 pickingColor = vec3(1.0, 0.0, 0.0);
+
+void main(void) {
+  geometry.worldPosition = positions;
+  geometry.uv = texCoords;
+  geometry.pickingColor = pickingColor;
+
+  gl_Position = project_position_to_clipspace(positions, positions64Low, vec3(0.0), geometry.position);
+  DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
+
+  vTexCoord = texCoords;
+
+  vec4 color = vec4(0.0);
+  DECKGL_FILTER_COLOR(color, geometry);
+}
+`;
+/**
+ * Fragment shader adapted to perform aggregation and
+ * take color scale functions + sliders into account.
+ * Reference: https://github.com/visgl/deck.gl/blob/8.2-release/modules/layers/src/bitmap-layer/bitmap-layer-fragment.js
+ * Reference: https://github.com/hms-dbmi/viv/blob/06231ae02cac1ff57ba458c71e9bc59ed2fc4f8b/src/layers/XRLayer/xr-layer-fragment-colormap.webgl1.glsl
+ */
+export const fragmentShader = `
+#define SHADER_NAME heatmap-bitmap-layer-fragment-shader
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+${colormaps}
+
+// The texture (GL.LUMINANCE & Uint8Array).
+uniform sampler2D uBitmapTexture;
+
+// What are the dimensions of the texture (width, height)?
+uniform vec2 uTextureSize;
+
+// How many consecutive pixels should be aggregated together along each axis?
+uniform vec2 uAggSize;
+
+// What are the values of the color scale sliders?
+uniform vec2 uColorScaleRange;
+
+// The texture coordinate, varying (interpolated between values set by the vertex shader).
+varying vec2 vTexCoord;
+
+void main(void) {
+  // Compute 1 pixel in texture coordinates
+  vec2 onePixel = vec2(1.0, 1.0) / uTextureSize;
+  
+  vec2 viewCoord = vec2(floor(vTexCoord.x * uTextureSize.x), floor(vTexCoord.y * uTextureSize.y));
+
+  // Compute (x % aggSizeX, y % aggSizeY).
+  // These values will be the number of values to the left / above the current position to consider.
+  vec2 modAggSize = vec2(-1.0 * mod(viewCoord.x, uAggSize.x), -1.0 * mod(viewCoord.y, uAggSize.y));
+
+  // Take the sum of values along each axis.
+  float intensitySum = 0.0;
+  vec2 offsetPixels = vec2(0.0, 0.0);
+
+  for(int i = 0; i < 16; i++) {
+    // Check to break outer loop early.
+    // Uniforms cannot be used as conditions in GLSL for loops.
+    if(float(i) >= uAggSize.y) {
+      // Done in the y direction.
+      break;
+    }
+
+    offsetPixels = vec2(offsetPixels.x, (modAggSize.y + float(i)) * onePixel.y);
+
+    for(int j = 0; j < 16; j++) {
+      // Check to break inner loop early.
+      // Uniforms cannot be used as conditions in GLSL for loops.
+      if(float(j) >= uAggSize.x) {
+        // Done in the x direction.
+        break;
+      }
+
+      offsetPixels = vec2((modAggSize.x + float(j)) * onePixel.x, offsetPixels.y);
+      intensitySum += texture2D(uBitmapTexture, vTexCoord + offsetPixels).r;
+    }
+  }
+  
+  // Compute the mean value.
+  float intensityMean = intensitySum / (uAggSize.x * uAggSize.y);
+  
+  // Re-scale using the color scale slider values.
+  float scaledIntensityMean = (intensityMean - uColorScaleRange[0]) / max(0.005, (uColorScaleRange[1] - uColorScaleRange[0]));
+
+  gl_FragColor = COLORMAP_FUNC(clamp(scaledIntensityMean, 0.0, 1.0));
+
+  geometry.uv = vTexCoord;
+  DECKGL_FILTER_COLOR(gl_FragColor, geometry);
+}
+`;

package/dist/heatmap-constants.js

@@ -0,0 +1,27 @@
+import GL from '@luma.gl/constants'; // eslint-disable-line import/no-extraneous-dependencies
+// Image texture dimensions
+export const TILE_SIZE = 4096;
+// Reshaped data texture dimensions
+export const DATA_TEXTURE_SIZE = 4096;
+export const MIN_ROW_AGG = 1;
+export const MAX_ROW_AGG = 16;
+export const COLOR_BAR_SIZE = 20;
+export const AXIS_LABEL_TEXT_SIZE = 11;
+export const AXIS_TITLE_TEXT_SIZE = 15;
+export const AXIS_MIN_SIZE = 12;
+export const AXIS_MAX_SIZE = 120;
+export const AXIS_MARGIN = 3;
+export const AXIS_PADDING = 10;
+export const THEME_TO_TEXT_COLOR = {
+    dark: [224, 224, 224],
+    light: [64, 64, 64],
+};
+export const AXIS_FONT_FAMILY = "-apple-system, 'Helvetica Neue', Arial, sans-serif";
+export const PIXELATED_TEXTURE_PARAMETERS = {
+    // NEAREST for integer data to prevent interpolation.
+    [GL.TEXTURE_MIN_FILTER]: GL.NEAREST,
+    [GL.TEXTURE_MAG_FILTER]: GL.NEAREST,
+    // CLAMP_TO_EDGE to remove tile artifacts.
+    [GL.TEXTURE_WRAP_S]: GL.CLAMP_TO_EDGE,
+    [GL.TEXTURE_WRAP_T]: GL.CLAMP_TO_EDGE,
+};

package/dist/index.js

@@ -0,0 +1,17 @@
+// Selection Layers
+export { getSelectionLayers } from './selection-utils';
+// Heatmap Layers
+export { default as HeatmapBitmapLayer } from './HeatmapBitmapLayer';
+export { default as PixelatedBitmapLayer } from './PixelatedBitmapLayer';
+export { default as HeatmapCompositeTextLayer } from './HeatmapCompositeTextLayer';
+export { default as PaddedExpressionHeatmapBitmapLayer } from './PaddedExpressionHeatmapBitmapLayer';
+export { GLSL_COLORMAPS, GLSL_COLORMAP_DEFAULT, DEFAULT_GL_OPTIONS, SELECTION_TYPE, } from './constants';
+// Layer extensions
+export { default as ScaledExpressionExtension } from './ScaledExpressionExtension';
+export { default as SelectionExtension } from './SelectionExtension';
+export { default as BitmaskLayer } from './BitmaskLayer';
+export { TILE_SIZE, MAX_ROW_AGG, MIN_ROW_AGG, COLOR_BAR_SIZE, AXIS_MARGIN, DATA_TEXTURE_SIZE, PIXELATED_TEXTURE_PARAMETERS, AXIS_LABEL_TEXT_SIZE, AXIS_FONT_FAMILY, AXIS_PADDING, AXIS_MIN_SIZE, AXIS_MAX_SIZE, } from './heatmap-constants';
+export * as viv from './viv';
+export * as luma from './luma';
+export * as deck from './deck';
+export { GLOBAL_LABELS, DEFAULT_CELLS_LAYER, DEFAULT_MOLECULES_LAYER, DEFAULT_NEIGHBORHOODS_LAYER, DEFAULT_RASTER_DOMAIN_TYPE, DEFAULT_RASTER_LAYER_PROPS, DEFAULT_LAYER_TYPE_ORDERING, square, initializeLayerChannels, initializeRasterLayersAndChannels, getSourceFromLoader, isRgb, } from './spatial';

package/dist/layer-controller.js

@@ -0,0 +1,109 @@
+import { Matrix4 } from 'math.gl';
+import { getChannelStats } from './viv';
+async function getSingleSelectionStats2D({ loader, selection }) {
+    const data = Array.isArray(loader) ? loader[loader.length - 1] : loader;
+    const raster = await data.getRaster({ selection });
+    const selectionStats = getChannelStats(raster.data);
+    const { domain, contrastLimits: slider } = selectionStats;
+    return { domain, slider };
+}
+async function getSingleSelectionStats3D({ loader, selection }) {
+    const lowResSource = loader[loader.length - 1];
+    const { shape, labels } = lowResSource;
+    // eslint-disable-next-line no-bitwise
+    const sizeZ = shape[labels.indexOf('z')] >> (loader.length - 1);
+    const raster0 = await lowResSource.getRaster({
+        selection: { ...selection, z: 0 },
+    });
+    const rasterMid = await lowResSource.getRaster({
+        selection: { ...selection, z: Math.floor(sizeZ / 2) },
+    });
+    const rasterTop = await lowResSource.getRaster({
+        selection: { ...selection, z: Math.max(0, sizeZ - 1) },
+    });
+    const stats0 = getChannelStats(raster0.data);
+    const statsMid = getChannelStats(rasterMid.data);
+    const statsTop = getChannelStats(rasterTop.data);
+    return {
+        domain: [
+            Math.min(stats0.domain[0], statsMid.domain[0], statsTop.domain[0]),
+            Math.max(stats0.domain[1], statsMid.domain[1], statsTop.domain[1]),
+        ],
+        slider: [
+            Math.min(stats0.contrastLimits[0], statsMid.contrastLimits[0], statsTop.contrastLimits[0]),
+            Math.max(stats0.contrastLimits[1], statsMid.contrastLimits[1], statsTop.contrastLimits[1]),
+        ],
+    };
+}
+/**
+ * Get bounding cube for a given loader i.e [[0, width], [0, height], [0, depth]]
+ * @param {Object} loader PixelSource|PixelSource[]
+ * @param {[]} selection Selection for stats.
+ * @param {boolean} use3d Whether or not to get 3d stats.
+ * @returns {Object} { domains, sliders }
+ */
+export const getSingleSelectionStats = async ({ loader, selection, use3d }) => {
+    const getStats = use3d
+        ? getSingleSelectionStats3D
+        : getSingleSelectionStats2D;
+    return getStats({ loader, selection });
+};
+export const getMultiSelectionStats = async ({ loader, selections, use3d }) => {
+    const stats = await Promise.all(selections.map(selection => getSingleSelectionStats({ loader, selection, use3d })));
+    const domains = stats.map(stat => stat.domain);
+    const sliders = stats.map(stat => stat.slider);
+    return { domains, sliders };
+};
+/**
+ * Get physical size scaling Matrix4
+ * @param {Object} loader PixelSource
+ * @returns {Object} matrix
+ */
+export function getPhysicalSizeScalingMatrix(loader) {
+    const { x, y, z } = loader?.meta?.physicalSizes ?? {};
+    if (x?.size && y?.size && z?.size) {
+        const min = Math.min(z.size, x.size, y.size);
+        const ratio = [x.size / min, y.size / min, z.size / min];
+        return new Matrix4().scale(ratio);
+    }
+    return new Matrix4().identity();
+}
+/**
+ * Get bounding cube for a given loader
+ * @param {Object} loader PixelSource|PixelSource[]
+ * @returns {Array} [0, width], [0, height], [0, depth]]
+ */
+export function getBoundingCube(loader) {
+    const source = Array.isArray(loader) ? loader[0] : loader;
+    const { shape, labels } = source;
+    const physicalSizeScalingMatrix = getPhysicalSizeScalingMatrix(source);
+    const xSlice = [0, physicalSizeScalingMatrix[0] * shape[labels.indexOf('x')]];
+    const ySlice = [0, physicalSizeScalingMatrix[5] * shape[labels.indexOf('y')]];
+    const zSlice = [
+        0,
+        physicalSizeScalingMatrix[10] * shape[labels.indexOf('z')],
+    ];
+    return [xSlice, ySlice, zSlice];
+}
+export function abbreviateNumber(value) {
+    // Return an abbreviated representation of value, in 5 characters or less.
+    const maxLength = 5;
+    let maxNaiveDigits = maxLength;
+    /* eslint-disable no-plusplus */
+    if (!Number.isInteger(value)) {
+        --maxNaiveDigits;
+    } // Wasted on "."
+    if (value < 1) {
+        --maxNaiveDigits;
+    } // Wasted on "0."
+    /* eslint-disable no-plusplus */
+    const naive = Intl.NumberFormat('en-US', {
+        maximumSignificantDigits: maxNaiveDigits,
+        useGrouping: false,
+    }).format(value);
+    if (naive.length <= maxLength)
+        return naive;
+    // "e+9" consumes 3 characters, so if we even had two significant digits,
+    // it would take take us to six characters, including the decimal point.
+    return value.toExponential(0);
+}

package/dist/luma.js

@@ -0,0 +1,2 @@
+export { default as GL } from '@luma.gl/constants';
+export { Texture2D } from '@luma.gl/core';