@vitessce/spatial-utils 2.0.3 → 3.0.0

package/dist/{index.mjs → index.js}

@@ -1,5 +1,4 @@
-import { D, e, a, b, c, d, G, g, i, f, h, j, s } from "./index.75f0a489.mjs";
-import "@vitessce/vit-s";
+import { D, e, a, b, c, d, G, n, l, m, h, i, f, j, k, s } from "./index-ce1fad7e.js";
 import "react";
 export {
   D as DEFAULT_CELLS_LAYER,
@@ -9,10 +8,13 @@ export {
   c as DEFAULT_RASTER_DOMAIN_TYPE,
   d as DEFAULT_RASTER_LAYER_PROPS,
   G as GLOBAL_LABELS,
-  g as getSourceFromLoader,
+  n as coordinateTransformationsToMatrix,
+  l as getNgffAxes,
+  m as getNgffAxesForTiff,
+  h as getSourceFromLoader,
   i as initializeLayerChannels,
   f as initializeRasterLayersAndChannels,
-  h as isInterleaved,
-  j as isRgb,
+  j as isInterleaved,
+  k as isRgb,
   s as square
 };

package/dist/{jpeg.1d104fed.mjs → jpeg-258024ce.js}

@@ -1,5 +1,4 @@
-import { B as BaseDecoder } from "./index.75f0a489.mjs";
-import "@vitessce/vit-s";
+import { B as BaseDecoder } from "./index-ce1fad7e.js";
 import "react";
 const dctZigZag = new Int32Array([
   0,

package/dist/{lerc.95b793c7.mjs → lerc-279c1032.js}

@@ -1,6 +1,5 @@
-import { i as inflate_1 } from "./pako.esm.4b234125.mjs";
-import { B as BaseDecoder } from "./index.75f0a489.mjs";
-import "@vitessce/vit-s";
+import { i as inflate_1 } from "./pako.esm-68f84e2a.js";
+import { g as getDefaultExportFromCjs, B as BaseDecoder } from "./index-ce1fad7e.js";
 import "react";
 const LercParameters = {
   Version: 0,
@@ -371,6 +370,8 @@ var LercDecode = { exports: {} };
     }();
     var Lerc2Decode = function() {
       var BitStuffer = {
+        //methods ending with 2 are for the new byte order used by Lerc2.3 and above.
+        //originalUnstuff is used to unpack Huffman code table. code is duplicated to unstuffx for performance reasons.
         unstuff: function(src, dest, bitsPerPixel, numPixels, lutArr, offset, scale, maxValue) {
           var bitMask = (1 << bitsPerPixel) - 1;
           var i = 0, o;
@@ -581,6 +582,7 @@ var LercDecode = { exports: {} };
       };
       var Lerc2Helpers = {
         HUFFMAN_LUT_BITS_MAX: 12,
+        //use 2^12 lut, treat it like constant
         computeChecksumFletcher32: function(input) {
           var sum1 = 65535, sum2 = 65535;
           var len = input.length;
@@ -1391,6 +1393,9 @@ var LercDecode = { exports: {} };
             data.pixels.resultPixels = Lerc2Helpers.swapDimensionOrder(data.pixels.resultPixels, numPixels, numDims, OutPixelTypeArray);
           }
         },
+        /*****************
+        *  private methods (helper methods)
+        *****************/
         formatFileInfo: function(data) {
           return {
             "fileIdentifierString": data.headerInfo.fileIdentifierString,
@@ -1410,6 +1415,7 @@ var LercDecode = { exports: {} };
             "pixels": {
               "numBlocksX": data.pixels.numBlocksX,
               "numBlocksY": data.pixels.numBlocksY,
+              //"numBytes": data.pixels.numBytes,
               "maxValue": data.headerInfo.zMax,
               "minValue": data.headerInfo.zMin,
               "noDataValue": data.noDataValue
@@ -1697,14 +1703,48 @@ var LercDecode = { exports: {} };
         this.right = right;
       };
       var Lerc2Decode2 = {
+        /*
+        * ********removed options compared to LERC1. We can bring some of them back if needed.
+         * removed pixel type. LERC2 is typed and doesn't require user to give pixel type
+         * changed encodedMaskData to maskData. LERC2 's js version make it faster to use maskData directly.
+         * removed returnMask. mask is used by LERC2 internally and is cost free. In case of user input mask, it's returned as well and has neglible cost.
+         * removed nodatavalue. Because LERC2 pixels are typed, nodatavalue will sacrify a useful value for many types (8bit, 16bit) etc,
+         *       user has to be knowledgable enough about raster and their data to avoid usability issues. so nodata value is simply removed now.
+         *       We can add it back later if their's a clear requirement.
+         * removed encodedMask. This option was not implemented in LercDecode. It can be done after decoding (less efficient)
+         * removed computeUsedBitDepths.
+         *
+         *
+         * response changes compared to LERC1
+         * 1. encodedMaskData is not available
+         * 2. noDataValue is optional (returns only if user's noDataValue is with in the valid data type range)
+         * 3. maskData is always available
+        */
+        /*****************
+        *  public properties
+        ******************/
+        //HUFFMAN_LUT_BITS_MAX: 12, //use 2^12 lut, not configurable
+        /*****************
+        *  public methods
+        *****************/
+        /**
+         * Decode a LERC2 byte stream and return an object containing the pixel data and optional metadata.
+         *
+         * @param {ArrayBuffer} input The LERC input byte stream
+         * @param {object} [options] options Decoding options
+         * @param {number} [options.inputOffset] The number of bytes to skip in the input byte stream. A valid LERC file is expected at that position
+         * @param {boolean} [options.returnFileInfo] If true, the return value will have a fileInfo property that contains metadata obtained from the LERC headers and the decoding process
+         * @param {boolean} [options.returnPixelInterleavedDims]  If true, returned dimensions are pixel-interleaved, a.k.a [p1_dim0, p1_dim1, p1_dimn, p2_dim0...], default is [p1_dim0, p2_dim0, ..., p1_dim1, p2_dim1...]
+         */
         decode: function(input, options) {
           options = options || {};
           var noDataValue = options.noDataValue;
           var i = 0, data = {};
           data.ptr = options.inputOffset || 0;
           data.pixels = {};
-          if (!Lerc2Helpers.readHeaderInfo(input, data))
-            ;
+          if (!Lerc2Helpers.readHeaderInfo(input, data)) {
+            return;
+          }
           var headerInfo = data.headerInfo;
           var fileVersion = headerInfo.fileVersion;
           var OutPixelTypeArray = Lerc2Helpers.getDataTypeArray(headerInfo.imageType);
@@ -1782,6 +1822,7 @@ var LercDecode = { exports: {} };
               maxValues: headerInfo.maxValues
             },
             maskData: data.pixels.resultMask
+            //noDataValue: noDataValue
           };
           if (data.pixels.resultMask && Lerc2Helpers.isValidPixelValue(headerInfo.imageType, noDataValue)) {
             var mask = data.pixels.resultMask;
@@ -1823,6 +1864,25 @@ var LercDecode = { exports: {} };
       return b[0] === 1;
     }();
     var Lerc2 = {
+      /************wrapper**********************************************/
+      /**
+       * A wrapper for decoding both LERC1 and LERC2 byte streams capable of handling multiband pixel blocks for various pixel types.
+       *
+       * @alias module:Lerc
+       * @param {ArrayBuffer} input The LERC input byte stream
+       * @param {object} [options] The decoding options below are optional.
+       * @param {number} [options.inputOffset] The number of bytes to skip in the input byte stream. A valid Lerc file is expected at that position.
+       * @param {string} [options.pixelType] (LERC1 only) Default value is F32. Valid pixel types for input are U8/S8/S16/U16/S32/U32/F32.
+       * @param {number} [options.noDataValue] (LERC1 only). It is recommended to use the returned mask instead of setting this value.
+       * @param {boolean} [options.returnPixelInterleavedDims] (nDim LERC2 only) If true, returned dimensions are pixel-interleaved, a.k.a [p1_dim0, p1_dim1, p1_dimn, p2_dim0...], default is [p1_dim0, p2_dim0, ..., p1_dim1, p2_dim1...]
+       * @returns {{width, height, pixels, pixelType, mask, statistics}}
+         * @property {number} width Width of decoded image.
+         * @property {number} height Height of decoded image.
+         * @property {array} pixels [band1, band2, …] Each band is a typed array of width*height.
+         * @property {string} pixelType The type of pixels represented in the output.
+         * @property {mask} mask Typed array with a size of width*height, or null if all pixels are valid.
+         * @property {array} statistics [statistics_band1, statistics_band2, …] Each element is a statistics object representing min and max values
+      **/
       decode: function(encodedData, options) {
         if (!isPlatformLittleEndian) {
           throw "Big endian system is not supported.";
@@ -1854,14 +1914,23 @@ var LercDecode = { exports: {} };
         while (inputOffset < eof) {
           var result = lerc.decode(encodedData, {
             inputOffset,
+            //for both lerc1 and lerc2
             encodedMaskData,
+            //lerc1 only
             maskData,
+            //lerc2 only
             returnMask: iPlane === 0 ? true : false,
+            //lerc1 only
             returnEncodedMask: iPlane === 0 ? true : false,
+            //lerc1 only
             returnFileInfo: true,
+            //for both lerc1 and lerc2
             returnPixelInterleavedDims: options.returnPixelInterleavedDims,
+            //for ndim lerc2 only
             pixelType: options.pixelType || null,
+            //lerc1 only
             noDataValue: options.noDataValue || null
+            //lerc1 only
           });
           inputOffset = result.fileInfo.eofOffset;
           maskData = result.maskData;
@@ -1914,7 +1983,8 @@ var LercDecode = { exports: {} };
     }
   })();
 })(LercDecode);
-const Lerc = LercDecode.exports;
+var LercDecodeExports = LercDecode.exports;
+const Lerc = /* @__PURE__ */ getDefaultExportFromCjs(LercDecodeExports);
 class LercDecoder extends BaseDecoder {
   constructor(fileDirectory) {
     super();

package/dist/{lzw.ade1d376.mjs → lzw-d830df9b.js}

@@ -1,5 +1,4 @@
-import { B as BaseDecoder } from "./index.75f0a489.mjs";
-import "@vitessce/vit-s";
+import { B as BaseDecoder } from "./index-ce1fad7e.js";
 import "react";
 const MIN_BITS = 9;
 const CLEAR_CODE = 256;

package/dist/{packbits.16b1394a.mjs → packbits-fe766b57.js}

@@ -1,5 +1,4 @@
-import { B as BaseDecoder } from "./index.75f0a489.mjs";
-import "@vitessce/vit-s";
+import { B as BaseDecoder } from "./index-ce1fad7e.js";
 import "react";
 class PackbitsDecoder extends BaseDecoder {
   decodeBlock(buffer) {

package/dist/{pako.esm.4b234125.mjs → pako.esm-68f84e2a.js}

@@ -27,9 +27,18 @@ const END_BLOCK = 256;
 const REP_3_6 = 16;
 const REPZ_3_10 = 17;
 const REPZ_11_138 = 18;
-const extra_lbits = new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0]);
-const extra_dbits = new Uint8Array([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13]);
-const extra_blbits = new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7]);
+const extra_lbits = (
+  /* extra bits for each length code */
+  new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0])
+);
+const extra_dbits = (
+  /* extra bits for each distance code */
+  new Uint8Array([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13])
+);
+const extra_blbits = (
+  /* extra bits for each bit length code */
+  new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7])
+);
 const bl_order = new Uint8Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
 const DIST_CODE_LEN = 512;
 const static_ltree = new Array((L_CODES$1 + 2) * 2);
@@ -79,7 +88,12 @@ const send_bits = (s, value, length) => {
   }
 };
 const send_code = (s, c, tree) => {
-  send_bits(s, tree[c * 2], tree[c * 2 + 1]);
+  send_bits(
+    s,
+    tree[c * 2],
+    tree[c * 2 + 1]
+    /*.Len*/
+  );
 };
 const bi_reverse = (code, len) => {
   let res = 0;
@@ -368,19 +382,44 @@ const build_tree = (s, desc) => {
   }
   node = elems;
   do {
-    n = s.heap[1];
-    s.heap[1] = s.heap[s.heap_len--];
-    pqdownheap(s, tree, 1);
-    m = s.heap[1];
+    n = s.heap[
+      1
+      /*SMALLEST*/
+    ];
+    s.heap[
+      1
+      /*SMALLEST*/
+    ] = s.heap[s.heap_len--];
+    pqdownheap(
+      s,
+      tree,
+      1
+      /*SMALLEST*/
+    );
+    m = s.heap[
+      1
+      /*SMALLEST*/
+    ];
     s.heap[--s.heap_max] = n;
     s.heap[--s.heap_max] = m;
     tree[node * 2] = tree[n * 2] + tree[m * 2];
     s.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1;
     tree[n * 2 + 1] = tree[m * 2 + 1] = node;
-    s.heap[1] = node++;
-    pqdownheap(s, tree, 1);
+    s.heap[
+      1
+      /*SMALLEST*/
+    ] = node++;
+    pqdownheap(
+      s,
+      tree,
+      1
+      /*SMALLEST*/
+    );
   } while (s.heap_len >= 2);
-  s.heap[--s.heap_max] = s.heap[1];
+  s.heap[--s.heap_max] = s.heap[
+    1
+    /*SMALLEST*/
+  ];
   gen_bitlen(s, desc);
   gen_codes(tree, max_code, s.bl_count);
 };
@@ -640,16 +679,26 @@ const crc32 = (crc, buf, len, pos) => {
 var crc32_1 = crc32;
 var messages = {
   2: "need dictionary",
+  /* Z_NEED_DICT       2  */
   1: "stream end",
+  /* Z_STREAM_END      1  */
   0: "",
+  /* Z_OK              0  */
   "-1": "file error",
+  /* Z_ERRNO         (-1) */
   "-2": "stream error",
+  /* Z_STREAM_ERROR  (-2) */
   "-3": "data error",
+  /* Z_DATA_ERROR    (-3) */
   "-4": "insufficient memory",
+  /* Z_MEM_ERROR     (-4) */
   "-5": "buffer error",
+  /* Z_BUF_ERROR     (-5) */
   "-6": "incompatible version"
+  /* Z_VERSION_ERROR (-6) */
 };
 var constants$2 = {
+  /* Allowed flush values; see deflate() and inflate() below for details */
   Z_NO_FLUSH: 0,
   Z_PARTIAL_FLUSH: 1,
   Z_SYNC_FLUSH: 2,
@@ -657,6 +706,9 @@ var constants$2 = {
   Z_FINISH: 4,
   Z_BLOCK: 5,
   Z_TREES: 6,
+  /* Return codes for the compression/decompression functions. Negative values
+  * are errors, positive values are used for special but normal events.
+  */
   Z_OK: 0,
   Z_STREAM_END: 1,
   Z_NEED_DICT: 2,
@@ -665,6 +717,8 @@ var constants$2 = {
   Z_DATA_ERROR: -3,
   Z_MEM_ERROR: -4,
   Z_BUF_ERROR: -5,
+  //Z_VERSION_ERROR: -6,
+  /* compression levels */
   Z_NO_COMPRESSION: 0,
   Z_BEST_SPEED: 1,
   Z_BEST_COMPRESSION: 9,
@@ -674,10 +728,14 @@ var constants$2 = {
   Z_RLE: 3,
   Z_FIXED: 4,
   Z_DEFAULT_STRATEGY: 0,
+  /* Possible values of the data_type field (though see inflate()) */
   Z_BINARY: 0,
   Z_TEXT: 1,
+  //Z_ASCII:                1, // = Z_TEXT (deprecated)
   Z_UNKNOWN: 2,
+  /* The deflate compression method */
   Z_DEFLATED: 8
+  //Z_NULL:                 null // Use -1 or null inline, depending on var type
 };
 const { _tr_init, _tr_stored_block, _tr_flush_block, _tr_tally, _tr_align } = trees;
 const {
@@ -1195,16 +1253,27 @@ function Config(good_length, max_lazy, nice_length, max_chain, func) {
   this.func = func;
 }
 const configuration_table = [
+  /*      good lazy nice chain */
   new Config(0, 0, 0, 0, deflate_stored),
+  /* 0 store only */
   new Config(4, 4, 8, 4, deflate_fast),
+  /* 1 max speed, no lazy matches */
   new Config(4, 5, 16, 8, deflate_fast),
+  /* 2 */
   new Config(4, 6, 32, 32, deflate_fast),
+  /* 3 */
   new Config(4, 4, 16, 16, deflate_slow),
+  /* 4 lazy matches */
   new Config(8, 16, 32, 32, deflate_slow),
+  /* 5 */
   new Config(8, 16, 128, 128, deflate_slow),
+  /* 6 */
   new Config(8, 32, 128, 256, deflate_slow),
+  /* 7 */
   new Config(32, 128, 258, 1024, deflate_slow),
+  /* 8 */
   new Config(32, 258, 258, 4096, deflate_slow)
+  /* 9 max compression */
 ];
 const lm_init = (s) => {
   s.window_size = 2 * s.w_size;
@@ -2247,6 +2316,7 @@ const CODES$1 = 0;
 const LENS$1 = 1;
 const DISTS$1 = 2;
 const lbase = new Uint16Array([
+  /* Length codes 257..285 base */
   3,
   4,
   5,
@@ -2280,6 +2350,7 @@ const lbase = new Uint16Array([
   0
 ]);
 const lext = new Uint8Array([
+  /* Length codes 257..285 extra */
   16,
   16,
   16,
@@ -2313,6 +2384,7 @@ const lext = new Uint8Array([
   78
 ]);
 const dbase = new Uint16Array([
+  /* Distance codes 0..29 base */
   1,
   2,
   3,
@@ -2347,6 +2419,7 @@ const dbase = new Uint16Array([
   0
 ]);
 const dext = new Uint8Array([
+  /* Distance codes 0..29 extra */
   16,
   16,
   16,
@@ -2799,7 +2872,10 @@ const inflate$2 = (strm, flush) => {
   const hbuf = new Uint8Array(4);
   let opts;
   let n;
-  const order = new Uint8Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+  const order = (
+    /* permutation of code lengths */
+    new Uint8Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15])
+  );
   if (!strm || !strm.state || !strm.output || !strm.input && strm.avail_in !== 0) {
     return Z_STREAM_ERROR$1;
   }
@@ -2848,7 +2924,8 @@ const inflate$2 = (strm, flush) => {
           if (state.head) {
             state.head.done = false;
           }
-          if (!(state.wrap & 1) || (((hold & 255) << 8) + (hold >> 8)) % 31) {
+          if (!(state.wrap & 1) || /* check if zlib header allowed */
+          (((hold & 255) << 8) + (hold >> 8)) % 31) {
             strm.msg = "incorrect header check";
             state.mode = BAD;
             break;
@@ -2988,8 +3065,11 @@ const inflate$2 = (strm, flush) => {
                 state.head.extra.set(
                   input.subarray(
                     next,
+                    // extra field is limited to 65536 bytes
+                    // - no need for additional size check
                     next + copy
                   ),
+                  /*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/
                   len
                 );
               }
@@ -3604,7 +3684,8 @@ const inflate$2 = (strm, flush) => {
             strm.total_out += _out;
             state.total += _out;
             if (_out) {
-              strm.adler = state.check = state.flags ? crc32_1(state.check, output, _out, put - _out) : adler32_1(state.check, output, _out, put - _out);
+              strm.adler = state.check = /*UPDATE(state.check, put - _out, _out);*/
+              state.flags ? crc32_1(state.check, output, _out, put - _out) : adler32_1(state.check, output, _out, put - _out);
             }
             _out = left;
             if ((state.flags ? hold : zswap32(hold)) !== state.check) {
@@ -3664,7 +3745,8 @@ const inflate$2 = (strm, flush) => {
   strm.total_out += _out;
   state.total += _out;
   if (state.wrap && _out) {
-    strm.adler = state.check = state.flags ? crc32_1(state.check, output, _out, strm.next_out - _out) : adler32_1(state.check, output, _out, strm.next_out - _out);
+    strm.adler = state.check = /*UPDATE(state.check, strm.next_out - _out, _out);*/
+    state.flags ? crc32_1(state.check, output, _out, strm.next_out - _out) : adler32_1(state.check, output, _out, strm.next_out - _out);
   }
   strm.data_type = state.bits + (state.last ? 64 : 0) + (state.mode === TYPE ? 128 : 0) + (state.mode === LEN_ || state.mode === COPY_ ? 256 : 0);
   if ((_in === 0 && _out === 0 || flush === Z_FINISH$1) && ret === Z_OK$1) {

package/dist/{raw.c3b45ab1.mjs → raw-f15bab0d.js}

@@ -1,5 +1,4 @@
-import { B as BaseDecoder } from "./index.75f0a489.mjs";
-import "@vitessce/vit-s";
+import { B as BaseDecoder } from "./index-ce1fad7e.js";
 import "react";
 class RawDecoder extends BaseDecoder {
   decodeBlock(buffer) {

package/dist/{webimage.53b9bf75.mjs → webimage-03150187.js}

@@ -1,5 +1,4 @@
-import { B as BaseDecoder } from "./index.75f0a489.mjs";
-import "@vitessce/vit-s";
+import { B as BaseDecoder } from "./index-ce1fad7e.js";
 import "react";
 class WebImageDecoder extends BaseDecoder {
   constructor() {

package/dist-tsc/index.d.ts

@@ -0,0 +1,2 @@
+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, isInterleaved, isRgb, getNgffAxes, getNgffAxesForTiff, coordinateTransformationsToMatrix } from "./spatial.js";
+//# sourceMappingURL=index.d.ts.map

package/dist-tsc/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":""}

package/dist-tsc/index.js

@@ -1 +1 @@
-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, isInterleaved, isRgb, } from './spatial';
+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, isInterleaved, isRgb, getNgffAxes, getNgffAxesForTiff, coordinateTransformationsToMatrix, } from './spatial.js';

package/dist-tsc/layer-controller.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Get physical size scaling Matrix4
+ * @param {Object} loader PixelSource
+ * @returns {Object} matrix
+ */
+export function getPhysicalSizeScalingMatrix(loader: Object): Object;
+/**
+ * Get bounding cube for a given loader
+ * @param {Object} loader PixelSource|PixelSource[]
+ * @returns {Array} [0, width], [0, height], [0, depth]]
+ */
+export function getBoundingCube(loader: Object): any[];
+export function abbreviateNumber(value: any): any;
+export function getSingleSelectionStats({ loader, selection, use3d }: Object): Object;
+export function getMultiSelectionStats({ loader, selections, use3d }: {
+    loader: any;
+    selections: any;
+    use3d: any;
+}): Promise<{
+    domains: any[];
+    sliders: any[];
+}>;
+//# sourceMappingURL=layer-controller.d.ts.map

package/dist-tsc/layer-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layer-controller.d.ts","sourceRoot":"","sources":["../src/layer-controller.js"],"names":[],"mappings":"AAuEA;;;;GAIG;AACH,qDAHW,MAAM,GACJ,MAAM,CAUlB;AAED;;;;GAIG;AACH,wCAHW,MAAM,SAchB;AAED,kDAwBC;AAzEM,sEALI,MAAM,GAGJ,MAAM,CAOlB;AAEM;;;;;;;GAON"}

package/dist-tsc/layer-controller.js

@@ -0,0 +1,109 @@
+import { Matrix4 } from 'math.gl';
+import { viv } from '@vitessce/gl';
+async function getSingleSelectionStats2D({ loader, selection }) {
+    const data = Array.isArray(loader) ? loader[loader.length - 1] : loader;
+    const raster = await data.getRaster({ selection });
+    const selectionStats = viv.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 = viv.getChannelStats(raster0.data);
+    const statsMid = viv.getChannelStats(rasterMid.data);
+    const statsTop = viv.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);
+}