{-# LANGUAGE CPP                      #-}
{-# LANGUAGE ForeignFunctionInterface #-}
module Graphics.ImageMagick.MagickWand.FFI.WandImage
  where

import           Foreign
import           Foreign.C.String
import           Foreign.C.Types

import           Graphics.ImageMagick.MagickCore.Types
import           Graphics.ImageMagick.MagickWand.FFI.Types

#include <wand/MagickWand.h>

-- | MagickGetImageHeight() returns the image height.
foreign import ccall "MagickGetImageHeight" magickGetImageHeight
  :: Ptr MagickWand -> IO CSize

-- | MagickGetImageWidth() returns the image width.
foreign import ccall "MagickGetImageWidth" magickGetImageWidth
  :: Ptr MagickWand -> IO CSize

-- | MagickGetImagePixelColor() returns the color of the specified pixel.
foreign import ccall "MagickGetImagePixelColor" magickGetImagePixelColor
  :: Ptr MagickWand
  -> CSize          -- ^ pixel x coordinate
  -> CSize          -- ^ pixel y coordinate
  -> Ptr PixelWand  -- ^ return the colormap color in this wand
  -> IO MagickBooleanType

-- |  MagickGetImageCompressionQuality() gets the image compression quality.
foreign import ccall "MagickGetImageCompressionQuality" magickGetImageCompressionQuality
  :: Ptr MagickWand -> IO CSize

-- | MagickSetImageCompression() sets the image compression.
foreign import ccall "MagickSetImageCompression" magickSetImageCompression
  :: Ptr MagickWand -> CompressionType -> IO MagickBooleanType

-- | MagickSetImageCompressionQuality() sets the image compression quality.
foreign import ccall "MagickSetImageCompressionQuality" magickSetImageCompressionQuality
  :: Ptr MagickWand -> CSize -> IO MagickBooleanType

-- | MagickGetImageBackgroundColor() returns the image background color.
foreign import ccall "MagickGetImageBackgroundColor" magickGetImageBackgroundColor
  :: Ptr MagickWand -> Ptr PixelWand -> IO MagickBooleanType

-- | MagickSetImageBackgroundColor() sets the image background color.
foreign import ccall "MagickSetImageBackgroundColor" magickSetImageBackgroundColor
  :: Ptr MagickWand -> Ptr PixelWand -> IO MagickBooleanType

-- | MagickExtentImage() extends the image as defined by the geometry, gravity,
-- and wand background color. Set the (x,y) offset of the geometry to move the
-- original wand relative to the extended wand.
foreign import ccall "MagickExtentImage" magickExtentImage
  :: Ptr MagickWand  -- ^ wand
  -> CSize           -- ^ width
  -> CSize           -- ^ height
  -> CSize           -- ^ x offset
  -> CSize           -- ^ y offset
  -> IO MagickBooleanType

-- | MagickFloodfillPaintImage() changes the color value of any pixel
-- that matches target and is an immediate neighbor. If the method FillToBorderMethod
-- is specified, the color value is changed for any neighbor pixel that does
-- not match the bordercolor member of image.
foreign import ccall "MagickFloodfillPaintImage" magickFloodfillPaintImage
  :: Ptr MagickWand    -- ^ wand
  -> ChannelType       -- ^ channel
  -> Ptr PixelWand     -- ^ fill
  -> CDouble           -- ^ fuzz
  -> Ptr PixelWand     -- ^ bordercolor
  -> CSize             -- ^ x offset
  -> CSize             -- ^ y offset
  -> MagickBooleanType -- ^ invert
  -> IO MagickBooleanType

-- | MagickNegateImage() negates the colors in the reference image.
-- The Grayscale option means that only grayscale values within the image are negated.
-- You can also reduce the influence of a particular channel with a gamma value of 0.
foreign import ccall "MagickNegateImage" magickNegateImage
  :: Ptr MagickWand
  -> MagickBooleanType      -- ^ negate gray
  -> IO MagickBooleanType

foreign import ccall "MagickNegateImageChannel" magickNegateImageChannel
  :: Ptr MagickWand
  -> ChannelType
  -> MagickBooleanType       -- ^ negate gray
  -> IO MagickBooleanType

-- | MagickGetImageClipMask() gets the image clip mask at the current image index.
foreign import ccall "MagickGetImageClipMask" magickGetImageClipMask
  :: Ptr MagickWand
  -> IO (Ptr MagickWand)

-- | MagickSetImageClipMask() sets image clip mask.
foreign import ccall "MagickSetImageClipMask" magickSetImageClipMask
  :: Ptr MagickWand
  -> Ptr MagickWand
  -> IO MagickBooleanType

-- | MagickCompositeImage() composite one image onto another at the specified offset.
foreign import ccall "MagickCompositeImage" magickCompositeImage
  :: Ptr MagickWand
  -> Ptr MagickWand      -- ^ source
  -> CompositeOperator
  -> CSize               -- ^ column offset
  -> CSize               -- ^ row offset
  -> IO MagickBooleanType

foreign import ccall "MagickCompositeImage" magickCompositeImageChannel
  :: Ptr MagickWand
  -> Ptr MagickWand      -- ^ source
  -> ChannelType
  -> CompositeOperator
  -> CSize               -- ^ column offset
  -> CSize               -- ^ row offset
  -> IO MagickBooleanType

-- | MagickTransparentPaintImage() changes any pixel that matches color with the color defined by fill.
foreign import ccall "MagickTransparentPaintImage" magickTransparentPaintImage
  :: Ptr MagickWand
  -> Ptr PixelWand        -- ^ change this color to specified opacity value withing the image
  -> Double               -- ^ the level of transarency: 1.0 fully opaque 0.0 fully transparent
  -> Double               -- ^ 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.
  -> MagickBooleanType    -- paint any pixel that does not match the target color.
  -> IO MagickBooleanType

-- | MagickBorderImage() surrounds the image with a border of the color
-- defined by the bordercolor pixel wand.
foreign import ccall "MagickBorderImage" magickBorderImage
  :: Ptr MagickWand    -- ^ wand
  -> Ptr PixelWand     -- ^ bordercolor
  -> CSize             -- ^ width
  -> CSize             -- ^ height
  -> IO MagickBooleanType

-- | 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.
foreign import ccall "MagickShaveImage" magickShaveImage
  :: Ptr MagickWand    -- ^ wand
  -> CSize             -- ^ columns
  -> CSize             -- ^ rows
  -> IO MagickBooleanType

-- | MagickSetImageAlphaChannel() activates, deactivates, resets, or
-- sets the alpha channel.
foreign import ccall "MagickSetImageAlphaChannel" magickSetImageAlphaChannel
  :: Ptr MagickWand    -- ^ wand
  -> AlphaChannelType  -- ^ alpha_type
  -> IO MagickBooleanType

-- | MagickNewImage() adds a blank image canvas of the specified size and background color to the wand.
foreign import ccall "MagickNewImage" magickNewImage
  :: Ptr MagickWand
  -> CSize                -- ^ width
  -> CSize                -- ^ height
  -> Ptr PixelWand        -- ^ background color
  -> IO MagickBooleanType

-- |  MagickDrawImage() renders the drawing wand on the current image.
foreign import ccall "MagickDrawImage" magickDrawImage
    :: Ptr MagickWand -> Ptr DrawingWand -> IO MagickBooleanType

-- | MagickFlopImage() creates a horizontal mirror image by reflecting the pixels around the central y-axis.
foreign import ccall "MagickFlopImage" magickFlopImage
  :: Ptr MagickWand -> IO MagickBooleanType


-- |  MagickAddNoiseImage() adds random noise to the image.
--    The type of noise: Uniform, Gaussian, Multiplicative, Impulse, Laplacian, or Poisson.
foreign import ccall "MagickAddNoiseImage" magickAddNoiseImage
  :: Ptr MagickWand -> NoiseType -> IO MagickBooleanType

-- | 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.
foreign import ccall "MagickAddImage" magickAddImage
  :: Ptr MagickWand -> Ptr MagickWand -> IO MagickBooleanType

-- | MagickFlipImage() creates a vertical mirror image by reflecting the pixels around the central x-axis.
foreign import ccall "MagickFlipImage" magickFlipImage
  :: Ptr MagickWand -> IO MagickBooleanType

-- | MagickSetImageVirtualPixelMethod() sets the image virtual pixel method.
--   the image virtual pixel method : UndefinedVirtualPixelMethod, ConstantVirtualPixelMethod,
--   EdgeVirtualPixelMethod, MirrorVirtualPixelMethod, or TileVirtualPixelMethod.
foreign import ccall "MagickSetImageVirtualPixelMethod" magickSetVirtualPixelMethod
  :: Ptr MagickWand -> VirtualPixelMethod -> IO VirtualPixelMethod

-- | 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.
foreign import ccall "MagickAppendImages" magickAppendImages
  :: Ptr MagickWand -> MagickBooleanType -> IO (Ptr MagickWand)

-- | MagickReadImage() reads an image or image sequence. The images are inserted at
-- the current image pointer position. Use MagickSetFirstIterator(), MagickSetLastIterator,
-- or MagickSetImageIndex() to specify the current image pointer position at the beginning
-- of the image list, the end, or anywhere in-between respectively.
foreign import ccall "MagickReadImage" magickReadImage
  :: Ptr MagickWand -> CString -> IO MagickBooleanType

-- | MagickReadImageBlob() reads an image or image sequence from a blob.
foreign import ccall "MagickReadImageBlob" magickReadImageBlob
  :: Ptr MagickWand -> Ptr () -> CSize -> IO MagickBooleanType

-- | MagickWriteImage() writes an image to the specified filename. If the filename
-- parameter is NULL, the image is written to the filename set by MagickReadImage()
-- or MagickSetImageFilename().
foreign import ccall "MagickWriteImage" magickWriteImage
  :: Ptr MagickWand -> CString -> IO (MagickBooleanType)

-- | 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.
--
-- The format of the MagickBlurImage method is:
foreign import ccall "MagickBlurImage" magickBlurImage
  :: Ptr MagickWand -> CDouble -> CDouble -> IO MagickBooleanType

foreign import ccall "MagickBlurImageChannel" magickBlurImageChannel
  :: Ptr MagickWand -> ChannelType -> CDouble -> CDouble -> IO MagickBooleanType

-- | MagickNormalizeImage() 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.
foreign import ccall "MagickNormalizeImage" magickNormalizeImage
  :: Ptr MagickWand -> IO MagickBooleanType

foreign import ccall "MagickNormalizeImageChannel" magickNormalizeImageChannel
  :: Ptr MagickWand -> ChannelType -> IO MagickBooleanType

-- | MagickShadowImage() simulates an image shadow.
foreign import ccall "MagickShadowImage" magickShadowImage
  :: Ptr MagickWand
  -> CDouble       -- ^ percentage transparency
  -> CDouble       -- ^ the standard deviation of the Gaussian, in pixels
  -> CSize         -- ^ the shadow x-offset
  -> CSize         -- ^ the shadow y-offset
  -> IO MagickBooleanType

-- | MagickTrimImage() remove edges that are the background color from the image.
foreign import ccall "MagickTrimImage" magickTrimImage
  :: Ptr MagickWand -> CDouble -> IO MagickBooleanType

-- | MagickResetImagePage() resets the Wand page canvas and position.
foreign import ccall "MagickResetImagePage" magickResetImagePage
  :: Ptr MagickWand -> CString -> IO MagickBooleanType

-- | MagickDistortImage() distorts an image using various distortion methods,
-- by mapping color lookups of the source image to a new destination image usally
-- of the same size as the source image, unless 'bestfit' is set to true.
-- If 'bestfit' is enabled, and distortion allows it, the destination image
-- is adjusted to ensure the whole source 'image' will just fit within the final
-- destination image, which will be sized and offset accordingly. Also in many cases
-- the virtual offset of the source image will be taken into account in the mapping.
foreign import ccall "MagickDistortImage" magickDistortImage
  :: Ptr MagickWand
  -> DistortImageMethod -- ^ the method of image distortion
  -> CSize              -- ^ the number of arguments given for this distortion method
  -> Ptr CDouble        -- ^ the arguments for this distortion method
  -> MagickBooleanType  -- ^ attempt to resize destination to fit distorted source
  -> IO MagickBooleanType

-- | 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.
foreign import ccall "MagickShadeImage" magickShadeImage
  :: Ptr MagickWand
  -> MagickBooleanType -- ^ a value other than zero shades the intensity of each pixel
  -> CDouble           -- ^ azimuth of the light source direction
  -> CDouble           -- ^ evelation of the light source direction
  -> IO MagickBooleanType

-- | MagickColorizeImage() blends the fill color with each pixel in the image.
foreign import ccall "MagickColorizeImage" magickColorizeImage
  :: Ptr MagickWand
  -> Ptr PixelWand     -- ^ the colorize pixel wand
  -> Ptr PixelWand     -- ^ the opacity pixel wand
  -> IO MagickBooleanType

-- | MagickFxImage() evaluate expression for each pixel in the image.
foreign import ccall "MagickFxImage" magickFxImage
  :: Ptr MagickWand
  -> CString     -- ^ the expression
  -> IO (Ptr MagickWand)

-- | MagickFxImageChannel() evaluate expression for each pixel in the image.
foreign import ccall "MagickFxImageChannel" magickFxImageChannel
  :: Ptr MagickWand
  -> ChannelType -- ^ the image channel(s)
  -> CString     -- ^ the expression
  -> IO (Ptr MagickWand)

-- | 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 `True`
-- to increase the image contrast otherwise the contrast is reduced.
foreign import ccall "MagickSigmoidalContrastImage" magickSigmoidalContrastImage
  :: Ptr MagickWand
  -> MagickBooleanType -- ^ increase or decrease image contrast
  -> CDouble           -- ^ strength of the contrast, the larger the number the more 'threshold-like' it becomes
  -> CDouble           -- ^ midpoint of the function as a color value 0 to `quantumRange`
  -> IO MagickBooleanType

-- | see `magickSigmoidalContrastImage`
foreign import ccall "MagickSigmoidalContrastImageChannel" magickSigmoidalContrastImageChannel
  :: Ptr MagickWand
  -> ChannelType       -- ^ identify which channel to level: `redChannel`, `greenChannel`
  -> MagickBooleanType -- ^ increase or decrease image contrast
  -> CDouble           -- ^ strength of the contrast, the larger the number the more 'threshold-like' it becomes
  -> CDouble           -- ^ midpoint of the function as a color value 0 to `quantumRange`
  -> IO MagickBooleanType

-- | MagickEvaluateImage() applies an arithmetic, relational, or logical
-- expression to an image. Use these operators to lighten or darken an image,
-- to increase or decrease contrast in an image, or to produce the "negative"
-- of an image.
foreign import ccall "MagickEvaluateImage" magickEvaluateImage
  :: Ptr MagickWand
  -> MagickEvaluateOperator -- ^ a channel operator
  -> CDouble                -- ^ value
  -> IO MagickBooleanType

-- | see `magickEvaluateImage`
foreign import ccall "MagickEvaluateImages" magickEvaluateImages
  :: Ptr MagickWand
  -> MagickEvaluateOperator -- ^ a channel operator
  -> IO MagickBooleanType

-- | see `magickEvaluateImage`
foreign import ccall "MagickEvaluateImageChannel" magickEvaluateImageChannel
  :: Ptr MagickWand
  -> ChannelType            -- ^ the channel(s)
  -> MagickEvaluateOperator -- ^ a channel operator
  -> CDouble                -- ^ value
  -> IO MagickBooleanType

-- | MagickRollImage() offsets an image as defined by x and y.
foreign import ccall "MagickRollImage" magickRollImage
  :: Ptr MagickWand
  -> CDouble                -- ^ the x offset
  -> CDouble                -- ^ the y offset
  -> IO MagickBooleanType

-- | MagickAnnotateImage() annotates an image with text.
foreign import ccall "MagickAnnotateImage" magickAnnotateImage
  :: Ptr MagickWand
  -> Ptr DrawingWand -- ^ the draw wand
  -> CDouble         -- ^ x ordinate to left of text
  -> CDouble         -- ^ y ordinate to text baseline
  -> CDouble         -- ^ rotate text relative to this angle
  -> CString         -- ^ text to draw
  -> IO MagickBooleanType

-- | MagickMergeImageLayers() composes all the image layers from the current
-- given image onward to produce a single image of the merged layers.
-- The inital canvas's size depends on the given ImageLayerMethod, and is
-- initialized using the first images background color. The images are then
-- compositied onto that image in sequence using the given composition that
-- has been assigned to each individual image.
foreign import ccall "MagickMergeImageLayers" magickMergeImageLayers
  :: Ptr MagickWand
  -> ImageLayerMethod -- ^ the method of selecting the size of the initial canvas
  -> IO (Ptr MagickWand)

-- | 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)))).
foreign import ccall "MagickTintImage" magickTintImage
  :: Ptr MagickWand
  -> Ptr PixelWand    -- ^ the tint pixel wand.
  -> Ptr PixelWand    -- ^ opacity pixel wand
  -> IO MagickBooleanType


