MagickWand class

The MagickWand can do operations on images like reading, resizing, writing, cropping an image, etc...

The MagickWand can hold reference to multiple images at a point in time, and thus it is an object that has a state. This state controls how the images are treated when you use the wand's methods. You can set the current referenced image by MagickSetIteratorIndex or reset it by MagickResetIterator. In general the operations called on the wand are done on the image at the current iterator index.

Initialize an instance of it with MagickWand.newMagickWand. When done from it, call destroyMagickWand to release the resources.

  • Never use a [MagickWand] after calling [destroyMagickWand] on it.
  • Some methods of the MagickWand accept params like strings, there is no way to validate what you are going to provide to these params by the plugin itself, it is your responsibility to pass valid values to these params as per the documentation, otherwise an invalid state may be reached and the app may crash.
    • See https://imagemagick.org/script/magick-wand.php for more information about the backing C-API.

    Constructors

    MagickWand.newMagickWand()
    Returns a wand required for all other methods in the API. A fatal exception is thrown if there is not enough memory to allocate the wand. Use destroyMagickWand() to dispose of the wand when it is no longer needed.
    factory

    Properties

    hashCode → int
    The hash code for this object.
    no setteroverride
    runtimeType → Type
    A representation of the runtime type of the object.
    no setterinherited

    Methods

    clearMagickWand() → void
    Clears resources associated with this wand, leaving the wand blank, and ready to be used for a new set of images.
    cloneMagickWand() → MagickWand
    Makes an exact copy of this wand.
    destroyMagickWand() → Future<void>
    Deallocates memory associated with this wand. You can't use the wand after calling this function.
    isMagickWand() → bool
    Returns true if this wand is verified as a magick wand. For example, after calling destroyMagickWand on this wand, then this method will return false.
    magickAdaptiveBlurImage(double radius, double sigma) → Future<bool>
    Adaptively blurs the image by blurring less intensely near image edges and more intensely far from edges. We blur the image with a Gaussian operator of the given radius and standard deviation (sigma). For reasonable results, radius should be larger than sigma. Use a radius of 0 and magickAdaptiveBlurImage() selects a suitable radius for you.
    magickAdaptiveResizeImage(int columns, int rows) → Future<bool>
    Adaptively resize image with data dependent triangulation.
    magickAdaptiveSharpenImage(double radius, double sigma) → Future<bool>
    Adaptively sharpens the image by sharpening more intensely near image edges and less intensely far from edges. We sharpen the image with a Gaussian operator of the given radius and standard deviation (sigma). For reasonable results, radius should be larger than sigma. Use a radius of 0 and magickAdaptiveSharpenImage() selects a suitable radius for you.
    magickAdaptiveThresholdImage({required int width, required int height, required double bias}) → Future<bool>
    Selects an individual threshold for each pixel based on the range of intensity values in its local neighborhood. This allows for thresholding of an image whose global intensity histogram doesn't contain distinctive peaks.
    magickAddImage(MagickWand other) → Future<bool>
    Adds a clone of the images from the second wand and inserts them into the first wand. Use magickSetLastIterator(), to append new images into an existing wand, current image will be set to last image so later adds with also be appended to end of wand. Use magickSetFirstIterator() to prepend new images into wand, any more images added will also be prepended before other images in the wand. However the order of a list of new images will not change. Otherwise the new images will be inserted just after the current image, and any later image will also be added after this current image but before the previously added images. Caution is advised when multiple image adds are inserted into the middle of the wand image list.
    magickAddNoiseImage(NoiseType noiseType, double attenuate) → Future<bool>
    Adds random noise to the image.
    magickAffineTransformImage(DrawingWand drawingWand) → Future<bool>
    Transforms an image as dictated by the affine matrix of the drawing wand.
    magickAnnotateImage({required DrawingWand drawingWand, required double x, required double y, required double angle, required String text}) → Future<bool>
    Annotates an image with text. This method runs inside an isolate different from the main isolate.
    magickAppendImages(bool stack) → Future<MagickWand?>
    Append the images in a wand from the current image onwards, creating a new wand with the single image result. This is affected by the gravity and background settings of the first image. Typically you would call either magickResetIterator() or magickSetFirstImage() before calling this function to ensure that all the images in the wand's image list will be appended together.
    magickAutoGammaImage() → Future<bool>
    Extracts the 'mean' from the image and adjust the image to try make set its gamma appropriately.
    magickAutoLevelImage() → Future<bool>
    Adjusts the levels of a particular image channel by scaling the minimum and maximum values to the full quantum range.
    magickAutoOrientImage() → Future<bool>
    Adjusts an image so that its orientation is suitable $ for viewing (i.e. top-left orientation).
    magickAutoThresholdImage(AutoThresholdMethod method) → Future<bool>
    Automatically performs image thresholding dependent on which method you specify.
    magickBilateralBlurImage({required double radius, required double sigma, required double intensitySigma, required double spatialSigma}) → Future<bool>
    magickBilateralBlurImage() is a non-linear, edge-preserving, and noise-reducing smoothing filter for images. It replaces the intensity of each pixel with a weighted average of intensity values from nearby pixels. This weight is based on a Gaussian distribution. The weights depend not only on Euclidean distance of pixels, but also on the radiometric differences (e.g., range differences, such as color intensity, depth distance, etc.). This preserves sharp edges.
    magickBlackThresholdImage(PixelWand pixelWand) → Future<bool>
    magickBlackThresholdImage() is like MagickThresholdImage() but forces all pixels below the threshold into black while leaving all pixels above the threshold unchanged.
    magickBlueShiftImage([double factor = 1.5]) → Future<bool>
    Mutes the colors of the image to simulate a scene at nighttime in the moonlight.
    magickBlurImage({required double radius, required double sigma}) → Future<bool>
    magickBlurImage() blurs an image. We convolve the image with a gaussian operator of the given radius and standard deviation (sigma). For reasonable results, the radius should be larger than sigma. Use a radius of 0 and BlurImage() selects a suitable radius for you.
    magickBorderImage({required PixelWand borderColorWand, required int width, required int height, required CompositeOperator compose}) → Future<bool>
    magickBorderImage() surrounds the image with a border of the color defined by the bordercolor pixel wand.
    magickBrightnessContrastImage({required double brightness, required double contrast}) → Future<bool>
    Use magickBrightnessContrastImage() to change the brightness and/or contrast of an image. It converts the brightness and contrast parameters into slope and intercept and calls a polynomial function to apply to the image.
    magickCannyEdgeImage({required double radius, required double sigma, required double lowerPercent, required double upperPercent}) → Future<bool>
    magickCannyEdgeImage() uses a multi-stage algorithm to detect a wide range of edges in images.
    magickChannelFxImage(String expression) → Future<MagickWand?>
    magickChannelFxImage() applies a channel expression to the specified image. The expression consists of one or more channels, either mnemonic or numeric (e.g. red, 1), separated by actions as follows: <=> exchange two channels (e.g. red<=>blue) => transfer a channel to another (e.g. red=>green) , separate channel operations (e.g. red, green) | read channels from next input image (e.g. red | green) ; write channels to next output image (e.g. red; green; blue) A channel without a operation symbol implies extract. For example, to create 3 grayscale images from the red, green, and blue channels of an image, use: -channel-fx "red; green; blue".
    magickCharcoalImage({required double radius, required double sigma}) → Future<bool>
    Simulates a charcoal drawing.
    magickChopImage({required int width, required int height, required int x, required int y}) → Future<bool>
    Removes a region of an image and collapses the image to occupy the removed portion.
    magickClaheImage({required int width, required int height, required double numberBins, required double clipLimit}) → Future<bool>
    magickCLAHEImage() is a variant of adaptive histogram equalization in which the contrast amplification is limited, so as to reduce this problem of noise amplification.
    magickClampImage() → Future<bool>
    Restricts the color range from 0 to the quantum depth.
    magickClearException() → bool
    Clears any exceptions associated with this wand.
    magickClipImage() → Future<bool>
    Clips along the first path from the 8BIM profile, if present.
    magickClipImagePath({required String pathName, required bool inside}) → Future<bool>
    Clips along the named paths from the 8BIM profile, if present. Later operations take effect inside the path. Id may be a number if preceded with #, to work on a numbered path, e.g., "#1" to use the first path.
    magickClutImage({required MagickWand clutImage, required PixelInterpolateMethod method}) → Future<bool>
    Replaces colors in the image from a color lookup table.
    magickCoalesceImages() → Future<MagickWand?>
    magickCoalesceImages() composites a set of images while respecting any page offsets and disposal methods. GIF, MIFF, and MNG animation sequences typically start with an image background and each subsequent image varies in size and offset. magickCoalesceImages() returns a new sequence where each image in the sequence is the same size as the first and composited with the next image in the sequence.
    magickColorDecisionListImage(String colorCorrectionCollection) → Future<bool>
    magickColorDecisionListImage() accepts a lightweight Color Correction Collection (CCC) file which solely contains one or more color corrections and applies the color correction to the image. Here is a sample CCC file: which includes the offset, slope, and power for each of the RGB channels as well as the saturation.
    magickColorizeImage({required PixelWand colorize, required PixelWand blend}) → Future<bool>
    Blends the fill color with each pixel in the image.
    magickColorMatrixImage({required KernelInfo colorMatrix}) → Future<bool>
    Apply color transformation to an image. The method permits saturation changes, hue rotation, luminance to alpha, and various other effects. Although variable-sized transformation matrices can be used, typically one uses a 5x5 matrix for an RGBA image and a 6x6 for CMYKA (or RGBA with offsets). The matrix is similar to those used by Adobe Flash except offsets are in column 6 rather than 5 (in support of CMYKA images) and offsets are normalized (divide Flash offset by 255).
    magickColorThresholdImage({required PixelWand startColor, required PixelWand stopColor}) → Future<bool>
    Forces all pixels in the color range to white otherwise black.
    magickCombineImages(ColorspaceType colorSpace) → Future<MagickWand?>
    magickCombineImages() combines one or more images into a single image. The grayscale value of the pixels of each image in the sequence is assigned in order to the specified channels of the combined image. The typical ordering would be image 1 => Red, 2 => Green, 3 => Blue, etc.
    magickCommentImage(String comment) → Future<bool>
    magickCommentImage() adds a comment to your image.
    magickCompareImages({required MagickWand reference, required MetricType metric, required Float64List distortion}) → Future<MagickWand?>
    Compares an image to a reconstructed image and returns the specified difference image.
    magickCompareImagesLayers(LayerMethod method) → Future<MagickWand?>
    magickCompareImagesLayers() compares each image with the next in a sequence and returns the maximum bounding region of any pixel differences it discovers.
    magickComplexImages(ComplexOperator operator) → Future<MagickWand?>
    Performs complex mathematics on an image sequence.
    magickCompositeImage({required MagickWand sourceImage, required CompositeOperator compose, required bool clipToSelf, required int x, required int y}) → Future<bool>
    Composite one image onto another at the specified offset.
    magickCompositeImageGravity({required MagickWand sourceWand, required CompositeOperator compose, required GravityType gravity}) → Future<bool>
    Composite one image onto another using the specified gravity.
    magickCompositeLayers({required MagickWand sourceWand, required CompositeOperator compose, required int x, required int y}) → Future<bool>
    magickCompositeLayers() composite the images in the source wand over the images in the destination wand in sequence, starting with the current image in both lists. Each layer from the two image lists are composted together until the end of one of the image lists is reached. The offset of each composition is also adjusted to match the virtual canvas offsets of each layer. As such the given offset is relative to the virtual canvas, and not the actual image. Composition uses given x and y offsets, as the 'origin' location of the source images virtual canvas (not the real image) allowing you to compose a list of 'layer images' into the destination images. This makes it well suitable for directly composing 'Clears Frame Animations' or 'Coalesced Animations' onto a static or other 'Coalesced Animation' destination image list. GIF disposal handling is not looked at. Special case:- If one of the image sequences is the last image (just a single image remaining), that image is repeatedly composed with all the images in the other image list. Either the source or destination lists may be the single image, for this situation. In the case of a single destination image (or last image given), that image will be cloned to match the number of images remaining in the source image list. This is equivalent to the "-layer Composite" Shell API operator.
    magickConstituteImageFromCharPixel({required int columns, required int rows, required String map, required Uint8List pixels}) → Future<bool>
    Adds an image to the wand comprised of the pixel data you supply. The pixel data must be in scanline order top-to-bottom. For example, to create a 640x480 image from unsigned red-green-blue character data, in the C API, you would use
    magickConstituteImageFromDoublePixel({required int columns, required int rows, required String map, required Float64List pixels}) → Future<bool>
    Adds an image to the wand comprised of the pixel data you supply. The pixel data must be in scanline order top-to-bottom.
    magickConstituteImageFromFloatPixel({required int columns, required int rows, required String map, required Float32List pixels}) → Future<bool>
    Adds an image to the wand comprised of the pixel data you supply. The pixel data must be in scanline order top-to-bottom.
    magickConstituteImageFromLongLongPixel({required int columns, required int rows, required String map, required Uint64List pixels}) → Future<bool>
    Adds an image to the wand comprised of the pixel data you supply. The pixel data must be in scanline order top-to-bottom.
    magickConstituteImageFromLongPixel({required int columns, required int rows, required String map, required Uint32List pixels}) → Future<bool>
    Adds an image to the wand comprised of the pixel data you supply. The pixel data must be in scanline order top-to-bottom.
    magickConstituteImageFromShortPixel({required int columns, required int rows, required String map, required Uint16List pixels}) → Future<bool>
    Adds an image to the wand comprised of the pixel data you supply. The pixel data must be in scanline order top-to-bottom.
    magickContrastImage(bool sharpen) → Future<bool>
    Enhances the intensity differences between the lighter and darker elements of the image. Set sharpen to a value other than 0 to increase the image contrast otherwise the contrast is reduced.
    magickContrastStretchImage({required double whitePoint, required double blackPoint}) → Future<bool>
    Enhances the contrast of a color image by adjusting the pixels color to span the entire range of colors available. You can also reduce the influence of a particular channel with a gamma value of 0.
    magickConvolveImage({required KernelInfo kernel}) → Future<bool>
    Applies a custom convolution kernel to the image.
    magickCropImage({required int width, required int height, required int x, required int y}) → Future<bool>
    Extracts a region of the image.
    magickCycleColormapImage(int displace) → Future<bool>
    Displaces an image's colormap by a given number of positions. If you cycle the colormap a number of times you can produce a psychodelic effect.
    magickDecipherImage(String passphrase) → Future<bool>
    Converts cipher pixels to plain pixels.
    magickDeconstructImages() → Future<MagickWand?>
    Compares each image with the next in a sequence and returns the maximum bounding region of any pixel differences it discovers.
    magickDeleteImageArtifact(String artifact) → bool
    Deletes a wand artifact.
    magickDeleteImageProperty(String property) → bool
    Deletes a wand property.
    magickDeleteOption(String option) → bool
    Deletes a wand option.
    magickDeskewImage(double threshold) → Future<bool>
    Removes skew from the image. Skew is an artifact that occurs in scanned images because of the camera being misaligned, imperfections in the scanning or surface, or simply because the paper was not placed completely flat when scanned.
    magickDespeckleImage() → Future<bool>
    Reduces the speckle noise in an image while preserving the edges of the original image.
    magickDistortImage({required DistortMethod method, required Float64List arguments, required bool bestFit}) → Future<bool>
    Distorts an image using various distortion methods, by mapping color lookups of the source image to a new destination image usually of the same size as the source image, unless 'bestfit' is set to true.
    magickDrawImage(DrawingWand drawWand) → Future<bool>
    Renders the drawing wand on the current image.
    magickEdgeImage(double radius) → Future<bool>
    Enhance edges within the image with a convolution filter of the given radius. Use a radius of 0 and Edge() selects a suitable radius for you.
    magickEmbossImage({required double radius, required double sigma}) → Future<bool>
    MagickEmbossImage() returns a grayscale image with a three-dimensional effect. We convolve the image with a Gaussian operator of the given radius and standard deviation (sigma). For reasonable results, radius should be larger than sigma. Use a radius of 0 and Emboss() selects a suitable radius for you.
    magickEncipherImage(String passphrase) → Future<bool>
    MagickEncipherImage() converts plaint pixels to cipher pixels.
    magickEnhanceImage() → Future<bool>
    MagickEnhanceImage() applies a digital filter that improves the quality of a noisy image.
    magickEqualizeImage() → Future<bool>
    MagickEqualizeImage() equalizes the image histogram.
    magickEvaluateImage({required MagickEvaluateOperator operator, required double value}) → Future<bool>
    MagickEvaluateImage() applies an arithmetic, relational, or logical expression to an image. Use these operators to lighten or darken an image, to increase or decrease contrast in an image, or to produce the "negative" of an image.
    magickExportImageCharPixels({required int x, required int y, required int columns, required int rows, required String map}) → Future<Uint8List?>
    Extracts pixel data from an image and returns it to you. The data is returned as in the order specified by map.
    magickExportImageDoublePixels({required int x, required int y, required int columns, required int rows, required String map}) → Future<Float64List?>
    Extracts pixel data from an image and returns it to you. The data is returned as in the order specified by map.
    magickExportImageFloatPixels({required int x, required int y, required int columns, required int rows, required String map}) → Future<Float32List?>
    Extracts pixel data from an image and returns it to you. The data is returned as in the order specified by map.
    magickExportImageLongLongPixels({required int x, required int y, required int columns, required int rows, required String map}) → Future<Uint64List?>
    Extracts pixel data from an image and returns it to you. The data is returned as in the order specified by map.
    magickExportImageLongPixels({required int x, required int y, required int columns, required int rows, required String map}) → Future<Uint32List?>
    Extracts pixel data from an image and returns it to you. The data is returned as in the order specified by map.
    magickExportImageShortPixels({required int x, required int y, required int columns, required int rows, required String map}) → Future<Uint16List?>
    Extracts pixel data from an image and returns it to you. The data is returned as in the order specified by map.
    magickExtentImage({required int width, required int height, required int x, required int y}) → Future<bool>
    Extends the image as defined by the geometry, gravity, and wand background color. Set the (x,y) offset of the geometry to move the original wand relative to the extended wand.
    magickFlipImage() → Future<bool>
    Creates a vertical mirror image by reflecting the pixels around the central x-axis.
    magickFloodfillPaintImage({required PixelWand fill, required double fuzz, required PixelWand bordercolor, required int x, required int y, required bool invert}) → Future<bool>
    Changes the color value of any pixel that matches target and is an immediate neighbor. If the method FillToBorderMethod is specified, the color value is changed for any neighbor pixel that does not match the bordercolor member of image.
    magickFlopImage() → Future<bool>
    Creates a horizontal mirror image by reflecting the pixels around the central y-axis.
    magickFrameImage({required PixelWand matteColor, required int width, required int height, required int innerBevel, required int outerBevel, required CompositeOperator compose}) → Future<bool>
    Adds a simulated three-dimensional border around the image. The width and height specify the border width of the vertical and horizontal sides of the frame. The inner and outer bevels indicate the width of the inner and outer shadows of the frame.
    magickFunctionImage({required MagickFunctionType function, required Float64List arguments}) → Future<bool>
    Applies an arithmetic, relational, or logical expression to an image. Use these operators to lighten or darken an image, to increase or decrease contrast in an image, or to produce the "negative" of an image.
    magickFxImage(String expression) → Future<MagickWand?>
    Evaluate expression for each pixel in the image.
    magickGammaImage(double level) → Future<bool>
    Gamma-corrects an image. The same image viewed on different devices will have perceptual differences in the way the image's intensities are represented on the screen. Specify individual gamma levels for the red, green, and blue channels, or adjust all three with the gamma parameter. Values typically range from 0.8 to 2.3.
    magickGaussianBlurImage({required double radius, required double sigma}) → Future<bool>
    Blurs an image. We convolve the image with a Gaussian operator of the given radius and standard deviation (sigma). For reasonable results, the radius should be larger than sigma. Use a radius of 0 and magickGaussianBlurImage() selects a suitable radius for you.
    magickGetAntialias() → bool
    Returns the antialias property associated with the wand.
    magickGetBackgroundColor() → PixelWand
    Returns the wand background color.
    magickGetColorspace() → ColorspaceType
    Gets the wand colorspace type.
    magickGetCompression() → CompressionType
    Gets the wand compression type.
    magickGetCompressionQuality() → int
    Gets the wand compression quality.
    magickGetException() → MagickGetExceptionResult
    Returns the severity, reason, and description of any error that occurs when using other methods with this wand. For example, failure to read an image using magickReadImage will cause an exception to be associated with this wand and which can be retrieved by this method.
    magickGetExceptionType() → ExceptionType
    Returns the exception type associated with this wand. If no exception has occurred, UndefinedException is returned.
    magickGetFilename() → String
    Returns the filename associated with an image sequence.
    magickGetFont() → String?
    Returns the font associated with the MagickWand.
    magickGetFormat() → String
    Returns the format of the magick wand.
    magickGetGravity() → GravityType
    Gets the wand gravity.
    magickGetImage() → Future<MagickWand?>
    Gets the image at the current image index.
    magickGetImageAlphaChannel() → bool
    Returns false if the image alpha channel is not activated. That is, the image is RGB rather than RGBA or CMYK rather than CMYKA.
    magickGetImageArtifact(String artifact) → String?
    Returns a value associated with the specified artifact.
    magickGetImageArtifacts(String pattern) → List<String>?
    Returns all the artifact names that match the specified pattern associated with a wand. Use magickGetImageProperty() to return the value of a particular artifact.
    magickGetImageBackgroundColor(PixelWand backgroundColor) → bool
    Returns the image background color.
    magickGetImageBlob() → Future<Uint8List?>
    Implements direct to memory image formats. It returns the image as a blob (a formatted "file" in memory), starting from the current position in the image sequence. Use MagickSetImageFormat() to set the format to write to the blob (GIF, JPEG, PNG, etc.). Utilize magickResetIterator() to ensure the write is from the beginning of the image sequence.
    magickGetImageBluePrimary() → MagickGetImageBluePrimaryResult?
    Returns the chromaticity blue primary point for the image.
    magickGetImageBorderColor(PixelWand borderColor) → bool
    Returns the image border color.
    magickGetImageColormapColor(int index, PixelWand color) → bool
    Returns the color of the specified colormap index.
    magickGetImageColors() → Future<int>
    Gets the number of unique colors in the image.
    magickGetImageColorspace() → ColorspaceType
    Gets the image colorspace.
    magickGetImageCompose() → CompositeOperator
    MagickGetImageCompose() returns the composite operator associated with the image.
    magickGetImageCompression() → CompressionType
    MagickGetImageCompression() gets the image compression.
    magickGetImageCompressionQuality() → int
    MagickGetImageCompressionQuality() gets the image compression quality.
    magickGetImageDelay() → int
    MagickGetImageDelay() gets the image delay.
    magickGetImageDepth() → int
    MagickGetImageDepth() gets the image depth.
    magickGetImageDispose() → DisposeType
    MagickGetImageDispose() gets the image disposal method.
    magickGetImageEndian() → EndianType
    MagickGetImageEndian() gets the image endian.
    magickGetImageFeatures(int distance) → Future<ChannelFeatures?>
    Returns features for each channel in the image in each of four directions (horizontal, vertical, left and right diagonals) for the specified distance. The features include the angular second moment, contrast, correlation, sum of squares: variance, inverse difference moment, sum average, sum variance, sum entropy, entropy, difference variance, difference entropy, information measures of correlation 1, information measures of correlation 2, and maximum correlation coefficient.
    magickGetImageFilename() → String
    MagickGetImageFilename() returns the filename of a particular image in a sequence.
    magickGetImageFormat() → String
    MagickGetImageFormat() returns the format of a particular image in a sequence.
    magickGetImageFuzz() → double
    MagickGetImageFuzz() gets the image fuzz.
    magickGetImageGamma() → double
    MagickGetImageGamma() gets the image gamma.
    magickGetImageGravity() → GravityType
    MagickGetImageGravity() gets the image gravity.
    magickGetImageGreenPrimary() → MagickGetImageGreenPrimaryResult?
    MagickGetImageGreenPrimary() returns the chromaticity green primary point.
    magickGetImageHeight() → int
    MagickGetImageHeight() returns the image height.
    magickGetImageHistogram() → Future<List<PixelWand>?>
    MagickGetImageHistogram() returns the image histogram as an array of PixelWand wands.
    magickGetImageInterlaceScheme() → InterlaceType
    MagickGetImageInterlaceScheme() gets the image interlace scheme.
    magickGetImageInterpolateMethod() → PixelInterpolateMethod
    MagickGetImageInterpolateMethod() returns the interpolation method for the specified image.
    magickGetImageIterations() → int
    MagickGetImageIterations() gets the image iterations.
    magickGetImageKurtosis() → Future<MagickGetImageKurtosisResult?>
    Gets the kurtosis and skewness of one or more image channels.
    magickGetImageLength() → int?
    MagickGetImageLength() returns the image length in bytes.
    magickGetImageMask(PixelMask type) → Future<MagickWand?>
    Gets the image clip mask at the current image index.
    magickGetImageMatteColor(PixelWand pixelWand) → bool
    MagickGetImageMatteColor() returns the image matte color.
    magickGetImageMean() → Future<MagickGetImageMeanResult?>
    Gets the mean and standard deviation of one or more image channels.
    magickGetImageOrientation() → OrientationType
    MagickGetImageOrientation() returns the image orientation.
    magickGetImagePage() → MagickGetImagePageResult?
    MagickGetImagePage() returns the page geometry associated with the image.
    magickGetImagePixelColor({required int x, required int y, required PixelWand pixelWand}) → bool
    MagickGetImagePixelColor() gets the color of the specified pixel.
    magickGetImageProfile(String name) → Uint8List?
    Returns the named image profile.
    magickGetImageProfiles(String pattern) → List<String>?
    MagickGetImageProfiles() returns all the profile names that match the specified pattern associated with a wand. Use magickGetImageProfile() to return the value of a particular property.
    magickGetImageProperties(String pattern) → List<String>?
    Returns all the property names that match the specified pattern associated with a wand. Use magickGetImageProperty() to return the value of a particular property.
    magickGetImageProperty(String property) → String?
    Returns a value associated with the specified property.
    magickGetImageRange() → Future<MagickGetImageRangeResult?>
    Gets the range for one or more image channels.
    magickGetImageRedPrimary() → MagickGetImageRedPrimaryResult?
    MagickGetImageRedPrimary() returns the chromaticity red primary point.
    magickGetImageRegion({required int width, required int height, required int x, required int y}) → Future<MagickWand?>
    MagickGetImageRegion() extracts a region of the image and returns it as a new wand.
    magickGetImageRenderingIntent() → RenderingIntent
    MagickGetImageRenderingIntent() gets the image rendering intent.
    magickGetImageResolution() → MagickGetImageResolutionResult?
    MagickGetImageResolution() gets the image X and Y resolution.
    magickGetImagesBlob() → Future<Uint8List?>
    Implements direct to memory image formats. It returns the image sequence as a blob and its length. The format of the image determines the format of the returned blob (GIF, JPEG, PNG, etc.). To return a different image format, use MagickSetImageFormat().
    magickGetImageScene() → int
    MagickGetImageScene() gets the image scene.
    magickGetImageSignature() → String?
    MagickGetImageSignature() generates an SHA-256 message digest for the image pixel stream.
    magickGetImageStatistics() → Future<ChannelStatistics?>
    Returns statistics for each channel in the image. The statistics include the channel depth, its minima and maxima, the mean, the standard deviation, the kurtosis and the skewness.
    magickGetImageTicksPerSecond() → int
    MagickGetImageTicksPerSecond() gets the image ticks-per-second.
    magickGetImageTotalInkDensity() → Future<double>
    MagickGetImageTotalInkDensity() gets the image total ink density.
    magickGetImageType() → ImageType
    MagickGetImageType() gets the potential image type.
    magickGetImageUnits() → ResolutionType
    MagickGetImageUnits() gets the image units of resolution.
    magickGetImageVirtualPixelMethod() → VirtualPixelMethod
    MagickGetImageVirtualPixelMethod() returns the virtual pixel method for the specified image.
    magickGetImageWhitePoint() → MagickGetImageWhitePointResult?
    MagickGetImageWhitePoint() returns the chromaticity white point.
    magickGetImageWidth() → int
    MagickGetImageWidth() returns the image width.
    magickGetInterlaceScheme() → InterlaceType
    Gets the wand interlace scheme.
    magickGetInterpolateMethod() → PixelInterpolateMethod
    Gets the wand compression.
    magickGetIteratorIndex() → int
    Returns the position of the iterator in the image list.
    magickGetNumberImages() → int
    MagickGetNumberImages() returns the number of images associated with a magick wand.
    magickGetOption(String key) → String?
    Returns a value associated with a wand and the specified key.
    magickGetOptions(String pattern) → List<String>?
    Returns all the option names that match the specified pattern associated with a wand. Use magickGetOption() to return the value of a particular option.
    magickGetOrientation() → OrientationType
    Gets the wand orientation type.
    magickGetPage() → MagickGetPageResult?
    Returns the page geometry associated with the magick wand.
    magickGetPointsize() → double
    Returns the font pointsize associated with the MagickWand.
    magickGetResolution() → MagickGetResolutionResult?
    Gets the image X and Y resolution.
    magickGetSamplingFactors() → Float64List?
    Gets the horizontal and vertical sampling factor.
    magickGetSize() → MagickGetSizeResult?
    Returns the size associated with the magick wand.
    magickGetSizeOffset() → int?
    Returns the size offset associated with the magick wand.
    magickGetType() → ImageType
    Returns the wand type
    magickHaldClutImage(MagickWand haldWand) → Future<bool>
    MagickHaldClutImage() replaces colors in the image from a Hald color lookup table. A Hald color lookup table is a 3-dimensional color cube mapped to 2 dimensions. Create it with the HALD coder. You can apply any color transformation to the Hald image and then use this method to apply the transform to the image.
    magickHasNextImage() → bool
    MagickHasNextImage() returns true if the wand has more images when traversing the list in the forward direction
    magickHasPreviousImage() → bool
    MagickHasPreviousImage() returns true if the wand has more images when traversing the list in the reverse direction.
    magickHoughLineImage(int width, int height, int threshold) → Future<bool>
    MagickHoughLineImage() can be used in conjunction with any binary edge extracted image (we recommend Canny) to identify lines in the image. The algorithm accumulates counts for every white pixel for every possible orientation (for angles from 0 to 179 in 1 degree increments) and distance from the center of the image to the corner (in 1 px increments) and stores the counts in an accumulator matrix of angle vs distance. The size of the accumulator is 180x(diagonal/2). Next it searches this space for peaks in counts and converts the locations of the peaks to slope and intercept in the normal x,y input image space. Use the slope/intercepts to find the endpoints clipped to the bounds of the image. The lines are then drawn. The counts are a measure of the length of the lines.
    magickIdentifyImage() → Future<String?>
    MagickIdentifyImage() identifies an image by its attributes. Attributes include the image width, height, size, and others.
    magickIdentifyImageType() → Future<ImageType>
    MagickIdentifyImageType() gets the potential image type:
    magickImplodeImage({required double amount, required PixelInterpolateMethod method}) → Future<bool>
    MagickImplodeImage() creates a new image that is a copy of an existing one with the image pixels "implode" by the specified percentage.
    magickImportImageCharPixels({required int x, required int y, required int columns, required int rows, required String map, required Uint8List pixels}) → Future<bool>
    MagickImportImageCharPixels() accepts pixel data and stores it in the image at the location you specify. The method returns true on success otherwise false if an error is encountered. The pixel data should be as the order specified by map.
    magickImportImageDoublePixels({required int x, required int y, required int columns, required int rows, required String map, required Float64List pixels}) → Future<bool>
    MagickImportImageDoublePixels() accepts pixel data and stores it in the image at the location you specify. The method returns true on success otherwise false if an error is encountered. The pixel data should be as the order specified by map.
    magickImportImageFloatPixels({required int x, required int y, required int columns, required int rows, required String map, required Float32List pixels}) → Future<bool>
    MagickImportImageFloatPixels() accepts pixel data and stores it in the image at the location you specify. The method returns true on success otherwise false if an error is encountered. The pixel data should be as the order specified by map.
    magickImportImageLongLongPixels({required int x, required int y, required int columns, required int rows, required String map, required Uint64List pixels}) → Future<bool>
    MagickImportImageLongLongPixels() accepts pixel data and stores it in the image at the location you specify. The method returns true on success otherwise false if an error is encountered. The pixel data should be as the order specified by map.
    magickImportImageLongPixels({required int x, required int y, required int columns, required int rows, required String map, required Uint32List pixels}) → Future<bool>
    MagickImportImageLongPixels() accepts pixel data and stores it in the image at the location you specify. The method returns true on success otherwise false if an error is encountered. The pixel data should be as the order specified by map.
    magickImportImageShortPixels({required int x, required int y, required int columns, required int rows, required String map, required Uint16List pixels}) → Future<bool>
    MagickImportImageShortPixels() accepts pixel data and stores it in the image at the location you specify. The method returns true on success otherwise false if an error is encountered. The pixel data should be as the order specified by map.
    magickInterpolativeResizeImage({required int columns, required int rows, required PixelInterpolateMethod method}) → Future<bool>
    MagickInterpolativeResizeImage() resize image using a interpolative method.
    magickKmeansImage({required int numberColors, required int maxIterations, required double tolerance}) → Future<bool>
    MagickKmeansImage() applies k-means color reduction to an image. This is a colorspace clustering or segmentation technique.
    magickKuwaharaImage({required double radius, required double sigma}) → Future<bool>
    Use MagickKuwaharaImage() is an edge preserving noise reduction filter.
    magickLabelImage(String label) → Future<bool>
    MagickLabelImage() adds a label to your image.
    magickLevelImage({required double blackPoint, required double gamma, required double whitePoint}) → Future<bool>
    MagickLevelImage() adjusts the levels of an image by scaling the colors falling between specified white and black points to the full available quantum range. The parameters provided represent the black, mid, and white points. The black point specifies the darkest color in the image. Colors darker than the black point are set to zero. Mid point specifies a gamma correction to apply to the image. White point specifies the lightest color in the image. Colors brighter than the white point are set to the maximum quantum value.
    magickLevelImageColors({required PixelWand blackColor, required PixelWand whiteColor, required bool invert}) → Future<bool>
    MagickLevelImageColors() maps the given color to "black" and "white" values, linearly spreading out the colors, and level values on a channel by channel bases, as per LevelImage(). The given colors allows you to specify different level ranges for each of the color channels separately.
    magickLevelizeImage({required double blackPoint, required double whitePoint, required double gamma}) → Future<bool>
    MagickLevelizeImage() applies the reversed MagickLevelImage(). It compresses the full range of color values, so that they lie between the given black and white points. Gamma is applied before the values are mapped. It can be used to de-contrast a greyscale image to the exact levels specified.
    magickLinearStretchImage({required double blackPoint, required double whitePoint}) → Future<bool>
    MagickLinearStretchImage() stretches with saturation the image intensity. You can also reduce the influence of a particular channel with a gamma value of 0.
    magickLiquidRescaleImage({required int columns, required int rows, required double deltaX, required double rigidity}) → Future<bool>
    MagickLiquidRescaleImage() rescales image with seam carving.
    magickLocalContrastImage({required double radius, required double strength}) → Future<bool>
    MagickLocalContrastImage() attempts to increase the appearance of large-scale light-dark transitions. Local contrast enhancement works similarly to sharpening with an unsharp mask, however the mask is instead created using an image with a greater blur distance.
    magickMagnifyImage() → Future<bool>
    MagickMagnifyImage() is a convenience method that scales an image proportionally to twice its original size.
    magickMeanShiftImage({required int width, required int height, required double colorDistance}) → Future<bool>
    MagickMeanShiftImage() delineate arbitrarily shaped clusters in the image. For each pixel, it visits all the pixels in the neighborhood specified by the window centered at the pixel and excludes those that are outside the radius=(window-1)/2 surrounding the pixel. From those pixels, it finds those that are within the specified color distance from the current mean, and computes a new x,y centroid from those coordinates and a new mean. This new x,y centroid is used as the center for a new window. This process iterates until it converges and the final mean is replaces the (original window center) pixel value. It repeats this process for the next pixel, etc., until it processes all pixels in the image. Results are typically better with colorspaces other than sRGB. We recommend YIQ, YUV or YCbCr.
    magickMergeImageLayers(LayerMethod method) → Future<MagickWand?>
    MagickMergeImageLayers() composes all the image layers from the current given image onward to produce a single image of the merged layers. The inital canvas's size depends on the given LayerMethod, and is initialized using the first images background color. The images are then composited onto that image in sequence using the given composition that has been assigned to each individual image.
    magickMinifyImage() → Future<bool>
    MagickMinifyImage() is a convenience method that scales an image proportionally to one-half its original size
    magickModulateImage({required double brightness, required double saturation, required double hue}) → Future<bool>
    MagickModulateImage() lets you control the brightness, saturation, and hue of an image. Hue is the percentage of absolute rotation from the current position. For example 50 results in a counter-clockwise rotation of 90 degrees, 150 results in a clockwise rotation of 90 degrees, with 0 and 200 both resulting in a rotation of 180 degrees. To increase the color brightness by 20 and decrease the color saturation by 10 and leave the hue unchanged, use: 120,90,100.
    magickMontageImage({required DrawingWand drawingWand, required String tileGeometry, required String thumbnailGeometry, required MontageMode mode, required String frame}) → Future<MagickWand?>
    MagickMontageImage() creates a composite image by combining several separate images. The images are tiled on the composite image with the name of the image optionally appearing just below the individual tile.
    magickMorphImages(int numberFrames) → Future<MagickWand?>
    MagickMorphImages() method morphs a set of images. Both the image pixels and size are linearly interpolated to give the appearance of a meta-morphosis from one image to the next.
    magickMorphologyImage({required MorphologyMethod method, required int iterations, required KernelInfo kernel}) → Future<bool>
    MagickMorphologyImage() applies a user supplied kernel to the image according to the given morphology method.
    magickMotionBlurImage({required double radius, required double sigma, required double angle}) → Future<bool>
    MagickMotionBlurImage() simulates motion blur. We convolve the image with a Gaussian operator of the given radius and standard deviation (sigma). For reasonable results, radius should be larger than sigma. Use a radius of 0 and MotionBlurImage() selects a suitable radius for you. Angle gives the angle of the blurring motion.
    magickNegateImage(bool gray) → Future<bool>
    MagickNegateImage() negates the colors in the reference image. The Grayscale option means that only grayscale values within the image are negated.
    magickNewImage({required int width, required int height, required PixelWand background}) → Future<bool>
    MagickNewImage() adds a blank image canvas of the specified size and background color to the wand.
    magickNextImage() → bool
    MagickNextImage() sets the next image in the wand as the current image. It is typically used after MagickResetIterator(), after which its first use will set the first image as the current image (unless the wand is empty). It will return false when no more images are left to be returned which happens when the wand is empty, or the current image is the last image. When the above condition (end of image list) is reached, the iterator is automatically set so that you can start using MagickPreviousImage() to again iterate over the images in the reverse direction, starting with the last image (again). You can jump to this condition immediately using MagickSetLastIterator().
    magickNormalizeImage() → Future<bool>
    MagickNormalizeImage() enhances the contrast of a color image by adjusting the pixels color to span the entire range of colors available.
    magickOilPaintImage({required double radius, required double sigma}) → Future<bool>
    MagickOilPaintImage() applies a special effect filter that simulates an oil painting. Each pixel is replaced by the most frequent color occurring in a circular region defined by radius.
    magickOpaquePaintImage({required PixelWand target, required PixelWand fill, required double fuzz, required bool invert}) → Future<bool>
    MagickOpaquePaintImage() changes any pixel that matches color with the color defined by fill.
    magickOptimizeImageLayers() → Future<MagickWand?>
    MagickOptimizeImageLayers() compares each image the GIF disposed forms of the previous image in the sequence. From this it attempts to select the smallest cropped image to replace each frame, while preserving the results of the animation.
    magickOptimizeImageTransparency() → Future<bool>
    MagickOptimizeImageTransparency() takes a frame optimized GIF animation, and compares the overlayed pixels against the disposal image resulting from all the previous frames in the animation. Any pixel that does not change the disposal image (and thus does not effect the outcome of an overlay) is made transparent.
    magickOrderedDitherImage(String thresholdMap) → Future<bool>
    MagickOrderedDitherImage() performs an ordered dither based on a number of pre-defined dithering threshold maps, but over multiple intensity levels, which can be different for different channels, according to the input arguments.
    magickPingImage(String fileName) → Future<bool>
    MagickPingImage() is the same as MagickReadImage() except the only valid information returned is the image width, height, size, and format. It is designed to efficiently obtain this information from a file without reading the entire image sequence into memory.
    magickPolaroidImage({required DrawingWand drawingWand, required String caption, required double angle, required PixelInterpolateMethod method}) → Future<bool>
    MagickPolaroidImage() simulates a Polaroid picture.
    magickPosterizeImage({required int levels, required DitherMethod method}) → Future<bool>
    MagickPosterizeImage() reduces the image to a limited number of color level.
    magickPreviewImages(PreviewType preview) → Future<MagickWand?>
    MagickPreviewImages() tiles 9 thumbnails of the specified image with an image processing operation applied at varying strengths. This helpful to quickly pin-point an appropriate parameter for an image processing operation.
    magickPreviousImage() → bool
    MagickPreviousImage() sets the previous image in the wand as the current image. It is typically used after magickSetLastIterator(), after which its first use will set the last image as the current image (unless the wand is empty). It will return false when no more images are left to be returned which happens when the wand is empty, or the current image is the first image. At that point the iterator is than reset to again process images in the forward direction, again starting with the first image in list. Images added at this point are prepended. Also at that point any images added to the wand using magickAddImages() or magickReadImages() will be prepended before the first image. In this sense the condition is not quite exactly the same as magickResetIterator().
    magickProfileImage(String name, Uint8List? profile) → bool
    Adds or removes a ICC, IPTC, or generic profile from an image. If the profile is NULL, it is removed from the image otherwise added. Use a name of '*' and a profile of NULL to remove all profiles from the image.
    magickQuantizeImage({required int numberColors, required ColorspaceType colorspace, required int treeDepth, required DitherMethod ditherMethod, required bool measureError}) → Future<bool>
    MagickQuantizeImage() analyzes the colors within a reference image and chooses a fixed number of colors to represent the image. The goal of the algorithm is to minimize the color difference between the input and output image while minimizing the processing time.
    magickQueryFontMetrics(DrawingWand drawingWand, String text) → Float64List?
    Returns a 13 element array representing the following font metrics:
    magickQueryMultilineFontMetrics(DrawingWand drawingWand, String text) → Float64List?
    Returns a 13 element array representing the following font metrics:
    magickRaiseImage({required int width, required int height, required int x, required int y, required bool raise}) → Future<bool>
    MagickRaiseImage() creates a simulated three-dimensional button-like effect by lightening and darkening the edges of the image. Members width and height of raise_info define the width of the vertical and horizontal edge of the effect.
    magickRandomThresholdImage({required double low, required double high}) → Future<bool>
    MagickRandomThresholdImage() changes the value of individual pixels based on the intensity of each pixel compared to threshold. The result is a high-contrast, two color image.
    magickRangeThresholdImage({required double lowBlack, required double lowWhite, required double highWhite, required double highBlack}) → Future<bool>
    MagickRangeThresholdImage() applies soft and hard thresholding.
    magickReadImage(String imageFilePath) → Future<bool>
    Reads an image or image sequence. The images are inserted just before the current image pointer position. Use magickSetFirstIterator(), to insert new images before all the current images in the wand, magickSetLastIterator() to append add to the end, magickSetIteratorIndex() to place images just after the given index.
    magickReadImageBlob(Uint8List blob) → Future<bool>
    MagickReadImageBlob() reads an image or image sequence from a blob. In all other respects it is like MagickReadImage().
    magickRemapImage({required MagickWand remapWand, required DitherMethod ditherMethod}) → Future<bool>
    MagickRemapImage() replaces the colors of an image with the closest color from a reference image.
    magickRemoveImage() → Future<bool>
    MagickRemoveImage() removes an image from the image list.
    magickRemoveImageProfile(String name) → Uint8List?
    Removes the named image profile and returns it.
    magickResampleImage({required double xResolution, required double yResolution, required FilterType filter}) → Future<bool>
    MagickResampleImage() resample image to desired resolution. Bessel Blackman Box Catrom Cubic Gaussian Hanning Hermite Lanczos Mitchell Point Quadratic Sinc Triangle Most of the filters are FIR (finite impulse response), however, Bessel, Gaussian, and Sinc are IIR (infinite impulse response). Bessel and Sinc are windowed (brought down to zero) with the Blackman filter.
    magickResetImagePage(String page) → Future<bool>
    MagickResetImagePage() resets the Wand page canvas and position.
    magickResetIterator() → void
    Resets the wand iterator.
    magickResizeImage({required int columns, required int rows, required FilterType filter}) → Future<bool>
    MagickResizeImage() scales an image to the desired dimensions with one of these filters:
    magickRollImage({required int x, required int y}) → Future<bool>
    MagickRollImage() offsets an image as defined by x and y.
    magickRotateImage({required PixelWand background, required double degrees}) → Future<bool>
    MagickRotateImage() rotates an image the specified number of degrees. Empty triangles left over from rotating the image are filled with the background color.
    magickRotationalBlurImage(double angle) → Future<bool>
    MagickRotationalBlurImage() rotational blurs an image.
    magickSampleImage({required int columns, required int rows}) → Future<bool>
    MagickSampleImage() scales an image to the desired dimensions with pixel sampling. Unlike other scaling methods, this method does not introduce any additional color into the scaled image.
    magickScaleImage({required int columns, required int rows}) → Future<bool>
    MagickScaleImage() scales the size of an image to the given dimensions.
    magickSegmentImage({required ColorspaceType colorspace, required bool verbose, required double clusterThreshold, required double smoothThreshold}) → Future<bool>
    MagickSegmentImage() segments an image by analyzing the histograms of the color components and identifying units that are homogeneous with the fuzzy C-means technique.
    magickSelectiveBlurImage({required double radius, required double sigma, required double threshold}) → Future<bool>
    MagickSelectiveBlurImage() selectively blur an image within a contrast threshold. It is similar to the unsharpen mask that sharpens everything with contrast above a certain threshold.
    magickSeparateImage(ChannelType channel) → Future<bool>
    MagickSeparateImage() separates a channel from the image and returns a grayscale image. A channel is a particular color component of each pixel in the image.
    magickSepiaToneImage(double threshold) → Future<bool>
    MagickSepiaToneImage() applies a special effect to the image, similar to the effect achieved in a photo darkroom by sepia toning. Threshold ranges from 0 to QuantumRange and is a measure of the extent of the sepia toning. A threshold of 80 is a good starting point for a reasonable tone.
    magickSetAntialias(bool antialias) → bool
    Sets the antialias property of the wand.
    magickSetBackgroundColor(PixelWand pixelWand) → bool
    Sets the wand background color.
    magickSetColorspace(ColorspaceType colorspaceType) → bool
    Sets the wand colorspace type.
    magickSetCompression(CompressionType compressionType) → bool
    Sets the wand compression type.
    magickSetCompressionQuality(int quality) → bool
    Sets the wand compression quality.
    magickSetDepth(int depth) → bool
    Sets the wand pixel depth.
    magickSetExtract(String geometry) → bool
    Sets the extract geometry before you read or write an image file. Use it for inline cropping (e.g. 200x200+0+0) or resizing (e.g.200x200).
    magickSetFilename(String filename) → bool
    Sets the filename before you read or write an image file.
    magickSetFirstIterator() → void
    Sets the wand iterator to the first image.
    magickSetFont(String font) → bool
    Sets the font associated with the MagickWand.
    magickSetFormat(String format) → bool
    Sets the format of the magick wand.
    magickSetGravity(GravityType gravityType) → bool
    Sets the gravity type.
    magickSetImage(MagickWand setWand) → Future<bool>
    MagickSetImage() replaces the last image returned by MagickSetIteratorIndex(), MagickNextImage(), MagickPreviousImage() with the images from the specified wand.
    magickSetImageAlpha(double alpha) → Future<bool>
    MagickSetImageAlpha() sets the image to the specified alpha level.
    magickSetImageAlphaChannel(AlphaChannelOption alphaType) → Future<bool>
    MagickSetImageAlphaChannel() activates, deactivates, resets, or sets the alpha channel.
    magickSetImageArtifact(String key, String value) → bool
    Sets a key-value pair in the image artifact namespace. Artifacts differ from properties. Properties are public and are generally exported to an external image format if the format supports it. Artifacts are private and are utilized by the internal ImageMagick API to modify the behavior of certain algorithms.
    magickSetImageBackgroundColor(PixelWand background) → bool
    MagickSetImageBackgroundColor() sets the image background color.
    magickSetImageBluePrimary({required double x, required double y, required double z}) → bool
    MagickSetImageBluePrimary() sets the image chromaticity blue primary point.
    magickSetImageBorderColor(PixelWand border) → bool
    MagickSetImageBorderColor() sets the image border color.
    magickSetImageChannelMask(ChannelType channelMask) → Future<bool>
    MagickSetImageChannelMask() sets image channel mask.
    magickSetImageColor(PixelWand background) → Future<bool>
    MagickSetImageColor() set the entire wand canvas to the specified color.
    magickSetImageColormapColor({required int index, required PixelWand color}) → Future<bool>
    MagickSetImageColormapColor() sets the color of the specified colormap index.
    magickSetImageColorspace(ColorspaceType colorspace) → Future<bool>
    MagickSetImageColorspace() sets the image colorspace. But does not modify the image data.
    magickSetImageCompose(CompositeOperator compose) → bool
    MagickSetImageCompose() sets the image composite operator, useful for specifying how to composite the image thumbnail when using the MagickMontageImage() method.
    magickSetImageCompression(CompressionType compression) → bool
    MagickSetImageCompression() sets the image compression.
    magickSetImageCompressionQuality(int quality) → bool
    MagickSetImageCompressionQuality() sets the image compression quality.
    magickSetImageDelay(int delay) → bool
    MagickSetImageDelay() sets the image delay.
    magickSetImageDepth(int depth) → Future<bool>
    MagickSetImageDepth() sets the image depth.
    magickSetImageDispose(DisposeType dispose) → bool
    MagickSetImageDispose() sets the image disposal method.
    magickSetImageEndian(EndianType endian) → bool
    MagickSetImageEndian() sets the image endian method.
    magickSetImageExtent({required int columns, required int rows}) → Future<bool>
    MagickSetImageExtent() sets the image size (i.e. columns & rows).
    magickSetImageFilename(String filename) → bool
    MagickSetImageFilename() sets the filename of a particular image in a sequence.
    magickSetImageFormat(String format) → bool
    MagickSetImageFormat() sets the format of a particular image in a sequence.
    magickSetImageFuzz(double fuzz) → bool
    MagickSetImageFuzz() sets the image fuzz.
    magickSetImageGamma(double gamma) → bool
    MagickSetImageGamma() sets the image gamma.
    magickSetImageGravity(GravityType gravity) → bool
    MagickSetImageGravity() sets the image gravity type.
    magickSetImageGreenPrimary(double x, double y, double z) → bool
    MagickSetImageGreenPrimary() sets the image chromaticity green primary point.
    magickSetImageInterlaceScheme(InterlaceType interlace) → bool
    MagickSetImageInterlaceScheme() sets the image interlace scheme.
    magickSetImageInterpolateMethod(PixelInterpolateMethod interpolate) → bool
    MagickSetImageInterpolateMethod() sets the image interpolate pixel method.
    magickSetImageIterations(int iterations) → bool
    MagickSetImageIterations() sets the image iterations.
    magickSetImageMask({required PixelMask type, required MagickWand clipMask}) → Future<bool>
    MagickSetImageMask() sets image clip mask.
    magickSetImageMatte(bool matte) → Future<bool>
    MagickSetImageMatte() sets the image matte channel.
    magickSetImageMatteColor(PixelWand matte) → bool
    MagickSetImageMatteColor() sets the image alpha color.
    magickSetImageOrientation(OrientationType orientation) → bool
    MagickSetImageOrientation() sets the image orientation.
    magickSetImagePage({required int width, required int height, required int x, required int y}) → bool
    MagickSetImagePage() sets the page geometry of the image.
    magickSetImagePixelColor({required int x, required int y, required PixelWand color}) → Future<bool>
    MagickSetImagePixelColor() sets the color of the specified pixel.
    magickSetImageProfile(String name, Uint8List profile) → bool
    Adds a named profile to the magick wand. If a profile with the same name already exists, it is replaced. This method differs from the MagickProfileImage() method in that it does not apply any CMS color profiles.
    magickSetImageProperty(String key, String value) → bool
    Associates a property with an image.
    magickSetImageRedPrimary({required double x, required double y, required double z}) → bool
    MagickSetImageRedPrimary() sets the image chromaticity red primary point.
    magickSetImageRenderingIntent(RenderingIntent renderingIntent) → bool
    MagickSetImageRenderingIntent() sets the image rendering intent.
    magickSetImageResolution({required double xResolution, required double yResolution}) → bool
    MagickSetImageResolution() sets the image resolution.
    magickSetImageScene(int scene) → bool
    MagickSetImageScene() sets the image scene.
    magickSetImageTicksPerSecond(int ticksPerSecond) → bool
    MagickSetImageTicksPerSecond() sets the image ticks-per-second.
    magickSetImageType(ImageType imageType) → Future<bool>
    MagickSetImageType() sets the image type.
    magickSetImageUnits(ResolutionType units) → bool
    MagickSetImageUnits() sets the image units of resolution.
    magickSetImageVirtualPixelMethod(VirtualPixelMethod method) → Future<bool>
    MagickSetImageVirtualPixelMethod() sets the image virtual pixel method.
    magickSetImageWhitePoint({required double x, required double y, required double z}) → bool
    MagickSetImageWhitePoint() sets the image chromaticity white point.
    magickSetInterlaceScheme(InterlaceType interlaceType) → bool
    Sets the image compression.
    magickSetInterpolateMethod(PixelInterpolateMethod pixelInterpolateMethod) → bool
    Sets the interpolate pixel method.
    magickSetIteratorIndex(int index) → bool
    Sets the iterator to the given position in the image list specified with the index parameter. A zero index will set the first image as current, and so on. Negative indexes can be used to specify an image relative to the end of the images in the wand, with -1 being the last image in the wand.
    magickSetLastIterator() → void
    Sets the wand iterator to the last image.
    magickSetOption(String key, String value) → bool
    Associates one or options with the wand (.e.g MagickSetOption(wand,"jpeg:perserve","yes")).
    magickSetOrientation(OrientationType orientationType) → bool
    Sets the wand orientation type.
    magickSetPage({required int width, required int height, required int x, required int y}) → bool
    Sets the page geometry of the magick wand.
    magickSetPassphrase(String passphrase) → bool
    Sets the passphrase.
    magickSetPointsize(double pointSize) → bool
    Sets the font pointsize associated with the MagickWand.
    magickSetProgressMonitor(MagickProgressMonitor progressMonitor, [dynamic clientData]) → Future<void>
    MagickSetProgressMonitor() sets the wand progress monitor to monitor the progress of an image operation to the specified method.
    magickSetResolution(double xResolution, double yResolution) → bool
    Sets the image resolution.
    magickSetSamplingFactors(Float64List samplingFactors) → bool
    Sets the image sampling factors.
    magickSetSecurityPolicy(String securityPolicy) → bool
    Sets the ImageMagick security policy. It returns false if the policy is already set or if the policy does not parse.
    magickSetSize(int width, int height) → bool
    Sets the size of the magick wand. Set it before you read a raw image format such as RGB, GRAY, or CMYK.
    magickSetSizeOffset({required int columns, required int rows, required int offset}) → bool
    Sets the size and offset of the magick wand. Set it before you read a raw image format such as RGB, GRAY, or CMYK.
    magickSetType(ImageType imageType) → bool
    Sets the image type attribute.
    magickShadeImage({required bool gray, required double azimuth, required double elevation}) → Future<bool>
    MagickShadeImage() shines a distant light on an image to create a three-dimensional effect. You control the positioning of the light with azimuth and elevation; azimuth is measured in degrees off the x axis and elevation is measured in pixels above the Z axis.
    magickShadowImage({required double alpha, required double sigma, required int x, required int y}) → Future<bool>
    MagickShadowImage() simulates an image shadow.
    magickSharpenImage({required double radius, required double sigma}) → Future<bool>
    MagickSharpenImage() sharpens an image. We convolve the image with a Gaussian operator of the given radius and standard deviation (sigma). For reasonable results, the radius should be larger than sigma. Use a radius of 0 and MagickSharpenImage() selects a suitable radius for you.
    magickShaveImage({required int columns, required int rows}) → Future<bool>
    MagickShaveImage() shaves pixels from the image edges.
    magickShearImage({required PixelWand background, required double xShear, required double yShear}) → Future<bool>
    MagickShearImage() slides one edge of an image along the X or Y axis, creating a parallelogram. An X direction shear slides an edge along the X axis, while a Y direction shear slides an edge along the Y axis. The amount of the shear is controlled by a shear angle. For X direction shears, x_shear is measured relative to the Y axis, and similarly, for Y direction shears y_shear is measured relative to the X axis. Empty triangles left over from shearing the image are filled with the background color.
    magickSigmoidalContrastImage({required bool sharpen, required double alpha, required double beta}) → Future<bool>
    MagickSigmoidalContrastImage() adjusts the contrast of an image with a non-linear sigmoidal contrast algorithm. Increase the contrast of the image using a sigmoidal transfer function without saturating highlights or shadows. Contrast indicates how much to increase the contrast (0 is none; 3 is typical; 20 is pushing it); mid-point indicates where midtones fall in the resultant image (0 is white; 50 is middle-gray; 100 is black). Set sharpen to true to increase the image contrast otherwise the contrast is reduced.
    magickSketchImage({required double radius, required double sigma, required double angle}) → Future<bool>
    MagickSketchImage() simulates a pencil sketch. We convolve the image with a Gaussian operator of the given radius and standard deviation (sigma). For reasonable results, radius should be larger than sigma. Use a radius of 0 and SketchImage() selects a suitable radius for you. Angle gives the angle of the blurring motion.
    magickSmushImages({required bool stack, required int offset}) → Future<MagickWand?>
    MagickSmushImages() takes all images from the current image pointer to the end of the image list and smushes them to each other top-to-bottom if the stack parameter is true, otherwise left-to-right.
    magickSolarizeImage(double threshold) → Future<bool>
    MagickSolarizeImage() applies a special effect to the image, similar to the effect achieved in a photo darkroom by selectively exposing areas of photo sensitive paper to light. Threshold ranges from 0 to QuantumRange and is a measure of the extent of the solarization.
    magickSparseColorImage({required SparseColorMethod method, required Float64List arguments}) → Future<bool>
    MagickSparseColorImage() given a set of coordinates, interpolates the colors found at those coordinates, across the whole image, using various methods.
    magickSpliceImage({required int width, required int height, required int x, required int y}) → Future<bool>
    MagickSpliceImage() splices a solid color into the image.
    magickSpreadImage({required PixelInterpolateMethod method, required double radius}) → Future<bool>
    MagickSpreadImage() is a special effects method that randomly displaces each pixel in a block defined by the radius parameter.
    magickStatisticImage({required StatisticType type, required int width, required int height}) → Future<bool>
    MagickStatisticImage() replace each pixel with corresponding statistic from the neighborhood of the specified width and height.
    magickSteganoImage({required MagickWand watermarkWand, required int offset}) → Future<MagickWand?>
    MagickSteganoImage() hides a digital watermark within the image. Recover the hidden watermark later to prove that the authenticity of an image. Offset defines the start position within the image to hide the watermark.
    magickStereoImage(MagickWand offsetWand) → Future<MagickWand?>
    MagickStereoImage() composites two images and produces a single image that is the composite of a left and right image of a stereo pair.
    magickStripImage() → Future<bool>
    MagickStripImage() strips an image of all profiles and comments.
    magickSwirlImage({required double degrees, required PixelInterpolateMethod method}) → Future<bool>
    MagickSwirlImage() swirls the pixels about the center of the image, where degrees indicates the sweep of the arc through which each pixel is moved. You get a more dramatic effect as the degrees move from 1 to 360.
    magickTextureImage(MagickWand textureWand) → Future<MagickWand?>
    MagickTextureImage() repeatedly tiles the texture image across and down the image canvas.
    magickThresholdImage(double threshold) → Future<bool>
    MagickThresholdImage() changes the value of individual pixels based on the intensity of each pixel compared to threshold. The result is a high-contrast, two color image.
    magickThresholdImageChannel({required ChannelType channel, required double threshold}) → Future<bool>
    MagickThresholdImageChannel() changes the value of individual pixels based on the intensity of each pixel compared to threshold. The result is a high-contrast, two color image. It differs from MagickThresholdImage() in that it lets you specify a channel.
    magickThumbnailImage({required int columns, required int rows}) → Future<bool>
    MagickThumbnailImage() changes the size of an image to the given dimensions and removes any associated profiles. The goal is to produce small low cost thumbnail images suited for display on the Web.
    magickTintImage({required PixelWand tint, required PixelWand blend}) → Future<bool>
    MagickTintImage() applies a color vector to each pixel in the image. The length of the vector is 0 for black and white and at its maximum for the midtones. The vector weighting function is f(x)=(1-(4.0*((x-0.5)*(x-0.5)))).
    magickTransformImageColorspace(ColorspaceType colorspace) → Future<bool>
    MagickTransformImageColorspace() transform the image colorspace, setting the images colorspace while transforming the images data to that colorspace.
    magickTransparentPaintImage({required PixelWand target, required double alpha, required double fuzz, required bool invert}) → Future<bool>
    MagickTransparentPaintImage() changes any pixel that matches color with the color defined by fill.
    magickTransposeImage() → Future<bool>
    MagickTransposeImage() creates a vertical mirror image by reflecting the pixels around the central x-axis while rotating them 90-degrees.
    magickTransverseImage() → Future<bool>
    MagickTransverseImage() creates a horizontal mirror image by reflecting the pixels around the central y-axis while rotating them 270-degrees.
    magickTrimImage(double fuzz) → Future<bool>
    MagickTrimImage() remove edges that are the background color from the image.
    magickUniqueImageColors() → Future<bool>
    MagickUniqueImageColors() discards all but one of any pixel color.
    magickUnsharpMaskImage({required double radius, required double sigma, required double gain, required double threshold}) → Future<bool>
    MagickUnsharpMaskImage() sharpens an image. We convolve the image with a Gaussian operator of the given radius and standard deviation (sigma). For reasonable results, radius should be larger than sigma. Use a radius of 0 and UnsharpMaskImage() selects a suitable radius for you.
    magickVignetteImage({required double radius, required double sigma, required int x, required int y}) → Future<bool>
    MagickVignetteImage() softens the edges of the image in vignette style.
    magickWaveImage({required double amplitude, required double waveLength, required PixelInterpolateMethod method}) → Future<bool>
    MagickWaveImage() creates a "ripple" effect in the image by shifting the pixels vertically along a sine wave whose amplitude and wavelength is specified by the given parameters.
    magickWaveletDenoiseImage({required double threshold, required double softness}) → Future<bool>
    MagickWaveletDenoiseImage() removes noise from the image using a wavelet transform. The wavelet transform is a fast hierarchical scheme for processing an image using a set of consecutive lowpass and high_pass filters, followed by a decimation. This results in a decomposition into different scales which can be regarded as different “frequency bands”, determined by the mother wavelet.
    magickWhiteBalanceImage() → Future<bool>
    MagickWhiteBalanceImage() applies white balancing to an image according to a grayworld assumption in the LAB colorspace.
    magickWhiteThresholdImage(PixelWand threshold) → Future<bool>
    MagickWhiteThresholdImage() is like ThresholdImage() but force all pixels above the threshold into white while leaving all pixels below the threshold unchanged.
    magickWriteImage(String imageFilePath) → Future<bool>
    Writes an image to the specified filename. If the filename parameter is NULL, the image is written to the filename set by magickReadImage() or magickSetImageFilename().
    magickWriteImages(String imageFilePath, bool adjoin) → Future<bool>
    MagickWriteImages() writes an image or image sequence.
    noSuchMethod(Invocation invocation) → dynamic
    Invoked when a nonexistent method or property is accessed.
    inherited
    toString() → String
    A string representation of this object.
    inherited

    Operators

    operator ==(Object other) → bool
    The equality operator.
    override