@aics/vole-core 3.12.4

package/es/utils/num_utils.js

@@ -0,0 +1,231 @@
+import { parseTimeUnit, TimeUnit } from "../constants/time.js";
+import { Axis } from "../VolumeRenderSettings.js";
+export const DEFAULT_SIG_FIGS = 5;
+const SECONDS_IN_MS = 1000;
+const MINUTES_IN_MS = SECONDS_IN_MS * 60;
+const HOURS_IN_MS = MINUTES_IN_MS * 60;
+const DAYS_IN_MS = HOURS_IN_MS * 24;
+
+// Adapted from https://gist.github.com/ArneS/2ecfbe4a9d7072ac56c0.
+function digitToUnicodeSupercript(n) {
+  const subst = [0x2070, 185, 178, 179, 0x2074, 0x2075, 0x2076, 0x2077, 0x2078, 0x2079];
+  return String.fromCharCode(subst[n]);
+}
+
+/**
+ * Converts a number to scientific notation with the specified number of significant
+ * figures, handling negative numbers and rounding.
+ * @param input The number to convert.
+ * @param significantFigures the number of signficant figures/digits. Must be >= 1.
+ * @returns a string, formatted as a number in scientific notation.
+ * @example
+ * ```
+ * numberToSciNotation(1, 3) // "1.00×10⁰"
+ * numberToSciNotation(0.99, 2) // "9.9×10⁻¹"
+ * numberToSciNotation(0.999, 2) // "1.0×10⁰"
+ * numberToSciNotation(-0.05, 1) // "-5×10⁻²"
+ * numberToSciNotation(1400, 3) // "1.40×10³"
+ * ```
+ */
+function numberToSciNotation(input, sigFigs = DEFAULT_SIG_FIGS) {
+  const nativeExpForm = input.toExponential(sigFigs - 1);
+  const [significand, exponent] = nativeExpForm.split("e");
+  const expSign = exponent[0] === "-" ? "⁻" : "";
+  const expDigits = exponent.slice(1).split("");
+  const expSuperscript = expDigits.map(digit => digitToUnicodeSupercript(Number(digit))).join("");
+  return `${significand}×10${expSign}${expSuperscript}`;
+}
+
+/**
+ * Returns a string-encoded number rounded to a specified decimal precision, without ever formatting in scientific
+ * notation like `Number.toPrecision` might do.
+ */
+function toSigFigs(value, sigFigs) {
+  const exponent = Math.floor(Math.log10(Math.abs(value)));
+  return value.toFixed(Math.max(sigFigs - exponent - 1, 0));
+}
+
+/** Trims trailing instances of `char` off the end of `str`. */
+// This is not technically a number utility, but it's useful to `formatNumber` below.
+function trimTrailing(str, char) {
+  let i = str.length - 1;
+  while (str[i] === char) {
+    i--;
+  }
+  return str.slice(0, i + 1);
+}
+
+/**
+ * Formats numbers for display as a string with a (hopefully) limited length.
+ *
+ * - If the number is an integer with 4 or fewer digits, it is returned as a string.
+ * - If the number is a decimal, it is rounded to `sigFigs` significant figures. (default 5)
+ * - If the number's absolute value is over 10,000 or less than 0.01, it is formatted in scientific notation to
+ *   `sciSigFigs` significant figures. (Default `sigFigs - 2`, so 3 if neither are specified. The `- 2` leaves space
+ *   for the exponential part. Remember: the purpose of this function is keeping number strings *consistently* short!)
+ */
+export function formatNumber(value, sigFigs = DEFAULT_SIG_FIGS, sciSigFigs = sigFigs - 2) {
+  const valueAbs = Math.abs(value);
+  if (Number.isInteger(value)) {
+    // Format integers with 5+ digits in scientific notation
+    if (valueAbs >= 10_000) {
+      return numberToSciNotation(value, sciSigFigs);
+    }
+    // Just stringify other integers
+    return value.toString();
+  } else {
+    const numStr = toSigFigs(value, sigFigs);
+    const numRounded = Math.abs(Number(numStr));
+    if (numRounded >= 10_000 || numRounded < 0.01) {
+      return numberToSciNotation(value, sciSigFigs);
+    }
+    const trimmed = trimTrailing(numStr, "0");
+    return trimmed.endsWith(".") ? trimmed.slice(0, -1) : trimmed;
+  }
+}
+const timeUnitEnumToMilliseconds = {
+  [TimeUnit.MILLISECOND]: 1,
+  [TimeUnit.SECOND]: SECONDS_IN_MS,
+  [TimeUnit.MINUTE]: MINUTES_IN_MS,
+  [TimeUnit.HOUR]: HOURS_IN_MS,
+  [TimeUnit.DAY]: DAYS_IN_MS
+};
+export function timeToMilliseconds(time, unit) {
+  const timeUnitMultiplier = timeUnitEnumToMilliseconds[unit];
+  if (timeUnitMultiplier === undefined) {
+    throw new Error("Unrecognized time unit");
+  }
+  return time * timeUnitMultiplier;
+}
+
+/**
+ * Pads the `value` with zeroes to the specified `length` if `shouldPad` is true
+ * and returns the resulting string. Otherwise, returns the string representation of `value`.
+ */
+function padConditionally(value, length, shouldPad) {
+  return shouldPad ? value.toString().padStart(length, "0") : value.toString();
+}
+function formatTimestamp(timeMs, options) {
+  const {
+    useMs,
+    useSec,
+    useMin,
+    useHours,
+    useDays
+  } = options;
+  const digits = [];
+  const units = [];
+  if (useDays) {
+    const days = Math.floor(timeMs / DAYS_IN_MS);
+    digits.push(days.toString());
+    units.push("d");
+  }
+  if (useHours) {
+    const hours = Math.floor(timeMs % DAYS_IN_MS / HOURS_IN_MS);
+    // If the previous unit is included, pad the hours to 2 digits so the
+    // timestamp is consistent.
+    digits.push(padConditionally(hours, 2, useDays));
+    units.push("h");
+  }
+  if (useMin) {
+    const minutes = Math.floor(timeMs % HOURS_IN_MS / MINUTES_IN_MS);
+    digits.push(padConditionally(minutes, 2, useHours));
+    units.push("m");
+  }
+  if (useSec) {
+    const seconds = Math.floor(timeMs % MINUTES_IN_MS / SECONDS_IN_MS);
+    let secondString = padConditionally(seconds, 2, useMin);
+    units.push("s");
+    // If using milliseconds, add as a decimal to the seconds string.
+    if (useMs) {
+      const milliseconds = Math.floor(timeMs % SECONDS_IN_MS);
+      secondString += "." + milliseconds.toString().padStart(3, "0");
+      // Do not add milliseconds to unit label, since they'll be shown as
+      // part of the seconds string.
+    }
+    digits.push(secondString);
+  } else if (useMs) {
+    const milliseconds = Math.floor(timeMs % SECONDS_IN_MS);
+    digits.push(milliseconds.toString());
+    units.push("ms");
+  }
+  return {
+    timestamp: digits.join(":"),
+    units: units.join(":")
+  };
+}
+
+/**
+ * Gets a timestamp formatted as `{time} / {total} {unit}`. If `unit` is a recognized
+ * time unit, the timestamp will be formatted as a `d:hh:mm:ss.ms` string.
+ *
+ * @param time Current time, in specified units.
+ * @param total Total time, in specified units.
+ * @param unit The unit of time.
+ * @returns A formatted timestamp string.
+ * - If `unit` is not recognized, the timestamp will be formatted as `{time} / {total} {unit}`,
+ * where `time` and `total` are formatted with significant digits as needed.
+ * - If `unit` is recognized, the timestamp will be formatted as `d:hh:mm:ss.ms`, specifying
+ * the most significant unit based on the total time, and the least significant unit with
+ * `unit`. See `parseTimeUnit()` for recognized time units.
+ */
+export function getTimestamp(time, total, unit) {
+  const timeUnit = parseTimeUnit(unit);
+  if (timeUnit === undefined) {
+    return `${formatNumber(time)} / ${formatNumber(total)} ${unit}`;
+  }
+  const timeMs = timeToMilliseconds(time, timeUnit);
+  const totalMs = timeToMilliseconds(total, timeUnit);
+
+  // Toggle each unit based on the total time and the provided timeUnit.
+  // Exploit an enum property where TimeUnit.Milliseconds < TimeUnit.Second < TimeUnit.Minute ... etc.
+  const options = {
+    useMs: timeUnit == TimeUnit.MILLISECOND,
+    useSec: timeUnit == TimeUnit.SECOND || timeUnit <= TimeUnit.SECOND && totalMs >= SECONDS_IN_MS,
+    useMin: timeUnit == TimeUnit.MINUTE || timeUnit <= TimeUnit.MINUTE && totalMs >= MINUTES_IN_MS,
+    useHours: timeUnit == TimeUnit.HOUR || timeUnit <= TimeUnit.HOUR && totalMs >= HOURS_IN_MS,
+    useDays: timeUnit == TimeUnit.DAY || timeUnit <= TimeUnit.DAY && totalMs >= DAYS_IN_MS
+  };
+  const {
+    timestamp,
+    units
+  } = formatTimestamp(timeMs, options);
+  const {
+    timestamp: totalTimestamp
+  } = formatTimestamp(totalMs, options);
+  return `${timestamp} / ${totalTimestamp} ${units}`;
+}
+
+/**
+ * Constrains the `src` vector relative to the `target` so it only has freedom along the
+ * specified `axis`. Does nothing if `axis = Axis.NONE`.
+ *
+ * @example
+ * ```
+ *   const src = [1, 2, 3];
+ *   const target = [4, 5, 6];
+ *   const constrained = constrainToAxis(src, target, Axis.X);
+ *   console.log(constrained); // [1, 5, 6]
+ * ```
+ */
+export function constrainToAxis(src, target, axis) {
+  switch (axis) {
+    case Axis.X:
+      return [src[0], target[1], target[2]];
+    case Axis.Y:
+      return [target[0], src[1], target[2]];
+    case Axis.Z:
+      return [target[0], target[1], src[2]];
+    default:
+      return [...src];
+  }
+}
+export function getDataRange(data) {
+  let min = data[0];
+  let max = data[0];
+  for (let i = 1; i < data.length; i++) {
+    min = Math.min(min, data[i]);
+    max = Math.max(max, data[i]);
+  }
+  return [min, max];
+}