-- | MagickSetImageMatte() sets the image matte channel.
foreign import ccall "MagickSetImageMatte" magickSetImageMatte
  :: Ptr MagickWand
  -> MagickBooleanType
  -> IO MagickBooleanType

-- | MagickCropImage() extracts a region of the image.
foreign import ccall "MagickCropImage" magickCropImage
  :: Ptr MagickWand
  -> CSize         -- ^ the region width
  -> CSize         -- ^ the region height
  -> CSize         -- ^ the region x-offset
  -> CSize         -- ^ the region y-offset
  -> IO MagickBooleanType

-- | 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.
foreign import ccall "MagickShearImage" magickShearImage
  :: Ptr MagickWand
  -> Ptr PixelWand -- ^ the background pixel wand
  -> CDouble       -- ^ the number of degrees to shear the image
  -> CDouble       -- ^ the number of degrees to shear the image
  -> IO MagickBooleanType

-- | MagickScaleImage() scales the size of an image to the given dimensions.
foreign import ccall "MagickScaleImage" magickScaleImage
  :: Ptr MagickWand
  -> CSize       -- ^ the number of columns in the scaled image
  -> CSize       -- ^ the number of rows in the scaled image
  -> IO MagickBooleanType

-- | MagickSparseColorImage(), given a set of coordinates, interpolates the
-- colors found at those coordinates, across the whole image, using various methods.
--
-- The format of the MagickSparseColorImage method is:
--   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.
--
-- Bilinear has no simple inverse mapping so will not allow 'bestfit' style of image sparseion.
--
-- Affine, Perspective, and Bilinear, will do least squares fitting of the distrotion when more
-- than the minimum number of control point pairs are provided.
--
-- 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.
foreign import ccall "MagickSparseColorImage" magickSparseColorImage
  :: Ptr MagickWand
  -> ChannelType
  -> SparseColorMethod
  -> CSize
  -> Ptr Double
  -> IO MagickBooleanType

