### ----------------------------------------------------
### -- MagickWand
### -- Licenses: MIT
### -- Authors: Ahmad M. Zawawi
### -- File: lib/MagickWand/NativeCall/Image.rakumod
### ----------------------------------------------------
### -- Chunk 4 of 6
 within the image. - fill: the fill 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. - invert: paint any pixel that does not match the target color. 
=end pod
sub MagickOpaquePaintImage(
   Pointer $wand,
   Pointer $target,
   Pointer $fill,
   num64 $fuzz,
   uint32 $invert
)
returns uint32 
is native(&library)
is export { * };

sub MagickOpaquePaintImageChannel(
   Pointer $wand,
   uint32 $channel,
   Pointer $target,
   Pointer $fill,
   num64 $fuzz,
   uint32 $invert
)
returns uint32
is native(&library)
is export { * };


=begin pod
=head1 MagickOptimizeImageLayers

    MagickWand *MagickOptimizeImageLayers(MagickWand *wand)

MagickOptimizeImageLayers() compares each image the GIF disposed forms of the previous image in the sequence.  From this it attempts to select the smallest cropped image to replace each frame, while preserving the results of the animation.- wand: the magick wand. 
=end pod
sub MagickOptimizeImageLayers(
   Pointer $wand
)
returns Pointer
is native(&library)
is export { * };


=begin pod
=head1 MagickOptimizeImageTransparency

    MagickBooleanType MagickOrderedPosterizeImage(MagickWand *wand,
      const char *threshold_map)
    MagickBooleanType MagickOrderedPosterizeImageChannel(MagickWand *wand,
      const ChannelType channel,const char *threshold_map)

MagickOptimizeImageTransparency() takes a frame optimized GIF animation, and compares the overlayed pixels against the disposal image resulting from all the previous frames in the animation.  Any pixel that does not change the disposal image (and thus does not effect the outcome of an overlay) is made transparent.WARNING: This modifies the current images directly, rather than generate a new image sequence. The format of the MagickOptimizeImageTransparency method is:<pre class="text">MagickBooleanType MagickOptimizeImageTransparency(MagickWand \*wand)</pre>- wand: the magick wand. <h2><a href="http://www.imagemagick.org/api/MagickWand/magick-image_8c.html" id="MagickOrderedPosterizeImage">MagickOrderedPosterizeImage</a></h2>MagickOrderedPosterizeImage() performs an ordered dither based on a number of pre-defined dithering threshold maps, but over multiple intensity levels, which can be different for different channels, according to the input arguments.- image: the image. - channel: the channel or channels to be thresholded. - threshold_map: A string containing the name of the threshold dither map to use, followed by zero or more numbers representing the number of color levels tho dither between. <dd> Any level number less than 2 is equivalent to 2, and means only binary dithering will be applied to each color channel. </dd><dd> No numbers also means a 2 level (bitmap) dither will be applied to all channels, while a single number is the number of levels applied to each channel in sequence.  More numbers will be applied in turn to each of the color channels. </dd><dd> For example: "o3x3,6" generates a 6 level posterization of the image with a ordered 3x3 diffused pixel dither being applied between each level. While checker,8,8,4 will produce a 332 colormaped image with only a single checkerboard hash pattern (50 grey) between each color level, to basically double the number of color levels with a bare minimim of dithering. </dd>
=end pod
sub MagickOrderedPosterizeImage(
   Pointer $wand,
   Str $threshold_map
)
returns uint32 
is native(&library)
is export { * };

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


=begin pod
=head1 MagickPingImage

    MagickBooleanType MagickPingImage(MagickWand *wand,const char *filename)

