@imagemagick/magick-wasm 0.0.8 → 0.0.11

package/magick-image-collection.js

@@ -3,10 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MagickImageCollection = void 0;
 const image_magick_1 = require("./image-magick");
 const exception_1 = require("./internal/exception/exception");
+const magick_error_1 = require("./magick-error");
 const magick_format_1 = require("./magick-format");
 const magick_image_1 = require("./magick-image");
 const magick_read_settings_1 = require("./settings/magick-read-settings");
 const magick_settings_1 = require("./settings/magick-settings");
+const pointer_1 = require("./internal/pointer/pointer");
 class MagickImageCollection extends Array {
     constructor() {
         super();
@@ -47,6 +49,37 @@ class MagickImageCollection extends Array {
             }
         });
     }
+    write(func, format) {
+        this.throwIfEmpty();
+        let bytes = new Uint8Array();
+        exception_1.Exception.use(exception => {
+            pointer_1.Pointer.use(pointer => {
+                const image = this[0];
+                const settings = this[0]._getSettings()._clone();
+                if (format !== undefined)
+                    settings.format = format;
+                else
+                    settings.format = image.format;
+                settings._use(nativeSettings => {
+                    let data = 0;
+                    try {
+                        this.attachImages();
+                        data = image_magick_1.ImageMagick._api._MagickImage_WriteBlob(image._instance, nativeSettings._instance, pointer.ptr, exception.ptr);
+                        if (data !== 0)
+                            bytes = image_magick_1.ImageMagick._api.HEAPU8.subarray(data, data + pointer.value);
+                    }
+                    catch (_a) {
+                        if (data !== 0)
+                            image_magick_1.ImageMagick._api._MagickMemory_Relinquish(data);
+                    }
+                    finally {
+                        this.detachImages();
+                    }
+                });
+            });
+        });
+        return func(bytes);
+    }
     static create() {
         return MagickImageCollection.createObject();
     }
@@ -63,14 +96,6 @@ class MagickImageCollection extends Array {
             this.dispose();
         }
     }
-    static createObject() {
-        return Object.create(MagickImageCollection.prototype);
-    }
-    static createSettings(settings) {
-        if (settings == null)
-            return new magick_settings_1.MagickSettings();
-        return new magick_read_settings_1.MagickReadSettings(settings);
-    }
     addImages(images, settings) {
         settings.format = magick_format_1.MagickFormat.Unknown;
         let image = images;
@@ -81,5 +106,25 @@ class MagickImageCollection extends Array {
             image = next;
         }
     }
+    attachImages() {
+        for (let i = 0; i < this.length - 1; i++)
+            image_magick_1.ImageMagick._api._MagickImage_SetNext(this[i]._instance, this[i + 1]._instance);
+    }
+    static createObject() {
+        return Object.create(MagickImageCollection.prototype);
+    }
+    static createSettings(settings) {
+        if (settings == null)
+            return new magick_settings_1.MagickSettings();
+        return new magick_read_settings_1.MagickReadSettings(settings);
+    }
+    detachImages() {
+        for (let i = 0; i < this.length - 1; i++)
+            image_magick_1.ImageMagick._api._MagickImage_SetNext(this[i]._instance, 0);
+    }
+    throwIfEmpty() {
+        if (this.length === 0)
+            throw new magick_error_1.MagickError("operation requires at least one image");
+    }
 }
 exports.MagickImageCollection = MagickImageCollection;

package/magick-image.d.ts

@@ -1,4 +1,5 @@
 import { AlphaOption } from './alpha-option';
+import { AutoThresholdMethod } from './auto-threshold-method';
 import { Channels } from './channels';
 import { ColorSpace } from './color-space';
 import { CompositeOperator } from './composite-operator';
@@ -8,6 +9,7 @@ import { ErrorMetric } from './error-metric';
 import { EvaluateOperator } from './evaluate-operator';
 import { FilterType } from './filter-type';
 import { Gravity } from './gravity';
+import { IDrawable } from './drawables/drawable';
 import { IImageProfile } from './profiles/image-profile';
 import { IMagickImageCollection } from './magick-image-collection';
 import { INativeInstance, NativeInstance } from './internal/native-instance';
@@ -19,29 +21,37 @@ import { OrientationType } from './orientation-type';
 import { Percentage } from './percentage';
 import { PixelChannel } from './pixel-channel';
 import { IPixelCollection } from './pixels/pixel-collection';