-- | MagickFunctionImage() applys an arithmetic, relational, or logical expression to an image.
-- Use these operators to lighten or darken an image, to increase or decrease contrast in an
-- image, or to produce the "negative" of an image.
foreign import ccall "MagickFunctionImage" magickFunctionImage
  :: Ptr MagickWand
  -> MagickFunction
  -> CSize
  -> Ptr Double
  -> IO MagickBooleanType

foreign import ccall "MagickFunctionImageChannel" magickFunctionImageChannel
  :: Ptr MagickWand
  -> ChannelType
  -> MagickFunction
  -> CSize
  -> Ptr Double
  -> IO MagickBooleanType

-- | 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.
foreign import ccall "MagickCoalesceImages" magickCoalesceImages
  :: Ptr MagickWand
  -> IO (Ptr MagickWand)

-- | MagickGetNumberImages() returns the number of images associated
-- with a magick wand.
foreign import ccall "MagickGetNumberImages" magickGetNumberImages
  :: Ptr MagickWand
  -> IO CSize

-- | MagickGetImage() gets the image at the current image index.
foreign import ccall "MagickGetImage" magickGetImage
  :: Ptr MagickWand
  -> IO (Ptr MagickWand)

-- | MagickCompareImageLayers() compares each image with the next in
-- a sequence and returns the maximum bounding region of any pixel
-- differences it discovers.
foreign import ccall "MagickCompareImageLayers" magickCompareImageLayers
  :: Ptr MagickWand
  -> ImageLayerMethod
  -> IO (Ptr MagickWand)

