### ----------------------------------------------------
### -- MagickWand
### -- Licenses: MIT
### -- Authors: Ahmad M. Zawawi
### -- File: lib/MagickWand/NativeCall/Image.rakumod
### ----------------------------------------------------
### -- Chunk 3 of 6
 };


=begin pod
=head1 MagickGetImageDispose

    DisposeType MagickGetImageDispose(MagickWand *wand)

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


=begin pod
=head1 MagickGetImageEndian

    EndianType MagickGetImageEndian(MagickWand *wand)

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


=begin pod
=head1 MagickGetImageFilename

    char *MagickGetImageFilename(MagickWand *wand)

MagickGetImageFilename() returns the filename of a particular image in a sequence.- wand: the magick wand. 
=end pod
sub MagickGetImageFilename(
   Pointer $wand
)
returns Str
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageFormat

    char *MagickGetImageFormat(MagickWand *wand)

MagickGetImageFormat() returns the format of a particular image in a sequence.- wand: the magick wand. 
=end pod
sub MagickGetImageFormat(
   Pointer $wand
)
returns Str
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageFuzz

    double MagickGetImageFuzz(MagickWand *wand)

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


=begin pod
=head1 MagickGetImageGamma

    double MagickGetImageGamma(MagickWand *wand)

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


=begin pod
=head1 MagickGetImageGravity

    GravityType MagickGetImageGravity(MagickWand *wand)

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


=begin pod
=head1 MagickGetImageGreenPrimary

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

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


=begin pod
=head1 MagickGetImageHeight

    size_t MagickGetImageHeight(MagickWand *wand)

MagickGetImageHeight() returns the image height.

- wand: the magick wand.

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


=begin pod
=head1 MagickGetImageHistogram

    PixelWand **MagickGetImageHistogram(MagickWand *wand,
      size_t *number_colors)

MagickGetImageHistogram() returns the image histogram as an array of PixelWand wands.- wand: the magick wand. - number_colors: the number of unique colors in the image and the number of pixel wands returned. 
=end pod
sub MagickGetImageHistogram(
   Pointer $wand,
   Pointer[int32] $number_colors
)
returns Pointer
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageInterlaceScheme

    InterlaceType MagickGetImageInterlaceScheme(MagickWand *wand)

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


=begin pod
=head1 MagickGetImageInterpolateMethod

    InterpolatePixelMethod MagickGetImageInterpolateMethod(MagickWand *wand)

MagickGetImageInterpolateMethod() returns the interpolation method for the sepcified image.- wand: the magick wand. 
=end pod
sub MagickGetImageInterpolateMethod(
   Pointer $wand
)
returns uint32
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageIterations

    size_t MagickGetImageIterations(MagickWand *wand)

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


=begin pod
=head1 MagickGetImageLength

    MagickBooleanType MagickGetImageLength(MagickWand *wand,
      MagickSizeType *length)