+import { PixelInterpolateMethod } from './pixel-interpolate-method';
 import { Point } from './point';
 import { VirtualPixelMethod } from './virtual-pixel-method';
 export interface IMagickImage extends INativeInstance {
-    readonly artifactNames: string[];
+    readonly artifactNames: ReadonlyArray<string>;
     backgroundColor: MagickColor;
+    borderColor: MagickColor;
     readonly channelCount: number;
+    colorFuzz: Percentage;
     colorSpace: ColorSpace;
     depth: number;
     filterType: FilterType;
-    format: string;
+    format: MagickFormat;
     hasAlpha: boolean;
+    interpolate: PixelInterpolateMethod;
     readonly height: number;
     orientation: OrientationType;
+    page: MagickGeometry;
     quality: number;
     readonly signature: string | null;
     virtualPixelMethod: VirtualPixelMethod;
     width: number;
     alpha(value: AlphaOption): void;
     autoOrient(): void;
+    autoThreshold(method: AutoThresholdMethod): void;
     blur(): void;
     blur(channels: Channels): void;
     blur(radius: number, sigma: number): void;
     blur(radius: number, sigma: number, channels: Channels): void;
+    border(size: number): void;
+    border(width: number, height: number): void;
     channelOffset(pixelChannel: PixelChannel): number;
     charcoal(): void;
     charcoal(radius: number, sigma: number): void;
@@ -74,9 +84,15 @@ export interface IMagickImage extends INativeInstance {
     compositeGravity(image: IMagickImage, gravity: Gravity, compose: CompositeOperator, point: Point, channels: Channels): void;
     compositeGravity(image: IMagickImage, gravity: Gravity, compose: CompositeOperator, point: Point, args: string): void;
     compositeGravity(image: IMagickImage, gravity: Gravity, compose: CompositeOperator, point: Point, args: string, channels: Channels): void;
+    crop(geometry: MagickGeometry): void;
+    crop(geometry: MagickGeometry, gravity: Gravity): void;
+    crop(width: number, height: number): void;
+    crop(width: number, height: number, gravity: Gravity): void;
     deskew(threshold: Percentage): number;
     distort(method: DistortMethod, params: number[]): void;
     distort(method: DistortMethod, settings: DistortSettings, params: number[]): void;
+    draw(drawables: IDrawable[]): void;
+    draw(...drawables: IDrawable[]): void;
     evaluate(channels: Channels, operator: EvaluateOperator, value: number): void;
     evaluate(channels: Channels, operator: EvaluateOperator, value: Percentage): void;
     evaluate(channels: Channels, geometry: MagickGeometry, operator: EvaluateOperator, value: number): void;
@@ -93,10 +109,17 @@ export interface IMagickImage extends INativeInstance {
     getWriteMask(func: (mask: IMagickImage | null) => void): void;
     getWriteMask(func: (mask: IMagickImage | null) => Promise<void>): Promise<void>;
     getPixels<TReturnType>(func: (pixels: IPixelCollection) => TReturnType): TReturnType;
+    histogram(): Map<string, number>;
+    inverseSigmoidalContrast(contrast: number): void;
+    inverseSigmoidalContrast(contrast: number, midpointPercentage: Percentage): void;
+    inverseSigmoidalContrast(contrast: number, midpoint: number): void;
+    inverseSigmoidalContrast(contrast: number, midpoint: number, channels: Channels): void;
     level(blackPoint: Percentage, whitePoint: Percentage): void;
     level(blackPoint: Percentage, whitePoint: Percentage, gamma: number): void;
     level(channels: Channels, blackPoint: Percentage, whitePoint: Percentage): void;
     level(channels: Channels, blackPoint: Percentage, whitePoint: Percentage, gamma: number): void;
+    liquidRescale(geometry: MagickGeometry): void;
+    liquidRescale(width: number, height: number): void;
     modulate(brightness: Percentage): void;
     modulate(brightness: Percentage, saturation: Percentage): void;
     modulate(brightness: Percentage, saturation: Percentage, hue: Percentage): void;
@@ -108,6 +131,7 @@ export interface IMagickImage extends INativeInstance {
     readFromCanvas(canvas: HTMLCanvasElement): void;
     removeArtifact(name: string): void;
     removeWriteMask(): void;
+    repage(): void;
     resize(geometry: MagickGeometry): void;
     resize(width: number, height: number): void;
     rotate(degrees: number): void;
@@ -115,11 +139,9 @@ export interface IMagickImage extends INativeInstance {
     sharpen(radius: number, sigma: number): void;
     sharpen(radius: number, sigma: number, channels: Channels): void;
     sigmoidalContrast(contrast: number): void;
-    sigmoidalContrast(sharpen: boolean, contrast: number): void;
-    sigmoidalContrast(contrast: number, midpoint: number): void;
-    sigmoidalContrast(sharpen: boolean, contrast: number, midpoint: number): void;
     sigmoidalContrast(contrast: number, midpointPercentage: Percentage): void;
-    sigmoidalContrast(sharpen: boolean, contrast: number, midpointPercentage: Percentage): void;
+    sigmoidalContrast(contrast: number, midpoint: number): void;
+    sigmoidalContrast(contrast: number, midpoint: number, channels: Channels): void;
     separate(func: (images: IMagickImageCollection) => void): void;
     separate(func: (images: IMagickImageCollection) => Promise<void>): Promise<void>;
     separate(func: (images: IMagickImageCollection) => void, channels: Channels): void;
@@ -128,6 +150,13 @@ export interface IMagickImage extends INativeInstance {
     setArtifact(name: string, value: boolean): void;
     setWriteMask(image: IMagickImage): void;
     toString(): string;
+    trim(): void;
+    trim(...edges: Gravity[]): void;
+    trim(percentage: Percentage): void;
+    vignette(): void;
+    vignette(radius: number, sigma: number, x: number, y: number): void;
+    wave(): void;
+    wave(method: PixelInterpolateMethod, amplitude: number, length: number): void;
     write(func: (data: Uint8Array) => void, format?: MagickFormat): void;
     write(func: (data: Uint8Array) => Promise<void>, format?: MagickFormat): Promise<void>;
     writeToCanvas(canvas: HTMLCanvasElement): void;
@@ -135,23 +164,31 @@ export interface IMagickImage extends INativeInstance {
 export declare class MagickImage extends NativeInstance implements IMagickImage {
     private readonly _settings;
     private constructor();
-    get artifactNames(): string[];
+    get artifactNames(): ReadonlyArray<string>;
     get backgroundColor(): MagickColor;
     set backgroundColor(value: MagickColor);
+    get borderColor(): MagickColor;
+    set borderColor(value: MagickColor);
     get channelCount(): number;
+    get colorFuzz(): Percentage;
+    set colorFuzz(value: Percentage);
     get colorSpace(): ColorSpace;
     set colorSpace(value: ColorSpace);
     get depth(): number;
     set depth(value: number);
     get filterType(): number;
     set filterType(value: number);
-    get format(): string;
-    set format(value: string);
+    get format(): MagickFormat;
+    set format(value: MagickFormat);
     get hasAlpha(): boolean;
     set hasAlpha(value: boolean);
+    get interpolate(): PixelInterpolateMethod;
+    set interpolate(value: PixelInterpolateMethod);
     get height(): number;
     get orientation(): OrientationType;
     set orientation(value: OrientationType);
+    get page(): MagickGeometry;
+    set page(value: MagickGeometry);
     get quality(): number;
     set quality(value: number);
     get signature(): string | null;
@@ -160,10 +197,13 @@ export declare class MagickImage extends NativeInstance implements IMagickImage
     get width(): number;
     alpha(value: AlphaOption): void;
     autoOrient(): void;
+    autoThreshold(method: AutoThresholdMethod): void;
     blur(): void;
     blur(channels: Channels): void;
     blur(radius: number, sigma: number): void;
     blur(radius: number, sigma: number, channels: Channels): void;
+    border(size: number): void;
+    border(width: number, height: number): void;
     channelOffset(pixelChannel: PixelChannel): number;
     charcoal(): void;
     charcoal(radius: number, sigma: number): void;
@@ -196,10 +236,16 @@ export declare class MagickImage extends NativeInstance implements IMagickImage
     compositeGravity(image: IMagickImage, gravity: Gravity, compose: CompositeOperator, point: Point, channels: Channels): void;
     compositeGravity(image: IMagickImage, gravity: Gravity, compose: CompositeOperator, point: Point, args: string): void;
     compositeGravity(image: IMagickImage, gravity: Gravity, compose: CompositeOperator, point: Point, args: string, channels: Channels): void;
+    crop(geometry: MagickGeometry): void;
+    crop(geometry: MagickGeometry, gravity: Gravity): void;
+    crop(width: number, height: number): void;
+    crop(width: number, height: number, gravity: Gravity): void;
     static create(): IMagickImage;
     deskew(threshold: Percentage): number;
     distort(method: DistortMethod, params: number[]): void;
     distort(method: DistortMethod, settings: DistortSettings, params: number[]): void;
+    draw(drawables: IDrawable[]): void;
+    draw(...drawables: IDrawable[]): void;
     evaluate(channels: Channels, operator: EvaluateOperator, value: number): void;
     evaluate(channels: Channels, operator: EvaluateOperator, value: Percentage): void;
     evaluate(channels: Channels, geometry: MagickGeometry, operator: EvaluateOperator, value: number): void;
@@ -216,10 +262,17 @@ export declare class MagickImage extends NativeInstance implements IMagickImage
     getWriteMask(func: (mask: IMagickImage | null) => void): void;
     getWriteMask(func: (mask: IMagickImage | null) => Promise<void>): Promise<void>;
     getPixels<TReturnType>(func: (pixels: IPixelCollection) => TReturnType): TReturnType;
+    histogram(): Map<string, number>;
+    inverseSigmoidalContrast(contrast: number): void;
+    inverseSigmoidalContrast(contrast: number, midpointPercentage: Percentage): void;
+    inverseSigmoidalContrast(contrast: number, midpoint: number): void;
+    inverseSigmoidalContrast(contrast: number, midpoint: number, channels: Channels): void;
     level(blackPoint: Percentage, whitePoint: Percentage): void;
     level(blackPoint: Percentage, whitePoint: Percentage, gamma: number): void;
     level(channels: Channels, blackPoint: Percentage, whitePoint: Percentage): void;
     level(channels: Channels, blackPoint: Percentage, whitePoint: Percentage, gamma: number): void;
+    liquidRescale(geometry: MagickGeometry): void;
+    liquidRescale(width: number, height: number): void;
     modulate(brightness: Percentage): void;
     modulate(brightness: Percentage, saturation: Percentage): void;
     modulate(brightness: Percentage, saturation: Percentage, hue: Percentage): void;
@@ -231,6 +284,7 @@ export declare class MagickImage extends NativeInstance implements IMagickImage
     readFromCanvas(canvas: HTMLCanvasElement): void;
     removeArtifact(name: string): void;
     removeWriteMask(): void;
+    repage(): void;
     resize(geometry: MagickGeometry): void;
     resize(width: number, height: number): void;
     rotate(degrees: number): void;
@@ -238,11 +292,9 @@ export declare class MagickImage extends NativeInstance implements IMagickImage
     sharpen(radius: number, sigma: number): void;
     sharpen(radius: number, sigma: number, channels: Channels): void;
     sigmoidalContrast(contrast: number): void;
-    sigmoidalContrast(sharpen: boolean, contrast: number): void;
-    sigmoidalContrast(contrast: number, midpoint: number): void;
-    sigmoidalContrast(sharpen: boolean, contrast: number, midpoint: number): void;
     sigmoidalContrast(contrast: number, midpointPercentage: Percentage): void;
-    sigmoidalContrast(sharpen: boolean, contrast: number, midpointPercentage: Percentage): void;
+    sigmoidalContrast(contrast: number, midpoint: number): void;
+    sigmoidalContrast(contrast: number, midpoint: number, channels: Channels): void;
     separate(func: (images: IMagickImageCollection) => void): void;
     separate(func: (images: IMagickImageCollection) => Promise<void>): Promise<void>;
     separate(func: (images: IMagickImageCollection) => void, channels: Channels): void;
@@ -251,10 +303,18 @@ export declare class MagickImage extends NativeInstance implements IMagickImage
     setArtifact(name: string, value: boolean): void;
     setWriteMask(image: IMagickImage): void;
     toString: () => string;
+    trim(): void;
+    trim(...edges: Gravity[]): void;
+    trim(percentage: Percentage): void;
+    wave(): void;
+    wave(method: PixelInterpolateMethod, amplitude: number, length: number): void;
+    vignette(): void;
+    vignette(radius: number, sigma: number, x: number, y: number): void;
     write(func: (data: Uint8Array) => void, format?: MagickFormat): void;
     write(func: (data: Uint8Array) => Promise<void>, format?: MagickFormat): Promise<void>;
     writeToCanvas(canvas: HTMLCanvasElement): void;
     static _use<TReturnType>(func: (image: IMagickImage) => Promise<TReturnType>): Promise<TReturnType>;
+    private privateSigmoidalContrast;
     private static createInstance;
     private fromBool;
     private readFromArray;