| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Codec.Picture
Contents
Description
Main module for image import/export into various image formats.
To use the library without thinking about it, look after decodeImage and
readImage.
Generally, the read* functions read the images from a file and try to decode
it, and the decode* functions try to decode a bytestring.
For an easy image writing use the saveBmpImage, saveJpgImage & savePngImage
functions
- readImage :: FilePath -> IO (Either String DynamicImage)
- readImageWithMetadata :: FilePath -> IO (Either String (DynamicImage, Metadatas))
- decodeImage :: ByteString -> Either String DynamicImage
- decodeImageWithMetadata :: ByteString -> Either String (DynamicImage, Metadatas)
- pixelMap :: forall a b. (Pixel a, Pixel b) => (a -> b) -> Image a -> Image b
- generateImage :: forall px. Pixel px => (Int -> Int -> px) -> Int -> Int -> Image px
- generateFoldImage :: forall a acc. Pixel a => (acc -> Int -> Int -> (acc, a)) -> acc -> Int -> Int -> (acc, Image a)
- withImage :: forall m pixel. (Pixel pixel, PrimMonad m) => Int -> Int -> (Int -> Int -> m pixel) -> m (Image pixel)
- convertRGB8 :: DynamicImage -> Image PixelRGB8
- convertRGBA8 :: DynamicImage -> Image PixelRGBA8
- type Traversal s t a b = forall f. Applicative f => (a -> f b) -> s -> f t
- imagePixels :: forall pxa pxb. (Pixel pxa, Pixel pxb) => Traversal (Image pxa) (Image pxb) pxa pxb
- imageIPixels :: forall pxa pxb. (Pixel pxa, Pixel pxb) => Traversal (Image pxa) (Image pxb) (Int, Int, pxa) pxb
- saveBmpImage :: FilePath -> DynamicImage -> IO ()
- saveJpgImage :: Int -> FilePath -> DynamicImage -> IO ()
- saveGifImage :: FilePath -> DynamicImage -> Either String (IO ())
- savePngImage :: FilePath -> DynamicImage -> IO ()
- saveTiffImage :: FilePath -> DynamicImage -> IO ()
- saveRadianceImage :: FilePath -> DynamicImage -> IO ()
- class BmpEncodable pixel
- writeBitmap :: BmpEncodable pixel => FilePath -> Image pixel -> IO ()
- encodeBitmap :: forall pixel. BmpEncodable pixel => Image pixel -> ByteString
- readBitmap :: FilePath -> IO (Either String DynamicImage)
- decodeBitmap :: ByteString -> Either String DynamicImage
- encodeDynamicBitmap :: DynamicImage -> Either String ByteString
- writeDynamicBitmap :: FilePath -> DynamicImage -> IO (Either String Bool)
- readGif :: FilePath -> IO (Either String DynamicImage)
- readGifImages :: FilePath -> IO (Either String [DynamicImage])
- decodeGif :: ByteString -> Either String DynamicImage
- decodeGifImages :: ByteString -> Either String [DynamicImage]
- encodeGifImage :: Image Pixel8 -> ByteString
- writeGifImage :: FilePath -> Image Pixel8 -> IO ()
- encodeGifImageWithPalette :: Image Pixel8 -> Palette -> Either String ByteString
- writeGifImageWithPalette :: FilePath -> Image Pixel8 -> Palette -> Either String (IO ())
- encodeColorReducedGifImage :: Image PixelRGB8 -> Either String ByteString
- writeColorReducedGifImage :: FilePath -> Image PixelRGB8 -> Either String (IO ())
- encodeGifImages :: GifLooping -> [(Palette, GifDelay, Image Pixel8)] -> Either String ByteString
- writeGifImages :: FilePath -> GifLooping -> [(Palette, GifDelay, Image Pixel8)] -> Either String (IO ())
- type GifDelay = Int
- data GifLooping
- encodeGifAnimation :: GifDelay -> GifLooping -> [Image PixelRGB8] -> Either String ByteString
- writeGifAnimation :: FilePath -> GifDelay -> GifLooping -> [Image PixelRGB8] -> Either String (IO ())
- readJpeg :: FilePath -> IO (Either String DynamicImage)
- decodeJpeg :: ByteString -> Either String DynamicImage
- encodeJpeg :: Image PixelYCbCr8 -> ByteString
- encodeJpegAtQuality :: Word8 -> Image PixelYCbCr8 -> ByteString
- class PngSavable a where
- readPng :: FilePath -> IO (Either String DynamicImage)
- decodePng :: ByteString -> Either String DynamicImage
- writePng :: PngSavable pixel => FilePath -> Image pixel -> IO ()
- encodePalettedPng :: Palette -> Image Pixel8 -> Either String ByteString
- encodeDynamicPng :: DynamicImage -> Either String ByteString
- writeDynamicPng :: FilePath -> DynamicImage -> IO (Either String Bool)
- readTGA :: FilePath -> IO (Either String DynamicImage)
- decodeTga :: ByteString -> Either String DynamicImage
- class TgaSaveable a
- encodeTga :: TgaSaveable px => Image px -> ByteString
- writeTga :: TgaSaveable pixel => FilePath -> Image pixel -> IO ()
- readTiff :: FilePath -> IO (Either String DynamicImage)
- class Pixel px => TiffSaveable px
- decodeTiff :: ByteString -> Either String DynamicImage
- encodeTiff :: forall px. TiffSaveable px => Image px -> ByteString
- writeTiff :: TiffSaveable pixel => FilePath -> Image pixel -> IO ()
- readHDR :: FilePath -> IO (Either String DynamicImage)
- decodeHDR :: ByteString -> Either String DynamicImage
- encodeHDR :: Image PixelRGBF -> ByteString
- writeHDR :: FilePath -> Image PixelRGBF -> IO ()
- data PaletteCreationMethod
- data PaletteOptions = PaletteOptions {}
- palettize :: PaletteOptions -> Image PixelRGB8 -> (Image Pixel8, Palette)
- data Image a = Image {
- imageWidth :: !Int
- imageHeight :: !Int
- imageData :: Vector (PixelBaseComponent a)
- data DynamicImage
- = ImageY8 (Image Pixel8)
- | ImageY16 (Image Pixel16)
- | ImageYF (Image PixelF)
- | ImageYA8 (Image PixelYA8)
- | ImageYA16 (Image PixelYA16)
- | ImageRGB8 (Image PixelRGB8)
- | ImageRGB16 (Image PixelRGB16)
- | ImageRGBF (Image PixelRGBF)
- | ImageRGBA8 (Image PixelRGBA8)
- | ImageRGBA16 (Image PixelRGBA16)
- | ImageYCbCr8 (Image PixelYCbCr8)
- | ImageCMYK8 (Image PixelCMYK8)
- | ImageCMYK16 (Image PixelCMYK16)
- type Palette = Image PixelRGB8
- class (Storable (PixelBaseComponent a), Num (PixelBaseComponent a), Eq a) => Pixel a where
- type PixelBaseComponent a :: *
- type Pixel8 = Word8
- type Pixel16 = Word16
- type PixelF = Float
- data PixelYA8 = PixelYA8 !Pixel8 !Pixel8
- data PixelYA16 = PixelYA16 !Pixel16 !Pixel16
- data PixelRGB8 = PixelRGB8 !Pixel8 !Pixel8 !Pixel8
- data PixelRGB16 = PixelRGB16 !Pixel16 !Pixel16 !Pixel16
- data PixelRGBF = PixelRGBF !PixelF !PixelF !PixelF
- data PixelRGBA8 = PixelRGBA8 !Pixel8 !Pixel8 !Pixel8 !Pixel8
- data PixelRGBA16 = PixelRGBA16 !Pixel16 !Pixel16 !Pixel16 !Pixel16
- data PixelYCbCr8 = PixelYCbCr8 !Pixel8 !Pixel8 !Pixel8
- data PixelCMYK8 = PixelCMYK8 !Pixel8 !Pixel8 !Pixel8 !Pixel8
- data PixelCMYK16 = PixelCMYK16 !Pixel16 !Pixel16 !Pixel16 !Pixel16
- imageFromUnsafePtr :: forall px. (Pixel px, PixelBaseComponent px ~ Word8) => Int -> Int -> ForeignPtr Word8 -> Image px
Generic functions
readImage :: FilePath -> IO (Either String DynamicImage) Source #
Load an image file without even thinking about it, it does everything
as decodeImage
readImageWithMetadata :: FilePath -> IO (Either String (DynamicImage, Metadatas)) Source #
Equivalent to readImage but also providing metadatas.
decodeImage :: ByteString -> Either String DynamicImage Source #
If you want to decode an image in a bytestring without even thinking in term of format or whatever, this is the function to use. It will try to decode in each known format and if one decoding succeeds, it will return the decoded image in it's own colorspace.
decodeImageWithMetadata :: ByteString -> Either String (DynamicImage, Metadatas) Source #
Equivalent to decodeImage, but also provide potential metadatas
present in the given file.
pixelMap :: forall a b. (Pixel a, Pixel b) => (a -> b) -> Image a -> Image b Source #
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)Arguments
| :: Pixel px | |
| => (Int -> Int -> px) | Generating function, with |
| -> Int | Width in pixels |
| -> Int | Height in pixels |
| -> Image px |
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
Arguments
| :: Pixel a | |
| => (acc -> Int -> Int -> (acc, a)) | Function taking the state, x and y |
| -> acc | Initial state |
| -> Int | Width in pixels |
| -> Int | Height in pixels |
| -> (acc, Image a) |
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).
Arguments
| :: (Pixel pixel, PrimMonad m) | |
| => Int | Image width |
| -> Int | Image height |
| -> (Int -> Int -> m pixel) | Generating functions |
| -> m (Image pixel) |
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).
RGB helper functions
convertRGB8 :: DynamicImage -> Image PixelRGB8 Source #
Convert by any mean possible a dynamic image to an image in RGB. The process can lose precision while converting from 16bits pixels or Floating point pixels. Any alpha layer will be dropped
convertRGBA8 :: DynamicImage -> Image PixelRGBA8 Source #
Convert by any mean possible a dynamic image to an image in RGBA. The process can lose precision while converting from 16bits pixels or Floating point pixels.
Lens compatibility
type Traversal s t a b = forall f. Applicative f => (a -> f b) -> s -> f t Source #
Traversal type matching the definition in the Lens package.
imagePixels :: forall pxa pxb. (Pixel pxa, Pixel pxb) => Traversal (Image pxa) (Image pxb) pxa pxb Source #
Traversal in "raster" order, from left to right the top to bottom. This traversal is matching pixelMap in spirit.
Since 3.2.4
imageIPixels :: forall pxa pxb. (Pixel pxa, Pixel pxb) => Traversal (Image pxa) (Image pxb) (Int, Int, pxa) pxb Source #
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
Generic image writing
saveBmpImage :: FilePath -> DynamicImage -> IO () Source #
Save an image to a '.bmp' file, will do everything it can to save an image.
saveJpgImage :: Int -> FilePath -> DynamicImage -> IO () Source #
Save an image to a '.jpg' file, will do everything it can to save an image.
saveGifImage :: FilePath -> DynamicImage -> Either String (IO ()) Source #
Save an image to a '.gif' file, will do everything it can to save it.
savePngImage :: FilePath -> DynamicImage -> IO () Source #
Save an image to a '.png' file, will do everything it can to save an image. For example, a simple transcoder to png
transcodeToPng :: FilePath -> FilePath -> IO ()
transcodeToPng pathIn pathOut = do
eitherImg <- readImage pathIn
case eitherImg of
Left _ -> return ()
Right img -> savePngImage pathOut imgsaveTiffImage :: FilePath -> DynamicImage -> IO () Source #
Save an image to a '.tiff' file, will do everything it can to save an image.
saveRadianceImage :: FilePath -> DynamicImage -> IO () Source #
Save an image to a '.hdr' file, will do everything it can to save an image.
Specific image format functions
Bitmap handling
class BmpEncodable pixel Source #
All the instance of this class can be written as a bitmap file using this library.
Minimal complete definition
bitsPerPixel, bmpEncode
Instances
writeBitmap :: BmpEncodable pixel => FilePath -> Image pixel -> IO () Source #
Write an image in a file use the bitmap format.
encodeBitmap :: forall pixel. BmpEncodable pixel => Image pixel -> ByteString Source #
Encode an image into a bytestring in .bmp format ready to be written on disk.
readBitmap :: FilePath -> IO (Either String DynamicImage) Source #
Try to load a .bmp file. The colorspace would be RGB, RGBA or Y.
decodeBitmap :: ByteString -> Either String DynamicImage Source #
Try to decode a bitmap image. Right now this function can output the following image:
encodeDynamicBitmap :: DynamicImage -> Either String ByteString Source #
Encode a dynamic image in BMP if possible, supported images are:
writeDynamicBitmap :: FilePath -> DynamicImage -> IO (Either String Bool) Source #
Write a dynamic image in a .bmp image file if possible.
The same restriction as encodeDynamicBitmap apply.
Gif handling
readGif :: FilePath -> IO (Either String DynamicImage) Source #
Helper function trying to load a gif file from a file on disk.
readGifImages :: FilePath -> IO (Either String [DynamicImage]) Source #
Helper function trying to load all the images of an animated gif file.
decodeGif :: ByteString -> Either String DynamicImage Source #
Transform a raw gif image to an image, without modifying the pixels. This function can output the following images:
decodeGifImages :: ByteString -> Either String [DynamicImage] Source #
Transform a raw gif to a list of images, representing all the images of an animation.
encodeGifImage :: Image Pixel8 -> ByteString Source #
Encode a greyscale image to a bytestring.
writeGifImage :: FilePath -> Image Pixel8 -> IO () Source #
Write a greyscale in a gif file on the disk.
encodeGifImageWithPalette :: Image Pixel8 -> Palette -> Either String ByteString Source #
Encode an image with a given palette. Can return errors if the palette is ill-formed.
- A palette must have between 1 and 256 colors
writeGifImageWithPalette :: FilePath -> Image Pixel8 -> Palette -> Either String (IO ()) Source #
Write a gif image with a palette to a file.
- A palette must have between 1 and 256 colors
encodeColorReducedGifImage :: Image PixelRGB8 -> Either String ByteString Source #
Encode a full color image to a gif by applying a color quantization algorithm on it.
writeColorReducedGifImage :: FilePath -> Image PixelRGB8 -> Either String (IO ()) Source #
Write a full color image to a gif by applying a color quantization algorithm on it.
encodeGifImages :: GifLooping -> [(Palette, GifDelay, Image Pixel8)] -> Either String ByteString Source #
Encode a gif animation to a bytestring.
- Every image must have the same size
- Every palette must have between one and 256 colors.
writeGifImages :: FilePath -> GifLooping -> [(Palette, GifDelay, Image Pixel8)] -> Either String (IO ()) Source #
Write a list of images as a gif animation in a file.
- Every image must have the same size
- Every palette must have between one and 256 colors.
Gif animation
Delay to wait before showing the next Gif image. The delay is expressed in 100th of seconds.
data GifLooping Source #
Help to control the behaviour of GIF animation looping.
Constructors
| LoopingNever | The animation will stop once the end is reached |
| LoopingForever | The animation will restart once the end is reached |
| LoopingRepeat Word16 | The animation will repeat n times before stoping |
encodeGifAnimation :: GifDelay -> GifLooping -> [Image PixelRGB8] -> Either String ByteString Source #
Helper function to create a gif animation. All the images of the animation are separated by the same delay.
writeGifAnimation :: FilePath -> GifDelay -> GifLooping -> [Image PixelRGB8] -> Either String (IO ()) Source #
Helper function to write a gif animation on disk. See encodeGifAnimation
Jpeg handling
readJpeg :: FilePath -> IO (Either String DynamicImage) Source #
Try to load a jpeg file and decompress. The colorspace is still
YCbCr if you want to perform computation on the luma part. You can
convert it to RGB using colorSpaceConversion.
decodeJpeg :: ByteString -> Either String DynamicImage Source #
Try to decompress and decode a jpeg file. The colorspace is still
YCbCr if you want to perform computation on the luma part. You can convert it
to RGB using convertImage from the ColorSpaceConvertible typeclass.
This function can output the following images:
encodeJpeg :: Image PixelYCbCr8 -> ByteString Source #
Encode an image in jpeg at a reasonnable quality level.
If you want better quality or reduced file size, you should
use encodeJpegAtQuality
Arguments
| :: Word8 | Quality factor |
| -> Image PixelYCbCr8 | Image to encode |
| -> ByteString | Encoded JPEG |
Function to call to encode an image to jpeg. The quality factor should be between 0 and 100 (100 being the best quality).
Png handling
class PngSavable a where Source #
Encode an image into a png if possible.
Minimal complete definition
Methods
encodePng :: Image a -> ByteString Source #
Transform an image into a png encoded bytestring, ready to be written as a file.
encodePngWithMetadata :: Metadatas -> Image a -> ByteString Source #
Encode a png using some metadatas. The following metadata keys will
be stored in a tEXt field :
TitleDescriptionAuthorCopyrightSoftwareCommentDisclaimerSourceWarningUnknownusing the key present in the constructor.
the followings metadata will bes tored in the gAMA chunk.
The followings metadata will be stored in a pHYs chunk
readPng :: FilePath -> IO (Either String DynamicImage) Source #
Helper function trying to load a png file from a file on disk.
decodePng :: ByteString -> Either String DynamicImage Source #
Transform a raw png image to an image, without modifying the underlying pixel type. If the image is greyscale and < 8 bits, a transformation to RGBA8 is performed. This should change in the future. The resulting image let you manage the pixel types.
This function can output the following images:
writePng :: PngSavable pixel => FilePath -> Image pixel -> IO () Source #
Helper function to directly write an image as a png on disk.
encodePalettedPng :: Palette -> Image Pixel8 -> Either String ByteString Source #
Encode a paletted image as a color indexed 8-bit PNG. the palette must have between 1 and 256 values in it.
encodeDynamicPng :: DynamicImage -> Either String ByteString Source #
Encode a dynamic image in PNG if possible, supported images are:
writeDynamicPng :: FilePath -> DynamicImage -> IO (Either String Bool) Source #
Write a dynamic image in a .png image file if possible. The same restriction as encodeDynamicPng apply.
TGA handling
decodeTga :: ByteString -> Either String DynamicImage Source #
Transform a raw tga image to an image, without modifying the underlying pixel type.
This function can output the following images:
class TgaSaveable a Source #
This typeclass determine if a pixel can be saved in the TGA format.
Minimal complete definition
tgaDataOfImage, tgaPixelDepthOfImage, tgaTypeOfImage
Instances
encodeTga :: TgaSaveable px => Image px -> ByteString Source #
Transform a compatible image to a raw bytestring representing a Targa file.
writeTga :: TgaSaveable pixel => FilePath -> Image pixel -> IO () Source #
Helper function to directly write an image a tga on disk.
Tiff handling
readTiff :: FilePath -> IO (Either String DynamicImage) Source #
Helper function trying to load tiff file from a file on disk.
class Pixel px => TiffSaveable px Source #
Class defining which pixel types can be serialized in a Tiff file.
Minimal complete definition
colorSpaceOfPixel
Instances
decodeTiff :: ByteString -> Either String DynamicImage Source #
Decode a tiff encoded image while preserving the underlying pixel type (except for Y32 which is truncated to 16 bits).
This function can output the following images:
encodeTiff :: forall px. TiffSaveable px => Image px -> ByteString Source #
Transform an image into a Tiff encoded bytestring, ready to be written as a file.
writeTiff :: TiffSaveable pixel => FilePath -> Image pixel -> IO () Source #
Helper function to directly write an image as a tiff on disk.
HDR (Radiance/RGBE) handling
readHDR :: FilePath -> IO (Either String DynamicImage) Source #
Try to load a .pic file. The colorspace can only be RGB with floating point precision.
decodeHDR :: ByteString -> Either String DynamicImage Source #
Decode an HDR (radiance) image, the resulting image can be:
encodeHDR :: Image PixelRGBF -> ByteString Source #
Encode an High dynamic range image into a radiance image file format. Alias for encodeRawHDR
writeHDR :: FilePath -> Image PixelRGBF -> IO () Source #
Write an High dynamic range image into a radiance image file on disk.
Color Quantization
data PaletteCreationMethod Source #
Define which palette creation method is used.
Constructors
| MedianMeanCut | MedianMeanCut method, provide the best results (visualy) at the cost of increased calculations. |
| Uniform | Very fast algorithm (one pass), doesn't provide good looking results. |
data PaletteOptions Source #
To specify how the palette will be created.
Constructors
| PaletteOptions | |
Fields
| |
palettize :: PaletteOptions -> Image PixelRGB8 -> (Image Pixel8, Palette) Source #
Reduces an image to a color palette according to PaletteOpts and
returns the indices image along with its Palette.
Image types and pixel types
Image
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.
Constructors
| Image | |
Fields
| |
data DynamicImage Source #
Image type enumerating all predefined pixel types. It enables loading and use of images of different pixel types.
Constructors
| ImageY8 (Image Pixel8) | A greyscale image. |
| ImageY16 (Image Pixel16) | A greyscale image with 16bit components |
| ImageYF (Image PixelF) | A greyscale HDR image |
| ImageYA8 (Image PixelYA8) | An image in greyscale with an alpha channel. |
| ImageYA16 (Image PixelYA16) | An image in greyscale with alpha channel on 16 bits. |
| ImageRGB8 (Image PixelRGB8) | An image in true color. |
| ImageRGB16 (Image PixelRGB16) | An image in true color with 16bit depth. |
| ImageRGBF (Image PixelRGBF) | An image with HDR pixels |
| ImageRGBA8 (Image PixelRGBA8) | An image in true color and an alpha channel. |
| ImageRGBA16 (Image PixelRGBA16) | A true color image with alpha on 16 bits. |
| ImageYCbCr8 (Image PixelYCbCr8) | An image in the colorspace used by Jpeg images. |
| ImageCMYK8 (Image PixelCMYK8) | An image in the colorspace CMYK |
| ImageCMYK16 (Image PixelCMYK16) | An image in the colorspace CMYK and 16 bits precision |
Instances
Pixels
class (Storable (PixelBaseComponent a), Num (PixelBaseComponent a), Eq a) => Pixel a where Source #
Definition of pixels used in images. Each pixel has a color space, and a representative component (Word8 or Float).
Minimal complete definition
mixWith, pixelOpacity, componentCount, colorMap, pixelAt, readPixel, writePixel, unsafePixelAt, unsafeReadPixel, unsafeWritePixel
Associated Types
type PixelBaseComponent a :: * Source #
Type of the pixel component, "classical" images would have Word8 type as their PixelBaseComponent, HDR image would have Float for instance
Methods
mixWith :: (Int -> PixelBaseComponent a -> PixelBaseComponent a -> PixelBaseComponent a) -> a -> a -> a Source #
Call the function for every component of the pixels. For example for RGB pixels mixWith is declared like this:
mixWith f (PixelRGB8 ra ga ba) (PixelRGB8 rb gb bb) = PixelRGB8 (f 0 ra rb) (f 1 ga gb) (f 2 ba bb)
mixWithAlpha :: (Int -> PixelBaseComponent a -> PixelBaseComponent a -> PixelBaseComponent a) -> (PixelBaseComponent a -> PixelBaseComponent a -> PixelBaseComponent a) -> a -> a -> a Source #
Extension of the mixWith which separate the treatment
of the color components of the alpha value (transparency component).
For pixel without alpha components, it is equivalent to mixWith.
mixWithAlpha f fa (PixelRGBA8 ra ga ba aa) (PixelRGB8 rb gb bb ab) = PixelRGBA8 (f 0 ra rb) (f 1 ga gb) (f 2 ba bb) (fa aa ab)
pixelOpacity :: a -> PixelBaseComponent a Source #
Return the opacity of a pixel, if the pixel has an alpha layer, return the alpha value. If the pixel doesn't have an alpha value, return a value representing the opaqueness.
componentCount :: a -> Int Source #
Return the number of components of the pixel
colorMap :: (PixelBaseComponent a -> PixelBaseComponent a) -> a -> a Source #
Apply a function to each component of a pixel. If the color type possess an alpha (transparency channel), it is treated like the other color components.
pixelBaseIndex :: Image a -> Int -> Int -> Int Source #
Calculate the index for the begining of the pixel
mutablePixelBaseIndex :: MutableImage s a -> Int -> Int -> Int Source #
Calculate theindex for the begining of the pixel at position x y
pixelAt :: Image a -> Int -> Int -> a Source #
Extract a pixel at a given position, (x, y), the origin is assumed to be at the corner top left, positive y to the bottom of the image
readPixel :: PrimMonad m => MutableImage (PrimState m) a -> Int -> Int -> m a Source #
Same as pixelAt but for mutable images.
writePixel :: PrimMonad m => MutableImage (PrimState m) a -> Int -> Int -> a -> m () Source #
Write a pixel in a mutable image at position x y
unsafePixelAt :: Vector (PixelBaseComponent a) -> Int -> a Source #
Unsafe version of pixelAt, read a pixel at the given index without bound checking (if possible). The index is expressed in number (PixelBaseComponent a)
unsafeReadPixel :: PrimMonad m => STVector (PrimState m) (PixelBaseComponent a) -> Int -> m a Source #
Unsafe version of readPixel, read a pixel at the given position without bound checking (if possible). The index is expressed in number (PixelBaseComponent a)
unsafeWritePixel :: PrimMonad m => STVector (PrimState m) (PixelBaseComponent a) -> Int -> a -> m () Source #
Unsafe version of writePixel, write a pixel at the given position without bound checking. This can be _really_ unsafe. The index is expressed in number (PixelBaseComponent a)
Instances
Type alias for 8bit greyscale pixels. For simplicity, greyscale pixels use plain numbers instead of a separate type.
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
Instances
Pixel type storing 16bit Luminance (Y) and alpha (A) information. Values are stored in the following order:
- Luminance
- Alpha
Instances
Classic pixel type storing 8bit red, green and blue (RGB) information. Values are stored in the following order:
- Red
- Green
- Blue
Instances
data PixelRGB16 Source #
Pixel type storing 16bit red, green and blue (RGB) information. Values are stored in the following order:
- Red
- Green
- Blue
Constructors
| PixelRGB16 !Pixel16 !Pixel16 !Pixel16 |
Instances
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
Instances
data PixelRGBA8 Source #
Classical pixel type storing 8bit red, green, blue and alpha (RGBA) information. Values are stored in the following order:
- Red
- Green
- Blue
- Alpha
Constructors
| PixelRGBA8 !Pixel8 !Pixel8 !Pixel8 !Pixel8 |
Instances
data PixelRGBA16 Source #
Pixel type storing 16bit red, green, blue and alpha (RGBA) information. Values are stored in the following order:
- Red
- Green
- Blue
- Alpha
Constructors
| PixelRGBA16 !Pixel16 !Pixel16 !Pixel16 !Pixel16 |
Instances
data PixelYCbCr8 Source #
Pixel type storing 8bit luminance, blue difference and red difference (YCbCr) information. Values are stored in the following order:
- Y (luminance)
- Cb
- Cr
Constructors
| PixelYCbCr8 !Pixel8 !Pixel8 !Pixel8 |
Instances
data PixelCMYK8 Source #
Pixel type storing 8bit cyan, magenta, yellow and black (CMYK) information. Values are stored in the following order:
- Cyan
- Magenta
- Yellow
- Black
Constructors
| PixelCMYK8 !Pixel8 !Pixel8 !Pixel8 !Pixel8 |
Instances
data PixelCMYK16 Source #
Pixel type storing 16bit cyan, magenta, yellow and black (CMYK) information. Values are stored in the following order:
- Cyan
- Magenta
- Yellow
- Black
Constructors
| PixelCMYK16 !Pixel16 !Pixel16 !Pixel16 !Pixel16 |
Instances
Foreign unsafe import
Arguments
| :: (Pixel px, PixelBaseComponent px ~ Word8) | |
| => Int | Width in pixels |
| -> Int | Height in pixels |
| -> ForeignPtr Word8 | Pointer to the raw data |
| -> Image px |
Import a image from an unsafe pointer The pointer must have a size of width * height * componentCount px