-- | MagickGetImageScene() gets the image scene
foreign import ccall "MagickGetImageScene" magickGetImageScene
  :: Ptr MagickWand -> IO CSize

-- | MagickRemoveImage() removes an image from the image list.
foreign import ccall "MagickRemoveImage" magickRemoveImage
  :: Ptr MagickWand -> IO MagickBooleanType

-- | MagickSetImage() replaces the last image returned by MagickSetImageIndex(),
-- MagickNextImage(), MagickPreviousImage() with the images from the specified
-- wand.
foreign import ccall "MagickSetImage" magickSetImage
  :: Ptr MagickWand -> Ptr MagickWand -> IO MagickBooleanType

-- | MagickImportImagePixels() accepts pixel data and stores it in the image at
-- the location you specify. The method returns MagickFalse on success otherwise
-- MagickTrue if an error is encountered. The pixel data can be either char,
-- short int, int, ssize_t, float, or double in the order specified by map.
--
-- Suppose your want to upload the first scanline of a 640x480 image from
-- character data in red-green-blue order:
--   magickImportImagePixels wand 0 0 640 1 "RGB" charPixel pixels
foreign import ccall "MagickImportImagePixels" magickImportImagePixels
  :: Ptr MagickWand
  -> CSize          -- ^ x
  -> CSize          -- ^ y
  -> CSize          -- ^ width
  -> CSize          -- ^ height
  -> CString        -- ^ 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.
  -> StorageType    -- define the data type of the pixels. Float and double types are expected
                    -- to be normalized [0..1] otherwise [0..QuantumRange]. Choose from these
                    -- types: CharPixel, ShortPixel, IntegerPixel, LongPixel, FloatPixel, or DoublePixel.
  -> Ptr ()         -- ^ 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
  -> IO MagickBooleanType

