The main type of this package, one that most functions work on, is Image.

Parameterized by the underlying pixel format it forms a rigid type. If you wish to store images of different or unknown pixel formats use DynamicImage.

Image is essentially a rectangular pixel buffer of specified width and height. The coordinates are assumed to start from the upper-left corner of the image, with the horizontal position first and vertical second.

Image or pixel buffer, the coordinates are assumed to start from the upper-left corner of the image, with the horizontal position first, then the vertical one. The image can be transformed in place.

Image type enumerating all predefined pixel types. It enables loading and use of images of different pixel types.

Type for the palette used in Gif & PNG files.

Create a mutable image, filled with the given background color.

Create a mutable image with garbage as content. All data is uninitialized.

`O(n)` Yield an immutable copy of an image by making a copy of it

`O(1)` Unsafe convert a mutable image to an immutable one without copying. The mutable image may not be used after this operation.

`O(n)` Yield a mutable copy of an image by making a copy of it.

`O(1)` Unsafe convert an imutable image to an mutable one without copying. The source image shouldn't be used after this operation.

Traversal type matching the definition in the Lens package.

Traversal in "raster" order, from left to right the top to bottom. This traversal is matching pixelMap in spirit.

Since 3.2.4

Traversal providing the pixel position with it's value. The traversal in raster order, from lef to right, then top to bottom. The traversal match pixelMapXY in spirit.

Since 3.2.4

Type alias for 8bit greyscale pixels. For simplicity, greyscale pixels use plain numbers instead of a separate type.

Type alias for 16bit greyscale pixels.

Type alias for 32bit greyscale pixels.

Type alias for 32bit floating point greyscale pixels. The standard bounded value range is mapped to the closed interval [0,1] i.e.

map promotePixel [0, 1 .. 255 :: Pixel8] == [0/255, 1/255 .. 1.0 :: PixelF]

Pixel type storing 8bit Luminance (Y) and alpha (A) information. Values are stored in the following order:

• Luminance
• Alpha

Pixel type storing 16bit Luminance (Y) and alpha (A) information. Values are stored in the following order:

• Luminance
• Alpha

Classic pixel type storing 8bit red, green and blue (RGB) information. Values are stored in the following order:

• Red
• Green
• Blue

Pixel type storing 16bit red, green and blue (RGB) information. Values are stored in the following order:

• Red
• Green
• Blue

HDR pixel type storing floating point 32bit red, green and blue (RGB) information. Same value range and comments apply as for PixelF. Values are stored in the following order:

• Red
• Green
• Blue

Classical pixel type storing 8bit red, green, blue and alpha (RGBA) information. Values are stored in the following order:

• Red
• Green
• Blue
• Alpha

Pixel type storing 16bit red, green, blue and alpha (RGBA) information. Values are stored in the following order:

• Red
• Green
• Blue
• Alpha

Pixel type storing 8bit cyan, magenta, yellow and black (CMYK) information. Values are stored in the following order:

• Cyan
• Magenta
• Yellow
• Black

Pixel type storing 16bit cyan, magenta, yellow and black (CMYK) information. Values are stored in the following order:

• Cyan
• Magenta
• Yellow
• Black

Pixel type storing 8bit luminance, blue difference and red difference (YCbCr) information. Values are stored in the following order:

• Y (luminance)
• Cb
• Cr

Pixel type storing value for the YCCK color space:

• Y (Luminance)
• Cb
• Cr
• Black

Implement upcasting for pixel types. Minimal declaration of promotePixel. It is strongly recommended to overload promoteImage to keep performance acceptable

Definition of pixels used in images. Each pixel has a color space, and a representative component (Word8 or Float).

This class abstract colorspace conversion. This conversion can be lossy, which ColorConvertible cannot

Helper class to help extract a luma plane out of an image or a pixel

Class modeling transparent pixel, should provide a method to combine transparent pixels

map equivalent for an image, working at the pixel level. Little example : a brightness function for an rgb image

brightnessRGB8 :: Int -> Image PixelRGB8 -> Image PixelRGB8
brightnessRGB8 add = pixelMap brightFunction
     where up v = fromIntegral (fromIntegral v + add)
           brightFunction (PixelRGB8 r g b) =
                   PixelRGB8 (up r) (up g) (up b)

