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

use v6;

unit module MagickWand::NativeCall::Image;

use NativeCall;
use MagickWand::NativeCall::Common;

=begin pod
=head1 GetImageFromMagickWand

    Image *GetImageFromMagickWand(const MagickWand *wand)

GetImageFromMagickWand() returns the current image from the magick wand.

- wand: the magick wand.

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


=begin pod
=head1 MagickAdaptiveBlurImage

    MagickBooleanType MagickAdaptiveBlurImage(MagickWand *wand,
      const double radius,const double sigma)
    MagickBooleanType MagickAdaptiveBlurImageChannel(MagickWand *wand,
      const ChannelType channel,const double radius,const double sigma)

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

- 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 MagickAdaptiveBlurImage(
   Pointer $wand,
   num64 $radius,
   num64 $sigma
)
returns uint32 
is native(&library)
is export { * };

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


=begin pod
=head1 MagickAdaptiveResizeImage

    MagickBooleanType MagickAdaptiveResizeImage(MagickWand *wand,
      const size_t columns,const size_t rows)

MagickAdaptiveResizeImage() adaptively resize image with data dependent
triangulation.

- wand: the magick wand.
- columns: the number of columns in the scaled image.
- rows: the number of rows in the scaled image.

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

=begin pod
=head1 MagickAdaptiveSharpenImage

MagickBooleanType MagickAdaptiveSharpenImage(MagickWand *wand,
  const double radius,const double sigma)
MagickBooleanType MagickAdaptiveSharpenImageChannel(MagickWand *wand,
  const ChannelType channel,const double radius,const double sigma)

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

- 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 MagickAdaptiveSharpenImage(
   Pointer $wand,
   num64 $radius,
   num64 $sigma
)
returns uint32
is native(&library)
is export { * };

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


=begin pod
=head1 MagickAdaptiveThresholdImage

    MagickBooleanType MagickAdaptiveThresholdImage(MagickWand *wand,
      const size_t width,const size_t height,const ssize_t offset)

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

- wand: the magick wand.
- width: the width of the local neighborhood.
- height: the height of the local neighborhood.
- offset: the mean offset.

