image-js 1.0.0 → 1.1.0

package/src/maskAnalysis/utils/monotoneChainConvexHull.ts

@@ -21,7 +21,8 @@ export function monotoneChainConvexHull(
 ): Point[] {
   const { sorted = false } = options;
   if (!sorted) {
-    points = points.slice().sort(byXThenY);
+    points = points.slice();
+    points.sort(byXThenY);
   }
 
   const n = points.length;

package/src/save/encodeBmp.ts

@@ -1,24 +1,31 @@
 import * as bmp from 'fast-bmp';
 
-import type { Image } from '../Image.js';
-import { Mask } from '../Mask.js';
+import { Image } from '../Image.js';
+import type { Mask } from '../Mask.js';
 
 /**
  * Creates a BMP buffer from a mask.
- * @param mask - The mask instance.
+ * @param image - The mask instance.
  * @returns The buffer.
  */
-export function encodeBmp(mask: Image | Mask) {
-  if (!(mask instanceof Mask)) {
-    throw new TypeError('Image bmp encoding is not implemented.');
+export function encodeBmp(image: Image | Mask) {
+  if (image instanceof Image) {
+    return bmp.encode({
+      width: image.width,
+      height: image.height,
+      components: image.components,
+      bitsPerPixel: image.channels * image.bitDepth,
+      channels: image.channels,
+      data: image.getRawImage().data,
+    });
+  } else {
+    return bmp.encode({
+      width: image.width,
+      height: image.height,
+      components: 1,
+      bitsPerPixel: 1,
+      channels: 1,
+      data: image.getRawImage().data,
+    });
   }
-  const imageData = mask.getRawImage();
-  return bmp.encode({
-    width: imageData.width,
-    height: imageData.height,
-    components: 1,
-    bitsPerPixel: 1,
-    channels: 1,
-    data: imageData.data,
-  });
 }

package/src/stack/load/decodeApng.ts

@@ -0,0 +1,71 @@
+import type { IndexedColors } from 'fast-png';
+import { decodeApng } from 'fast-png';
+
+import { Image } from '../../Image.ts';
+import { Stack } from '../../Stack.ts';
+import type { ImageColorModel } from '../../utils/constants/colorModels.ts';
+
+/**
+ * Decodes APNG image into a Stack
+ * @param data - APNG data.
+ * @returns stack of frames.
+ */
+export function decodeStackFromApng(data: Uint8Array) {
+  const decodedApng = decodeApng(data);
+  const images: Image[] = [];
+  let colorModel: ImageColorModel;
+  switch (decodedApng.channels) {
+    case 1:
+      if (decodedApng.palette) {
+        colorModel = decodedApng.palette[0].length === 3 ? 'RGB' : 'RGBA';
+      } else {
+        colorModel = 'GREY';
+      }
+      break;
+    case 2:
+      colorModel = 'GREYA';
+      break;
+    case 3:
+      colorModel = 'RGB';
+      break;
+    default:
+      colorModel = 'RGBA';
+      break;
+  }
+  if (decodedApng.palette) {
+    for (const image of decodedApng.frames) {
+      images.push(
+        new Image(decodedApng.width, decodedApng.height, {
+          data: convertIndexedData(
+            image.data as Uint8Array,
+            decodedApng.palette,
+          ),
+          colorModel,
+        }),
+      );
+    }
+  } else {
+    for (const image of decodedApng.frames) {
+      images.push(
+        new Image(decodedApng.width, decodedApng.height, {
+          data: image.data,
+          colorModel,
+        }),
+      );
+    }
+  }
+
+  const stack = new Stack(images);
+
+  return stack;
+}
+
+function convertIndexedData(data: Uint8Array, palette: IndexedColors) {
+  const result = new Uint8Array(data.length * palette[0].length);
+  for (let i = 0; i < data.length; i++) {
+    for (let channel = 0; channel < palette[0].length; channel++) {
+      result[i * palette[0].length + channel] = palette[data[i]][channel];
+    }
+  }
+  return result;
+}

package/src/stack/load/decodeStack.ts

@@ -3,6 +3,7 @@ import { match } from 'ts-pattern';
 
 import type { Stack } from '../../Stack.js';
 
+import { decodeStackFromApng } from './decodeApng.ts';
 import { decodeStackFromTiff } from './decodeTiff.js';
 
 /**
@@ -20,6 +21,7 @@ export function decodeStack(data: ArrayBufferView): Stack {
   const type = imageType(typedArray);
   return match(type)
     .with({ mime: 'image/tiff' }, () => decodeStackFromTiff(typedArray))
+    .with({ mime: 'image/png' }, () => decodeStackFromApng(typedArray))
     .otherwise(() => {
       throw new RangeError(`invalid data format: ${type?.mime}`);
     });

package/src/utils/geometry/points.ts

@@ -94,9 +94,11 @@ export function round(point: Point): Point {
  * @returns Sorted points.
  */
 export function sortByColumnRow(points: Point[]): Point[] {
-  return points.slice().sort((point1, point2) => {
+  const sortedPoints = points.slice();
+  sortedPoints.sort((point1, point2) => {
     if (point1.column < point2.column) return -1;
     if (point1.column > point2.column) return 1;
     return point1.row - point2.row;
   });
+  return sortedPoints;
 }

package/src/utils/geometry/removeClosePoints.ts

@@ -42,7 +42,8 @@ export function removeClosePoints(
   const channel = options?.channel || 0;
   const isMax = kind === 'maximum';
 
-  const sortedPoints = points.slice().sort(getSort(image, channel, isMax));
+  const sortedPoints = points.slice();
+  sortedPoints.sort(getSort(image, channel, isMax));
 
   if (distance > 0) {
     for (let i = 0; i < sortedPoints.length; i++) {