### ----------------------------------------------------
### -- MagickWand
### -- Licenses: MIT
### -- Authors: Ahmad M. Zawawi
### -- File: lib/MagickWand/NativeCall/Image.rakumod
### ----------------------------------------------------
### -- Chunk 5 of 6
. 
=end pod
sub MagickSetImageFilename(
   Pointer $wand,
   Str $filename
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSetImageFormat

    MagickBooleanType MagickSetImageFormat(MagickWand *wand,
      const char *format)

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


=begin pod
=head1 MagickSetImageFuzz

    MagickBooleanType MagickSetImageFuzz(MagickWand *wand,
      const double fuzz)

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


=begin pod
=head1 MagickSetImageGamma

    MagickBooleanType MagickSetImageGamma(MagickWand *wand,
      const double gamma)

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


=begin pod
=head1 MagickSetImageGravity

    MagickBooleanType MagickSetImageGravity(MagickWand *wand,
      const GravityType gravity)

MagickSetImageGravity() sets the image gravity type.- wand: the magick wand. - gravity: the image interlace scheme: NoInterlace, LineInterlace, PlaneInterlace, PartitionInterlace. 
=end pod
sub MagickSetImageGravity(
   Pointer $wand,
   uint32 $gravity
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSetImageGreenPrimary

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

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


=begin pod
=head1 MagickSetImageInterlaceScheme

    MagickBooleanType MagickSetImageInterlaceScheme(MagickWand *wand,
      const InterlaceType interlace)

MagickSetImageInterlaceScheme() sets the image interlace scheme.- wand: the magick wand. - interlace: the image interlace scheme: NoInterlace, LineInterlace, PlaneInterlace, PartitionInterlace. 
=end pod
sub MagickSetImageInterlaceScheme(
   Pointer $wand,
   uint32 $interlace
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSetImageInterpolateMethod

    MagickBooleanType MagickSetImageInterpolateMethod(MagickWand *wand,
      const InterpolatePixelMethod method)

MagickSetImageInterpolateMethod() sets the image interpolate pixel method.- wand: the magick wand. - method: the image interpole pixel methods: choose from Undefined, Average, Bicubic, Bilinear, Filter, Integer, Mesh, NearestNeighbor. 
=end pod
sub MagickSetImageInterpolateMethod(
   Pointer $wand,
   uint32 $method
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSetImageIterations

    MagickBooleanType MagickSetImageIterations(MagickWand *wand,
      const size_t iterations)

MagickSetImageIterations() sets the image iterations.- wand: the magick wand. - delay: the image delay in 1/100th of a second. 
=end pod
sub MagickSetImageIterations(
   Pointer $wand,
   int32 $iterations
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSetImageMatte

    MagickBooleanType MagickSetImageMatteColor(MagickWand *wand,
      const MagickBooleanType *matte)

MagickSetImageMatte() sets the image matte channel.- wand: the magick wand. - matte: Set to MagickTrue to enable the image matte channel otherwise MagickFalse. 
=end pod
multi sub MagickSetImageMatteColor(
   Pointer $wand,
   CArray[uint32] $matte
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSetImageMatteColor

    MagickBooleanType MagickSetImageMatteColor(MagickWand *wand,
      const PixelWand *matte)

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


=begin pod
=head1 MagickSetImageOpacity

    MagickBooleanType MagickSetImageOpacity(MagickWand *wand,
      const double alpha)

MagickSetImageOpacity() sets the image to the specified opacity level.- wand: the magick wand. - alpha: the level of transparency: 1.0 is fully opaque and 0.0 is fully transparent. 
=end pod
sub MagickSetImageOpacity(
   Pointer $wand,
   num64 $alpha
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSetImageOrientation

    MagickBooleanType MagickSetImageOrientation(MagickWand *wand,
      const OrientationType orientation)

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


=begin pod
=head1 MagickSetImagePage

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

MagickSetImagePage() sets the page geometry of 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 MagickSetImagePage(
   Pointer $wand,
   int32 $width,
   int32 $height,
   uint32 $x,
   uint32 $y
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSetImageProgressMonitor

    MagickProgressMonitor MagickSetImageProgressMonitor(MagickWand *wand
      const MagickProgressMonitor progress_monitor,void *client_data)

MagickSetImageProgressMonitor() sets the wand image progress monitor to the specified method and returns the previous progress monitor if any.  The progress monitor method looks like this:<pre class="text">    MagickBooleanType MagickProgressMonitor(const char \*text,const MagickOffsetType offset,const MagickSizeType span,void \*client_data)</pre>If the progress monitor returns MagickFalse, the current operation is interrupted.- wand: the magick wand. - progress_monitor: Specifies a pointer to a method to monitor progress of an image operation. - client_data: Specifies a pointer to any client data. 
=end pod
sub MagickSetImageProgressMonitor(
  Pointer $wand,
  Pointer $progress_monitor,
  Pointer[void] $client_data
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSetImageRedPrimary

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

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


=begin pod
=head1 MagickSetImageRenderingIntent

    MagickBooleanType MagickSetImageRenderingIntent(MagickWand *wand,
      const RenderingIntent rendering_intent)

MagickSetImageRenderingIntent() sets the image rendering intent.- wand: the magick wand. - rendering_intent: the image rendering intent: UndefinedIntent, SaturationIntent, PerceptualIntent, AbsoluteIntent, or RelativeIntent. 
=end pod
sub MagickSetImageRenderingIntent(
   Pointer $wand,
   uint32 $rendering_intent
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSetImageResolution

    MagickBooleanType MagickSetImageResolution(MagickWand *wand,
      const double x_resolution,const double y_resolution)

MagickSetImageResolution() sets the image resolution.- wand: the magick wand. - x_resolution: the image x resolution. - y_resolution: the image y resolution. 
=end pod
sub MagickSetImageResolution(
   Pointer $wand,
   num64 $x_resolution,
   num64 $y_resolution
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSetImageScene

    MagickBooleanType MagickSetImageScene(MagickWand *wand,
      const size_t scene)

MagickSetImageScene() sets the image scene.- wand: the magick wand. - delay: the image scene number. 
=end pod
sub MagickSetImageScene(
   Pointer $wand,
   int32 $scene
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSetImageTicksPerSecond

    MagickBooleanType MagickSetImageTicksPerSecond(MagickWand *wand,
      const ssize_t ticks_per-second)

MagickSetImageTicksPerSecond() sets the image ticks-per-second.- wand: the magick wand. - ticks_per_second: the units to use for the image delay. 
=end pod
sub MagickSetImageTicksPerSecond(
   Pointer $wand,
   uint32 $ticks_per-second
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSetImageType

    MagickBooleanType MagickSetImageType(MagickWand *wand,
      const ImageType image_type)

MagickSetImageType() sets the image type.

- wand: the magick wand.
- image_type: the image type:   UndefinedType,
- BilevelType, GrayscaleType, GrayscaleMatteType, PaletteType, PaletteMatteType,
- TrueColorType, TrueColorMatteType, ColorSeparationType,
- ColorSeparationMatteType, or OptimizeType.

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


=begin pod
=head1 MagickSetImageUnits

    MagickBooleanType MagickSetImageUnits(MagickWand *wand,
      const ResolutionType units)

MagickSetImageUnits() sets the image units of resolution.- wand: the magick wand. - units: the image units of resolution : UndefinedResolution, PixelsPerInchResolution, or PixelsPerCentimeterResolution. 
=end pod
sub MagickSetImageUnits(
   Pointer $wand,
   uint32 $units
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSetImageVirtualPixelMethod

    VirtualPixelMethod MagickSetImageVirtualPixelMethod(MagickWand *wand,
      const VirtualPixelMethod method)

MagickSetImageVirtualPixelMethod() sets the image virtual pixel method.- wand: the magick wand. - method: the image virtual pixel method : UndefinedVirtualPixelMethod, ConstantVirtualPixelMethod,  EdgeVirtualPixelMethod, MirrorVirtualPixelMethod, or TileVirtualPixelMethod. 
=end pod
sub MagickSetImageVirtualPixelMethod(
   Pointer $wand,
   uint32 $method
)
returns uint32
is native(&library)
is export { * };


=begin pod
=head1 MagickSetImageWhitePoint

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

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


=begin pod
=head1 MagickShadeImage

    MagickBooleanType MagickShadeImage(MagickWand *wand,
      const MagickBooleanType gray,const double azimuth,
      const double elevation)

MagickShadeImage() shines a distant light on an image to create a
three-dimensional effect. You control the positioning of the light with azimuth
and elevation; azimuth is measured in degrees off the x axis and elevation is
measured in pixels above the Z axis.

- wand: the magick wand.
- gray: A value other than zero shades the intensity of each pixel.
- azimuth, elevation: Define the light source direction. 

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


=begin pod
=head1 MagickShadowImage

    MagickBooleanType MagickShadowImage(MagickWand *wand,
      const double opacity,const double sigma,const ssize_t x,const ssize_t y)

MagickShadowImage() simulates an image shadow.- wand: the magick wand. - opacity: percentage transparency. - sigma: the standard deviation of the Gaussian, in pixels. - x: the shadow x-offset. - y: the shadow y-offset. 
=end pod
sub MagickShadowImage(
   Pointer $wand,
   num64 $opacity,
   num64 $sigma,
   uint32 $x,
   uint32 $y
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSharpenImage

    MagickBooleanType MagickSharpenImage(MagickWand *wand,
      const double radius,const double sigma)
    MagickBooleanType MagickSharpenImageChannel(MagickWand *wand,
      const ChannelType channel,const double radius,const double sigma)

MagickSharpenImage() sharpens an image.  We convolve the image with a Gaussian
operator of the given radius and standard deviation (sigma). For reasonable
results, the radius should be larger than sigma.  Use a radius of 0 and
MagickSharpenImage() selects a suitable radius for you.

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

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


=begin pod
=head1 MagickShaveImage

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

MagickShaveImage() shaves pixels from the image edges.  It allocates the memory
necessary for the new Image structure and returns a pointer to the new 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 MagickShaveImage(
   Pointer $wand,
   int32 $columns,
   int32 $rows
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickShearImage

    MagickBooleanType MagickShearImage(MagickWand *wand,
      const PixelWand *background,const double x_shear,const double y_shear)

MagickShearImage() slides one edge of an image along the X or Y axis, creating a parallelogram.  An X direction shear slides an edge along the X axis, while a Y direction shear slides an edge along the Y axis.  The amount of the shear is controlled by a shear angle.  For X direction shears, x_shear is measured relative to the Y axis, and similarly, for Y direction shears y_shear is measured relative to the X axis.  Empty triangles left over from shearing the image are filled with the background color.- wand: the magick wand. - background: the background pixel wand. - x_shear: the number of degrees to shear the image. - y_shear: the number of degrees to shear the image. 
=end pod
sub MagickShearImage(
   Pointer $wand,
   Pointer $background,
   num64 $x_shear,
   num64 $y_shear
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSigmoidalContrastImage

    MagickBooleanType MagickSigmoidalContrastImage(MagickWand *wand,
      const MagickBooleanType sharpen,const double alpha,const double beta)
    MagickBooleanType MagickSigmoidalContrastImageChannel(MagickWand *wand,
      const ChannelType channel,const MagickBooleanType sharpen,
      const double alpha,const double beta)

MagickSigmoidalContrastImage() adjusts the contrast of an image with a
non-linear sigmoidal contrast algorithm.  Increase the contrast of the image
using a sigmoidal transfer function without saturating highlights or shadows.
Contrast indicates how much to increase the contrast (0 is none; 3 is typical;
20 is pushing it); mid-point indicates where midtones fall in the resultant
image (0 is white; 50 is middle-gray; 100 is black).  Set sharpen to MagickTrue
to increase the image contrast otherwise the contrast is reduced.

- wand: the magick wand.
- channel: Identify which channel to level: RedChannel, GreenChannel,
- sharpen: Increase or decrease image contrast. 
- alpha: strength of the contrast, the larger the number the more
  'threshold-like' it becomes.
- beta: midpoint of the function as a color value 0 to QuantumRange.

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

sub MagickSigmoidalContrastImageChannel(
   Pointer $wand,
   uint32 $channel,
   uint32 $sharpen,
   num64 $alpha,
   num64 $beta
)
returns uint32
is native(&library)
is export { * };


=begin pod
=head1 MagickSimilarityImage

    MagickWand *MagickSimilarityImage(MagickWand *wand,
      const MagickWand *reference,RectangeInfo *offset,double *similarity)

MagickSimilarityImage() compares the reference image of the image and returns the best match offset.  In addition, it returns a similarity image such that an exact match location is completely white and if none of the pixels match, black, otherwise some gray level in-between.- wand: the magick wand. - reference: the reference wand. - offset: the best match offset of the reference image within the image. - similarity: the computed similarity between the images. 
=end pod
sub MagickSimilarityImage(
   Pointer $wand,
   Pointer $reference,
   Pointer $offset,
   CArray[num64] $similarity
)
returns Pointer
is native(&library)
is export { * };


=begin pod
=head1 MagickSketchImage

    MagickBooleanType MagickSketchImage(MagickWand *wand,
      const double radius,const double sigma,const double angle)

MagickSketchImage() simulates a pencil sketch.  We convolve the image with a Gaussian operator of the given radius and standard deviation (sigma). For reasonable results, radius should be larger than sigma.  Use a radius of 0 and SketchImage() selects a suitable radius for you. Angle gives the angle of the blurring motion.- 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. - angle: Apply the effect along this angle. 
=end pod
sub MagickSketchImage(
   Pointer $wand,
   num64 $radius,
   num64 $sigma,
   num64 $angle
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSmushImages

    MagickWand *MagickSmushImages(MagickWand *wand,
      const MagickBooleanType stack,const ssize_t offset)

MagickSmushImages() takes all images from the current image pointer to the end of the image list and smushs them to each other top-to-bottom if the stack parameter is true, otherwise left-to-right.- wand: the magick wand. - stack: By default, images are stacked left-to-right. Set stack to MagickTrue to stack them top-to-bottom. - offset: minimum distance in pixels between images. 
=end pod
sub MagickSmushImages(
   Pointer $wand,
   uint32 $stack,
   uint32 $offset
)
returns Pointer
is native(&library)
is export { * };


=begin pod
=head1 MagickSolarizeImage

    MagickBooleanType MagickSolarizeImage(MagickWand *wand,
      const double threshold)
    MagickBooleanType MagickSolarizeImageChannel(MagickWand *wand,
      const ChannelType channel,const double threshold)

MagickSolarizeImage() applies a special effect to the image, similar to the
effect achieved in a photo darkroom by selectively exposing areas of photo
sensitive paper to light.  Threshold ranges from 0 to QuantumRange and is a
measure of the extent of the solarization.

- wand: the magick wand.
- channel: the image channel(s).
- threshold:  Define the extent of the solarization.  

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

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


=begin pod
=head1 MagickSparseColorImage

    MagickBooleanType MagickSparseColorImage(MagickWand *wand,
      const ChannelType channel,const SparseColorMethod method,
      const size_t number_arguments,const double *arguments)

MagickSparseColorImage(), given a set of coordinates, interpolates the colors found at those coordinates, across the whole image, using various methods.- image: the image to be sparseed. - method: the method of image sparseion. <dd> ArcSparseColorion will always ignore source image offset, and always 'bestfit' the destination image with the top left corner offset relative to the polar mapping center. </dd><dd> Bilinear has no simple inverse mapping so will not allow 'bestfit' style of image sparseion. </dd><dd> Affine, Perspective, and Bilinear, will do least squares fitting of the distrotion when more than the minimum number of control point pairs are provided. </dd><dd> Perspective, and Bilinear, will fall back to a Affine sparseion when less than 4 control point pairs are provided. While Affine sparseions will let you use any number of control point pairs, that is Zero pairs is a No-Op (viewport only) distrotion, one pair is a translation and two pairs of control points will do a scale-rotate-translate, without any shearing. </dd>- number_arguments: the number of arguments given for this sparseion method. - arguments: the arguments for this sparseion method. 
=end pod
sub MagickSparseColorImage(
   Pointer $wand,
   uint32 $channel,
   uint32 $method,
   int32 $number_arguments,
   CArray[num64] $arguments
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSpliceImage

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

MagickSpliceImage() splices a solid color into 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 MagickSpliceImage(
   Pointer $wand,
   int32 $width,
   int32 $height,
   uint32 $x,
   uint32 $y
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSpreadImage

    MagickBooleanType MagickSpreadImage(MagickWand *wand,const double radius)

MagickSpreadImage() is a special effects method that randomly displaces each
pixel in a block defined by the radius parameter.

- wand: the magick wand.
- radius:  Choose a random pixel in a neighborhood of this extent.

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


=begin pod
=head1 MagickStatisticImage

    MagickBooleanType MagickStatisticImage(MagickWand *wand,
      const StatisticType type,const double width,const size_t height)
    MagickBooleanType MagickStatisticImageChannel(MagickWand *wand,
      const ChannelType channel,const StatisticType type,const double width,
      const size_t height)

MagickStatisticImage() replace each pixel with corresponding statistic from
the neighborhood of the specified width and height.

- wand: the magick wand.
- channel: the image channel(s).
- type: the statistic type (e.g. median, mode, etc.).
- width: the width of the pixel neighborhood.
- height: the height of the pixel neighborhood.

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

sub MagickStatisticImageChannel(
   Pointer $wand,
   uint32 $channel,
   uint32 $type,
   num64 $width,
   int32 $height
)
returns uint32
is native(&library)
is export { * };


=begin pod
=head1 MagickSteganoImage

    MagickWand *MagickSteganoImage(MagickWand *wand,
      const MagickWand *watermark_wand,const ssize_t offset)

MagickSteganoImage() hides a digital watermark within the image. Recover the hidden watermark later to prove that the authenticity of an image.  Offset defines the start position within the image to hide the watermark.- wand: the magick wand. - watermark_wand: the watermark wand. - offset: Start hiding at this offset into the image. 
=end pod
sub MagickSteganoImage(
   Pointer $wand,
   Pointer $watermark_wand,
   uint32 $offset
)
returns Pointer
is native(&library)
is export { * };


=begin pod
=head1 MagickStereoImage

    MagickWand *MagickStereoImage(MagickWand *wand,
      const MagickWand *offset_wand)

MagickStereoImage() composites two images and produces a single image that is the composite of a left and right image of a stereo pair- wand: the magick wand. - offset_wand: Another image wand. 
=end pod
sub MagickStereoImage(
   Pointer $wand,
   Pointer $offset_wand
)
returns Pointer
is native(&library)
is export { * };


=begin pod
=head1 MagickStripImage

    MagickBooleanType MagickStripImage(MagickWand *wand)

MagickStripImage() strips an image of all profiles and comments.- wand: the magick wand. 
=end pod
sub MagickStripImage(
   Pointer $wand
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickSwirlImage

    MagickBooleanType MagickSwirlImage(MagickWand *wand,const double degrees)

MagickSwirlImage() swirls the pixels about the center of the image, where
degrees indicates the sweep of the arc through which each pixel is moved. You
get a more dramatic effect as the degrees move from 1 to 360.

- wand: the magick wand.
- degrees: Define the tightness of the swirling effect.

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


=begin pod
=head1 MagickTextureImage

    MagickWand *MagickTextureImage(MagickWand *wand,
      const MagickWand *texture_wand)

MagickTextureImage() repeatedly tiles the texture image across and down the image canvas.- wand: the magick wand. - texture_wand: the texture wand 
=end pod
sub MagickTextureImage(
   Pointer $wand,
   Pointer $texture_wand
)
returns Pointer
is native(&library)
is export { * };


=begin pod
=head1 MagickThresholdImage

    MagickBooleanType MagickThresholdImage(MagickWand *wand,
      const double threshold)
    MagickBooleanType MagickThresholdImageChannel(MagickWand *wand,
      const ChannelType channel,const double threshold)

MagickThresholdImage() changes the value of individual pixels based on the intensity of each pixel compared to threshold.  The result is a high-contrast, two color image.- wand: the magick wand. - channel: the image channel(s). - threshold: Define the threshold value. 
=end pod
sub MagickThresholdImage(
   Pointer $wand,
   num64 $threshold
)
returns uint32 
is native(&library)
is export { * };

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


=begin pod
=head1 MagickThumbnailImage

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

MagickThumbnailImage()  changes the size of an image to the given dimensions and removes any associated profiles.  The goal is to produce small low cost thumbnail images suited for display on the Web.- 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 MagickThumbnailImage(
   Pointer $wand,
   int32 $columns,
   int32 $rows
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickTintImage

    MagickBooleanType MagickTintImage(MagickWand *wand,
      const PixelWand *tint,const PixelWand *opacity)

MagickTintImage() applies a color vector to each pixel in the image.  The length of the vector is 0 for black and white and at its maximum for the midtones.  The vector weighting function is f(x)=(1-(4.0\*((x-0.5)\*(x-0.5)))).- wand: the magick wand. - tint: the tint pixel wand. - opacity: the opacity pixel wand. 
=end pod
sub MagickTintImage(
   Pointer $wand,
   Pointer $tint,
   Pointer $opacity
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickTransformImage

    MagickWand *MagickTransformImage(MagickWand *wand,const char *crop,
      const char *geometry)

MagickTransformImage() is a convenience method that behaves like MagickResizeImage() or MagickCropImage() but accepts scaling and/or cropping information as a region geometry specification.  If the operation fails, a NULL image handle is returned.- wand: the magick wand. - crop: A crop geometry string.  This geometry defines a subregion of the image to crop. - geometry: An image geometry string.  This geometry defines the final size of the image. 
=end pod
sub MagickTransformImage(
   Pointer $wand,
   Str $crop,
   Str $geometry
)
returns Pointer
is native(&library)
is export { * };


=begin pod
=head1 MagickTransformImageColorspace

    MagickBooleanType MagickTransformImageColorspace(MagickWand *wand,
      const ColorspaceType colorspace)

MagickTransformImageColorspace() transform the image colorspace,  setting
theimages colorspace while transforming the images data to that colorspace.

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

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


=begin pod
=head1 MagickTransparentPaintImage

    MagickBooleanType MagickTransparentPaintImage(MagickWand *wand,
      const PixelWand *target,const double alpha,const double fuzz,
      const MagickBooleanType invert)

MagickTransparentPaintImage() changes any pixel that matches color with the color defined by fill.- wand: the magick wand. - target: Change this target color to specified opacity value within the image. - alpha: the level of transparency: 1.0 is fully opaque and 0.0 is fully transparent. - 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 MagickTransparentPaintImage(
   Pointer $wand,
   Pointer $target,
   num64 $alpha,
   num64 $fuzz,
   uint32 $invert
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickTransposeImage

    MagickBooleanType MagickTransposeImage(MagickWand *wand)

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


=begin pod
=head1 MagickTransverseImage

    MagickBooleanType MagickTransverseImage(MagickWand *wand)

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


=begin pod
=head1 MagickTrimImage

    MagickBooleanType MagickTrimImage(MagickWand *wand,const double fuzz)

MagickTrimImage() remove edges that are the background color from the image.- wand: the magick 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. 
=end pod
sub MagickTrimImage(
   Pointer $wand,
   num64 $fuzz
)
returns uint32 
is native(&library)
is export { * };


=begin pod
=head1 MagickUniqueImageColors

    MagickBooleanType MagickUniqueImageColors(MagickWand *wand