=end pod
sub MagickAdaptiveThresholdImage(
   Pointer $wand,
   uint32 $width,
   uint32 $height,
   uint32 $offset
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickAddImage

    MagickBooleanType MagickAddImage(MagickWand *wand,
      const MagickWand *add_wand)

MagickAddImage() 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 appened 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.- wand: the magick wand. - add_wand: A wand that contains the image list to be added 
=end pod
sub MagickAddImage(
   Pointer $wand,
   Pointer $add_wand
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickAddNoiseImage

    MagickBooleanType MagickAddNoiseImage(MagickWand *wand,
      const uint32 noise_type)
    MagickBooleanType MagickAddNoiseImageChannel(MagickWand *wand,
      const ChannelType channel,const uint32 noise_type)

MagickAddNoiseImage() adds random noise to the image.

- wand: the magick wand.
- channel: the image channel(s).
- noise_type: The type of noise: Uniform, Gaussian, Multiplicative, Impulse,
  Laplacian, or Poisson.

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

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


=begin pod
=head1 MagickAffineTransformImage

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

MagickAffineTransformImage() transforms an image as dictated by the affine matrix of the drawing wand.- wand: the magick wand. - drawing_wand: the draw wand. 
=end pod
sub MagickAffineTransformImage(
   Pointer $wand,
   Pointer $drawing_wand
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickAnnotateImage

    MagickBooleanType MagickAnnotateImage(MagickWand *wand,
      const DrawingWand *drawing_wand,const double x,const double y,
      const double angle,const char *text)

MagickAnnotateImage() annotates an image with text.

- wand: the magick wand.
- drawing_wand: the draw wand.
- x: x ordinate to left of text
- y: y ordinate to text baseline
- angle: rotate text relative to this angle.
- text: text to draw

=end pod
sub MagickAnnotateImage(
   Pointer $wand,
   Pointer $drawing_wand,
   num64 $x,
   num64 $y,
   num64 $angle,
   Str $text
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickAnimateImages

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

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


=begin pod
=head1 MagickAppendImages

    MagickWand *MagickAppendImages(MagickWand *wand,
      const MagickBooleanType stack)

MagickAppendImages() 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.- wand: the magick wand. - stack: By default, images are stacked left-to-right. Set stack to MagickTrue to stack them top-to-bottom. 
=end pod
sub MagickAppendImages(
   Pointer $wand,
   uint32 $stack
)
returns Pointer
is native(&library)
is export { * };


=begin pod
=head1 MagickAutoGammaImage

    MagickBooleanType MagickAutoGammaImage(MagickWand *wand)
    MagickBooleanType MagickAutoGammaImageChannel(MagickWand *wand,
      const ChannelType channel)

MagickAutoGammaImage() extracts the 'mean' from the image and adjust the image to try make set its gamma appropriatally.- wand: the magick wand. - channel: the image channel(s). 
=end pod
sub MagickAutoGammaImage(
   Pointer $wand
)
returns uint32 
is native(&library)
is export { * };

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


=begin pod
=head1 MagickAutoLevelImage

    MagickBooleanType MagickAutoLevelImage(MagickWand *wand)
    MagickBooleanType MagickAutoLevelImageChannel(MagickWand *wand,
      const ChannelType channel)

MagickAutoLevelImage() adjusts the levels of a particular image channel by
scaling the minimum and maximum values to the full quantum range.

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

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

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


=begin pod
=head1 MagickAutoOrientImage

    MagickBooleanType MagickAutoOrientImage(MagickWand *image)

MagickAutoOrientImage() adjusts an image so that its orientation is suitable $  for viewing (i.e. top-left orientation).- wand: the magick wand. 
=end pod
sub MagickAutoOrientImage(
   Pointer $image
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickBlackThresholdImage

    MagickBooleanType MagickBlackThresholdImage(MagickWand *wand,
      const PixelWand *threshold)

MagickBlackThresholdImage() is like MagickThresholdImage() but  forces all pixels below the threshold into black while leaving all pixels above the threshold unchanged.- wand: the magick wand. - threshold: the pixel wand. 
=end pod
sub MagickBlackThresholdImage(
   Pointer $wand,
   Pointer $threshold
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickBlueShiftImage

    MagickBooleanType MagickBlueShiftImage(MagickWand *wand,
      const double factor)

MagickBlueShiftImage() mutes the colors of the image to simulate a scene at nighttime in the moonlight.- wand: the magick wand. - factor: the blue shift factor (default 1.5) 
=end pod
sub MagickBlueShiftImage(
   Pointer $wand,
   num64 $factor
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickBlurImage

    MagickBooleanType MagickBlurImage(MagickWand *wand,const double radius,
      const double sigma)
    MagickBooleanType MagickBlurImageChannel(MagickWand *wand,
      const ChannelType channel,const double radius,const double sigma)

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.- wand: the magick wand. - channel: the image channel(s). - radius: the radius of the , in pixels, not counting the center pixel. - sigma: the standard deviation of the , in pixels. 
=end pod
sub MagickBlurImage(
   Pointer $wand,
   num64 $radius,
   num64 $sigma
)
returns uint32 
is native(&library)
is export { * };

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


=begin pod
=head1 MagickBorderImage

    MagickBooleanType MagickBorderImage(MagickWand *wand,
      const PixelWand *bordercolor,const size_t width,
      const size_t height)

MagickBorderImage() surrounds the image with a border of the color defined by
the bordercolor pixel wand.

- wand: the magick wand.
- bordercolor: the border color pixel wand.
- width: the border width.
- height: the border height.

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


=begin pod
=head1 Use_MagickBrightnessContrastImage

    MagickBooleanType MagickBrightnessContrastImage(MagickWand *wand,
      const double brightness,const double contrast)
    MagickBooleanType MagickBrightnessContrastImageChannel(MagickWand *wand,
      const ChannelType channel,const double brightness,
      const double contrast)

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 polynomical function to apply to the image.- wand: the magick wand. - channel: the image channel(s). - brightness: the brightness percent (-100 .. 100). - contrast: the contrast percent (-100 .. 100). 
=end pod
sub MagickBrightnessContrastImage(
   Pointer $wand,
   num64 $brightness,
   num64 $contrast
)
returns uint32 
is native(&library)
is export { * };

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


=begin pod
=head1 MagickCharcoalImage

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

MagickCharcoalImage() simulates a charcoal drawing.- 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 MagickCharcoalImage(
   Pointer $wand,
   num64 $radius,
   num64 $sigma
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickChopImage

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

MagickChopImage() removes a region of an image and collapses the image to occupy the removed portion- 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 MagickChopImage(
   Pointer $wand,
   int32 $width,
   int32 $height,
   uint32 $x,
   uint32 $y
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickClampImage

    MagickBooleanType MagickClampImage(MagickWand *wand)
    MagickBooleanType MagickClampImageChannel(MagickWand *wand,
      const ChannelType channel)

MagickClampImage() restricts the color range from 0 to the quantum depth.- wand: the magick wand. - channel: the channel. 
=end pod
sub MagickClampImage(
   Pointer $wand
)
returns uint32 
is native(&library)
is export { * };

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


=begin pod
=head1 MagickClipImage

    MagickBooleanType MagickClipImage(MagickWand *wand)

MagickClipImage() clips along the first path from the 8BIM profile, if present.- wand: the magick wand. 
=end pod
sub MagickClipImage(
   Pointer $wand
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickClipImagePath

    MagickBooleanType MagickClipImagePath(MagickWand *wand,
      const char *pathname,const MagickBooleanType inside)

MagickClipImagePath() 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.- wand: the magick wand. - pathname: name of clipping path resource. If name is preceded by #, use clipping path numbered by name. - inside: if non-zero, later operations take effect inside clipping path. Otherwise later operations take effect outside clipping path. 
=end pod
sub MagickClipImagePath(
   Pointer $wand,
   Str $pathname,
   uint32 $inside
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickClutImage

    MagickBooleanType MagickClutImage(MagickWand *wand,
      const MagickWand *clut_wand)
    MagickBooleanType MagickClutImageChannel(MagickWand *wand,
      const ChannelType channel,const MagickWand *clut_wand)

MagickClutImage() replaces colors in the image from a color lookup table.- wand: the magick wand. - clut_image: the clut image. 
=end pod
sub MagickClutImage(
   Pointer $wand,
   Pointer $clut_wand
)
returns uint32 
is native(&library)
is export { * };

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


=begin pod
=head1 MagickCoalesceImages

    MagickWand *MagickCoalesceImages(MagickWand *wand)

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.- wand: the magick wand. 
=end pod
sub MagickCoalesceImages(
   Pointer $wand
)
returns Pointer
is native(&library)
is export { * };


=begin pod
=head1 MagickColorDecisionListImage

    MagickBooleanType MagickColorDecisionListImage(MagickWand *wand,
      const char *color_correction_collection)

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:<pre class="text">    &lt;ColorCorrectionCollection xmlns="urn:ASC:CDL:v1.2"&gt;    &lt;ColorCorrection id="cc03345"&gt;          &lt;SOPNode&gt;               &lt;Slope&gt; 0.9 1.2 0.5 &lt;/Slope&gt;               &lt;Offset&gt; 0.4 -0.5 0.6 &lt;/Offset&gt;               &lt;Power&gt; 1.0 0.8 1.5 &lt;/Power&gt;          &lt;/SOPNode&gt;          &lt;SATNode&gt;               &lt;Saturation&gt; 0.85 &lt;/Saturation&gt;          &lt;/SATNode&gt;    &lt;/ColorCorrection&gt;    &lt;/ColorCorrectionCollection&gt;</pre>which includes the offset, slope, and power for each of the RGB channels as well as the saturation.- wand: the magick wand. - color_correction_collection: the color correction collection in XML. 

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


=begin pod
=head1 MagickColorizeImage

    MagickBooleanType MagickColorizeImage(MagickWand *wand,
      const PixelWand *colorize,const PixelWand *opacity)

MagickColorizeImage() blends the fill color with each pixel in the image.- wand: the magick wand. - colorize: the colorize pixel wand. - opacity: the opacity pixel wand. 
=end pod
sub MagickColorizeImage(
   Pointer $wand,
   Pointer $colorize,
   Pointer $opacity
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickColorMatrixImage

    MagickBooleanType MagickColorMatrixImage(MagickWand *wand,
      const KernelInfo *color_matrix)

MagickColorMatrixImage() 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).- wand: the magick wand. - color_matrix:
the color matrix. 

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


=begin pod
=head1 MagickCombineImages

    MagickWand *MagickCombineImages(MagickWand *wand,
      const ChannelType channel)

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  hannels of the combined image.   The typical ordering would be image 1 =&gt; Red, 2 =&gt; Green, 3 =&gt; Blue, etc.- wand: the magick wand. - channel: the channel. 
=end pod
sub MagickCombineImages(
   Pointer $wand,
   uint32 $channel
)
returns Pointer
is native(&library)
is export { * };


=begin pod
=head1 MagickCommentImage

    MagickBooleanType MagickCommentImage(MagickWand *wand,
      const char *comment)

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


=begin pod
=head1 MagickCompareImageChannels

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

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


=begin pod
=head1 MagickCompareImageLayers

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

MagickCompareImageLayers() 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. - method: the compare method. 
=end pod
sub MagickCompareImageLayers(
   Pointer $wand,
   uint32 $method
)
returns Pointer
is native(&library)
is export { * };


=begin pod
=head1 MagickCompareImages

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

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


=begin pod
=head1 MagickCompositeImage

    MagickBooleanType MagickCompositeImage(MagickWand *wand,
      const MagickWand *source_wand,const CompositeOperator compose,
      const ssize_t x,const ssize_t y)
    MagickBooleanType MagickCompositeImageChannel(MagickWand *wand,
      const ChannelType channel,const MagickWand *composite_wand,
      const CompositeOperator compose,const ssize_t x,const ssize_t y)

MagickCompositeImage() composite one image onto another at the specified offset.- wand: the magick wand holding the destination images - source_image: the magick wand holding source image. - compose: This operator affects how the composite is applied to the image.  The default is Over.  These are some of the compose methods availble. <dd> OverCompositeOp       InCompositeOp         OutCompositeOp AtopCompositeOp       XorCompositeOp        PlusCompositeOp MinusCompositeOp      AddCompositeOp        SubtractCompositeOp DifferenceCompositeOp BumpmapCompositeOp    CopyCompositeOp DisplaceCompositeOp </dd>- x: the column offset of the composited image. - y: the row offset of the composited image. 
=end pod
sub MagickCompositeImage(
   Pointer $wand,
   Pointer $source_wand,
   uint32 $compose,
   uint32 $x,
   uint32 $y
)
returns uint32 
is native(&library)
is export { * };

sub MagickCompositeImageChannel(
   Pointer $wand,
   uint32 $channel,
   Pointer $composite_wand,
  uint32 $compose,
   uint32 $x,
   uint32 $y
)
returns uint32
is native(&library)
is export { * };


=begin pod
=head1 MagickCompositeImageGravity

    MagickBooleanType MagickCompositeImageGravity(MagickWand *wand,
      const MagickWand *source_wand,const CompositeOperator compose,
      const GravityType gravity)

MagickCompositeImageGravity() composite one image onto another using the specified gravity.- wand: the magick wand holding the destination images - source_image: the magick wand holding source image. - compose: This operator affects how the composite is applied to the image.  The default is Over.  These are some of the compose methods availble. <dd> OverCompositeOp       InCompositeOp         OutCompositeOp AtopCompositeOp       XorCompositeOp        PlusCompositeOp MinusCompositeOp      AddCompositeOp        SubtractCompositeOp DifferenceCompositeOp BumpmapCompositeOp    CopyCompositeOp DisplaceCompositeOp </dd>- gravity: positioning gravity (NorthWestGravity, NorthGravity, NorthEastGravity, WestGravity, CenterGravity, EastGravity, SouthWestGravity, SouthGravity, SouthEastGravity) 
=end pod
sub MagickCompositeImageGravity(
   Pointer $wand,
   Pointer $source_wand,
  uint32 $compose,
   uint32 $gravity
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickCompositeLayers

    MagickBooleanType MagickCompositeLayers(MagickWand *wand,
      const MagickWand *source_wand, const CompositeOperator compose,
      const ssize_t x,const ssize_t y)

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 destiantioni images.  This makes it well sutiable for directly composing 'Clears Frame Animations' or 'Coaleased Animations' onto a static or other 'Coaleased 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 repeatally 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 ve cloned to match the number of images remaining in the source image list.This is equivelent to the "-layer Composite" Shell API operator.- wand: the magick wand holding destaintion images - source_wand: the wand holding the source images - compose, x, y:  composition arguments 
=end pod
sub MagickCompositeLayers(
   Pointer $wand,
   Pointer $source_wand,
  uint32 $compose,
   uint32 $x,
   uint32 $y
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickContrastImage

    MagickBooleanType MagickContrastImage(MagickWand *wand,
      const MagickBooleanType sharpen)

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

- wand: the magick wand.
- sharpen: Increase or decrease image contrast.

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


=begin pod
=head1 MagickContrastStretchImage

    MagickBooleanType MagickContrastStretchImage(MagickWand *wand,
      const double black_point,const double white_point)
    MagickBooleanType MagickContrastStretchImageChannel(MagickWand *wand,
      const ChannelType channel,const double black_point,
      const double white_point)

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

- wand: the magick wand.
- channel: the image channel(s).
- black_point: the black point.
- white_point: the white point.

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

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


=begin pod
=head1 MagickConvolveImage

    MagickBooleanType MagickConvolveImage(MagickWand *wand,
      const size_t order,const double *kernel)
    MagickBooleanType MagickConvolveImageChannel(MagickWand *wand,
      const ChannelType channel,const size_t order,
      const double *kernel)

MagickConvolveImage() applies a custom convolution kernel to the image.

- wand: the magick wand.
- channel: the image channel(s).
- order: the number of columns and rows in the filter kernel.
- kernel: An array of doubles representing the convolution kernel.

=end pod
sub MagickConvolveImage(
   Pointer $wand,
   uint32 $order,
   CArray[num64] $kernel
)
returns uint32
is native(&library)
is export { * };

sub MagickConvolveImageChannel(
   Pointer $wand,
   uint32 $channel,
   uint32 $order,
   CArray[num64] $kernel
)
returns uint32
is native(&library)
is export { * };


=begin pod
=head1 MagickCropImage

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

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


=begin pod
=head1 MagickCycleColormapImage

    MagickBooleanType MagickCycleColormapImage(MagickWand *wand,
      const ssize_t displace)

MagickCycleColormapImage() 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.- wand: the magick wand. - pixel_wand: the pixel wand. 
=end pod
sub MagickCycleColormapImage(
   Pointer $wand,
   uint32 $displace
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickConstituteImage

    MagickBooleanType MagickConstituteImage(MagickWand *wand,
      const size_t columns,const size_t rows,const char *map,
      const StorageType storage,void *pixels)

MagickConstituteImage() adds an image to the wand comprised of the pixel data you supply.  The pixel data must be in scanline order top-to-bottom. The data can be char, short int, int, float, or double.  Float and double require the pixels to be normalized [0..1], otherwise [0..Max],  where Max is the maximum value the type can accomodate (e.g. 255 for char).  For example, to create a 640x480 image from unsigned red-green-blue character data, useMagickConstituteImage(wand,640,480,"RGB",CharPixel,pixels);- wand: the magick wand. - columns: width in pixels of the image. - rows: height in pixels of the image. - 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 MagickConstituteImage(
   Pointer $wand,
   int32 $columns,
   int3