plexora 0.0.1__py3-none-any.whl

plexora/client/src/js/workers/tileDecoder.js

@@ -0,0 +1,130 @@
+/**
+ * Tile decode worker.
+ *
+ * Turns one compressed WebP channel tile into the single-channel Uint8Array the
+ * WebGL colorize pass uploads as an R8UI texture.
+ *
+ * This runs off the main thread because at high channel counts the decode is
+ * the dominant cost of panning. A CPU profile of a 15-channel pan attributed
+ * ~60% of all time to this work when it ran inline on the main thread:
+ * handleTileLoaded 24.6%, getImageData 23.5%, plus Blob/createImageBitmap/
+ * bitmap.close and the garbage collection of the ~3 MB of intermediates each
+ * tile allocates. At 7 channels the same work was only ~2%, which is why it
+ * initially looked not worth moving -- it scales with the number of tiles
+ * streaming in, i.e. with the channel count.
+ *
+ * createImageBitmap alone was already off-thread; what was not is everything
+ * after it -- the canvas draw, the getImageData readback, and the per-pixel
+ * loop over 1,048,576 pixels for a 1024x1024 tile.
+ *
+ * Only the default 8-bit WebP path lives here. The HD 16-bit and segmentation
+ * paths decode via UPNG.js, which is loaded as a plain global script and is not
+ * reachable from a worker; they also run far less often (HD is a parked-view
+ * mode, segmentation is a single layer rather than one per channel).
+ */
+
+/**
+ * Decode a 16-bit grayscale PNG (the HD channel path) into its raw big-endian
+ * sample bytes, using the browser's native inflate instead of UPNG.js/pako.
+ *
+ * A CPU profile of a 7-channel HD pan put 81% of ALL time in pako's JavaScript
+ * inflate -- inflate_fast alone was 71% -- with UPNG's unfiltering another 7%.
+ * DecompressionStream does the same job in native code, and doing it here keeps
+ * it off the main thread entirely.
+ *
+ * Only handles what fast_png.py actually emits: non-interlaced, filter type 0
+ * on every scanline. Anything else returns null so the caller can fall back to
+ * UPNG on the main thread.
+ */
+async function decodeGray16Png(buffer) {
+    const bytes = new Uint8Array(buffer);
+    const view = new DataView(buffer);
+    // PNG signature
+    if (bytes.length < 8 || bytes[0] !== 0x89 || bytes[1] !== 0x50) {
+        return null;
+    }
+    let pos = 8;
+    let width = 0, height = 0, bitDepth = 0, colorType = 0, interlace = 0;
+    const idat = [];
+    while (pos + 8 <= bytes.length) {
+        const length = view.getUint32(pos);
+        const type = String.fromCharCode(bytes[pos + 4], bytes[pos + 5], bytes[pos + 6], bytes[pos + 7]);
+        if (type === "IHDR") {
+            width = view.getUint32(pos + 8);
+            height = view.getUint32(pos + 12);
+            bitDepth = bytes[pos + 16];
+            colorType = bytes[pos + 17];
+            interlace = bytes[pos + 20];
+        } else if (type === "IDAT") {
+            idat.push(bytes.subarray(pos + 8, pos + 8 + length));
+        } else if (type === "IEND") {
+            break;
+        }
+        pos += 12 + length;
+    }
+    if (bitDepth !== 16 || colorType !== 0 || interlace !== 0 || !idat.length) {
+        return null;
+    }
+
+    // IDAT carries a zlib-wrapped stream, so "deflate" (not "deflate-raw").
+    const stream = new Blob(idat).stream().pipeThrough(new DecompressionStream("deflate"));
+    const inflated = new Uint8Array(await new Response(stream).arrayBuffer());
+
+    const stride = width * 2; // 16-bit grayscale = 2 bytes per pixel
+    if (inflated.length < height * (stride + 1)) {
+        return null;
+    }
+    const array = new Uint8Array(height * stride);
+    for (let row = 0; row < height; row++) {
+        const src = row * (stride + 1);
+        if (inflated[src] !== 0) {
+            return null; // a real filter we are not equipped to undo
+        }
+        array.set(inflated.subarray(src + 1, src + 1 + stride), row * stride);
+    }
+    return { array, width, height };
+}
+
+async function decodeWebp(buffer) {
+    const blob = new Blob([buffer], { type: "image/webp" });
+    // premultiplyAlpha/colorSpaceConversion "none" keep the stored byte
+    // values exact -- these tiles are quantized measurements, not photos,
+    // so any colour management would corrupt them.
+    const bitmap = await createImageBitmap(blob, {
+        premultiplyAlpha: "none",
+        colorSpaceConversion: "none",
+    });
+    const { width, height } = bitmap; // capture before close() zeroes them
+    const canvas = new OffscreenCanvas(width, height);
+    const ctx = canvas.getContext("2d", { willReadFrequently: true });
+    ctx.drawImage(bitmap, 0, 0);
+    const rgba = ctx.getImageData(0, 0, width, height).data;
+    bitmap.close();
+
+    // The server writes a grayscale value into every colour channel, so
+    // taking R reconstructs the original single-channel tile.
+    const array = new Uint8Array(width * height);
+    for (let i = 0; i < array.length; i++) {
+        array[i] = rgba[i * 4];
+    }
+    return { array, width, height };
+}
+
+self.onmessage = async (event) => {
+    const { id, buffer, kind } = event.data;
+    try {
+        const decoded = kind === "gray16png"
+            ? await decodeGray16Png(buffer)
+            : await decodeWebp(buffer);
+        if (!decoded) {
+            // Unsupported PNG shape -- tell the caller to decode it itself
+            // rather than guessing.
+            self.postMessage({ id, ok: false, unsupported: true, error: "unsupported PNG variant" });
+            return;
+        }
+        // Transfer the output (1-2 MB for a 1024x1024 tile) rather than copying.
+        self.postMessage({ id, ok: true, ...decoded }, [decoded.array.buffer]);
+    } catch (error) {
+        self.postMessage({ id, ok: false, error: String(error) });
+    }
+};

