image-js 1.0.0-alpha.3 → 1.0.0

package/lib/Image.d.ts

@@ -1,180 +1,537 @@
-import { IInvertOptions } from './filters/invert';
-import { IConvertColorOptions } from './operations/convertColor';
-import { IHistogramOptions } from './compute';
-import { IBlurOptions, IConvolutionOptions, GaussianBlurOptions } from './filters';
-import { IResizeOptions, IRotateOptions, ITransformOptions } from './geometry';
-import { ThresholdOptions } from './operations';
-declare type ImageDataArray = Uint8Array | Uint16Array;
-export declare enum ColorDepth {
-    UINT8 = 8,
-    UINT16 = 16
-}
-export declare enum ImageKind {
-    GREY = "GREY",
-    GREYA = "GREYA",
-    RGB = "RGB",
-    RGBA = "RGBA"
-}
-export declare enum ImageCoordinates {
-    CENTER = "CENTER",
-    TOP_LEFT = "TOP_LEFT",
-    TOP_RIGHT = "TOP_RIGHT",
-    BOTTOM_LEFT = "BOTTOM_LEFT",
-    BOTTOM_RIGHT = "BOTTOM_RIGHT"
-}
-export interface INewImageOptions {
-    /**
-     * Number of bits per value in each channel.
-     * Default: `ColorDepth.UINT8`.
-     */
-    depth?: ColorDepth;
-    /**
-     * Typed array holding the image data.
-     */
-    data?: ImageDataArray;
-    /**
-     * Height of the image.
-     */
-    height?: number;
-    /**
-     * Kind of the created image.
-     * Default: `ImageKind.RGB`.
-     */
-    kind?: ImageKind;
-    /**
-     * Width of the image.
-     */
-    width?: number;
-}
-export declare type ImageValues = [number, number, number, number];
-export declare class Image {
-    /**
-     * The number of columns of the image.
-     */
-    readonly width: number;
-    /**
-     * The number of rows of the image.
-     */
-    readonly height: number;
-    /**
-     * The total number of pixels in the image (width x height).
-     */
-    readonly size: number;
-    /**
-     * The number of bits per value in each channel.
-     */
-    readonly depth: ColorDepth;
-    /**
-     * The kind of the image.
-     */
-    readonly kind: ImageKind;
-    /**
-     * The number of color channels in the image, excluding the alpha channel.
-     * A grey image has 1 component. An RGB image has 3 components.
-     */
-    readonly components: number;
-    /**
-     * The total number of channels in the image, including the alpha channel.
-     */
-    readonly channels: number;
-    /**
-     * Whether the image has an alpha channel or not.
-     */
-    readonly alpha: boolean;
-    /**
-     * The maximum value that a pixel channel can have.
-     */
-    readonly maxValue: number;
-    /**
-     * Typed array holding the image data.
-     */
-    readonly data: ImageDataArray;
-    /**
-     * Construct a new image knowing its dimensions.
-     * @param width
-     * @param height
-     * @param options
-     */
-    constructor(width: number, height: number, options?: INewImageOptions);
-    /**
-     * Construct a new image only with options.
-     * @param options
-     */
-    constructor(options?: INewImageOptions);
-    /**
-     * Create a new image base on the properties of an existing one.
-     * @param other - Reference image.
-     */
-    static createFrom(other: Image, options?: INewImageOptions): Image;
-    /**
-     * Get all the values of a pixel.
-     * @param y - Row index.
-     * @param x - Column index.
-     * @returns Values of the pixel.
-     */
-    get(y: number, x: number): number[];
-    /**
-     * Set all the values of a pixel.
-     * @param y - Row index.
-     * @param x - Column index.
-     * @param value - Values of the pixel to set.
-     */
-    set(y: number, x: number, value: number[]): void;
-    /**
-     * Get the value of a specific pixel channel.
-     * @param y - Row index.
-     * @param x - Column index.
-     * @param channel - Channel index.
-     */
-    getValue(y: number, x: number, channel: number): number;
-    /**
-     * Set the value of a specific pixel channel.
-     * @param y - Row index.
-     * @param x - Column index.
-     * @param channel - Channel index.
-     * @param value - Value to set.
-     */
-    setValue(y: number, x: number, channel: number, value: number): void;
-    /**
-     * Fill the image with a value or a color
-     */
-    fill(value: number | number[]): this;
-    /**
-     * Fill one channel with a value
-     * @param channel - The channel to fill.
-     * @param value - The new value.
-     */
-    fillChannel(channel: number, value: number): this;
-    /**
-     * Fill the alpha channel with the specified value.
-     */
-    fillAlpha(value: number): this;
-    /**
-     * Create a copy of this image.
-     */
-    clone(): Image;
-    changeEach(cb: (value: number) => number): void;
-    /**
-     * Returns a histogram of pixel intensities.
-     * @param image
-     */
-    histogram(options?: IHistogramOptions): number[];
-    blur(options: IBlurOptions): Image;
-    directConvolution(kernel: number[][], options?: IConvolutionOptions): Image;
-    separableConvolution(kernelX: number[], kernelY: number[], options?: IConvolutionOptions): Image;
-    gaussianBlur(options: GaussianBlurOptions): Image;
-    /**
-     * Invert the colors of the image.
-     */
-    invert(options?: IInvertOptions): Image;
-    resize(options: IResizeOptions): Image;
-    rotate(angle: number, options?: IRotateOptions): Image;
-    transform(transformMatrix: number[][], options?: ITransformOptions): Image;
-    convertColor(kind: ImageKind, options?: IConvertColorOptions): Image;
-    convertDepth(newDepth: ColorDepth): Image;
-    split(): Image[];
-    threshold(options: ThresholdOptions): Image;
-    getCoordinates(coordinates: ImageCoordinates, round?: boolean): [number, number];
-}
-export {};
+import type { RgbColor } from 'colord';
+import type { Mask } from './Mask.js';
+import type { DivideOptions } from './compare/divide.js';
+import type { SubtractImageOptions } from './compare/index.js';
+import type { MultiplyOptions } from './compare/multiply.js';
+import type { HistogramOptions, MeanOptions, MedianOptions, VarianceOptions } from './compute/index.js';
+import type { DrawCircleOnImageOptions, DrawLineOnImageOptions, DrawMarkerOptions, DrawPointsOptions, DrawPolygonOnImageOptions, DrawPolylineOnImageOptions, DrawRectangleOptions } from './draw/index.js';
+import type { BlurOptions, ConvolutionOptions, DerivativeFilterOptions, FlipOptions, GaussianBlurOptions, GradientFilterOptions, HypotenuseOptions, IncreaseContrastOptions, InvertOptions, LevelOptions, MedianFilterOptions, PixelateOptions } from './filters/index.js';
+import type { Point, ResizeOptions, RotateAngle, TransformOptions, TransformRotateOptions } from './geometry/index.js';
+import type { ImageMetadata } from './load/load.types.js';
+import type { BottomHatOptions, CannyEdgeOptions, CloseOptions, DilateOptions, ErodeOptions, MorphologicalGradientOptions, OpenOptions, TopHatOptions } from './morphology/index.js';
+import type { ConvertBitDepthOptions, ConvertColorOptions, CopyToOptions, CropAlphaOptions, CropOptions, CropRectangleOptions, ExtractOptions, GreyOptions, PaintMaskOnImageOptions, ThresholdOptions } from './operations/index.js';
+import type { ImageColorModel } from './utils/constants/colorModels.js';
+export type ImageDataArray = Uint8Array | Uint16Array | Uint8ClampedArray;
+/**
+ * Bit depth of the image (nb of bits that encode each value in the image).
+ */
+export type BitDepth = 1 | 8 | 16;
+export declare const ImageCoordinates: {
+    readonly CENTER: "center";
+    readonly TOP_LEFT: "top-left";
+    readonly TOP_RIGHT: "top-right";
+    readonly BOTTOM_LEFT: "bottom-left";
+    readonly BOTTOM_RIGHT: "bottom-right";
+};
+export type ImageCoordinates = (typeof ImageCoordinates)[keyof typeof ImageCoordinates];
+export interface ImageOptions {
+    /**
+     * Number of bits per value in each channel.
+     * @default `8`.
+     */
+    bitDepth?: BitDepth;
+    /**
+     * Typed array holding the image data.
+     */
+    data?: ImageDataArray;
+    /**
+     * Color model of the created image.
+     * @default `'RGB'`.
+     */
+    colorModel?: ImageColorModel;
+    /**
+     * Origin of the image relative to a parent image (top-left corner).
+     * @default `{row: 0, column: 0}`
+     */
+    origin?: Point;
+    meta?: ImageMetadata;
+}
+export interface CreateFromOptions extends ImageOptions {
+    width?: number;
+    height?: number;
+}
+export type ImageValues = [number, number, number, number];
+export declare class Image {
+    /**
+     * The number of columns of the image.
+     */
+    readonly width: number;
+    /**
+     * The number of rows of the image.
+     */
+    readonly height: number;
+    /**
+     * The total number of pixels in the image (width × height).
+     */
+    readonly size: number;
+    /**
+     * The number of bits per value in each channel.
+     */
+    readonly bitDepth: BitDepth;
+    /**
+     * The color model of the image.
+     */
+    readonly colorModel: ImageColorModel;
+    /**
+     * The number of color channels in the image, excluding the alpha channel.
+     * A GREY image has 1 component. An RGB image has 3 components.
+     */
+    readonly components: number;
+    /**
+     * The total number of channels in the image, including the alpha channel.
+     */
+    readonly channels: number;
+    /**
+     * Whether the image has an alpha channel or not.
+     */
+    readonly alpha: boolean;
+    /**
+     * The maximum value that a pixel channel can have.
+     */
+    readonly maxValue: number;
+    /**
+     * Origin of the image relative to a the parent image.
+     */
+    readonly origin: Point;
+    readonly meta?: ImageMetadata;
+    /**
+     * Typed array holding the image data.
+     */
+    private readonly data;
+    /**
+     * Construct a new Image knowing its dimensions.
+     * @param width - Image width.
+     * @param height - Image height.
+     * @param options - Image options.
+     */
+    constructor(width: number, height: number, options?: ImageOptions);
+    /**
+     * Create a new Image based on the properties of an existing one.
+     * @param other - Reference image.
+     * @param options - Image options.
+     * @returns New image.
+     */
+    static createFrom(other: Image | Mask, options?: CreateFromOptions): Image;
+    /**
+     * Get all the channels of a pixel.
+     * @param column - Column index.
+     * @param row - Row index.
+     * @returns Channels of the pixel.
+     */
+    getPixel(column: number, row: number): number[];
+    getColumn(column: number): number[][];
+    getRow(row: number): number[][];
+    /**
+     * Set all the channels of a pixel.
+     * @param column - Column index.
+     * @param row - Row index.
+     * @param value - New color of the pixel to set.
+     */
+    setPixel(column: number, row: number, value: number[]): void;
+    /**
+     * Set all the channels of a pixel if the coordinates are inside the image.
+     * @param column - Column index.
+     * @param row - Row index.
+     * @param value - New color of the pixel to set.
+     */
+    setVisiblePixel(column: number, row: number, value: number[]): void;
+    /**
+     * Get all the channels of a pixel using its index.
+     * @param index - Index of the pixel.
+     * @returns Channels of the pixel.
+     */
+    getPixelByIndex(index: number): number[];
+    /**
+     * Set all the channels of a pixel using its index.
+     * @param index - Index of the pixel.
+     * @param value - New channel values of the pixel to set.
+     */
+    setPixelByIndex(index: number, value: number[]): void;
+    /**
+     * Get the value of a specific pixel channel. Select pixel using coordinates.
+     * @param column - Column index.
+     * @param row - Row index.
+     * @param channel - Channel index.
+     * @returns Value of the specified channel of one pixel.
+     */
+    getValue(column: number, row: number, channel: number): number;
+    /**
+     * Set the value of a specific pixel channel. Select pixel using coordinates.
+     * @param column - Column index.
+     * @param row - Row index.
+     * @param channel - Channel index.
+     * @param value - Value to set.
+     */
+    setValue(column: number, row: number, channel: number, value: number): void;
+    /**
+     * Set the value of a specific pixel channel. Select pixel using coordinates.
+     * If the value is out of range it is set to the closest extremety.
+     * @param column - Column index.
+     * @param row - Row index.
+     * @param channel - Channel index.
+     * @param value - Value to set.
+     */
+    setClampedValue(column: number, row: number, channel: number, value: number): void;
+    /**
+     * Get the value of a specific pixel channel. Select pixel using index.
+     * @param index - Index of the pixel.
+     * @param channel - Channel index.
+     * @returns Value of the channel of the pixel.
+     */
+    getValueByIndex(index: number, channel: number): number;
+    /**
+     * Set the value of a specific pixel channel. Select pixel using index.
+     * @param index - Index of the pixel.
+     * @param channel - Channel index.
+     * @param value - Value to set.
+     */
+    setValueByIndex(index: number, channel: number, value: number): void;
+    /**
+     * Set the value of a specific pixel channel. Select pixel using index.
+     * If the value is out of range it is set to the closest extremety.
+     * @param index - Index of the pixel.
+     * @param channel - Channel index.
+     * @param value - Value to set.
+     */
+    setClampedValueByIndex(index: number, channel: number, value: number): void;
+    /**
+     * Get the value of a specific pixel channel. Select pixel using a point.
+     * @param point - Coordinates of the desired pixel.
+     * @param channel - Channel index.
+     * @returns Value of the channel of the pixel.
+     */
+    getValueByPoint(point: Point, channel: number): number;
+    /**
+     * Set the value of a specific pixel channel. Select pixel using a point.
+     * @param point - Coordinates of the pixel.
+     * @param channel - Channel index.
+     * @param value - Value to set.
+     */
+    setValueByPoint(point: Point, channel: number, value: number): void;
+    /**
+     * Find the min and max values of each channel of the image.
+     * @returns An object with arrays of the min and max values.
+     */
+    minMax(): {
+        min: number[];
+        max: number[];
+    };
+    /**
+     * Return the raw image data.
+     * @returns The raw data.
+     */
+    getRawImage(): {
+        width: number;
+        height: number;
+        data: ImageDataArray;
+        channels: number;
+        bitDepth: BitDepth;
+    };
+    /**
+     * Fill the image with a value or a color.
+     * @param value - Value or color.
+     * @returns The image instance.
+     */
+    fill(value: number | number[]): this;
+    /**
+     * Fill one channel with a value.
+     * @param channel - The channel to fill.
+     * @param value - The new value.
+     * @returns The image instance.
+     */
+    fillChannel(channel: number, value: number): this;
+    /**
+     * Get one channel of the image as an array.
+     * @param channel - The channel to fill.
+     * @returns Array with the channel values.
+     */
+    getChannel(channel: number): number[];
+    /**
+     * Fill the alpha channel with the specified value.
+     * @param value - New channel value.
+     * @returns The image instance.
+     */
+    fillAlpha(value: number): this;
+    /**
+     * Create a copy of this image.
+     * @returns The image clone.
+     */
+    clone(): Image;
+    /**
+     * Modify all the values of the image using the given callback.
+     * @param cb - Callback that modifies a given value.
+     */
+    changeEach(cb: (value: number) => number): void;
+    /**
+     * Get the coordinates of a point in the image. The reference is the top-left corner.
+     * @param coordinates - The point for which you want the coordinates.
+     * @param round - Whether the coordinates should be rounded. This is useful when you want the center of the image.
+     * @returns Coordinates of the point in the format [column, row].
+     */
+    getCoordinates(coordinates: ImageCoordinates, round?: boolean): Point;
+    /**
+     * Subtract other from an image.
+     * @param other - Image to subtract.
+     * @param options - Inversion options.
+     * @returns The subtracted image.
+     */
+    subtract(other: Image, options?: SubtractImageOptions): Image;
+    add(other: Image): Image;
+    /**
+     *  Multiply image pixels by a constant.
+     * @param value - Value which pixels will be multiplied to.
+     * @param options - Multiply options.
+     * @returns Multiplied image.
+     */
+    multiply(value: number, options?: MultiplyOptions): Image;
+    /**
+     *  Divide image pixels by a constant.
+     * @param value - Value which pixels will be divided to.
+     * @param options - Divide options.
+     * @returns Divided image.
+     */
+    divide(value: number, options?: DivideOptions): Image;
+    histogram(options?: HistogramOptions): Uint32Array;
+    /**
+     * Compute the mean pixel of an image.
+     * @param options - Mean options.
+     * @returns The mean pixel.
+     */
+    mean(options?: MeanOptions): number[];
+    /**
+     * Compute the median pixel of an image.
+     * @param options - Median options.
+     * @returns The median pixel.
+     */
+    median(options?: MedianOptions): number[];
+    /**
+     * Compute the variance of each channel of an image.
+     * @param options - Variance options.
+     * @returns The variance of the channels of the image.
+     */
+    variance(options?: VarianceOptions): number[];
+    /**
+     * Draw a set of points on an image.
+     * @param points - Array of points.
+     * @param options - Draw points on Image options.
+     * @returns New mask.
+     */
+    drawPoints(points: Point[], options?: DrawPointsOptions): Image;
+    /**
+     * Draw a line defined by two points onto an image.
+     * @param from - Line starting point.
+     * @param to - Line ending point.
+     * @param options - Draw Line options.
+     * @returns The mask with the line drawing.
+     */
+    drawLine(from: Point, to: Point, options?: DrawLineOnImageOptions): Image;
+    /**
+     * Draw a rectangle defined by position of the top-left corner, width and height.
+     * @param options - Draw rectangle options.
+     * @returns The image with the rectangle drawing.
+     */
+    drawRectangle(options?: DrawRectangleOptions<Image>): Image;
+    /**
+     * Draw a polyline defined by an array of points on an image.
+     * @param points - Polyline array of points.
+     * @param options - Draw polyline options.
+     * @returns The image with the polyline drawing.
+     */
+    drawPolyline(points: Point[], options?: DrawPolylineOnImageOptions): Image;
+    /**
+     * Draw a polygon defined by an array of points onto an image.
+     * @param points - Polygon vertices.
+     * @param options - Draw Line options.
+     * @returns The image with the polygon drawing.
+     */
+    drawPolygon(points: Point[], options?: DrawPolygonOnImageOptions): Image;
+    /**
+     * Draw a circle defined by center and radius onto an image.
+     * @param center - Circle center.
+     * @param radius - Circle radius.
+     * @param options - Draw circle options.
+     * @returns The image with the circle drawing.
+     */
+    drawCircle(center: Point, radius: number, options?: DrawCircleOnImageOptions): Image;
+    /**
+     * Draw a marker on the image.
+     * @param point - Marker center point.
+     * @param options - Draw marker options.
+     * @returns The image with the marker drawing.
+     */
+    drawMarker(point: Point, options?: DrawMarkerOptions): Image;
+    /**
+     * Draw markers on the image.
+     * @param points - Markers center points.
+     * @param options - Draw marker options.
+     * @returns The image with the markers drawing.
+     */
+    drawMarkers(points: Point[], options?: DrawMarkerOptions): Image;
+    split(): Image[];
+    convertColor(colorModel: ImageColorModel, options?: ConvertColorOptions): Image;
+    convertBitDepth(newDepth: BitDepth, options?: ConvertBitDepthOptions): Image;
+    grey(options?: GreyOptions): Image;
+    copyTo(target: Image, options?: CopyToOptions<Image>): Image;
+    threshold(options?: ThresholdOptions): Mask;
+    /**
+     * Crop the input image to a desired size.
+     * @param [options] - Crop options.
+     * @returns The new cropped image.
+     */
+    crop(options?: CropOptions): Image;
+    /**
+     * Crop an oriented rectangle from the image.
+     * If the rectangle's length or width are not an integers, its dimension is expanded in both directions such as the length and width are integers.
+     * @param points - The points of the rectangle. Points must be circling around the rectangle (clockwise or anti-clockwise)
+     * @param options - Crop options, see {@link CropRectangleOptions}
+     * @returns The cropped image. The orientation of the image is the one closest to the rectangle passed as input.
+     */
+    cropRectangle(points: Point[], options?: CropRectangleOptions): Image;
+    /**
+     * Crops the image based on the alpha channel
+     * This removes lines and columns where the alpha channel is lower than a threshold value.
+     * @param options - Crop alpha options.
+     * @returns The cropped image.
+     */
+    cropAlpha(options?: CropAlphaOptions): Image;
+    /**
+     * Extract the pixels of an image, as specified in a mask.
+     * @param mask - The mask defining which pixels to keep.
+     * @param options - Extract options.
+     * @returns The extracted image.
+     */
+    extract(mask: Mask, options?: ExtractOptions): Image;
+    /**
+     * Paint a mask onto an image and the given position and with the given color.
+     * @param mask - Mask to paint on the image.
+     * @param options - Paint mask options.
+     * @returns The painted image.
+     */
+    paintMask(mask: Mask, options?: PaintMaskOnImageOptions): Image;
+    blur(options: BlurOptions): Image;
+    pixelate(options: PixelateOptions): Image;
+    directConvolution(kernel: number[][], options?: ConvolutionOptions): Image;
+    /**
+     * Compute direct convolution of an image and return an array with the raw values.
+     * @param kernel - Kernel used for the convolution.
+     * @param options - Convolution options.
+     * @returns Array with the raw convoluted values.
+     */
+    rawDirectConvolution(kernel: number[][], options?: ConvolutionOptions): Float64Array;
+    separableConvolution(kernelX: number[], kernelY: number[], options?: ConvolutionOptions): Image;
+    /**
+     * Apply a gaussian filter to an image.
+     * @param options - Gaussian blur options.
+     * @returns The blurred image.
+     */
+    gaussianBlur(options: GaussianBlurOptions): Image;
+    /**
+     * Flip the image.
+     * @param options - Flip options.
+     * @returns The flipped image.
+     */
+    flip(options?: FlipOptions): Image;
+    /**
+     *   Invert the colors of the image.
+     * @param options - Inversion options.
+     * @returns The inverted image.
+     */
+    invert(options?: InvertOptions): Image;
+    /**
+     * Calculate a new image that is the hypotenuse between the current image and the other.
+     * @param other - Other image.
+     * @param options - Hypotenuse options.
+     * @returns Hypotenuse of the two images.
+     */
+    hypotenuse(other: Image, options?: HypotenuseOptions): Image;
+    /**
+     * Apply a gradient filter to an image.
+     * @param options - Gradient filter options.
+     * @returns The gradient image.
+     */
+    gradientFilter(options: GradientFilterOptions): Image;
+    /**
+     * Apply a derivative filter to an image.
+     * @param options - Derivative filter options.
+     * @returns The processed image.
+     */
+    derivativeFilter(options?: DerivativeFilterOptions): Image;
+    /**
+     * Level the image using the optional input and output value. This function allows you to enhance the image's contrast.
+     * @param options - Level options.
+     * @returns The levelled image.
+     */
+    level(options?: LevelOptions): Image;
+    /**
+     * Increase the contrast of an image by spanning each channel on the range [0, image.maxValue].
+     * @param options - Increase contrast options.
+     * @returns The enhanced image.
+     */
+    increaseContrast(options?: IncreaseContrastOptions): Image;
+    /**
+     * Correct the colors in an image using the reference colors.
+     * @param measuredColors - Colors from the image, which will be compared to the reference.
+     * @param referenceColors - Reference colors.
+     * @returns Image with the colors corrected.
+     */
+    correctColor(measuredColors: RgbColor[], referenceColors: RgbColor[]): Image;
+    /**
+     * Apply a median filter to the image.
+     * @param options - Options to apply for median filter.
+     * @returns Image after median filter.
+     */
+    medianFilter(options: MedianFilterOptions): Image;
+    resize(options: ResizeOptions): Image;
+    rotate(angle: RotateAngle): Image;
+    transform(transformMatrix: number[][], options?: TransformOptions): Image;
+    transformRotate(angle: number, options?: TransformRotateOptions): Image;
+    /**
+     * Erode an image.
+     * @param options - Erode options.
+     * @returns The eroded image.
+     */
+    erode(options?: ErodeOptions): Image;
+    /**
+     * Dilate an image.
+     * @param options - Dilate options.
+     * @returns The dilated image.
+     */
+    dilate(options?: DilateOptions): Image;
+    /**
+     * Open an image.
+     * @param options - Open options.
+     * @returns The opened image.
+     */
+    open(options?: OpenOptions): Image;
+    /**
+     * Close an image.
+     * @param options - Close options.
+     * @returns The closed image.
+     */
+    close(options?: CloseOptions): Image;
+    /**
+     * Top hat of an image.
+     * @param options - Top hat options.
+     * @returns The top-hatted image.
+     */
+    topHat(options?: TopHatOptions): Image;
+    /**
+     * Bottom hat of an image.
+     * @param options - Bottom hat options.
+     * @returns The bottom-hatted image.
+     */
+    bottomHat(options?: BottomHatOptions): Image;
+    /**
+     * Apply morphological gradient to an image.
+     * @param options - Morphological gradient options.
+     * @returns The processed image.
+     */
+    morphologicalGradient(options?: MorphologicalGradientOptions): Image;
+    /**
+     * Apply Canny edge detection to an image.
+     * @param options - Canny edge detection options.
+     * @returns The processed image.
+     */
+    cannyEdgeDetector(options?: CannyEdgeOptions): Mask;
+}
 //# sourceMappingURL=Image.d.ts.map