Codec.Picture.Types

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)

Flatten a PalettedImage to a DynamicImage

Convert a palette to an image. Used mainly for backward compatibility.

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 (fromIntegral x) (fromIntegral 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.