-- | MagickExportImagePixels() extracts pixel data from an image and returns it
-- to you. The method returns MagickTrue on success otherwise MagickFalse if an
-- error is encountered. The data is returned as char, short int, int, ssize_t,
-- float, or double in the order specified by map.
foreign import ccall "MagickExportImagePixels" magickExportImagePixels
  :: Ptr MagickWand
  -> CSize          -- ^ x
  -> CSize          -- ^ y
  -> CSize          -- ^ width
  -> CSize          -- ^ height
  -> CString        -- ^ 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.
  -> StorageType    -- define the data type of the pixels. Float and double types are expected
                    -- to be normalized [0..1] otherwise [0..QuantumRange]. Choose from these
                    -- types: CharPixel, ShortPixel, IntegerPixel, LongPixel, FloatPixel, or DoublePixel.
  -> Ptr ()         -- ^ 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
  -> IO MagickBooleanType

-- | MagickRotateImage() rotates an image the specified number of degrees.
-- Empty triangles left over from rotating the image are filled with the
-- background color.
foreign import ccall "MagickRotateImage" magickRotateImage
  :: Ptr MagickWand -> Ptr PixelWand -> CDouble -> IO MagickBooleanType

-- | MagickSetImageDepth() sets the image depth.
foreign import ccall "MagickSetImageDepth" magickSetImageDepth
  :: Ptr MagickWand -> CSize -> IO MagickBooleanType

