Added quantize to MagickImageCollection.

src/magick-image-collection.ts

@@ -18,6 +18,7 @@ import { IMagickImage } from './magick-image';
 import { IntPointer } from './internal/pointer/int-pointer';
 import { LayerMethod } from './enums/layer-method';
 import { MagickError } from './magick-error';
+import { MagickErrorInfo } from './types/magick-error-info';
 import { MagickFormat } from './enums/magick-format';
 import { MagickImage } from './magick-image';
 import { MagickReadSettings } from './settings/magick-read-settings';
@@ -281,6 +282,11 @@ export interface IMagickImageCollection extends Array<IMagickImage>, IDisposable
      */
     polynomial<TReturnType>(terms: number[], func: AsyncImageCallback<TReturnType>): TReturnType | Promise<TReturnType>;
 
+    /**
+     *  Quantize images (reduce number of colors).
+     */
+    quantize(settings?: QuantizeSettings): MagickErrorInfo | null;
+
     /**
      * Read all image frames.
      * @param fileName - The fully qualified name of the image file, or the relative image file name.
@@ -548,6 +554,24 @@ export class MagickImageCollection extends Array<MagickImage> implements IMagick
         }, func);
     }
 
+    quantize(settingsOrUndefined?: QuantizeSettings): MagickErrorInfo | null {
+        this.throwIfEmpty();
+        const settings = settingsOrUndefined === undefined ? new QuantizeSettings() : settingsOrUndefined;
+
+        this.attachImages(instance => {
+            settings._use(nativeSettings => {
+                Exception.usePointer(exception => {
+                    ImageMagick._api._MagickImageCollection_Quantize(instance, nativeSettings._instance, exception);
+                });
+            });
+        });
+
+        if (settings.measureErrors)
+            return MagickErrorInfo._create(this[0]);
+
+        return null;
+    }
+
     read(fileName: string, settings?: MagickReadSettings): void;
     read(array: ByteArray, settings?: MagickReadSettings): void;
     read(fileNameOrArray: string | ByteArray, settings?: MagickReadSettings): void {

tests/magick-image-collection/quantize.spec.ts

@@ -0,0 +1,46 @@
+/*
+  Copyright Dirk Lemstra https://github.com/dlemstra/magick-wasm.
+  Licensed under the Apache License, Version 2.0.
+*/
+
+import { ErrorMetric } from '@src/enums/error-metric';
+import { QuantizeSettings } from '@src/settings/quantize-settings';
+import { TestImages } from '@test/test-images';
+
+describe('MagickImageCollection#flatten', () => {
+    it('should throw exception when collection is empty', () => {
+        TestImages.emptyCollection.use((images) => {
+            expect(() => {
+                images.quantize();
+            }).toThrowError('operation requires at least one image');
+        });
+    });
+
+    it('should return null when measureErrors is not true', () => {
+        TestImages.roseSparkleGif.use(images => {
+            const result = images.quantize();
+
+            expect(result).toBeNull();
+        });
+    });
+
+    it('should quantize the images', () => {
+        TestImages.roseSparkleGif.use(images => {
+            const settings = new QuantizeSettings
+            {
+                settings.colors = 3;
+                settings.measureErrors = true;
+            };
+
+            const result = images.quantize(settings);
+
+            expect(result).not.toBeNull();
+
+            TestImages.roseSparkleGif.use(original => {
+                expect(images[0].compare(original[0], ErrorMetric.RootMeanSquared)).toBeCloseTo(0.18152);
+                expect(images[1].compare(original[1], ErrorMetric.RootMeanSquared)).toBeCloseTo(0.14315);
+                expect(images[2].compare(original[2], ErrorMetric.RootMeanSquared)).toBeCloseTo(0.14822);
+            });
+        });
+    });
+});