Just like pixelMap only the function takes the pixel coordinates as additional parameters.

Fold over the pixel of an image with a raster scan order: from top to bottom, left to right

Fold over the pixel of an image with a raster scan order: from top to bottom, left to right, carrying out a state

Fold over the pixel of an image with a raster scan order: from top to bottom, left to right. This functions is analog to the foldMap from the Foldable typeclass, but due to the Pixel constraint, Image cannot be made an instance of it.

Helper function to help extract information from dynamic image. To get the width of a dynamic image, you can use the following snippet:

dynWidth :: DynamicImage -> Int
dynWidth img = dynamicMap imageWidth img

Equivalent of the pixelMap function for the dynamic images. You can perform pixel colorspace independant operations with this function.

For instance, if you want to extract a square crop of any image, without caring about colorspace, you can use the following snippet.

 dynSquare :: DynamicImage -> DynamicImage
 dynSquare = dynamicPixelMap squareImage

 squareImage :: Pixel a => Image a -> Image a
 squareImage img = generateImage (\x y -> pixelAt img x y) edge edge
    where edge = min (imageWidth img) (imageHeight img)

For any image with an alpha component (transparency), drop it, returning a pure opaque image.

Create an image using a monadic initializer function. The function will receive values from 0 to width-1 for the x parameter and 0 to height-1 for the y parameter. The coordinates 0,0 are the upper left corner of the image, and (width-1, height-1) the lower right corner.

The function is called for each pixel in the line from left to right (0 to width - 1) and for each line (0 to height - 1).

Combine, pixel by pixel and component by component the values of 3 different images. Usage example:

averageBrightNess c1 c2 c3 = clamp $ toInt c1 + toInt c2 + toInt c3
  where clamp = fromIntegral . min 0 . max 255
        toInt :: a -> Int
        toInt = fromIntegral
ziPixelComponent3 averageBrightNess img1 img2 img3

Create an image given a function to generate pixels. The function will receive values from 0 to width-1 for the x parameter and 0 to height-1 for the y parameter. The coordinates 0,0 are the upper left corner of the image, and (width-1, height-1) the lower right corner.

for example, to create a small gradient image:

imageCreator :: String -> IO ()
imageCreator path = writePng path $ generateImage pixelRenderer 250 300
   where pixelRenderer x y = PixelRGB8 x y 128

Create an image given a function to generate pixels. The function will receive values from 0 to width-1 for the x parameter and 0 to height-1 for the y parameter. The coordinates 0,0 are the upper left corner of the image, and (width-1, height-1) the lower right corner.

the acc parameter is a user defined one.

The function is called for each pixel in the line from left to right (0 to width - 1) and for each line (0 to height - 1).

Perform a gamma correction for an image with HDR pixels.

Perform a tone mapping operation on an High dynamic range image.

Class used to describle plane present in the pixel type. If a pixel has a plane description associated, you can use the plane name to extract planes independently.

Define the plane for the red color component

Define the plane for the green color component

Define the plane for the blue color component

Define the plane for the alpha (transparency) component

Define the plane for the luma component

Define the plane for the Cr component

Define the plane for the Cb component

Define plane for the cyan component of the CMYK color space.

Define plane for the magenta component of the CMYK color space.

Define plane for the yellow component of the CMYK color space.

Define plane for the black component of the CMYK color space.

Extract a color plane from an image given a present plane in the image examples:

 extractRedPlane :: Image PixelRGB8 -> Image Pixel8
 extractRedPlane = extractComponent PlaneRed

Extract a plane of an image. Returns the requested color component as a greyscale image.

If you ask for a component out of bound, the error function will be called.

This typeclass exist for performance reason, it allow to pack a pixel value to a simpler "primitive" data type to allow faster writing to moemory.

This function will fill an image with a simple packeable pixel. It will be faster than any unsafeWritePixel.

Read a packeable pixel from an image. Equivalent to unsafeReadPixel

Write a packeable pixel into an image. equivalent to unsafeWritePixel.

Fill a packeable pixel between two bounds.