-- | MagickSetImageDelay() sets the image delay.
foreign import ccall "MagickSetImageDelay" magickSetImageDelay
  :: Ptr MagickWand -> CSize -> IO MagickBooleanType

-- | MagickGetImageDelay() gets the image delay.
foreign import ccall "MagickGetImageDelay" magickGetImageDelay
  :: Ptr MagickWand -> IO CSize

-- | MagickGetImageBlob() implements direct to memory image formats.
-- It returns the image as a blob (a formatted "file" in memory) and
-- its length, starting from the current position in the image sequence.
-- Use MagickSetImageFormat() to set the format to write to the blob (GIF, JPEG, PNG, etc.).
-- Utilize MagickResetIterator() to ensure the write is from the beginning of the image sequence.
-- Use MagickRelinquishMemory() to free the blob when you are done with it.
-- The format of the MagickGetImageBlob method is:
foreign import ccall "MagickGetImageBlob" magickGetImageBlob
  :: Ptr MagickWand -> Ptr CSize -> IO (Ptr CChar)

-- | MagickGetImagesBlob() implements direct to memory image formats ideal
-- for use with sequenced images to get a dump of the whole sequence
foreign import ccall "MagickGetImagesBlob" magickGetImagesBlob
  :: Ptr MagickWand -> Ptr CSize -> IO (Ptr CChar)

