@aics/vole-core 3.15.6 → 4.0.0

package/es/ContourPass.js

@@ -1,8 +1,8 @@
 import { Color, DataTexture, FloatType, RedIntegerFormat, RGBAFormat, Uniform, UnsignedIntType } from "three";
-import RenderToBuffer, { RenderPassType } from "./RenderToBuffer";
+import { clamp } from "three/src/math/MathUtils.js";
+import RenderToBuffer, { RenderPassType } from "./RenderToBuffer.js";
 /* babel-plugin-inline-import './constants/shaders/contour.frag' */
 const contourFragShader = "precision highp float;\nprecision highp int;\nprecision highp usampler2D;\nprecision highp sampler3D;\n\n/**\n * LUT mapping from the segmentation ID (raw pixel value) to the\n * global ID (index in data buffers like `featureData` and `outlierData`).\n * \n * For a given local pixel ID `localId`, the global ID is given by:\n * `localIdToGlobalId[localId - localIdOffset] - 1`.\n*/\nuniform usampler2D localIdToGlobalId;\nuniform uint localIdOffset;\nuniform bool useGlobalIdLookup;\n/* Pick buffer. Used to determine IDs. */\nuniform sampler2D pickBuffer;\n\nuniform int highlightedId;\nuniform int outlineThickness;\nuniform float outlineAlpha;\nuniform vec3 outlineColor;\nuniform float devicePixelRatio;\n\nconst uint BACKGROUND_ID = 0u;\nconst uint MISSING_DATA_ID = 0xFFFFFFFFu;\nconst int ID_OFFSET = 1;\n\nuvec4 getUintFromTex(usampler2D tex, int index) {\n  int width = textureSize(tex, 0).x;\n  ivec2 featurePos = ivec2(index % width, index / width);\n  return uvec4(texelFetch(tex, featurePos, 0));\n}\n\nuint getId(ivec2 uv) {\n  float rawId = texelFetch(pickBuffer, uv, 0).g;\n  if (rawId == 0.0) {\n    return BACKGROUND_ID;\n  }\n  int localId = int(rawId) - int(localIdOffset);\n  if (!useGlobalIdLookup) {\n    return uint(localId + ID_OFFSET);\n  }\n  uvec4 c = getUintFromTex(localIdToGlobalId, localId);\n  // Note: IDs are offset by `ID_OFFSET` (`=1`) to reserve `0` for local IDs\n  // that don't have associated data in the global lookup. `ID_OFFSET` MUST be\n  // subtracted from the ID when accessing data buffers.\n  uint globalId = c.r;\n  if (globalId == 0u) {\n    return MISSING_DATA_ID;\n  }\n  return globalId;\n}\n\nbool isEdge(ivec2 uv, int id, int thickness) {\n  float wStep = 1.0;\n  float hStep = 1.0;\n  float thicknessFloat = float(thickness);\n  // sample around the pixel to see if we are on an edge\n  int R = int(getId(uv + ivec2(thicknessFloat * wStep, 0))) - ID_OFFSET;\n  int L = int(getId(uv + ivec2(-thicknessFloat * wStep, 0))) - ID_OFFSET;\n  int T = int(getId(uv + ivec2(0, thicknessFloat * hStep))) - ID_OFFSET;\n  int B = int(getId(uv + ivec2(0, -thicknessFloat * hStep))) - ID_OFFSET;\n  // if any neighbors are not id then this is an edge\n  return id != -1 && (R != id || L != id || T != id || B != id);\n}\n\nvoid main(void) {\n  ivec2 vUv = ivec2(int(gl_FragCoord.x / devicePixelRatio), int(gl_FragCoord.y / devicePixelRatio));\n\n  uint rawId = getId(vUv);\n  int id = int(rawId) - ID_OFFSET;\n\n  if (id == highlightedId && isEdge(vUv, id, outlineThickness)) {\n    gl_FragColor = vec4(outlineColor, outlineAlpha);\n  } else {\n    gl_FragColor = vec4(0, 0, 0, 0.0);\n  }\n}";