package/es/workers/FetchTiffWorker.js

@@ -0,0 +1,153 @@
+import { fromUrl } from "geotiff";
+import { serializeError } from "serialize-error";
+import { VolumeLoadError, VolumeLoadErrorType } from "../loaders/VolumeLoadError.js";
+// from TIFF
+const SAMPLEFORMAT_UINT = 1;
+const SAMPLEFORMAT_INT = 2;
+const SAMPLEFORMAT_IEEEFP = 3;
+function getDtype(sampleFormat, bytesPerPixel) {
+  if (sampleFormat === SAMPLEFORMAT_IEEEFP) {
+    if (bytesPerPixel === 4) {
+      return "float32";
+    }
+  } else if (sampleFormat === SAMPLEFORMAT_INT) {
+    if (bytesPerPixel === 1) {
+      return "int8";
+    } else if (bytesPerPixel === 2) {
+      return "int16";
+    } else if (bytesPerPixel === 4) {
+      return "int32";
+    }
+  } else if (sampleFormat === SAMPLEFORMAT_UINT) {
+    if (bytesPerPixel === 1) {
+      return "uint8";
+    } else if (bytesPerPixel === 2) {
+      return "uint16";
+    } else if (bytesPerPixel === 4) {
+      return "uint32";
+    }
+  }
+  console.error(`TIFF Worker: unsupported sample format ${sampleFormat} and bytes per pixel ${bytesPerPixel}`);
+  return "uint8";
+}
+function castToArray(buf, bytesPerPixel, sampleFormat) {
+  if (sampleFormat === SAMPLEFORMAT_IEEEFP) {
+    if (bytesPerPixel === 4) {
+      return new Float32Array(buf);
+    }
+  } else if (sampleFormat === SAMPLEFORMAT_INT) {
+    if (bytesPerPixel === 1) {
+      return new Int8Array(buf);
+    } else if (bytesPerPixel === 2) {
+      return new Int16Array(buf);
+    } else if (bytesPerPixel === 4) {
+      return new Int32Array(buf);
+    }
+  } else if (sampleFormat === SAMPLEFORMAT_UINT) {
+    if (bytesPerPixel === 1) {
+      return new Uint8Array(buf);
+    } else if (bytesPerPixel === 2) {
+      return new Uint16Array(buf);
+    } else if (bytesPerPixel === 4) {
+      return new Uint32Array(buf);
+    }
+  }
+  console.error(`TIFF Worker: unsupported sample format ${sampleFormat} and bytes per pixel ${bytesPerPixel}`);
+  return new Uint8Array(buf);
+}
+async function loadTiffChannel(e) {
+  // TODO index images by time
+  // const time = e.data.time;
+
+  const channelIndex = e.data.channel;
+  const tilesizex = e.data.tilesizex;
+  const tilesizey = e.data.tilesizey;
+  const sizez = e.data.sizez;
+  const sizec = e.data.sizec;
+  const dimensionOrder = e.data.dimensionOrder;
+  const bytesPerSample = e.data.bytesPerSample;
+  const tiff = await fromUrl(e.data.url, {
+    allowFullFile: true
+  });
+
+  // load the images of this channel from the tiff
+  // today assume TCZYX so the slices are already in order.
+  let startindex = 0;
+  let incrementz = 1;
+  if (dimensionOrder === "XYZCT") {
+    // we have XYZCT which is the "good" case
+    // TCZYX
+    startindex = sizez * channelIndex;
+    incrementz = 1;
+  } else if (dimensionOrder === "XYCZT") {
+    // we have to loop differently to increment channels
+    // TZCYX
+    startindex = channelIndex;
+    incrementz = sizec;
+  }
+
+  // huge assumption: planes are in a particular order relative to z and c
+
+  // get first plane, to get some details about the image
+  const image = await tiff.getImage(startindex);
+  // on first image, set up some stuff:
+  const sampleFormat = image.getSampleFormat();
+  const bytesPerPixel = image.getBytesPerPixel();
+  // allocate a buffer for one channel
+  const buffer = new ArrayBuffer(tilesizex * tilesizey * sizez * bytesPerPixel);
+  const u8 = new Uint8Array(buffer);
+  for (let imageIndex = startindex, zslice = 0; zslice < sizez; imageIndex += incrementz, ++zslice) {
+    const image = await tiff.getImage(imageIndex);
+    // download and downsample on client
+    const result = await image.readRasters({
+      width: tilesizex,
+      height: tilesizey
+    });
+    const arrayresult = Array.isArray(result) ? result[0] : result;
+    // deposit in full channel array in the right place
+    const offset = zslice * tilesizex * tilesizey;
+    if (arrayresult.BYTES_PER_ELEMENT > 4) {
+      throw new VolumeLoadError("byte size not supported yet: " + arrayresult.BYTES_PER_ELEMENT, {
+        type: VolumeLoadErrorType.INVALID_METADATA
+      });
+    } else if (arrayresult.BYTES_PER_ELEMENT !== bytesPerSample) {
+      throw new VolumeLoadError("tiff bytes per element mismatch with OME metadata", {
+        type: VolumeLoadErrorType.INVALID_METADATA
+      });
+    } else {
+      u8.set(new Uint8Array(arrayresult.buffer), offset * arrayresult.BYTES_PER_ELEMENT);
+    }
+  }
+  // all slices collected, now resample to 8 bits full data range
+  const src = castToArray(buffer, bytesPerPixel, sampleFormat);
+  const dtype = getDtype(sampleFormat, bytesPerPixel);
+  let chmin = src[0];
+  let chmax = src[0];
+  for (let j = 0; j < src.length; ++j) {
+    const val = src[j];
+    if (val < chmin) {
+      chmin = val;
+    }
+    if (val > chmax) {
+      chmax = val;
+    }
+  }
+  return {
+    data: src,
+    channel: channelIndex,
+    range: [chmin, chmax],
+    dtype: dtype,
+    isError: false
+  };
+}
+self.onmessage = async e => {
+  try {
+    const result = await loadTiffChannel(e);
+    self.postMessage(result, [result.data.buffer]);
+  } catch (err) {
+    self.postMessage({
+      isError: true,
+      error: serializeError(err)
+    });
+  }
+};