plexora/client/src/shaders/frag.glsl

@@ -0,0 +1,528 @@
+#version 300 es
+precision highp int;
+precision highp float;
+precision highp usampler2D;
+
+uniform usampler2D u_ids;
+uniform usampler2D u_tile;
+uniform sampler2D u_cell_ranges;
+uniform sampler2D u_centers;
+uniform usampler2D u_pickings;
+uniform sampler2D u_mag_0;
+uniform sampler2D u_mag_1;
+uniform sampler2D u_mag_2;
+uniform sampler2D u_mag_3;
+uniform ivec2 u_ids_shape;
+uniform vec2 u_tile_shape;
+uniform ivec2 u_cell_range_shape;
+uniform ivec3 u_center_shape;
+uniform ivec2 u_picking_shape;
+uniform ivec2 u_magnitude_shape;
+uniform ivec4 u_marker_sample;
+
+uniform float u_tile_fraction;
+uniform float u_tile_scale;
+uniform float u_pie_radius;
+uniform vec2 u_tile_origin;
+uniform vec2 u_tile_range;
+uniform vec3 u_tile_color;
+uniform bvec2 u_draw_mode;
+uniform vec2 u_x_bounds;
+uniform vec2 u_y_bounds;
+uniform int u_tile_fmt;
+uniform int u_picked_end;
+uniform int u_id_end;
+
+in vec2 uv;
+out vec4 color;
+
+// Fixed maximum number of ids
+const uint MAX = uint(16384) * uint(16384);
+const uint bMAX = uint(ceil(log2(float(MAX))));
+// Fixed range of radians
+const vec2 TAU = vec2(0., 6.2831853);
+const float PI = 3.14159265;
+// Fixed maximum number of channels
+const int kMAX = 4;
+
+// square given float
+float pow2(float v) {
+  return v * v;
+}
+
+// difference
+float dx(vec2 v) {
+  return v[1] - v[0];
+}
+
+// rgba to one integer
+uint unpack(uvec4 id) {
+  return id.x + uint(256)*id.y + uint(65536)*id.z + uint(16777216)*id.w;
+}
+
+// Check if value between min and max
+bool check_range(float value, vec2 range) {
+  return value >= range.x && value <= range.y;
+}
+
+// Interpolate between domain and range
+float linear(vec2 ran, float dom, float x) {
+  float b = ran[0];
+  float m = dx(ran) / dom; 
+  return m * float(clamp(x, 0., dom)) + b;
+}
+
+// From screen to local tile coordinates
+vec2 screen_to_tile(vec2 screen) {
+  float x = linear(u_x_bounds, 1., screen.x);
+  float y = linear(u_y_bounds, 1., screen.y);
+  return vec2(x, y) * u_tile_shape;
+}
+
+// From global to local tile coordinates
+vec2 global_to_tile(vec2 v) {
+  vec2 c = v / u_tile_scale - u_tile_origin;
+  return vec2(c.x, u_tile_shape.y - c.y);
+}
+
+// Check if values in array match
+bool check_same(uvec4 arr, ivec2 ii) {
+  if (arr[ii.x] == arr[ii.y]) return true;
+  return false;
+}
+bool check_same(uvec4 arr, ivec3 ii) {
+  if (arr[ii.x] == arr[ii.y]) return true;
+  if (arr[ii.y] == arr[ii.z]) return true;
+  if (arr[ii.x] == arr[ii.z]) return true;
+  return false;
+}
+
+// Float ratio of two integers
+float division(int ai, int bi) {
+  return float(ai) / float(bi);
+}
+
+// Float modulo of two integers
+float modulo(uint ai, uint bi) {
+  return mod(float(ai), float(bi));
+}
+
+// Turn 2D ratios to coordinates for 2D texture
+vec2 to_texture_xy(vec2 s, float x, float y) {
+  return vec2((x + 0.5) / s.x, 1.0 - (y + 0.5) / s.y);
+}
+
+// Turn 2D integers to coordinates for wrapped texture
+// Note: needed for 2D textures larger than normal limits
+vec2 to_flat_texture_xy(ivec3 size, int cell_index, int d) {
+  uint idx = uint(cell_index * size.z + d);
+  float idx_x = modulo(idx, uint(size.x));
+  float idx_y = floor(division(int(idx), size.x));
+  return to_texture_xy(vec2(size.xy), idx_x, idx_y);
+}
+
+// Access cell center at cell index
+vec2 sample_center(int cell_index) {
+  ivec3 size = u_center_shape;
+  vec2 center_x = to_flat_texture_xy(size, cell_index, 0);
+  vec2 center_y = to_flat_texture_xy(size, cell_index, 1);
+  float cx = texture(u_centers, center_x).r;
+  float cy = texture(u_centers, center_y).r;
+  return vec2(cx, cy);
+}
+
+// Access marker key magnitude at cell index
+float sample_magnitude(int cell_index, int key) {
+  ivec3 size = ivec3(u_magnitude_shape, 1);
+  vec2 idx_2d = to_flat_texture_xy(size, cell_index, 0);
+  // Use any of available samplers
+  if (u_marker_sample[0] == key) {
+    return texture(u_mag_0, idx_2d).r;
+  }
+  else if (u_marker_sample[1] == key) {
+    return texture(u_mag_1, idx_2d).r;
+  }
+  else if (u_marker_sample[2] == key) {
+    return texture(u_mag_2, idx_2d).r;
+  }
+  else if (u_marker_sample[3] == key) {
+    return texture(u_mag_3, idx_2d).r;
+  }
+  else {
+    return -1.;
+  }
+}
+
+// Access marker key gating parameter
+float sample_cell_range(float param, float key) {
+  vec2 size = vec2(u_cell_range_shape);
+  vec2 idx_2d = to_texture_xy(size, param, key);
+  return texture(u_cell_ranges, idx_2d).r;
+}
+
+// Access marker key gated min/max
+vec2 sample_cell_range_bounds(float key) {
+  float min_range = sample_cell_range(0., key);
+  float max_range = sample_cell_range(1., key);
+  return vec2(min_range, max_range);
+}
+
+// Access marker key gated color
+vec3 sample_cell_range_color(float key) {
+  float r = sample_cell_range(2., key);
+  float g = sample_cell_range(3., key);
+  float b = sample_cell_range(4., key);
+  return vec3(r, g, b);
+}
+
+// Check if angle is within one evenly divided slice
+bool match_angle(int count, int total, float angle) {
+  float rad_min = linear(TAU, float(total), float(count) - 1.);
+  float rad_max = linear(TAU, float(total), float(count));
+  vec2 rad_range = vec2(rad_min, rad_max);
+  return check_range(angle, rad_range);
+}
+
+// Access cell id at cell index
+uint sample_id(usampler2D sam, ivec2 size, uint idx) {
+  float idx_x = modulo(idx, uint(size.x));
+  float idx_y = floor(division(int(idx), int(size.x)));
+  vec2 ids_idx = to_texture_xy(vec2(size), idx_x, idx_y);
+  uvec4 m_value = texture(sam, ids_idx);
+  return unpack(m_value);
+}
+
+// Sample texture at given texel offset
+uvec4 offset(usampler2D sam, vec2 size, vec2 pos, vec2 off) {
+  float x_pos = pos.x + off.x / size.x;
+  float y_pos = pos.y + off.y / size.y;
+  float x = linear(u_x_bounds, 1., x_pos);
+  float y = linear(u_y_bounds, 1., y_pos);
+  return texture(sam, vec2(x, y));
+}
+
+// Generic binary search of ids
+int binary_search(usampler2D sam, ivec2 size, uint last, uint ikey) {
+  uint first = uint(0);
+  // Search within log(n) runtime
+  for (uint i = uint(0); i <= bMAX; i++) {
+    // Evaluate the midpoint
+    uint mid = (first + last) / uint(2);
+    uint here = sample_id(sam, size, mid);
+
+    // Break if list gone
+    if (first == last && ikey != here) {
+      break;
+    }
+
+    // Search below midpoint
+    if (here > ikey) last = mid;
+
+    // Search above midpoint
+    else if (ikey > here) first = mid;
+
+    // Found at midpoint
+    else return int(mid);
+  }
+  // Return -1 if id not in list
+  return -1;
+}
+
+// Sample index of cell at given offset
+// Note: will be -1 if cell not in cell list
+int sample_cell_index(vec2 off) {
+  // Find cell id at given offset 
+  uint ikey = unpack(offset(u_tile, u_tile_shape, uv, off));
+
+  // Array size
+  // Return -1 if background
+  if (ikey == uint(0)) {
+    return -1;
+  }
+
+  uint n_i = uint(u_id_end);
+  uint n_p = uint(max(u_picked_end, 0));
+
+  // Use any possible id
+  if (u_picked_end < 0) {
+    return binary_search(u_ids, u_ids_shape, n_i, ikey);
+  }
+  // Use externally picked id
+  int is_picked = binary_search(u_pickings, u_picking_shape, n_p, ikey);
+  if (is_picked > -1) {
+    return binary_search(u_ids, u_ids_shape, n_i, ikey);
+  }
+  return -1;
+}
+
+// Limit to available marker keys
+bool catch_key(int key) {
+  if (key >= u_cell_range_shape.y) {
+    return true;
+  }
+  return false;
+}
+
+// Count total OR-mode pie chart slices 
+int count_gated_keys(int cell_index) {
+  int gated_total = 0;
+  for (int key = 0; key <= kMAX; key++) {
+    if (catch_key(key)) {
+      return gated_total;
+    }
+    float scale = sample_magnitude(cell_index, key);
+    vec2 range = sample_cell_range_bounds(float(key));
+    if (check_range(scale, range)) {
+      gated_total = gated_total + 1;
+    }
+  }
+  return gated_total;
+}
+
+float dist (vec2 v) {
+  return sqrt(pow2(v.x) + pow2(v.y));
+}
+
+// Match channel to cell index
+int to_and_gate(int cell_index) {
+  // Check each possible key for color
+  for (int key = 0; key <= kMAX; key++) {
+    if (catch_key(key)) {
+      return 0;
+    }
+    float scale = sample_magnitude(cell_index, key);
+    vec2 range = sample_cell_range_bounds(float(key));
+    if (!check_range(scale, range)) {
+      return -1;
+    }
+  }
+  return 0;
+}
+
+// Return angle within pie chart
+float to_chart_angle(int cell_index, float radius) {
+  if (cell_index < 0) {
+    return -1.;
+  }
+  float pie_radius = radius * u_tile_fraction;
+  vec2 global_center = sample_center(cell_index);
+  vec2 center = global_to_tile(global_center);
+  vec2 pos = screen_to_tile(uv);
+  vec2 delta = pos - center;
+
+  if (dist(delta) > pie_radius) {
+    return -1.;
+  }
+  float rad = atan(delta.y, delta.x);
+  float angle = mod(rad + PI, TAU.y);
+  return angle;
+}
+
+// Match channel to cell index
+int to_or_gate(int cell_index, float radius) {
+  float angle = 0.0;
+  int gated_count = 0;
+  int gated_total = count_gated_keys(cell_index);
+  // Outside of circle
+  if (radius > 0.0) {
+    angle = to_chart_angle(cell_index, radius);
+    if (angle < 0.0) {
+      return -1;
+    }
+  }
+  // Check each possible key for color
+  for (int key = 0; key <= kMAX; key++) {
+    if (catch_key(key)) {
+      return -1;
+    }
+    float scale = sample_magnitude(cell_index, key);
+    vec2 range = sample_cell_range_bounds(float(key));
+    if (check_range(scale, range)) {
+      gated_count = gated_count + 1;
+      if (radius <= 0.0) {
+        return key;
+      }
+      if (match_angle(gated_count, gated_total, angle)) {
+        return key;
+      }
+    }
+  }
+  return -1;
+}
+
+// Match channel to cell index
+int to_gate(int cell_index, bvec2 mode, float radius) {
+  int n_gates = u_cell_range_shape.y;
+  if (n_gates < 1 || cell_index < 0) {
+    return -1;
+  }
+  bool or_mode = mode.y;
+  if (or_mode) {
+    return to_or_gate(cell_index, radius);
+  }
+  else {
+    return to_and_gate(cell_index);
+  }
+}
+
+// Sample gating state of cell at given offset
+int sample_cell_gate(vec2 off, bvec2 mode, float radius) {
+  int cell_index = sample_cell_index(off);
+  return to_gate(cell_index, mode, radius);
+}
+
+// Sample gated cell index at given offset
+int gate_cell_index(vec2 off, bvec2 mode, float radius) {
+  if (u_cell_range_shape.y < 1 && mode.x) {
+    return sample_cell_index(off);
+  }
+  int cell_gate = sample_cell_gate(off, mode, radius);
+  if (cell_gate == -1) {
+    return -1;
+  }
+  return sample_cell_index(off);
+}
+
+bool in_diff(usampler2D sam, vec2 pos, float one, bvec2 mode) {
+  int cell_idx = gate_cell_index(vec2(0., 0.), mode, -1.0);
+
+  int right = gate_cell_index(vec2(1. * one, 0.), mode, -1.0);
+  int left = gate_cell_index(vec2(-1. * one, 0.), mode, -1.0);
+  int down = gate_cell_index(vec2(0., -1. * one), mode, -1.0);
+  int top = gate_cell_index(vec2(0., 1. * one), mode, -1.0);
+
+  bool right_d = right != cell_idx;
+  bool left_d = left != cell_idx;
+  bool down_d = down != cell_idx;
+  bool top_d = top != cell_idx;
+
+  // Avoid double counting when zoomed in
+  if (one > 1.0 && cell_idx != -1) {
+    if (right == -1 || left == -1 || down == -1 || top == -1) {
+      return false;
+    }
+  }
+  // Count any border of gated cell
+  return (right_d || left_d || down_d || top_d);
+}
+
+bool equals4(uvec4 id1, uvec4 id2) {
+  return all(equal(id1, id2));
+}
+
+// Check if pixel is on a border
+bool near_cell_edge(float one, bvec2 mode) {
+  uvec4 empty_val = uvec4(0., 0., 0., 0.);
+  int cell_index = sample_cell_index(vec2(0, 0));
+  uvec4 pixel = offset(u_tile, u_tile_shape, uv, vec2(0., 0.));
+  bool background = equals4(empty_val, pixel);
+
+  // Background not counted
+  if (one == 1.0 && background) {
+    return false;
+  }
+  // pixels are at different cells
+  return in_diff(u_tile, uv, one, mode);
+}
+
+// Colorize discrete u32 signal
+vec4 u32_rgba_map(bvec2 mode) {
+  vec4 empty_pixel = vec4(0., 0., 0., 0.);
+  vec4 white_pixel = vec4(1., 1., 1., 1.);
+  bool edge_mode = mode.x;
+  bool or_mode = mode.y;
+  if (!edge_mode) {
+    return empty_pixel;
+  }
+
+  int cell_index = sample_cell_index(vec2(0., 0.));
+  if (cell_index < 0) {
+    return empty_pixel;
+  }
+
+  if (!or_mode) {
+    return white_pixel;
+  }
+
+  if (u_cell_range_shape.y < 1) {
+    return white_pixel;
+  }
+
+  int key = to_gate(cell_index, mode, -1.0);
+  if (key > -1) {
+    return vec4(sample_cell_range_color(float(key)), 1.0);
+  }
+  return empty_pixel;
+}
+
+// Clamp signal between given min/max
+float range_clamp(float value) {
+  float min_ = u_tile_range[0];
+  float max_ = u_tile_range[1];
+  return clamp((value - min_) / (max_ - min_), 0.0, 1.0);
+}
+
+// Colorize continuous u16 signal
+vec4 u16_rg_range(float alpha) {
+  uvec2 pixel = offset(u_tile, u_tile_shape, uv, vec2(0, 0)).rg;
+  float value = float(pixel.r * uint(255) + pixel.g) / 65535.;
+
+  // Threshhold pixel within range
+  float pixel_val = range_clamp(value);
+
+  // Color pixel value
+  vec3 pixel_color = u_tile_color * pixel_val;
+  return vec4(pixel_color, alpha);
+}
+
+// Colorize a quantized 8-bit signal (the fast/default WebP tile path).
+// The server already quantized the original 16-bit value into [0, 255]
+// (linear against the channel's true max); u_tile_range is expressed in
+// that SAME [0, 255] domain in this mode (see viewerSidebar.js), so the
+// quantized byte can feed range_clamp directly -- no reconstruction back
+// into 16-bit units, and therefore no precision mismatch between the
+// slider's domain and the encoded data's domain.
+vec4 u8_r_range(float alpha) {
+  uint pixel = offset(u_tile, u_tile_shape, uv, vec2(0, 0)).r;
+  float quant = float(pixel) / 255.;
+
+  // Threshhold pixel within range
+  float pixel_val = range_clamp(quant);
+
+  // Color pixel value
+  vec3 pixel_color = u_tile_color * pixel_val;
+  return vec4(pixel_color, alpha);
+}
+
+// True while `screen` (quad-space uv) maps inside the tile's actual valid
+// data region. u_x_bounds/u_y_bounds can legitimately extend outside
+// [0, 1] -- e.g. an edge tile stretched past its real coverage while
+// zoomed beyond native resolution (see toMagnifiedBounds in
+// viewerManager.js) -- and outside that range GL's CLAMP_TO_EDGE wrap mode
+// just keeps returning the boundary texel forever. Without this check
+// those out-of-bounds fragments painted a solid smear of that edge
+// texel/color across the rest of the quad instead of showing nothing.
+bool in_tile_bounds(vec2 screen) {
+  float x = linear(u_x_bounds, 1., screen.x);
+  float y = linear(u_y_bounds, 1., screen.y);
+  return x >= 0.0 && x <= 1.0 && y >= 0.0 && y <= 1.0;
+}
+
+//
+// Entrypoint
+//
+
+void main() {
+  if (u_tile_fmt == 32) {
+    color = u32_rgba_map(u_draw_mode);
+  }
+  else if (!in_tile_bounds(uv)) {
+    color = vec4(0.);
+  }
+  else if (u_tile_fmt == 8) {
+    color = u8_r_range(0.9);
+  }
+  else {
+    color = u16_rg_range(0.9);
+  }
+}

plexora/client/src/shaders/vert.glsl

@@ -0,0 +1,12 @@
+#version 300 es
+in vec2 a_uv;
+out vec2 uv;
+
+void main() {
+  // Texture coordinates
+  uv = a_uv;
+
+  // Clip coordinates
+  vec2 full_pos = 2. * a_uv - 1.;
+  gl_Position = vec4(full_pos, 0., 1.);
+}