### ----------------------------------------------------
### -- MagickWand
### -- Licenses: MIT
### -- Authors: Ahmad M. Zawawi
### -- File: lib/MagickWand/NativeCall/Image.rakumod
### ----------------------------------------------------
### -- Chunk 2 of 6
2 $rows,
   Str $map,
   uint32 $storage,
   Pointer[void] $pixels
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickDecipherImage

    MagickBooleanType MagickDecipherImage(MagickWand *wand,
      const char *passphrase)

MagickDecipherImage() converts cipher pixels to plain pixels.- wand: the magick wand. - passphrase: the passphrase. 
=end pod
sub MagickDecipherImage(
   Pointer $wand,
   Str $passphrase
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickDeconstructImages

    MagickWand *MagickDeconstructImages(MagickWand *wand)

MagickDeconstructImages() compares each image with the next in a sequence and returns the maximum bounding region of any pixel differences it discovers.- wand: the magick wand. 
=end pod
sub MagickDeconstructImages(
   Pointer $wand
)
returns Pointer
is native(&library)
is export { * };


=begin pod
=head1 MagickDeskewImage

    MagickBooleanType MagickDeskewImage(MagickWand *wand,
      const double threshold)

MagickDeskewImage() 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.- wand: the magick wand. - threshold: separate background from foreground. 
=end pod
sub MagickDeskewImage(
   Pointer $wand,
   num64 $threshold
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickDespeckleImage

    MagickBooleanType MagickDespeckleImage(MagickWand *wand)

MagickDespeckleImage() reduces the speckle noise in an image while perserving the edges of the original image.- wand: the magick wand. 
=end pod
sub MagickDespeckleImage(
   Pointer $wand
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickDestroyImage

    Image *MagickDestroyImage(Image *image)

MagickDestroyImage() dereferences an image, deallocating memory associated with the image if the reference count becomes zero.- image: the image. 
=end pod
sub MagickDestroyImage(
   Pointer $image
)
returns Pointer
is native(&library)
is export { * };


=begin pod
=head1 MagickDisplayImage

    MagickBooleanType MagickDisplayImage(MagickWand *wand,
      const char *server_name)

MagickDisplayImage() displays an image.- wand: the magick wand. - server_name: the X server name. 
=end pod
sub MagickDisplayImage(
   Pointer $wand,
   Str $server_name
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickDisplayImages

    MagickBooleanType MagickDisplayImages(MagickWand *wand,
      const char *server_name)

MagickDisplayImages() displays an image or image sequence.- wand: the magick wand. - server_name: the X server name. 
=end pod
sub MagickDisplayImages(
   Pointer $wand,
   Str $server_name
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickDistortImage

    MagickBooleanType MagickDistortImage(MagickWand *wand,
      const DistortImageMethod method,const size_t number_arguments,
      const double *arguments,const MagickBooleanType bestfit)

MagickDistortImage() distorts an image using various distortion methods, by mapping color lookups of the source image to a new destination image usally of the same size as the source image, unless 'bestfit' is set to true.If 'bestfit' is enabled, and distortion allows it, the destination image is adjusted to ensure the whole source 'image' will just fit within the final destination image, which will be sized and offset accordingly.  Also in many cases the virtual offset of the source image will be taken into account in the mapping.- image: the image to be distorted. - method: the method of image distortion. <dd> ArcDistortion always ignores the source image offset, and always 'bestfit' the destination image with the top left corner offset relative to the polar mapping center. </dd><dd> Bilinear has no simple inverse mapping so it does not allow 'bestfit' style of image distortion. </dd><dd> Affine, Perspective, and Bilinear, do least squares fitting of the distortion when more than the minimum number of control point pairs are provided. </dd><dd> Perspective, and Bilinear, falls back to a Affine distortion when less that 4 control point pairs are provided. While Affine distortions let you use any number of control point pairs, that is Zero pairs is a no-Op (viewport only) distrotion, one pair is a translation and two pairs of control points do a scale-rotate-translate, without any shearing. </dd>- number_arguments: the number of arguments given for this distortion method. - arguments: the arguments for this distortion method. - bestfit: Attempt to resize destination to fit distorted source. 
=end pod
sub MagickDistortImage(
   Pointer $wand,
   uint32 $method,
   int32 $number_arguments,
   CArray[num64] $arguments,
   uint32 $bestfit
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickDrawImage

    MagickBooleanType MagickDrawImage(MagickWand *wand,
      const DrawingWand *drawing_wand)

MagickDrawImage() renders the drawing wand on the current image.- wand: the magick wand. - drawing_wand: the draw wand. 
=end pod
sub MagickDrawImage(
   Pointer $wand,
   Pointer $drawing_wand
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickEdgeImage

    MagickBooleanType MagickEdgeImage(MagickWand *wand,const double radius)

MagickEdgeImage() 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.

- wand: the magick wand.
- radius: the radius of the pixel neighborhood.

=end pod
sub MagickEdgeImage(
   Pointer $wand,
   num64 $radius
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickEmbossImage

    MagickBooleanType MagickEmbossImage(MagickWand *wand,const double radius,
      const double sigma)

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.

- wand: the magick wand.
- radius: the radius of the Gaussian, in pixels, not counting the
center pixel.
- sigma: the standard deviation of the Gaussian, in pixels.

=end pod
sub MagickEmbossImage(
   Pointer $wand,
   num64 $radius,
   num64 $sigma
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickEncipherImage

    MagickBooleanType MagickEncipherImage(MagickWand *wand,
      const char *passphrase)

MagickEncipherImage() converts plaint pixels to cipher pixels.

- wand: the magick wand.
- passphrase: the passphrase.

=end pod
sub MagickEncipherImage(
   Pointer $wand,
   Str $passphrase
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickEnhanceImage

    MagickBooleanType MagickEnhanceImage(MagickWand *wand)

MagickEnhanceImage() applies a digital filter that improves the quality of a noisy image.- wand: the magick wand. 
=end pod
sub MagickEnhanceImage(
   Pointer $wand
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickEqualizeImage

    MagickBooleanType MagickEqualizeImage(MagickWand *wand)
    MagickBooleanType MagickEqualizeImageChannel(MagickWand *wand,
      const ChannelType channel)

MagickEqualizeImage() equalizes the image histogram.- wand: the magick wand. - channel: the image channel(s). 
=end pod
sub MagickEqualizeImage(
   Pointer $wand
)
returns uint32 
is native(&library)
is export { * };

sub MagickEqualizeImageChannel(
   Pointer $wand,
   uint32 $channel
)
returns uint32
is native(&library)
is export { * };


=begin pod
=head1 MagickEvaluateImage

    MagickBooleanType MagickEvaluateImage(MagickWand *wand,
      const MagickEvaluateOperator operator,const double value)
    MagickBooleanType MagickEvaluateImages(MagickWand *wand,
      const MagickEvaluateOperator operator)
    MagickBooleanType MagickEvaluateImageChannel(MagickWand *wand,
      const ChannelType channel,const MagickEvaluateOperator op,
      const double value)

MagickEvaluateImage() applys 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.- wand: the magick wand. - channel: the channel(s). - op: A channel operator. - value: A value value. 
=end pod
sub MagickEvaluateImage(
   Pointer $wand,
   uint32 $operator,
   num64 $value
)
returns uint32 
is native(&library)
is export { * };

sub MagickEvaluateImages(
   Pointer $wand,
   uint32 $operator
)
returns uint32
is native(&library)
is export { * };

sub MagickEvaluateImageChannel(
   Pointer $wand,
   uint32 $channel,
   uint32 $op,
   num64 $value
)
returns uint32
is native(&library)
is export { * };


=begin pod
=head1 MagickExportImagePixels

    MagickBooleanType MagickExportImagePixels(MagickWand *wand,
      const ssize_t x,const ssize_t y,const size_t columns,
      const size_t rows,const char *map,const StorageType storage,
      void *pixels)

MagickExportImagePixels() extracts pixel data from an image and returns it to you.  The method returns MagickTrue on success otherwise MagickFalse if an error is encountered.  The data is returned as char, short int, int, ssize_t, float, or double in the order specified by map.Suppose you want to extract the first scanline of a 640x480 image as character data in red-green-blue order:<pre class="text">MagickExportImagePixels(wand,0,0,640,1,"RGB",CharPixel,pixels);</pre>- wand: the magick wand. - x, y, columns, rows:  These values define the perimeter of a region of pixels you want to extract. - map:  This string reflects the expected ordering of the pixel array. It can be any combination or order of R = red, G = green, B = blue, A = alpha (0 is transparent), O = opacity (0 is opaque), C = cyan, Y = yellow, M = magenta, K = black, I = intensity (for grayscale), P = pad. - storage: Define the data type of the pixels.  Float and double types are expected to be normalized [0..1] otherwise [0..QuantumRange].  Choose from these types: CharPixel, DoublePixel, FloatPixel, IntegerPixel, LongPixel, QuantumPixel, or ShortPixel. - pixels: This array of values contain the pixel components as defined by map and type.  You must preallocate this array where the expected length varies depending on the values of width, height, map, and type. 
=end pod
sub MagickExportImagePixels(
   Pointer $wand,
   uint32 $x,
   uint32 $y,
   int32 $columns,
   int32 $rows,
   Str $map,
   uint32 $storage,
   Pointer[void] $pixels
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickExtentImage

    MagickBooleanType MagickExtentImage(MagickWand *wand,const size_t width,
      const size_t height,const ssize_t x,const ssize_t y)

MagickExtentImage() 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.- wand: the magick wand. - width: the region width. - height: the region height. - x: the region x offset. - y: the region y offset. 
=end pod
sub MagickExtentImage(
   Pointer $wand,
   int32 $width,
   int32 $height,
   uint32 $x,
   uint32 $y
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickFilterImage

    MagickBooleanType MagickFilterImage(MagickWand *wand,
      const KernelInfo *kernel)
    MagickBooleanType MagickFilterImageChannel(MagickWand *wand,
      const ChannelType channel,const KernelInfo *kernel)

MagickFilterImage() applies a custom convolution kernel to the image.- wand: the magick wand. - channel: the image channel(s). - kernel: An array of doubles representing the convolution kernel. 

sub MagickFilterImage(
   Pointer $wand,
   Pointer[KernelInfo] $kernel
)
returns uint32 
is native(&library)
is export { * };

sub MagickFilterImageChannel(
   Pointer $wand,
   uint32 $channel,
   Pointer[KernelInfo] $kernel
)
returns uint32
is native(&library)
is export { * };
=end pod

=begin pod
=head1 MagickFlipImage

    MagickBooleanType MagickFlipImage(MagickWand *wand)

MagickFlipImage() creates a vertical mirror image by reflecting the pixels around the central x-axis.- wand: the magick wand. 
=end pod
sub MagickFlipImage(
   Pointer $wand
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickFloodfillPaintImage

    MagickBooleanType MagickFloodfillPaintImage(MagickWand *wand,
      const ChannelType channel,const PixelWand *fill,const double fuzz,
      const PixelWand *bordercolor,const ssize_t x,const ssize_t y,
      const MagickBooleanType invert)

MagickFloodfillPaintImage() 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.- wand: the magick wand. - channel: the channel(s). - fill: the floodfill color pixel wand. - fuzz: By default target must match a particular pixel color exactly.  However, in many cases two colors may differ by a small amount. The fuzz member of image defines how much tolerance is acceptable to consider two colors as the same.  For example, set fuzz to 10 and the color red at intensities of 100 and 102 respectively are now interpreted as the same color for the purposes of the floodfill. - bordercolor: the border color pixel wand. - x,y: the starting location of the operation. - invert: paint any pixel that does not match the target color. 
=end pod
sub MagickFloodfillPaintImage(
   Pointer $wand,
   uint32 $channel,
   Pointer $fill,
   num64 $fuzz,
   Pointer $bordercolor,
   uint32 $x,
   uint32 $y,
   uint32 $invert
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickFlopImage

    MagickBooleanType MagickFlopImage(MagickWand *wand)

MagickFlopImage() creates a horizontal mirror image by reflecting the pixels around the central y-axis.- wand: the magick wand. 
=end pod
sub MagickFlopImage(
   Pointer $wand
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickForwardFourierTransformImage

    MagickBooleanType MagickForwardFourierTransformImage(MagickWand *wand,
      const MagickBooleanType magnitude)

MagickForwardFourierTransformImage() implements the discrete Fourier transform (DFT) of the image either as a magnitude / phase or real / imaginary image pair.- wand: the magick wand. - magnitude: if true, return as magnitude / phase pair otherwise a real / imaginary image pair. 
=end pod
sub MagickForwardFourierTransformImage(
   Pointer $wand,
   uint32 $magnitude
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickFrameImage

    MagickBooleanType MagickFrameImage(MagickWand *wand,
      const PixelWand *matte_color,const size_t width,
      const size_t height,const ssize_t inner_bevel,
      const ssize_t outer_bevel)

MagickFrameImage() 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.

- wand: the magick wand.
- matte_color: the frame color pixel wand.
- width: the border width.
- height: the border height.
- inner_bevel: the inner bevel width.
- outer_bevel: the outer bevel width.

=end pod
sub MagickFrameImage(
   Pointer $wand,
   Pointer $matte_color,
   int32 $width,
   int32 $height,
   uint32 $inner_bevel,
   uint32 $outer_bevel
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickFunctionImage

    MagickBooleanType MagickFunctionImage(MagickWand *wand,
      const MagickFunction function,const size_t number_arguments,
      const double *arguments)
    MagickBooleanType MagickFunctionImageChannel(MagickWand *wand,
      const ChannelType channel,const MagickFunction function,
      const size_t number_arguments,const double *arguments)

MagickFunctionImage() applys 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.- wand: the magick wand. - channel: the channel(s). - function: the image function. - number_arguments: the number of function arguments. - arguments: the function arguments. 
=end pod
sub MagickFunctionImage(
   Pointer $wand,
   uint32 $function,
   int32 $number_arguments,
   CArray[num64] $arguments
)
returns uint32 
is native(&library)
is export { * };

sub MagickFunctionImageChannel(
   Pointer $wand,
   uint32 $channel,
   uint32 $function,
   int32 $number_arguments,
   CArray[num64] $arguments
)
returns uint32
is native(&library)
is export { * };


=begin pod
=head1 MagickFxImage

    MagickWand *MagickFxImage(MagickWand *wand,const char *expression)
    MagickWand *MagickFxImageChannel(MagickWand *wand,
      const ChannelType channel,const char *expression)

MagickFxImage() evaluate expression for each pixel in the image.

- wand: the magick wand.
- channel: the image channel(s).
- expression: the expression.

=end pod
sub MagickFxImage(
   Pointer $wand,
   Str $expression
)
returns Pointer
is native(&library)
is export { * };

sub MagickFxImageChannel(
   Pointer $wand,
   uint32 $channel,
   Str $expression
)
returns 
Pointer
is native(&library)
is export { * };


=begin pod
=head1 MagickGammaImage

    MagickBooleanType MagickGammaImage(MagickWand *wand,const double gamma)
    MagickBooleanType MagickGammaImageChannel(MagickWand *wand,
      const ChannelType channel,const double gamma)

MagickGammaImage() 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.You can also reduce the influence of a
particular channel with a gamma value of 0.

- wand: the magick wand.
- channel: the channel.
- level: Define the level of gamma correction.

=end pod
sub MagickGammaImage(
   Pointer $wand,
   num64 $gamma
)
returns uint32 
is native(&library)
is export { * };

sub MagickGammaImageChannel(
   Pointer $wand,
   uint32 $channel,
   num64 $gamma
)
returns uint32
is native(&library)
is export { * };


=begin pod
=head1 MagickGaussianBlurImage

    MagickBooleanType MagickGaussianBlurImage(MagickWand *wand,
      const double radius,const double sigma)
    MagickBooleanType MagickGaussianBlurImageChannel(MagickWand *wand,
      const ChannelType channel,const double radius,const double sigma)

MagickGaussianBlurImage() 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.

- wand: the magick wand.
- channel: the image channel(s).
- radius: the radius of the Gaussian, in pixels, not counting the center pixel.
- sigma: the standard deviation of the Gaussian, in pixels.

=end pod
sub MagickGaussianBlurImage(
   Pointer $wand,
   num64 $radius,
   num64 $sigma
)
returns uint32 
is native(&library)
is export { * };

sub MagickGaussianBlurImageChannel(
   Pointer $wand,
   uint32 $channel,
   num64 $radius,
   num64 $sigma
)
returns uint32
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImage

    MagickWand *MagickGetImage(MagickWand *wand)

MagickGetImage() gets the image at the current image index.- wand: the magick wand. 
=end pod
sub MagickGetImage(
   Pointer $wand
)
returns Pointer
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageAlphaChannel

    MagickBooleanType MagickGetImageAlphaChannel(MagickWand *wand)

MagickGetImageAlphaChannel() returns MagickFalse if the image alpha channel is not activated.  That is, the image is RGB rather than RGBA or CMYK rather than CMYKA.- wand: the magick wand. 
=end pod
sub MagickGetImageAlphaChannel(
   Pointer $wand
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageClipMask

    MagickWand *MagickGetImageClipMask(MagickWand *wand)

MagickGetImageClipMask() gets the image clip mask at the current image index.- wand: the magick wand. 
=end pod
sub MagickGetImageClipMask(
   Pointer $wand
)
returns Pointer
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageBackgroundColor

    MagickBooleanType MagickGetImageBackgroundColor(MagickWand *wand,
      PixelWand *background_color)

MagickGetImageBackgroundColor() returns the image background color.- wand: the magick wand. - background_color: Return the background color. 
=end pod
sub MagickGetImageBackgroundColor(
   Pointer $wand,
   Pointer $background_color
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageBlob

    unsigned char *MagickGetImageBlob(MagickWand *wand,size_t *length)

MagickGetImageBlob() implements direct to memory image formats.  It returns the image as a blob (a formatted "file" in memory) and its length, 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.Use MagickRelinquishMemory() to free the blob when you are done with it.- wand: the magick wand. - length: the length of the blob. 
=end pod
sub MagickGetImageBlob(
   Pointer $wand,
   Pointer[int32] $length
)
returns Str
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageBlob

    unsigned char *MagickGetImagesBlob(MagickWand *wand,size_t *length)

MagickGetImageBlob() 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().Note, some image formats do not permit multiple images to the same image stream (e.g. JPEG).  in this instance, just the first image of the sequence is returned as a blob.- wand: the magick wand. - length: the length of the blob. 
=end pod
sub MagickGetImagesBlob(
   Pointer $wand,
   Pointer[int32] $length
)
returns Str
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageBluePrimary

    MagickBooleanType MagickGetImageBluePrimary(MagickWand *wand,double *x,
      double *y)

MagickGetImageBluePrimary() returns the chromaticy blue primary point for the image.- wand: the magick wand. - x: the chromaticity blue primary x-point. - y: the chromaticity blue primary y-point. 
=end pod
sub MagickGetImageBluePrimary(
   Pointer $wand,
   CArray[num64] $x,
   CArray[num64] $y
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageBorderColor

    MagickBooleanType MagickGetImageBorderColor(MagickWand *wand,
      PixelWand *border_color)

MagickGetImageBorderColor() returns the image border color.- wand: the magick wand. - border_color: Return the border color. 
=end pod
sub MagickGetImageBorderColor(
   Pointer $wand,
   Pointer $border_color
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageChannelDepth

    size_t MagickGetImageChannelDepth(MagickWand *wand,
      const ChannelType channel)

MagickGetImageChannelDepth() gets the depth for one or more image channels.- wand: the magick wand. - channel: the image channel(s). 
=end pod
sub MagickGetImageChannelDepth(
   Pointer $wand,
   uint32 $channel
)
returns int32 
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageChannelDistortion

    MagickBooleanType MagickGetImageChannelDistortion(MagickWand *wand,
      const MagickWand *reference,const ChannelType channel,
      const MetricType metric,double *distortion)

MagickGetImageChannelDistortion() compares one or more image channels of an image to a reconstructed image and returns the specified distortion metric.- wand: the magick wand. - reference: the reference wand. - channel: the channel. - metric: the metric. - distortion: the computed distortion between the images. 
=end pod
multi sub MagickGetImageChannelDistortion(
   Pointer $wand,
   Pointer $reference,
   uint32 $channel,
   uint32 $metric,
   CArray[num64] $distortion
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageChannelDistortions

    double *MagickGetImageChannelDistortion(MagickWand *wand,
      const MagickWand *reference,const MetricType metric)

MagickGetImageChannelDistortions() compares one or more image channels of an image to a reconstructed image and returns the specified distortion metrics.Use MagickRelinquishMemory() to free the metrics when you are done with them.- wand: the magick wand. - reference: the reference wand. - metric: the metric. 
=end pod
multi sub MagickGetImageChannelDistortion(
   Pointer $wand,
   Pointer $reference,
   uint32 $metric
)
returns num64
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageChannelFeatures

    ChannelFeatures *MagickGetImageChannelFeatures(MagickWand *wand,
      const size_t distance)

MagickGetImageChannelFeatures() 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 varience, sum entropy, entropy, difference variance, difference entropy, information measures of correlation 1, information measures of correlation 2, and maximum correlation coefficient.  You can access the red channel contrast, for example, like this:<pre class="text">channel_features=MagickGetImageChannelFeatures(wand,1);contrast=channel_features[RedChannel].contrast[0];</pre>Use MagickRelinquishMemory() to free the statistics buffer.- wand: the magick wand. - distance: the distance. 
=end pod
sub MagickGetImageChannelFeatures(
   Pointer $wand,
   int32 $distance
)
returns Pointer
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageChannelKurtosis

    MagickBooleanType MagickGetImageChannelKurtosis(MagickWand *wand,
      const ChannelType channel,double *kurtosis,double *skewness)

MagickGetImageChannelKurtosis() gets the kurtosis and skewness of one or more image channels.- wand: the magick wand. - channel: the image channel(s). - kurtosis:  The kurtosis for the specified channel(s). - skewness:  The skewness for the specified channel(s). 
=end pod
sub MagickGetImageChannelKurtosis(
   Pointer $wand,
   uint32 $channel,
   CArray[num64] $kurtosis,
   CArray[num64] $skewness
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageChannelMean

    MagickBooleanType MagickGetImageChannelMean(MagickWand *wand,
      const ChannelType channel,double *mean,double *standard_deviation)

MagickGetImageChannelMean() gets the mean and standard deviation of one or more image channels.- wand: the magick wand. - channel: the image channel(s). - mean:  The mean pixel value for the specified channel(s). - standard_deviation:  The standard deviation for the specified channel(s). 
=end pod
sub MagickGetImageChannelMean(
   Pointer $wand,
   uint32 $channel,
   CArray[num64] $mean,
   CArray[num64] $standard_deviation
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageChannelRange

    MagickBooleanType MagickGetImageChannelRange(MagickWand *wand,
      const ChannelType channel,double *minima,double *maxima)

MagickGetImageChannelRange() gets the range for one or more image channels.- wand: the magick wand. - channel: the image channel(s). - minima:  The minimum pixel value for the specified channel(s). - maxima:  The maximum pixel value for the specified channel(s). 
=end pod
sub MagickGetImageChannelRange(
   Pointer $wand,
   uint32 $channel,
   CArray[num64] $minima,
   CArray[num64] $maxima
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageChannelStatistics

    ChannelStatistics *MagickGetImageChannelStatistics(MagickWand *wand)

MagickGetImageChannelStatistics() 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. You can access the red channel mean, for example, like this:<pre class="text">channel_statistics=MagickGetImageChannelStatistics(wand);red_mean=channel_statistics[RedChannel].mean;</pre>Use MagickRelinquishMemory() to free the statistics buffer.- wand: the magick wand. 
=end pod
sub MagickGetImageChannelStatistics(
   Pointer $wand
)
returns Pointer
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageColormapColor

    MagickBooleanType MagickGetImageColormapColor(MagickWand *wand,
      const size_t index,PixelWand *color)

MagickGetImageColormapColor() returns the color of the specified colormap index.- wand: the magick wand. - index: the offset into the image colormap. - color: Return the colormap color in this wand. 
=end pod
sub MagickGetImageColormapColor(
   Pointer $wand,
   int32 $index,
   Pointer $color
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageColors

    size_t MagickGetImageColors(MagickWand *wand)

MagickGetImageColors() gets the number of unique colors in the image.- wand: the magick wand. 
=end pod
sub MagickGetImageColors(
   Pointer $wand
)
returns int32 
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageColorspace

    ColorspaceType MagickGetImageColorspace(MagickWand *wand)

MagickGetImageColorspace() gets the image colorspace.

- wand: the magick wand.

=end pod
sub MagickGetImageColorspace(
   Pointer $wand
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageCompose

    CompositeOperator MagickGetImageCompose(MagickWand *wand)

MagickGetImageCompose() returns the composite operator associated with the image.- wand: the magick wand. 
=end pod
sub MagickGetImageCompose(
   Pointer $wand
)
returns uint32
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageCompression

    CompressionType MagickGetImageCompression(MagickWand *wand)

MagickGetImageCompression() gets the image compression.- wand: the magick wand. 
=end pod
sub MagickGetImageCompression(
   Pointer $wand
)
returns uint32
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageCompressionQuality

    size_t MagickGetImageCompressionQuality(MagickWand *wand)

MagickGetImageCompressionQuality() gets the image compression quality.- wand: the magick wand. 
=end pod
sub MagickGetImageCompressionQuality(
   Pointer $wand
)
returns int32 
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageDelay

    size_t MagickGetImageDelay(MagickWand *wand)

MagickGetImageDelay() gets the image delay.- wand: the magick wand. 
=end pod
sub MagickGetImageDelay(
   Pointer $wand
)
returns int32 
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageDepth

    size_t MagickGetImageDepth(MagickWand *wand)

MagickGetImageDepth() gets the image depth.- wand: the magick wand. 
=end pod
sub MagickGetImageDepth(
   Pointer $wand
)
returns int32 
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageDistortion

    MagickBooleanType MagickGetImageDistortion(MagickWand *wand,
      const MagickWand *reference,const MetricType metric,
      double *distortion)

MagickGetImageDistortion() compares an image to a reconstructed image and returns the specified distortion metric.- wand: the magick wand. - reference: the reference wand. - metric: the metric. - distortion: the computed distortion between the images. 
=end pod
sub MagickGetImageDistortion(
   Pointer $wand,
   Pointer $reference,
   uint32 $metric,
   CArray[num64] $distortion
)
returns uint32 
is native(&library)
is export { *