MagickGetImageLength() returns the image length in bytes.- wand: the magick wand. - length: the image length in bytes. 
=end pod
sub MagickGetImageLength(
   Pointer $wand,
   CArray[uint32] $length
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageMatteColor

    MagickBooleanType MagickGetImagematteColor(MagickWand *wand,
      PixelWand *matte_color)

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


=begin pod
=head1 MagickGetImageOrientation

    OrientationType MagickGetImageOrientation(MagickWand *wand)

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


=begin pod
=head1 MagickGetImagePage

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

MagickGetImagePage() returns the page geometry associated with the image.- wand: the magick wand. - width: the page width. - height: the page height. - x: the page x-offset. - y: the page y-offset. 
=end pod
sub MagickGetImagePage(
   Pointer $wand,
   Pointer[int32] $width,
   Pointer[int32] $height,
   Pointer[int32] $x,
   Pointer[int32] $y
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImagePixelColor

    MagickBooleanType MagickGetImagePixelColor(MagickWand *wand,
      const ssize_t x,const ssize_t y,PixelWand *color)

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


=begin pod
=head1 MagickGetImageRedPrimary

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

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


=begin pod
=head1 MagickGetImageRegion

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

MagickGetImageRegion() extracts a region of the image and returns it as a a new 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 MagickGetImageRegion(
   Pointer $wand,
   int32 $width,
   int32 $height,
   uint32 $x,
   uint32 $y
)
returns Pointer
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageRenderingIntent

    RenderingIntent MagickGetImageRenderingIntent(MagickWand *wand)

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


=begin pod
=head1 MagickGetImageResolution

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

MagickGetImageResolution() gets the image X and Y resolution.- wand: the magick wand. - x: the image x-resolution. - y: the image y-resolution. 
=end pod
sub MagickGetImageResolution(
   Pointer $wand,
   CArray[num64] $x,
   CArray[num64] $y
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageScene

    size_t MagickGetImageScene(MagickWand *wand)

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


=begin pod
=head1 MagickGetImageSignature

    char *MagickGetImageSignature(MagickWand *wand)

MagickGetImageSignature() generates an SHA-256 message digest for the image pixel stream.- wand: the magick wand. 
=end pod
sub MagickGetImageSignature(
   Pointer $wand
)
returns Str
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageTicksPerSecond

    size_t MagickGetImageTicksPerSecond(MagickWand *wand)

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


=begin pod
=head1 MagickGetImageType

    ImageType MagickGetImageType(MagickWand *wand)

MagickGetImageType() gets the potential image type: Bilevel, Grayscale
GrayscaleMatte, Palette, PaletteMatte, TrueColor, TrueColorMatte
ColorSeparation and ColorSeparationMatte

To ensure the image type matches its potential, use MagickSetImageType()

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


=begin pod
=head1 MagickGetImageUnits

    ResolutionType MagickGetImageUnits(MagickWand *wand)

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


=begin pod
=head1 MagickGetImageVirtualPixelMethod

    VirtualPixelMethod MagickGetImageVirtualPixelMethod(MagickWand *wand)

MagickGetImageVirtualPixelMethod() returns the virtual pixel method for the sepcified image.- wand: the magick wand. 
=end pod
sub MagickGetImageVirtualPixelMethod(
   Pointer $wand
)
returns uint32
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageWhitePoint

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

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


=begin pod
=head1 MagickGetImageWidth

    size_t MagickGetImageWidth(MagickWand *wand)

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


=begin pod
=head1 MagickGetNumberImages

    size_t MagickGetNumberImages(MagickWand *wand)

MagickGetNumberImages() returns the number of images associated with a magick wand.- wand: the magick wand. 
=end pod
sub MagickGetNumberImages(
   Pointer $wand
)
returns int32 
is native(&library)
is export { * };


=begin pod
=head1 MagickGetImageTotalInkDensity

    double MagickGetImageTotalInkDensity(MagickWand *wand)

MagickGetImageTotalInkDensity() gets the image total ink density.- wand: the magick wand. 
=end pod
sub MagickGetImageTotalInkDensity(
   Pointer $wand
)
returns num64
is native(&library)
is export { * };


=begin pod
=head1 MagickHaldClutImage

    MagickBooleanType MagickHaldClutImage(MagickWand *wand,
      const MagickWand *hald_wand)
    MagickBooleanType MagickHaldClutImageChannel(MagickWand *wand,
      const ChannelType channel,const MagickWand *hald_wand)

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.- wand: the magick wand. - hald_image: the hald CLUT image. 
=end pod
sub MagickHaldClutImage(
   Pointer $wand,
   Pointer $hald_wand
)
returns uint32 
is native(&library)
is export { * };

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


=begin pod
=head1 MagickHasNextImage

    MagickBooleanType MagickHasNextImage(MagickWand *wand)

MagickHasNextImage() returns MagickTrue if the wand has more images when traversing the list in the forward direction- wand: the magick wand. 
=end pod
sub MagickHasNextImage(
   Pointer $wand
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickHasPreviousImage

    MagickBooleanType MagickHasPreviousImage(MagickWand *wand)

MagickHasPreviousImage() returns MagickTrue if the wand has more images when traversing the list in the reverse direction- wand: the magick wand. 
=end pod
sub MagickHasPreviousImage(
   Pointer $wand
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickIdentifyImage

    const char *MagickIdentifyImage(MagickWand *wand)

MagickIdentifyImage() identifies an image by printing its attributes to the file.  Attributes include the image width, height, size, and others.- wand: the magick wand. 
=end pod
sub MagickIdentifyImage(
   Pointer $wand
)
returns Str
is native(&library)
is export { * };


=begin pod
=head1 MagickImplodeImage

    MagickBooleanType MagickImplodeImage(MagickWand *wand,
      const double radius)

MagickImplodeImage() creates a new image that is a copy of an existing one with the image pixels "implode" by the specified percentage.  It allocates the memory necessary for the new Image structure and returns a pointer to the new image.- wand: the magick wand. - amount: Define the extent of the implosion. 
=end pod
sub MagickImplodeImage(
   Pointer $wand,
   num64 $radius
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickImportImagePixels

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

MagickImportImagePixels() accepts pixel datand stores it in the image at the location you specify.  The method returns MagickFalse on success otherwise MagickTrue if an error is encountered.  The pixel data can be either char, short int, int, ssize_t, float, or double in the order specified by map.Suppose your want to upload the first scanline of a 640x480 image from character data in red-green-blue order:<pre class="text">MagickImportImagePixels(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 define. - 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, ShortPixel, IntegerPixel, LongPixel, FloatPixel, or DoublePixel. - 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 MagickImportImagePixels(
   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 MagickInverseFourierTransformImage

    MagickBooleanType MagickInverseFourierTransformImage(
      MagickWand *magnitude_wand,MagickWand *phase_wand,
      const MagickBooleanType magnitude)

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


=begin pod
=head1 MagickLabelImage

    MagickBooleanType MagickLabelImage(MagickWand *wand,const char *label)

MagickLabelImage() adds a label to your image.- wand: the magick wand. - label: the image label. 
=end pod
sub MagickLabelImage(
   Pointer $wand,
   Str $label
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickLevelImage

    MagickBooleanType MagickLevelImage(MagickWand *wand,
      const double black_point,const double gamma,const double white_point)
    MagickBooleanType MagickLevelImageChannel(MagickWand *wand,
      const ChannelType channel,const double black_point,const double gamma,
      const double white_point)

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.

- wand: the magick wand.
- channel: Identify which channel to level: RedChannel, GreenChannel,
- black_point: the black point.
- gamma: the gamma.
- white_point: the white point.

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

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


=begin pod
=head1 MagickLinearStretchImage

    MagickBooleanType MagickLinearStretchImage(MagickWand *wand,
      const double black_point,const double white_point)

MagickLinearStretchImage() stretches with saturation the image intensity.You can also reduce the influence of a particular channel with a gamma value of 0.- wand: the magick wand. - black_point: the black point. - white_point: the white point. 
=end pod
sub MagickLinearStretchImage(
   Pointer $wand,
   num64 $black_point,
   num64 $white_point
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickLiquidRescaleImage

    MagickBooleanType MagickMagnifyImage(MagickWand *wand)

MagickLiquidRescaleImage() rescales image with seam carving.MagickBooleanType MagickLiquidRescaleImage(MagickWand \*wand, const size_t columns,const size_t rows,const double delta_x, const double rigidity)- wand: the magick wand. - columns: the number of columns in the scaled image. - rows: the number of rows in the scaled image. - delta_x: maximum seam transversal step (0 means straight seams). - rigidity: introduce a bias for non-straight seams (typically 0). <h2><a href="http://www.imagemagick.org/api/MagickWand/magick-image_8c.html" id="MagickLocalContrastImage">MagickLocalContrastImage</a></h2>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.MagickBooleanType MagickLocalContrastImage(MagickWand \*wand, const double radius,const double strength)- image: the image. - radius: the radius of the Gaussian, in pixels, not counting the center pixel. - strength: the strength of the blur mask in percentage. <h2><a href="http://www.imagemagick.org/api/MagickWand/magick-image_8c.html" id="MagickMagnifyImage">MagickMagnifyImage</a></h2>MagickMagnifyImage() is a convenience method that scales an image proportionally to twice its original size.- wand: the magick wand. 
=end pod
sub MagickMagnifyImage(
   Pointer $wand
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickMergeImageLayers

    MagickWand *MagickMergeImageLayers(MagickWand *wand,
      const ImageLayerMethod method)

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 ImageLayerMethod, and is initialized using the first images background color.  The images are then compositied onto that image in sequence using the given composition that has been assigned to each individual image.- wand: the magick wand. - method: the method of selecting the size of the initial canvas. <dd> MergeLayer: Merge all layers onto a canvas just large enough to hold all the actual images. The virtual canvas of the first image is preserved but otherwise ignored. </dd><dd> FlattenLayer: Use the virtual canvas size of first image. Images which fall outside this canvas is clipped. This can be used to 'fill out' a given virtual canvas. </dd><dd> MosaicLayer: Start with the virtual canvas of the first image, enlarging left and right edges to contain all images. Images with negative offsets will be clipped. </dd>
=end pod
sub MagickMergeImageLayers(
   Pointer $wand,
   uint32 $method
)
returns Pointer
is native(&library)
is export { * };


=begin pod
=head1 MagickMinifyImage

    MagickBooleanType MagickMinifyImage(MagickWand *wand)

MagickMinifyImage() is a convenience method that scales an image proportionally to one-half its original size- wand: the magick wand. 
=end pod
sub MagickMinifyImage(
   Pointer $wand
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickModulateImage

    MagickBooleanType MagickModulateImage(MagickWand *wand,
      const double brightness,const double saturation,const double hue)

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.- wand:
the magick wand.

- brightness: the percent change in brighness.
- saturation: the percent change in saturation.
- hue: the percent change in hue.

=end pod
sub MagickModulateImage(
   Pointer $wand,
   num64 $brightness,
   num64 $saturation,
   num64 $hue
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickMontageImage

    MagickWand *MagickMontageImage(MagickWand *wand,
      const DrawingWand drawing_wand,const char *tile_geometry,
      const char *thumbnail_geometry,const MontageMode mode,
      const char *frame)

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.

- wand: the magick wand.
- drawing_wand: the drawing wand.  The font name, size, and color are obtained
from this wand.
- tile_geometry: the number of tiles per row and page (e.g.6x4+0+0).
- thumbnail_geometry: Preferred image size and border size of each
thumbnail (e.g. 120x120+4+3>).
- mode: Thumbnail framing mode: Frame, Unframe, or Concatenate.
- frame: Surround the image with an ornamental border (e.g. 15x15+3+3). The
frame color is that of the thumbnail's matte color.

=end pod
sub MagickMontageImage(
   Pointer $wand,
   uint32 $drawing_wand,
   Str $tile_geometry,
   Str $thumbnail_geometry,
   uint32 $mode,
   Str $frame
)
returns Pointer
is native(&library)
is export { * };


=begin pod
=head1 MagickMorphImages

    MagickWand *MagickMorphImages(MagickWand *wand,
      const size_t number_frames)

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.- wand: the magick wand. - number_frames: the number of in-between images to generate. 
=end pod
sub MagickMorphImages(
   Pointer $wand,
   int32 $number_frames
)
returns Pointer
is native(&library)
is export { * };


=begin pod
=head1 MagickMorphologyImage

    MagickBooleanType MagickMorphologyImage(MagickWand *wand,
      MorphologyMethod method,const ssize_t iterations,KernelInfo *kernel)
    MagickBooleanType MagickMorphologyImageChannel(MagickWand *wand,
      ChannelType channel,MorphologyMethod method,const ssize_t iterations,
      Pointer[KernelInfo]kernel)

MagickMorphologyImage() applies a user supplied kernel to the image according to the given mophology method.- wand: the magick wand. - channel: the image channel(s). - method: the morphology method to be applied. - iterations: apply the operation this many times (or no change). A value of -1 means loop until no change found.  How this is applied may depend on the morphology method.  Typically this is a value of 1. - kernel: An array of doubles representing the morphology kernel. 

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

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

=begin pod
=head1 MagickMotionBlurImage

    MagickBooleanType MagickMotionBlurImage(MagickWand *wand,
      const double radius,const double sigma,const double angle)
    MagickBooleanType MagickMotionBlurImageChannel(MagickWand *wand,
      const ChannelType channel,const double radius,const double sigma,
      const double angle)

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.

- 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.
- angle: Apply the effect along this angle.

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

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


=begin pod
=head1 MagickNegateImage

    MagickBooleanType MagickNegateImage(MagickWand *wand,
      const MagickBooleanType gray)
    MagickBooleanType MagickNegateImageChannel(MagickWand *wand,
      const ChannelType channel,const MagickBooleanType gray)

MagickNegateImage() negates the colors in the reference image. The Grayscale
option means that only grayscale values within the image are negated.You can
also reduce the influence of a particular channel with a gamma value of 0.

- wand: the magick wand.
- channel: the image channel(s).
- gray: If MagickTrue, only negate grayscale pixels within the image.

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

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


=begin pod
=head1 MagickNewImage

    MagickBooleanType MagickNewImage(MagickWand *wand,
      const size_t columns,const size_t rows,
      const PixelWand *background)

MagickNewImage() adds a blank image canvas of the specified size and background color to the wand.- wand: the magick wand. - width: the image width. - height: the image height. - background: the image color. 
=end pod
sub MagickNewImage(
   Pointer $wand,
   int32 $columns,
   int32 $rows,
   Pointer $background
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickNextImage

    MagickBooleanType MagickNextImage(MagickWand *wand)

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 MagickFalse 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 automaticall 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 immeditally using MagickSetLastIterator().- wand: the magick wand. 
=end pod
sub MagickNextImage(
   Pointer $wand
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickNormalizeImage

    MagickBooleanType MagickNormalizeImage(MagickWand *wand)
    MagickBooleanType MagickNormalizeImageChannel(MagickWand *wand,
      const ChannelType channel)

MagickNormalizeImage() enhances the contrast of a color image by adjusting the
pixels color to span the entire range of colors availableYou can also reduce the
influence of a particular channel with a gamma value of 0.

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

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

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


=begin pod
=head1 MagickOilPaintImage

    MagickBooleanType MagickOilPaintImage(MagickWand *wand,
      const double radius)

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.

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

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


=begin pod
=head1 MagickOpaquePaintImage

    MagickBooleanType MagickOpaquePaintImage(MagickWand *wand,
      const PixelWand *target,const PixelWand *fill,const double fuzz,
      const MagickBooleanType invert)
    MagickBooleanType MagickOpaquePaintImageChannel(MagickWand *wand,
      const ChannelType channel,const PixelWand *target,
      const PixelWand *fill,const double fuzz,const MagickBooleanType invert)

MagickOpaquePaintImage() changes any pixel that matches color with the color defined by fill.- wand: the magick wand. - channel: the channel(s). - target: Change this target color to the fill color