package/es/workers/VolumeLoadWorker.js

@@ -0,0 +1,129 @@
+import { serializeError } from "serialize-error";
+import VolumeCache from "../VolumeCache.js";
+import { VolumeFileFormat, createVolumeLoader, pathToFileType } from "../loaders/index.js";
+import { VolumeLoadError } from "../loaders/VolumeLoadError.js";
+import RequestQueue from "../utils/RequestQueue.js";
+import SubscribableRequestQueue from "../utils/SubscribableRequestQueue.js";
+import { WorkerEventType, WorkerMsgType, WorkerResponseResult } from "./types.js";
+import { rebuildLoadSpec } from "./util.js";
+let cache = undefined;
+let queue = undefined;
+let subscribableQueue = undefined;
+let loader = undefined;
+let initialized = false;
+let copyOnLoad = false;
+const messageHandlers = {
+  [WorkerMsgType.INIT]: ({
+    maxCacheSize,
+    maxActiveRequests,
+    maxLowPriorityRequests
+  }) => {
+    if (!initialized) {
+      cache = new VolumeCache(maxCacheSize);
+      queue = new RequestQueue(maxActiveRequests, maxLowPriorityRequests);
+      subscribableQueue = new SubscribableRequestQueue(queue);
+      initialized = true;
+    }
+    return Promise.resolve();
+  },
+  [WorkerMsgType.CREATE_LOADER]: async ({
+    path,
+    options
+  }) => {
+    const pathString = Array.isArray(path) ? path[0] : path;
+    const fileType = options?.fileType || pathToFileType(pathString);
+    copyOnLoad = fileType === VolumeFileFormat.JSON;
+    loader = await createVolumeLoader(path, {
+      ...options,
+      cache,
+      queue: subscribableQueue
+    });
+    return loader !== undefined;
+  },
+  [WorkerMsgType.CREATE_VOLUME]: async loadSpec => {
+    if (loader === undefined) {
+      throw new VolumeLoadError("No loader created");
+    }
+    return await loader.createImageInfo(rebuildLoadSpec(loadSpec));
+  },
+  [WorkerMsgType.LOAD_DIMS]: async loadSpec => {
+    if (loader === undefined) {
+      throw new VolumeLoadError("No loader created");
+    }
+    return await loader.loadDims(rebuildLoadSpec(loadSpec));
+  },
+  [WorkerMsgType.LOAD_VOLUME_DATA]: ({
+    imageInfo,
+    loadSpec,
+    loaderId,
+    loadId
+  }) => {
+    if (loader === undefined) {
+      throw new VolumeLoadError("No loader created");
+    }
+    return loader.loadRawChannelData(imageInfo, rebuildLoadSpec(loadSpec), (imageInfo, loadSpec) => {
+      const message = {
+        responseResult: WorkerResponseResult.EVENT,
+        eventType: WorkerEventType.METADATA_UPDATE,
+        loaderId,
+        loadId,
+        imageInfo,
+        loadSpec
+      };
+      self.postMessage(message);
+    }, (channelIndex, dtype, data, ranges, atlasDims) => {
+      const message = {
+        responseResult: WorkerResponseResult.EVENT,
+        eventType: WorkerEventType.CHANNEL_LOAD,
+        loaderId,
+        loadId,
+        channelIndex,
+        dtype,
+        data,
+        ranges,
+        atlasDims
+      };
+      self.postMessage(message, copyOnLoad ? [] : data.map(d => d.buffer));
+    });
+  },
+  [WorkerMsgType.SET_PREFETCH_PRIORITY_DIRECTIONS]: directions => {
+    // Silently does nothing if the loader isn't an `OMEZarrLoader`
+    loader?.setPrefetchPriority(directions);
+    return Promise.resolve();
+  },
+  [WorkerMsgType.SYNCHRONIZE_MULTICHANNEL_LOADING]: syncChannels => {
+    loader?.syncMultichannelLoading(syncChannels);
+    return Promise.resolve();
+  },
+  [WorkerMsgType.UPDATE_FETCH_OPTIONS]: fetchOptions => {
+    loader?.updateFetchOptions(fetchOptions);
+    return Promise.resolve();
+  }
+};
+self.onmessage = async ({
+  data
+}) => {
+  const {
+    msgId,
+    type,
+    payload
+  } = data;
+  let message;
+  try {
+    const response = await messageHandlers[type](payload);
+    message = {
+      responseResult: WorkerResponseResult.SUCCESS,
+      msgId,
+      type,
+      payload: response
+    };
+  } catch (e) {
+    message = {
+      responseResult: WorkerResponseResult.ERROR,
+      msgId,
+      type,
+      payload: serializeError(e)
+    };
+  }
+  self.postMessage(message);
+};