MagickPingImage() is like MagickReadImage() except the only valid information returned is the image width, height, size, and format.  It is designed to efficiently obtain this information from a file without reading the entire image sequence into memory.- wand: the magick wand. - filename: the image filename. 
=end pod
sub MagickPingImage(
   Pointer $wand,
   Str $filename
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickPingImageBlob

    MagickBooleanType MagickPingImageBlob(MagickWand *wand,
      const void *blob,const size_t length)

MagickPingImageBlob() pings an image or image sequence from a blob.- wand: the magick wand. - blob: the blob. - length: the blob length. 
=end pod
sub MagickPingImageBlob(
   Pointer $wand,
   Pointer[void] $blob,
   int32 $length
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickPolaroidImage

    MagickBooleanType MagickPolaroidImage(MagickWand *wand,
      const DrawingWand *drawing_wand,const double angle)

MagickPolaroidImage() simulates a Polaroid picture.- wand: the magick wand. - drawing_wand: the draw wand. - angle: Apply the effect along this angle. 
=end pod
sub MagickPolaroidImage(
   Pointer $wand,
   Pointer $drawing_wand,
   num64 $angle
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickPosterizeImage

    MagickBooleanType MagickPosterizeImage(MagickWand *wand,
      const size_t levels,const MagickBooleanType dither)

MagickPosterizeImage() reduces the image to a limited number of color level.- wand: the magick wand. - levels: Number of color levels allowed in each channel.  Very low values (2, 3, or 4) have the most visible effect. - dither: Set this integer value to something other than zero to dither the mapped image. 
=end pod
sub MagickPosterizeImage(
   Pointer $wand,
   int32 $levels,
   uint32 $dither
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickPreviewImages

    MagickWand *MagickPreviewImages(MagickWand *wand,
      const PreviewType preview)

MagickPreviewImages() tiles 9 thumbnails of the specified image with an image processing operation applied at varying strengths.  This helpful to quickly pin-point an appropriate parameter for an image processing operation.- wand: the magick wand. - preview: the preview type. 
=end pod
sub MagickPreviewImages(
   Pointer $wand,
   uint32 $preview
)
returns Pointer
is native(&library)
is export { * };


=begin pod
=head1 MagickPreviousImage

    MagickBooleanType MagickPreviousImage(MagickWand *wand)

MagickPreviousImage() sets the previous image in the wand as the current image.It is typically used after MagickSetLastIterator(), after which its first use will set the last image as the current image (unless the wand is empty).It will return MagickFalse when no more images are left to be returned which happens when the wand is empty, or the current image is the first image.  At that point the iterator is than reset to again process images in the forward direction, again starting with the first image in list. Images added at this point are prepended.Also at that point any images added to the wand using MagickAddImages() or MagickReadImages() will be prepended before the first image. In this sense the condition is not quite exactly the same as MagickResetIterator().- wand: the magick wand. 
=end pod
sub MagickPreviousImage(
   Pointer $wand
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickQuantizeImage

    MagickBooleanType MagickQuantizeImage(MagickWand *wand,
      const size_t number_colors,const ColorspaceType colorspace,
      const size_t treedepth,const MagickBooleanType dither,
      const MagickBooleanType measure_error)

MagickQuantizeImage() analyzes the colors within a reference image and chooses a
fixed number of colors to represent the image.  The goal of the algorithm is to
minimize the color difference between the input and output image while
minimizing the processing time.

- wand: the magick wand.
- number_colors: the number of colors.
- colorspace: Perform color reduction in this colorspace, typically
RGBColorspace.
- treedepth: Normally, this integer value is zero or one.  A zero or one tells
Quantize to choose a optimal tree depth of Log4(number_colors). A tree of this
depth generally allows the best representation of the reference image with the
least amount of memory and the fastest computational speed.  In some cases, such
as an image with low color dispersion (a few number of colors), a value other
than Log4(number_colors) is required.  To expand the color tree completely, use
a value of 8.
- dither: A value other than zero distributes the difference between an original
image and the corresponding color reduced image to neighboring pixels along a
Hilbert curve.
- measure_error: A value other than zero measures the difference between
the original and quantized images.  This difference is the total quantization
error.  The error is computed by summing over all pixels in an image the
distance squared in RGB space between each reference pixel value and its
quantized value.

=end pod
sub MagickQuantizeImage(
   Pointer $wand,
   int32 $number_colors,
   uint32 $colorspace,
   int32 $treedepth,
   uint32 $dither,
   uint32 $measure_error
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickQuantizeImages

    MagickBooleanType MagickQuantizeImages(MagickWand *wand,
      const size_t number_colors,const ColorspaceType colorspace,
      const size_t treedepth,const MagickBooleanType dither,
      const MagickBooleanType measure_error)

MagickQuantizeImages() analyzes the colors within a sequence of images and chooses a fixed number of colors to represent the image.  The goal of the algorithm is to minimize the color difference between the input and output image while minimizing the processing time.- wand: the magick wand. - number_colors: the number of colors. - colorspace: Perform color reduction in this colorspace, typically RGBColorspace. - treedepth: Normally, this integer value is zero or one.  A zero or one tells Quantize to choose a optimal tree depth of Log4(number_colors).      A tree of this depth generally allows the best representation of the reference image with the least amount of memory and the fastest computational speed.  In some cases, such as an image with low color dispersion (a few number of colors), a value other than Log4(number_colors) is required.  To expand the color tree completely, use a value of 8. - dither: A value other than zero distributes the difference between an original image and the corresponding color reduced algorithm to neighboring pixels along a Hilbert curve. - measure_error: A value other than zero measures the difference between the original and quantized images.  This difference is the total quantization error.  The error is computed by summing over all pixels in an image the distance squared in RGB space between each reference pixel value and its quantized value. 
=end pod
sub MagickQuantizeImages(
   Pointer $wand,
   int32 $number_colors,
   uint32 $colorspace,
   int32 $treedepth,
   uint32 $dither,
   uint32 $measure_error
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickRaiseImage

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

MagickRaiseImage() creates a simulated three-dimensional button-like effect by
lightening and darkening the edges of the image.  Members width and height of
raise_info define the width of the vertical and horizontal edge of the effect.

- wand: the magick wand.
- width,height,x,y:  Define the dimensions of the area to raise.
- raise: A value other than zero creates a 3-D raise effect, otherwise it has a
lowered effect.

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


=begin pod
=head1 MagickRandomThresholdImage

    MagickBooleanType MagickRandomThresholdImage(MagickWand *wand,
      const double low,const double high)
    MagickBooleanType MagickRandomThresholdImageChannel(MagickWand *wand,
      const ChannelType channel,const double low,const double high)

MagickRandomThresholdImage() changes the value of individual pixels based on the intensity of each pixel compared to threshold.  The result is a high-contrast, two color image.- wand: the magick wand. - channel: the image channel(s). - low,high: Specify the high and low thresholds.  These values range from 0 to QuantumRange. 
=end pod
sub MagickRandomThresholdImage(
   Pointer $wand,
   num64 $low,
   num64 $high
)
returns uint32 
is native(&library)
is export { * };

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


=begin pod
=head1 MagickReadImage

    MagickBooleanType MagickReadImage(MagickWand *wand,const char *filename)

MagickReadImage() reads an image or image sequence.

The images are inserted at the current image pointer position.

Use MagickSetFirstIterator(), MagickSetLastIterator, or MagickSetIteratorIndex()
to specify the current image pointer position at the beginning of the image
list, the end, or anywhere in-between respectively.

- wand: the magick wand.
- filename: the image filename.

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


=begin pod
=head1 MagickReadImageBlob

    MagickBooleanType MagickReadImageBlob(MagickWand *wand,
      const void *blob,const size_t length)

MagickReadImageBlob() reads an image or image sequence from a blob.- wand: the magick wand. - blob: the blob. - length: the blob length. 
=end pod
sub MagickReadImageBlob(
   Pointer $wand,
   Pointer $blob,
   size_t $length
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickRemapImage

    MagickBooleanType MagickRemapImage(MagickWand *wand,
      const MagickWand *remap_wand,const DitherMethod method)

MagickRemapImage() replaces the colors of an image with the closest color from a reference image.- wand: the magick wand. - affinity: the affinity wand. - method: choose from these dither methods: NoDitherMethod, RiemersmaDitherMethod, or FloydSteinbergDitherMethod. 
=end pod
sub MagickRemapImage(
   Pointer $wand,
   Pointer $remap_wand,
   uint32 $method
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickRemoveImage

    MagickBooleanType MagickRemoveImage(MagickWand *wand)

MagickRemoveImage() removes an image from the image list.- wand: the magick wand. - insert: the splice wand. 
=end pod
sub MagickRemoveImage(
   Pointer $wand
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickResampleImage

    MagickBooleanType MagickResampleImage(MagickWand *wand,
      const double x_resolution,const double y_resolution,
      const FilterTypes filter,const double blur)

MagickResampleImage() resample image to desired resolution.Bessel   Blackman   Box Catrom   Cubic      Gaussian Hanning  Hermite    Lanczos Mitchell Point      Quandratic Sinc     TriangleMost of the filters are FIR (finite impulse response), however, Bessel, Gaussian, and Sinc are IIR (infinite impulse response).  Bessel and Sinc are windowed (brought down to zero) with the Blackman filter.- wand: the magick wand. - x_resolution: the new image x resolution. - y_resolution: the new image y resolution. - filter: Image filter to use. - blur: the blur factor where &gt; 1 is blurry, &lt; 1 is sharp. 
=end pod
sub MagickResampleImage(
   Pointer $wand,
   num64 $x_resolution,
   num64 $y_resolution,
   uint32 $filter,
   num64 $blur
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickResetImagePage

    MagickBooleanType MagickResetImagePage(MagickWand *wand,
      const char *page)

MagickResetImagePage() resets the Wand page canvas and position.- wand: the magick wand. - page: the relative page specification. 
=end pod
sub MagickResetImagePage(
   Pointer $wand,
   Str $page
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickResizeImage

    MagickBooleanType MagickResizeImage(MagickWand *wand,
      const size_t columns,const size_t rows,
      const FilterTypes filter,const double blur)

MagickResizeImage() scales an image to the desired dimensions with one of these
filters: Bessel, Blackman, Box, Catrom, CubicGaussian, Hanning, Hermite,Lanczos,
Mitchell, PointQuandratic, Sinc, Triangle

Most of the filters are FIR (finite impulse response), however, Bessel,
Gaussian, and Sinc are IIR (infinite impulse response).  Bessel and Sinc are
windowed (brought down to zero) with the Blackman filter.

- wand: the magick wand.
- columns: the number of columns in the scaled image.
- rows: the number of rows in the scaled image.
- filter: Image filter to use.
- blur: the blur factor where > 1 is blurry, < 1 is sharp.

=end pod
sub MagickResizeImage(
   Pointer $wand,
   int32 $columns,
   int32 $rows,
   uint32 $filter,
   num64 $blur
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickRollImage

    MagickBooleanType MagickRollImage(MagickWand *wand,const ssize_t x,
      const size_t y)

MagickRollImage() offsets an image as defined by x and y.

- wand: the magick wand.
- x: the x offset.
- y: the y offset.

=end pod
sub MagickRollImage(
   Pointer $wand,
   uint32 $x,
   int32 $y
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickRotateImage

    MagickBooleanType MagickRotateImage(MagickWand *wand,
      const PixelWand *background,const double degrees)

MagickRotateImage() rotates an image the specified number of degrees. Empty
triangles left over from rotating the image are filled with the background
color.

- wand: the magick wand.
- background: the background pixel wand.
- degrees: the number of degrees to rotate the image.

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


=begin pod
=head1 MagickRotationalBlurImage

    MagickBooleanType MagickRotationalBlurImage(MagickWand *wand,
      const double angle)
    MagickBooleanType MagickRotationalBlurImageChannel(MagickWand *wand,
      const ChannelType channel,const double angle)

MagickRotationalBlurImage() rotational blurs an image.

- wand: the magick wand.
- channel: the image channel(s).
- angle: the angle of the blur in degrees.

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

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


=begin pod
=head1 MagickSampleImage

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

MagickSampleImage() scales an image to the desired dimensions with pixel
sampling.  Unlike other scaling methods, this method does not introduce any
additional color into the scaled image.

- 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 MagickSampleImage(
   Pointer $wand,
   int32 $columns,
   int32 $rows
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickScaleImage

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

MagickScaleImage() scales the size of an image to the given dimensions.

- 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 MagickScaleImage(
   Pointer $wand,
   int32 $columns,
   int32 $rows
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSegmentImage

    MagickBooleanType MagickSegmentImage(MagickWand *wand,
      const ColorspaceType colorspace,const MagickBooleanType verbose,
      const double cluster_threshold,const double smooth_threshold)

MagickSegmentImage() segments an image by analyzing the histograms of the color components and identifying units that are homogeneous with the fuzzy C-means technique.A description of each parameter follows.- wand</dt>the wand.<dt>colorspace</dt>the image colorspace.<dt>verbose</dt>Set to MagickTrue to print detailed information about the identified classes.<dt>cluster_threshold</dt>This represents the minimum number of pixels contained in a hexahedra before it can be considered valid (expressed as a percentage).<dt>smooth_threshold</dt>the smoothing threshold eliminates noise in the second derivative of the histogram.  As the value is increased, you can expect a smoother second derivative.<h2><a href="http://www.imagemagick.org/api/MagickWand/magick-image_8c.html" id="MagickSelectiveBlurImage">MagickSelectiveBlurImage</a></h2>MagickSelectiveBlurImage() selectively blur an image within a contrast threshold. It is similar to the unsharpen mask that sharpens everything with contrast above a certain threshold.The format of the MagickSelectiveBlurImage method is:<pre class="text">MagickBooleanType MagickSelectiveBlurImage(MagickWand \*wand,  const double radius,const double sigma,const double threshold)MagickBooleanType MagickSelectiveBlurImageChannel(MagickWand \*wand,  const ChannelType channel,const double radius,const double sigma,  const double threshold)</pre><dt>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. - threshold: only pixels within this contrast threshold are included in the blur operation. 
=end pod
sub MagickSegmentImage(
   Pointer $wand,
   uint32 $colorspace,
   uint32 $verbose,
   num64 $cluster_threshold,
   num64 $smooth_threshold
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSeparateImageChannel

    MagickBooleanType MagickSeparateImageChannel(MagickWand *wand,
      const ChannelType channel)

MagickSeparateImageChannel() separates a channel from the image and returns a
grayscale image.  A channel is a particular color component of each pixel in the
image.

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

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

=begin pod
=head1 MagickSeparateImage

    MagickBooleanType MagickSeparateImageChannel(MagickWand *wand,
      const ChannelType channel)

MagickSeparateImageChannel() separates a channel from the image and returns a
grayscale image.  A channel is a particular color component of each pixel in the
image.

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

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


=begin pod
=head1 MagickSepiaToneImage

    MagickBooleanType MagickSepiaToneImage(MagickWand *wand,
      const double threshold)

MagickSepiaToneImage() applies a special effect to the image, similar to the effect achieved in a photo darkroom by sepia toning.  Threshold ranges from 0 to QuantumRange and is a measure of the extent of the sepia toning.  A threshold of 80 is a good starting point for a reasonable tone.- wand: the magick wand. - threshold:  Define the extent of the sepia toning. 
=end pod
sub MagickSepiaToneImage(
   Pointer $wand,
   num64 $threshold
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSetImage

    MagickBooleanType MagickSetImage(MagickWand *wand,
      const MagickWand *set_wand)

MagickSetImage() replaces the last image returned by MagickSetIteratorIndex(), MagickNextImage(), MagickPreviousImage() with the images from the specified wand.- wand: the magick wand. - set_wand: the set_wand wand. 
=end pod
sub MagickSetImage(
   Pointer $wand,
   Pointer $set_wand
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSetImageAlphaChannel

    MagickBooleanType MagickSetImageAlphaChannel(MagickWand *wand,
      const AlphaChannelType alpha_type)

MagickSetImageAlphaChannel() activates, deactivates, resets, or sets the alpha channel.- wand: the magick wand. - alpha_type: the alpha channel type: ActivateAlphaChannel, DeactivateAlphaChannel, OpaqueAlphaChannel, or SetAlphaChannel. 
=end pod
sub MagickSetImageAlphaChannel(
   Pointer $wand,
   uint32 $alpha_type
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSetImageBackgroundColor

    MagickBooleanType MagickSetImageBackgroundColor(MagickWand *wand,
      const PixelWand *background)

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


=begin pod
=head1 MagickSetImageBias

    MagickBooleanType MagickSetImageBias(MagickWand *wand,
      const double bias)

MagickSetImageBias() sets the image bias for any method that convolves an image (e.g. MagickConvolveImage()).- wand: the magick wand. - bias: the image bias. 
=end pod
sub MagickSetImageBias(
   Pointer $wand,
   num64 $bias
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSetImageBluePrimary

    MagickBooleanType MagickSetImageBluePrimary(MagickWand *wand,
      const double x,const double y)

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


=begin pod
=head1 MagickSetImageBorderColor

    MagickBooleanType MagickSetImageBorderColor(MagickWand *wand,
      const PixelWand *border)

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


=begin pod
=head1 MagickSetImageChannelDepth

    MagickBooleanType MagickSetImageChannelDepth(MagickWand *wand,
      const ChannelType channel,const size_t depth)

MagickSetImageChannelDepth() sets the depth of a particular image channel.- wand: the magick wand. - channel: the image channel(s). - depth: the image depth in bits. 
=end pod
sub MagickSetImageChannelDepth(
   Pointer $wand,
   uint32 $channel,
   int32 $depth
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSetImageClipMask

    MagickBooleanType MagickSetImageClipMask(MagickWand *wand,
      const MagickWand *clip_mask)

MagickSetImageClipMask() sets image clip mask.- wand: the magick wand. - clip_mask: the clip_mask wand. 
=end pod
sub MagickSetImageClipMask(
   Pointer $wand,
   Pointer $clip_mask
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSetImageColor

    MagickBooleanType MagickSetImageColor(MagickWand *wand,
      const PixelWand *color)

MagickSetImageColor() set the entire wand canvas to the specified color.- wand: the magick wand. - background: the image color. 
=end pod
sub MagickSetImageColor(
   Pointer $wand,
   Pointer $color
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSetImageColormapColor

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

MagickSetImageColormapColor() sets 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 MagickSetImageColormapColor(
   Pointer $wand,
   int32 $index,
   Pointer $color
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSetImageColorspace

    MagickBooleanType MagickSetImageColorspace(MagickWand *wand,
      const ColorspaceType colorspace)

MagickSetImageColorspace() sets the image colorspace.

- wand: the magick wand.
- colorspace: the image colorspace:   UndefinedColorspace, RGBColorspace,
  GRAYColorspace, TransparentColorspace, OHTAColorspace, XYZColorspace,
  YCbCrColorspace, YCCColorspace, YIQColorspace, YPbPrColorspace,
  YPbPrColorspace, YUVColorspace, CMYKColorspace, sRGBColorspace, HSLColorspace,
  or HWBColorspace.

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


=begin pod
=head1 MagickSetImageCompose

    MagickBooleanType MagickSetImageCompose(MagickWand *wand,
      const CompositeOperator compose)

MagickSetImageCompose() sets the image composite operator, useful for specifying
how to composite the image thumbnail when using the MagickMontageImage() method.

- wand: the magick wand.
- compose: the image composite operator.

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


=begin pod
=head1 MagickSetImageCompression

    MagickBooleanType MagickSetImageCompression(MagickWand *wand,
      const CompressionType compression)

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


=begin pod
=head1 MagickSetImageCompressionQuality

    MagickBooleanType MagickSetImageCompressionQuality(MagickWand *wand,
      const size_t quality)

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


=begin pod
=head1 MagickSetImageDelay

    MagickBooleanType MagickSetImageDelay(MagickWand *wand,
      const size_t delay)

MagickSetImageDelay() sets the image delay.- wand: the magick wand. - delay: the image delay in ticks-per-second units. 
=end pod
sub MagickSetImageDelay(
   Pointer $wand,
   int32 $delay
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSetImageDepth

    MagickBooleanType MagickSetImageDepth(MagickWand *wand,
      const size_t depth)

MagickSetImageDepth() sets the image depth.- wand: the magick wand. - depth: the image depth in bits: 8, 16, or 32. 
=end pod
sub MagickSetImageDepth(
   Pointer $wand,
   int32 $depth
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSetImageDispose

    MagickBooleanType MagickSetImageDispose(MagickWand *wand,
      const DisposeType dispose)

MagickSetImageDispose() sets the image disposal method.- wand: the magick wand. - dispose: the image disposeal type. 
=end pod
sub MagickSetImageDispose(
   Pointer $wand,
   uint32 $dispose
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSetImageEndian

    MagickBooleanType MagickSetImageEndian(MagickWand *wand,
      const EndianType endian)

MagickSetImageEndian() sets the image endian method.- wand: the magick wand. - endian: the image endian type. 
=end pod
sub MagickSetImageEndian(
   Pointer $wand,
   uint32 $endian
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSetImageExtent

    MagickBooleanType MagickSetImageExtent(MagickWand *wand,
      const size_t columns,const unsigned rows)

MagickSetImageExtent() sets the image size (i.e. columns &amp; rows).- wand: the magick wand. - columns:  The image width in pixels. - rows:  The image height in pixels. 
=end pod
sub MagickSetImageExtent(
   Pointer $wand,
   int32 $columns,
   uint32 $rows
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSetImageFilename

    MagickBooleanType MagickSetImageFilename(MagickWand *wand,
      const char *filename)

MagickSetImageFilename() sets the filename of a particular image in a sequence.- wand: the magick wand. - filename: the image filename