-import { clamp } from "three/src/math/MathUtils";
 const makeDefaultUniforms = () => {
   const pickBufferTex = new DataTexture(new Float32Array([1, 0, 0, 0]), 1, 1, RGBAFormat, FloatType);
   const localIdToGlobalId = new DataTexture(new Uint32Array([0]), 1, 1, RedIntegerFormat, UnsignedIntType);

package/es/Histogram.js

@@ -1,3 +1,4 @@
+import { isFloatTypeArray } from "./types.js";
 const NBINS = 256;
 /**
  * Builds a histogram with 256 bins from a data array. Assume data is 8 bit single channel grayscale.
@@ -59,20 +60,38 @@ export default class Histogram {
       }
     }
   }
-
-  // return the bin index of the given data value
-  static findBin(dataValue, dataMin, binSize, numBins) {
-    let binIndex = Math.floor((dataValue - dataMin) / binSize);
-    // for values that lie exactly on last bin we need to subtract one
-    if (binIndex === numBins) {
-      binIndex--;
+  static findBin(dataValue, dataMin, binSize, castToInt) {
+    const binIndex = (dataValue - dataMin) / binSize;
+    if (!castToInt) {
+      return binIndex;
     }
-    return binIndex;
+    return Math.max(Math.min(Math.floor(binIndex), NBINS - 1), 0);
   }
 
-  // return the bin index of the given data value
+  /**
+   * Returns the integer bin index for the given value. If a value is outside
+   * the histogram range, it will be clamped to the nearest bin.
+   */
   findBinOfValue(value) {
-    return Histogram.findBin(value, this.min, this.binSize, NBINS);
+    return Histogram.findBin(value, this.min, this.binSize, true);
+  }
+
+  /**
+   * Returns a fractional bin index for the given value. If a value is not a bin
+   * boundary, returns an interpolated index. Note that this can return a value
+   * outside the range of valid bins.
+   */
+  findFractionalBinOfValue(value) {
+    return Histogram.findBin(value, this.min, this.binSize, false);
+  }
+
+  /**
+   * Returns an absolute data value from a given (integer or fractional) bin index.
+   * Note that, if the bin index is outside of the bin range, the returned value
+   * will also be outside the value range.
+   */
+  getValueFromBinIndex(binIndex) {
+    return this.min + binIndex * this.binSize;
   }
 
   /**
@@ -234,10 +253,34 @@ export default class Histogram {
       }
     }
     const bins = new Uint32Array(numBins).fill(0);
-    const binSize = (max - min) / numBins === 0 ? 1 : (max - min) / numBins;
+
+    // Bins should have equal widths and span the data min to the data max. The
+    // handling of the max value is slightly different between integers and
+    // floats; in the float case, the last bin should have `max` as its
+    // inclusive upper bound, while in the integer case, the last bin should
+    // have an exclusive upper bound of `max + 1`.
+    //
+    // For example, let's say we have a data range of `[min=0, max=3]` and 4
+    // bins.
+    //
+    // If this is integer data, we want each bin to have ranges [0, 1), [1, 2),
+    // [2, 3), [3, 4), and a bin size of 1.
+    //
+    // |----|----|----|----|
+    // 0    1    2    3    4 <- exclusive
+    //
+    // For continuous (float) data, our bins should have ranges [0, 0.75),
+    // [0.75, 1.5), [1.5, 2.25), [2.25, 3] and a bin size of 0.75.
+    //
+    // |----|----|----|----|
+    // 0  0.75  1.5  2.25  3 <- inclusive
+    //
+
+    const binMax = isFloatTypeArray(arr) ? max : max + 1;
+    const binSize = binMax <= min ? 1 : (binMax - min) / numBins;
     for (let i = 0; i < arr.length; i++) {
       const item = arr[i];
-      const binIndex = Histogram.findBin(item, min, binSize, numBins);
+      const binIndex = Histogram.findBin(item, min, binSize, true);
       bins[binIndex]++;
     }
     return {

package/es/Line3d.js

@@ -1,8 +1,8 @@
 import { Group, Vector3 } from "three";
-import { LineMaterial } from "three/addons/lines/LineMaterial";
-import { MESH_NO_PICK_OCCLUSION_LAYER, OVERLAY_LAYER } from "./ThreeJsPanel";
-import { LineSegments2 } from "three/addons/lines/LineSegments2";
-import { LineSegmentsGeometry } from "three/addons/lines/LineSegmentsGeometry";
+import { LineMaterial } from "three/addons/lines/LineMaterial.js";
+import { LineSegments2 } from "three/addons/lines/LineSegments2.js";
+import { LineSegmentsGeometry } from "three/addons/lines/LineSegmentsGeometry.js";
+import { MESH_NO_PICK_OCCLUSION_LAYER, OVERLAY_LAYER } from "./ThreeJsPanel.js";
 const DEFAULT_VERTEX_BUFFER_SIZE = 1020;
 
 /**

package/es/loaders/TiffLoader.js

@@ -11,15 +11,16 @@ function prepareXML(xml) {
   return xml.trim().replace(expr, "").trim();
 }
 function getOME(xml) {
+  if (xml === undefined) {
+    return undefined;
+  }
+  const prepared = prepareXML(xml);
   const parser = new DOMParser();
   try {
-    const xmlDoc = parser.parseFromString(xml, "text/xml");
+    const xmlDoc = parser.parseFromString(prepared, "text/xml");
     return xmlDoc.getElementsByTagName("OME")[0];
   } catch (e) {
-    throw new VolumeLoadError("Could not find OME metadata in TIFF file", {
-      type: VolumeLoadErrorType.INVALID_METADATA,
-      cause: e
-    });
+    return undefined;
   }
 }
 class OMEDims {
@@ -85,6 +86,7 @@ function getOMEDims(imageEl) {
   return dims;
 }
 const getBytesPerSample = type => type === "uint8" ? 1 : type === "uint16" ? 2 : 4;
+const getPixelType = pxSize => pxSize === 1 ? "uint8" : pxSize === 2 ? "uint16" : "uint32";
 
 // Despite the class `TiffLoader` extends, this loader is not threadable, since geotiff internally uses features that
 // aren't available on workers. It uses its own specialized workers anyways.
@@ -95,17 +97,32 @@ class TiffLoader extends ThreadableVolumeLoader {
   }
   async loadOmeDims() {
     if (!this.dims) {
-      const tiff = await fromUrl(this.url, {
+      const tiff = await fromUrl(this.url[0], {
         allowFullFile: true
-      }).catch(wrapVolumeLoadError(`Could not open TIFF file at ${this.url}`, VolumeLoadErrorType.NOT_FOUND));
+      }).catch(wrapVolumeLoadError(`Could not open TIFF file at ${this.url[0]}`, VolumeLoadErrorType.NOT_FOUND));
       // DO NOT DO THIS, ITS SLOW
       // const imagecount = await tiff.getImageCount();
       // read the FIRST image
       const image = await tiff.getImage().catch(wrapVolumeLoadError("Failed to open TIFF image", VolumeLoadErrorType.NOT_FOUND));
-      const tiffimgdesc = prepareXML(image.getFileDirectory().ImageDescription);
-      const omeEl = getOME(tiffimgdesc);
-      const image0El = omeEl.getElementsByTagName("Image")[0];
-      this.dims = getOMEDims(image0El);
+      const omeEl = getOME(image.getFileDirectory().ImageDescription);
+      if (omeEl !== undefined) {
+        const image0El = omeEl.getElementsByTagName("Image")[0];
+        this.dims = getOMEDims(image0El);
+      } else {
+        console.warn("Could not read OME-TIFF metadata from file. Doing our best with base TIFF metadata.");
+        this.dims = new OMEDims();
+        this.dims.sizex = image.getWidth();
+        this.dims.sizey = image.getHeight();
+        // TODO this is a big hack/assumption about only loading multi-source tiffs that are not OMETIFF.
+        // We really have to check each url in the array for sizec to get the total number of channels
+        // See combinedNumChannels in ImageInfo below.
+        // Also compare with how OMEZarrLoader does this.
+        this.dims.sizec = this.url.length > 1 ? this.url.length : 1; // if multiple urls, assume one channel per url
+        this.dims.pixeltype = getPixelType(image.getBytesPerPixel());
+        this.dims.channelnames = Array.from({
+          length: this.dims.sizec
+        }, (_, i) => "Channel" + i);
+      }
     }
     return this.dims;
   }
@@ -189,7 +206,7 @@ class TiffLoader extends ThreadableVolumeLoader {
           sizez: volumeSize.z,
           dimensionOrder: dims.dimensionorder,
           bytesPerSample: getBytesPerSample(dims.pixeltype),
-          url: this.url
+          url: this.url.length > 1 ? this.url[channel] : this.url[0] // if multiple urls, use the channel index to select the right one
         };
         const worker = new Worker(new URL("../workers/FetchTiffWorker", import.meta.url), {
           type: "module"

package/es/loaders/index.js

@@ -24,13 +24,14 @@ export function pathToFileType(path) {
 export async function createVolumeLoader(path, options) {
   const pathString = Array.isArray(path) ? path[0] : path;
   const fileType = options?.fileType || pathToFileType(pathString);
+  const pathArrayForTiffLoader = Array.isArray(path) ? path : [path];
   switch (fileType) {
     case VolumeFileFormat.ZARR:
       return await OMEZarrLoader.createLoader(path, options?.scene, options?.cache, options?.queue, options?.fetchOptions);
     case VolumeFileFormat.JSON:
       return new JsonImageInfoLoader(path, options?.cache);
     case VolumeFileFormat.TIFF:
-      return new TiffLoader(pathString);
+      return new TiffLoader(pathArrayForTiffLoader);
     case VolumeFileFormat.DATA:
       if (!options?.rawArrayOptions) {
         throw new Error("Must provide RawArrayOptions for RawArrayLoader");

package/es/types/ContourPass.d.ts

@@ -1,5 +1,5 @@
 import { Color, WebGLRenderer, WebGLRenderTarget } from "three";
-import { ColorizeFeature } from "./types";
+import { ColorizeFeature } from "./types.js";
 export default class ContourPass {
     private pass;
     private frameToGlobalIdLookup;

package/es/types/Histogram.d.ts

@@ -1,4 +1,4 @@
-import type { TypedArray, NumberType } from "./types.js";
+import { type TypedArray, type NumberType } from "./types.js";
 /**
  * Builds a histogram with 256 bins from a data array. Assume data is 8 bit single channel grayscale.
  * @class
@@ -19,8 +19,24 @@ export default class Histogram {
     private pixelCount;
     maxBin: number;
     constructor(data: TypedArray<NumberType>);
-    static findBin(dataValue: number, dataMin: number, binSize: number, numBins: number): number;
+    private static findBin;
+    /**
+     * Returns the integer bin index for the given value. If a value is outside
+     * the histogram range, it will be clamped to the nearest bin.
+     */
     findBinOfValue(value: number): number;
+    /**
+     * Returns a fractional bin index for the given value. If a value is not a bin
+     * boundary, returns an interpolated index. Note that this can return a value
+     * outside the range of valid bins.
+     */
+    findFractionalBinOfValue(value: number): number;
+    /**
+     * Returns an absolute data value from a given (integer or fractional) bin index.
+     * Note that, if the bin index is outside of the bin range, the returned value
+     * will also be outside the value range.
+     */
+    getValueFromBinIndex(binIndex: number): number;
     /**
      * Return the min data value
      * @return {number}

package/es/types/Line3d.d.ts

@@ -1,5 +1,5 @@
 import { Color, Euler, Group, Vector3 } from "three";
-import { IDrawableObject } from "./types";
+import { IDrawableObject } from "./types.js";
 /**
  * Simple wrapper for a 3D line segments object, with controls for vertex data,
  * color, width, and segments visible.

package/es/types/loaders/TiffLoader.d.ts

@@ -34,9 +34,9 @@ export type TiffLoadResult = {
     range: [number, number];
 };
 declare class TiffLoader extends ThreadableVolumeLoader {
-    url: string;
+    url: string[];
     dims?: OMEDims;
-    constructor(url: string);
+    constructor(url: string[]);
     private loadOmeDims;
     loadDims(_loadSpec: LoadSpec): Promise<VolumeDims[]>;
     createImageInfo(_loadSpec: LoadSpec): Promise<LoadedVolumeInfo>;

package/es/types/types.d.ts

@@ -27,6 +27,7 @@ export declare const ARRAY_CONSTRUCTORS: {
     float32: Float32ArrayConstructor;
     float64: Float64ArrayConstructor;
 };
+export declare function isFloatTypeArray(array: TypedArray<NumberType>): array is Float32Array | Float64Array;
 export interface ColorizeFeature {
     idsToFeatureValue: DataTexture;
     featureValueToColor: DataTexture;

package/es/types.js

@@ -13,6 +13,9 @@ export const ARRAY_CONSTRUCTORS = {
   float32: Float32Array,
   float64: Float64Array
 };
+export function isFloatTypeArray(array) {
+  return array instanceof Float32Array || array instanceof Float64Array;
+}
 /** If `FuseChannel.rgbColor` is this value, it is disabled from fusion. */
 export const FUSE_DISABLED_RGB_COLOR = 0;
 

package/es/workers/VolumeLoaderContext.js

@@ -164,7 +164,9 @@ class VolumeLoaderContext {
     const pathString = Array.isArray(path) ? path[0] : path;
     const fileType = options?.fileType || pathToFileType(pathString);
     if (fileType === VolumeFileFormat.TIFF) {
-      return new TiffLoader(pathString);
+      // tiff loader accepts array of paths for separate channel sources
+      const pathArray = Array.isArray(path) ? path : [path];
+      return new TiffLoader(pathArray);
     } else if (fileType === VolumeFileFormat.DATA) {
       if (!options?.rawArrayOptions) {
         throw new Error("Failed to create loader: Must provide RawArrayOptions for RawArrayLoader");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aics/vole-core",
-  "version": "3.15.6",
+  "version": "4.0.0",
   "description": "volume renderer for 3d, 4d, or 5d imaging data with OME-Zarr support",
   "main": "es/index.js",
   "type": "module",