Implement decodeStack (#422)

* feat(stack): decode stack from tiff

Closes: #421

* chore: run prettier

* fix: export decodeStack

src/load/decodeTiff.ts

@@ -14,15 +14,15 @@ type TiffIfd = ReturnType<typeof decode>[number];
 export function decodeTiff(buffer: Uint8Array): Image {
   const result = decode(buffer);
   return getImageFromIFD(result[0]);
-  // TODO: handle stacks (many IFDs)
+  // TODO: optimize not to decode whole file
 }
 
 /**
  * Create image from a single IFD.
  * @param ifd - The IFD.
  * @returns The decoded image.
  */
-function getImageFromIFD(ifd: TiffIfd): Image {
+export function getImageFromIFD(ifd: TiffIfd): Image {
   if (ifd.type === 3) {
     // Palette
     const data = new Uint16Array(3 * ifd.width * ifd.height);

src/stack/index.ts

@@ -0,0 +1,7 @@
+export * from './compute/histogram';
+export * from './compute/maxImage';
+export * from './compute/meanImage';
+export * from './compute/medianImage';
+export * from './load/decodeStack';
+export * from './compute/minImage';
+export * from './compute/sum';

src/stack/load/__tests__/decodeStack.test.ts

@@ -0,0 +1,42 @@
+import { TestImagePath } from '../../../../test/TestImagePath';
+import { decodeStack } from '../decodeStack';
+
+test.each([
+  {
+    name: 'formats/tif/grey8-multi.tif',
+    colorModel: 'GREY',
+    bitDepth: 8,
+    pages: 2,
+  },
+  {
+    name: 'formats/tif/grey16-multi.tif',
+    colorModel: 'GREY',
+    bitDepth: 16,
+    pages: 2,
+  },
+  {
+    name: 'formats/tif/color8-multi.tif',
+    colorModel: 'RGB',
+    bitDepth: 8,
+    pages: 2,
+  },
+  {
+    name: 'formats/tif/color16-multi.tif',
+    colorModel: 'RGB',
+    bitDepth: 16,
+    pages: 2,
+  },
+])('stacks with 2 images ($colorModel, bitDepth = $bitDepth)', (data) => {
+  const buffer = testUtils.loadBuffer(data.name as TestImagePath);
+  const stack = decodeStack(buffer);
+  expect(stack.size).toBe(data.pages);
+  for (const image of stack) {
+    expect(image.colorModel).toBe(data.colorModel);
+    expect(image.bitDepth).toBe(data.bitDepth);
+  }
+});
+
+test('invalid data format', () => {
+  const buffer = testUtils.loadBuffer('formats/grey8.png');
+  expect(() => decodeStack(buffer)).toThrow('invalid data format: image/png');
+});

src/stack/load/decodeStack.ts

@@ -0,0 +1,26 @@
+import imageType from 'image-type';
+
+import { Stack } from '../../Stack';
+
+import { decodeStackFromTiff } from './decodeTiff';
+
+/**
+ * Decode input data and create stack. Data format is automatically detected.
+ * Possible formats: tiff.
+ * @param data - Data to decode.
+ * @returns The decoded image.
+ */
+export function decodeStack(data: ArrayBufferView): Stack {
+  const typedArray = new Uint8Array(
+    data.buffer,
+    data.byteOffset,
+    data.byteLength,
+  );
+  const type = imageType(typedArray);
+  switch (type?.mime) {
+    case 'image/tiff':
+      return decodeStackFromTiff(typedArray);
+    default:
+      throw new RangeError(`invalid data format: ${type?.mime}`);
+  }
+}

src/stack/load/decodeTiff.ts

@@ -0,0 +1,19 @@
+import { decode } from 'tiff';
+
+import { Stack } from '../../Stack';
+import { getImageFromIFD } from '../../load/decodeTiff';
+
+/**
+ * Decode a TIFF and create a stack of images.
+ * @param buffer - The data to decode.
+ * @returns The stack of images.
+ */
+export function decodeStackFromTiff(buffer: Uint8Array): Stack {
+  const decoded = decode(buffer);
+  const images = [];
+  for (const IFD of decoded) {
+    images.push(getImageFromIFD(IFD));
+  }
+
+  return new Stack(images);
+}

test/TestImagePath.ts

@@ -21,6 +21,10 @@ export type TestImagePath =
   | 'formats/tif/greya32.tif'
   | 'formats/tif/rgb16.tif'
   | 'formats/tif/rgba8.tif'
+  | 'formats/tif/grey8-multi.tif'
+  | 'formats/tif/grey16-multi.tif'
+  | 'formats/tif/rgb16-multi.tif'
+  | 'formats/tif/rgba8-multi.tif'
   | 'formats/tif/palette.tif'
   | 'opencv/test.png'
   | 'opencv/testBlur.png'