-- | MagickGetImageDepth() gets the image depth.
foreign import ccall "MagickGetImageDepth" magickGetImageDepth
  :: Ptr MagickWand -> IO CSize

-- | MagickGetImageFormat() returns the format of a particular image in a sequence.
foreign import ccall "MagickGetImageFormat" magickGetImageFormat
  :: Ptr MagickWand -> IO CString

-- | MagickSetImageFormat() sets the format of a particular image in a sequence.
foreign import ccall "MagickSetImageFormat" magickSetImageFormat
  :: Ptr MagickWand -> CString -> IO MagickBooleanType

-- | MagickStripImage() strips an image of all profiles and comments.
foreign import ccall "MagickStripImage" magickStripImage
  :: Ptr MagickWand -> IO MagickBooleanType

-- | MagickGetImageSignature() generates an SHA-256 message digest for the image pixel stream.
foreign import ccall "MagickGetImageSignature" magickGetImageSignature
  :: Ptr MagickWand -> IO CString

-- | MagickGetImageAlphaChannel() returns MagickFalse if the image alpha
-- channel is not activated. That is, the image is RGB rather than RGBA
-- or CMYK rather than CMYKA.
foreign import ccall "MagickGetImageAlphaChannel" magickGetImageAlphaChannel
  :: Ptr MagickWand -> IO MagickBooleanType

-- | MagickSetImageType() sets the image type.
foreign import ccall "MagickSetImageType" magickSetImageType
  :: Ptr MagickWand -> ImageType -> IO MagickBooleanType