Copyright	(c) Alexey Kuleshevich 2017
License	BSD3
Maintainer	Alexey Kuleshevich <lehins@yandex.ru>
Stability	experimental
Portability	non-portable
Safe Haskell	None
Language	Haskell2010

Graphics.Image.ColorSpace

Contents

Pixels
ColorSpace
Precision

Description

Synopsis

Pixels

Family of Pixels

Pixel is a type family for all available color spaces. Below is the listed of all class instances, that pixels are installed in, as well as all pixel constructors.

>>> :t (PixelY 0) -- Black pixel in Luma
(PixelY 0) :: Num e => Pixel Y e
>>> PixelRGB 255 0 0 :: Pixel RGB Word8 -- Red pixel in RGB
<RGB:(255|0|0)>
>>> PixelRGB 1 0 0 :: Pixel RGB Double -- Same red pixel in RGB with Double precision.
<RGB:(1.0|0.0|0.0)>
>>> (PixelRGB 255 0 0 :: Pixel RGB Word8) == (toWord8 <$> (PixelRGB 1 0 0 :: Pixel RGB Double))
True

data family Pixel cs e :: * #

A Pixel family with a color space and a precision of elements.

Instances

Array arr X Bit => Thresholding Pixel (Image arr) arr #
Methods (!==!) :: (Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Pixel cs e -> Image arr cs e -> Image arr cs Bit # (!/=!) :: (Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Pixel cs e -> Image arr cs e -> Image arr cs Bit # (!<!) :: (Ord e, Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Pixel cs e -> Image arr cs e -> Image arr cs Bit # (!<=!) :: (Ord e, Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Pixel cs e -> Image arr cs e -> Image arr cs Bit # (!>!) :: (Ord e, Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Pixel cs e -> Image arr cs e -> Image arr cs Bit # (!>=!) :: (Ord e, Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Pixel cs e -> Image arr cs e -> Image arr cs Bit # (.==.) :: (Array arr cs e, Array arr X Bit) => Pixel cs e -> Image arr cs e -> Image arr X Bit # (./=.) :: (Array arr cs e, Array arr X Bit) => Pixel cs e -> Image arr cs e -> Image arr X Bit # (.<.) :: (Ord (Pixel cs e), Array arr cs e, Array arr X Bit) => Pixel cs e -> Image arr cs e -> Image arr X Bit # (.<=.) :: (Ord (Pixel cs e), Array arr cs e, Array arr X Bit) => Pixel cs e -> Image arr cs e -> Image arr X Bit # (.>.) :: (Ord (Pixel cs e), Array arr cs e, Array arr X Bit) => Pixel cs e -> Image arr cs e -> Image arr X Bit # (.>=.) :: (Ord (Pixel cs e), Array arr cs e, Array arr X Bit) => Pixel cs e -> Image arr cs e -> Image arr X Bit #
Monad (Pixel Y) #
Methods (>>=) :: Pixel Y a -> (a -> Pixel Y b) -> Pixel Y b # (>>) :: Pixel Y a -> Pixel Y b -> Pixel Y b # return :: a -> Pixel Y a # fail :: String -> Pixel Y a #
Monad (Pixel X) #
Methods (>>=) :: Pixel X a -> (a -> Pixel X b) -> Pixel X b # (>>) :: Pixel X a -> Pixel X b -> Pixel X b # return :: a -> Pixel X a # fail :: String -> Pixel X a #
Functor (Pixel YCbCrA) #
Methods fmap :: (a -> b) -> Pixel YCbCrA a -> Pixel YCbCrA b # (<$) :: a -> Pixel YCbCrA b -> Pixel YCbCrA a #
Functor (Pixel YCbCr) #
Methods fmap :: (a -> b) -> Pixel YCbCr a -> Pixel YCbCr b # (<$) :: a -> Pixel YCbCr b -> Pixel YCbCr a #
Functor (Pixel YA) #
Methods fmap :: (a -> b) -> Pixel YA a -> Pixel YA b # (<$) :: a -> Pixel YA b -> Pixel YA a #
Functor (Pixel Y) #
Methods fmap :: (a -> b) -> Pixel Y a -> Pixel Y b # (<$) :: a -> Pixel Y b -> Pixel Y a #
Functor (Pixel X) #
Methods fmap :: (a -> b) -> Pixel X a -> Pixel X b # (<$) :: a -> Pixel X b -> Pixel X a #
Functor (Pixel RGBA) #
Methods fmap :: (a -> b) -> Pixel RGBA a -> Pixel RGBA b # (<$) :: a -> Pixel RGBA b -> Pixel RGBA a #
Functor (Pixel RGB) #
Methods fmap :: (a -> b) -> Pixel RGB a -> Pixel RGB b # (<$) :: a -> Pixel RGB b -> Pixel RGB a #
Functor (Pixel HSIA) #
Methods fmap :: (a -> b) -> Pixel HSIA a -> Pixel HSIA b # (<$) :: a -> Pixel HSIA b -> Pixel HSIA a #
Functor (Pixel HSI) #
Methods fmap :: (a -> b) -> Pixel HSI a -> Pixel HSI b # (<$) :: a -> Pixel HSI b -> Pixel HSI a #
Functor (Pixel CMYKA) #
Methods fmap :: (a -> b) -> Pixel CMYKA a -> Pixel CMYKA b # (<$) :: a -> Pixel CMYKA b -> Pixel CMYKA a #
Functor (Pixel CMYK) #
Methods fmap :: (a -> b) -> Pixel CMYK a -> Pixel CMYK b # (<$) :: a -> Pixel CMYK b -> Pixel CMYK a #
Applicative (Pixel YCbCrA) #
Methods pure :: a -> Pixel YCbCrA a # (<>) :: Pixel YCbCrA (a -> b) -> Pixel YCbCrA a -> Pixel YCbCrA b # (>) :: Pixel YCbCrA a -> Pixel YCbCrA b -> Pixel YCbCrA b # (<*) :: Pixel YCbCrA a -> Pixel YCbCrA b -> Pixel YCbCrA a #
Applicative (Pixel YCbCr) #
Methods pure :: a -> Pixel YCbCr a # (<>) :: Pixel YCbCr (a -> b) -> Pixel YCbCr a -> Pixel YCbCr b # (>) :: Pixel YCbCr a -> Pixel YCbCr b -> Pixel YCbCr b # (<*) :: Pixel YCbCr a -> Pixel YCbCr b -> Pixel YCbCr a #
Applicative (Pixel YA) #
Methods pure :: a -> Pixel YA a # (<>) :: Pixel YA (a -> b) -> Pixel YA a -> Pixel YA b # (>) :: Pixel YA a -> Pixel YA b -> Pixel YA b # (<*) :: Pixel YA a -> Pixel YA b -> Pixel YA a #
Applicative (Pixel Y) #
Methods pure :: a -> Pixel Y a # (<>) :: Pixel Y (a -> b) -> Pixel Y a -> Pixel Y b # (>) :: Pixel Y a -> Pixel Y b -> Pixel Y b # (<*) :: Pixel Y a -> Pixel Y b -> Pixel Y a #
Applicative (Pixel X) #
Methods pure :: a -> Pixel X a # (<>) :: Pixel X (a -> b) -> Pixel X a -> Pixel X b # (>) :: Pixel X a -> Pixel X b -> Pixel X b # (<*) :: Pixel X a -> Pixel X b -> Pixel X a #
Applicative (Pixel RGBA) #
Methods pure :: a -> Pixel RGBA a # (<>) :: Pixel RGBA (a -> b) -> Pixel RGBA a -> Pixel RGBA b # (>) :: Pixel RGBA a -> Pixel RGBA b -> Pixel RGBA b # (<*) :: Pixel RGBA a -> Pixel RGBA b -> Pixel RGBA a #
Applicative (Pixel RGB) #
Methods pure :: a -> Pixel RGB a # (<>) :: Pixel RGB (a -> b) -> Pixel RGB a -> Pixel RGB b # (>) :: Pixel RGB a -> Pixel RGB b -> Pixel RGB b # (<*) :: Pixel RGB a -> Pixel RGB b -> Pixel RGB a #
Applicative (Pixel HSIA) #
Methods pure :: a -> Pixel HSIA a # (<>) :: Pixel HSIA (a -> b) -> Pixel HSIA a -> Pixel HSIA b # (>) :: Pixel HSIA a -> Pixel HSIA b -> Pixel HSIA b # (<*) :: Pixel HSIA a -> Pixel HSIA b -> Pixel HSIA a #
Applicative (Pixel HSI) #
Methods pure :: a -> Pixel HSI a # (<>) :: Pixel HSI (a -> b) -> Pixel HSI a -> Pixel HSI b # (>) :: Pixel HSI a -> Pixel HSI b -> Pixel HSI b # (<*) :: Pixel HSI a -> Pixel HSI b -> Pixel HSI a #
Applicative (Pixel CMYKA) #
Methods pure :: a -> Pixel CMYKA a # (<>) :: Pixel CMYKA (a -> b) -> Pixel CMYKA a -> Pixel CMYKA b # (>) :: Pixel CMYKA a -> Pixel CMYKA b -> Pixel CMYKA b # (<*) :: Pixel CMYKA a -> Pixel CMYKA b -> Pixel CMYKA a #
Applicative (Pixel CMYK) #
Methods pure :: a -> Pixel CMYK a # (<>) :: Pixel CMYK (a -> b) -> Pixel CMYK a -> Pixel CMYK b # (>) :: Pixel CMYK a -> Pixel CMYK b -> Pixel CMYK b # (<*) :: Pixel CMYK a -> Pixel CMYK b -> Pixel CMYK a #
Foldable (Pixel YCbCrA) #
Methods fold :: Monoid m => Pixel YCbCrA m -> m # foldMap :: Monoid m => (a -> m) -> Pixel YCbCrA a -> m # foldr :: (a -> b -> b) -> b -> Pixel YCbCrA a -> b # foldr' :: (a -> b -> b) -> b -> Pixel YCbCrA a -> b # foldl :: (b -> a -> b) -> b -> Pixel YCbCrA a -> b # foldl' :: (b -> a -> b) -> b -> Pixel YCbCrA a -> b # foldr1 :: (a -> a -> a) -> Pixel YCbCrA a -> a # foldl1 :: (a -> a -> a) -> Pixel YCbCrA a -> a # toList :: Pixel YCbCrA a -> [a] # null :: Pixel YCbCrA a -> Bool # length :: Pixel YCbCrA a -> Int # elem :: Eq a => a -> Pixel YCbCrA a -> Bool # maximum :: Ord a => Pixel YCbCrA a -> a # minimum :: Ord a => Pixel YCbCrA a -> a # sum :: Num a => Pixel YCbCrA a -> a # product :: Num a => Pixel YCbCrA a -> a #
Foldable (Pixel YCbCr) #
Methods fold :: Monoid m => Pixel YCbCr m -> m # foldMap :: Monoid m => (a -> m) -> Pixel YCbCr a -> m # foldr :: (a -> b -> b) -> b -> Pixel YCbCr a -> b # foldr' :: (a -> b -> b) -> b -> Pixel YCbCr a -> b # foldl :: (b -> a -> b) -> b -> Pixel YCbCr a -> b # foldl' :: (b -> a -> b) -> b -> Pixel YCbCr a -> b # foldr1 :: (a -> a -> a) -> Pixel YCbCr a -> a # foldl1 :: (a -> a -> a) -> Pixel YCbCr a -> a # toList :: Pixel YCbCr a -> [a] # null :: Pixel YCbCr a -> Bool # length :: Pixel YCbCr a -> Int # elem :: Eq a => a -> Pixel YCbCr a -> Bool # maximum :: Ord a => Pixel YCbCr a -> a # minimum :: Ord a => Pixel YCbCr a -> a # sum :: Num a => Pixel YCbCr a -> a # product :: Num a => Pixel YCbCr a -> a #
Foldable (Pixel YA) #
Methods fold :: Monoid m => Pixel YA m -> m # foldMap :: Monoid m => (a -> m) -> Pixel YA a -> m # foldr :: (a -> b -> b) -> b -> Pixel YA a -> b # foldr' :: (a -> b -> b) -> b -> Pixel YA a -> b # foldl :: (b -> a -> b) -> b -> Pixel YA a -> b # foldl' :: (b -> a -> b) -> b -> Pixel YA a -> b # foldr1 :: (a -> a -> a) -> Pixel YA a -> a # foldl1 :: (a -> a -> a) -> Pixel YA a -> a # toList :: Pixel YA a -> [a] # null :: Pixel YA a -> Bool # length :: Pixel YA a -> Int # elem :: Eq a => a -> Pixel YA a -> Bool # maximum :: Ord a => Pixel YA a -> a # minimum :: Ord a => Pixel YA a -> a # sum :: Num a => Pixel YA a -> a # product :: Num a => Pixel YA a -> a #
Foldable (Pixel Y) #
Methods fold :: Monoid m => Pixel Y m -> m # foldMap :: Monoid m => (a -> m) -> Pixel Y a -> m # foldr :: (a -> b -> b) -> b -> Pixel Y a -> b # foldr' :: (a -> b -> b) -> b -> Pixel Y a -> b # foldl :: (b -> a -> b) -> b -> Pixel Y a -> b # foldl' :: (b -> a -> b) -> b -> Pixel Y a -> b # foldr1 :: (a -> a -> a) -> Pixel Y a -> a # foldl1 :: (a -> a -> a) -> Pixel Y a -> a # toList :: Pixel Y a -> [a] # null :: Pixel Y a -> Bool # length :: Pixel Y a -> Int # elem :: Eq a => a -> Pixel Y a -> Bool # maximum :: Ord a => Pixel Y a -> a # minimum :: Ord a => Pixel Y a -> a # sum :: Num a => Pixel Y a -> a # product :: Num a => Pixel Y a -> a #
Foldable (Pixel X) #
Methods fold :: Monoid m => Pixel X m -> m # foldMap :: Monoid m => (a -> m) -> Pixel X a -> m # foldr :: (a -> b -> b) -> b -> Pixel X a -> b # foldr' :: (a -> b -> b) -> b -> Pixel X a -> b # foldl :: (b -> a -> b) -> b -> Pixel X a -> b # foldl' :: (b -> a -> b) -> b -> Pixel X a -> b # foldr1 :: (a -> a -> a) -> Pixel X a -> a # foldl1 :: (a -> a -> a) -> Pixel X a -> a # toList :: Pixel X a -> [a] # null :: Pixel X a -> Bool # length :: Pixel X a -> Int # elem :: Eq a => a -> Pixel X a -> Bool # maximum :: Ord a => Pixel X a -> a # minimum :: Ord a => Pixel X a -> a # sum :: Num a => Pixel X a -> a # product :: Num a => Pixel X a -> a #
Foldable (Pixel RGBA) #
Methods fold :: Monoid m => Pixel RGBA m -> m # foldMap :: Monoid m => (a -> m) -> Pixel RGBA a -> m # foldr :: (a -> b -> b) -> b -> Pixel RGBA a -> b # foldr' :: (a -> b -> b) -> b -> Pixel RGBA a -> b # foldl :: (b -> a -> b) -> b -> Pixel RGBA a -> b # foldl' :: (b -> a -> b) -> b -> Pixel RGBA a -> b # foldr1 :: (a -> a -> a) -> Pixel RGBA a -> a # foldl1 :: (a -> a -> a) -> Pixel RGBA a -> a # toList :: Pixel RGBA a -> [a] # null :: Pixel RGBA a -> Bool # length :: Pixel RGBA a -> Int # elem :: Eq a => a -> Pixel RGBA a -> Bool # maximum :: Ord a => Pixel RGBA a -> a # minimum :: Ord a => Pixel RGBA a -> a # sum :: Num a => Pixel RGBA a -> a # product :: Num a => Pixel RGBA a -> a #
Foldable (Pixel RGB) #
Methods fold :: Monoid m => Pixel RGB m -> m # foldMap :: Monoid m => (a -> m) -> Pixel RGB a -> m # foldr :: (a -> b -> b) -> b -> Pixel RGB a -> b # foldr' :: (a -> b -> b) -> b -> Pixel RGB a -> b # foldl :: (b -> a -> b) -> b -> Pixel RGB a -> b # foldl' :: (b -> a -> b) -> b -> Pixel RGB a -> b # foldr1 :: (a -> a -> a) -> Pixel RGB a -> a # foldl1 :: (a -> a -> a) -> Pixel RGB a -> a # toList :: Pixel RGB a -> [a] # null :: Pixel RGB a -> Bool # length :: Pixel RGB a -> Int # elem :: Eq a => a -> Pixel RGB a -> Bool # maximum :: Ord a => Pixel RGB a -> a # minimum :: Ord a => Pixel RGB a -> a # sum :: Num a => Pixel RGB a -> a # product :: Num a => Pixel RGB a -> a #
Foldable (Pixel HSIA) #
Methods fold :: Monoid m => Pixel HSIA m -> m # foldMap :: Monoid m => (a -> m) -> Pixel HSIA a -> m # foldr :: (a -> b -> b) -> b -> Pixel HSIA a -> b # foldr' :: (a -> b -> b) -> b -> Pixel HSIA a -> b # foldl :: (b -> a -> b) -> b -> Pixel HSIA a -> b # foldl' :: (b -> a -> b) -> b -> Pixel HSIA a -> b # foldr1 :: (a -> a -> a) -> Pixel HSIA a -> a # foldl1 :: (a -> a -> a) -> Pixel HSIA a -> a # toList :: Pixel HSIA a -> [a] # null :: Pixel HSIA a -> Bool # length :: Pixel HSIA a -> Int # elem :: Eq a => a -> Pixel HSIA a -> Bool # maximum :: Ord a => Pixel HSIA a -> a # minimum :: Ord a => Pixel HSIA a -> a # sum :: Num a => Pixel HSIA a -> a # product :: Num a => Pixel HSIA a -> a #
Foldable (Pixel HSI) #
Methods fold :: Monoid m => Pixel HSI m -> m # foldMap :: Monoid m => (a -> m) -> Pixel HSI a -> m # foldr :: (a -> b -> b) -> b -> Pixel HSI a -> b # foldr' :: (a -> b -> b) -> b -> Pixel HSI a -> b # foldl :: (b -> a -> b) -> b -> Pixel HSI a -> b # foldl' :: (b -> a -> b) -> b -> Pixel HSI a -> b # foldr1 :: (a -> a -> a) -> Pixel HSI a -> a # foldl1 :: (a -> a -> a) -> Pixel HSI a -> a # toList :: Pixel HSI a -> [a] # null :: Pixel HSI a -> Bool # length :: Pixel HSI a -> Int # elem :: Eq a => a -> Pixel HSI a -> Bool # maximum :: Ord a => Pixel HSI a -> a # minimum :: Ord a => Pixel HSI a -> a # sum :: Num a => Pixel HSI a -> a # product :: Num a => Pixel HSI a -> a #
Foldable (Pixel CMYKA) #
Methods fold :: Monoid m => Pixel CMYKA m -> m # foldMap :: Monoid m => (a -> m) -> Pixel CMYKA a -> m # foldr :: (a -> b -> b) -> b -> Pixel CMYKA a -> b # foldr' :: (a -> b -> b) -> b -> Pixel CMYKA a -> b # foldl :: (b -> a -> b) -> b -> Pixel CMYKA a -> b # foldl' :: (b -> a -> b) -> b -> Pixel CMYKA a -> b # foldr1 :: (a -> a -> a) -> Pixel CMYKA a -> a # foldl1 :: (a -> a -> a) -> Pixel CMYKA a -> a # toList :: Pixel CMYKA a -> [a] # null :: Pixel CMYKA a -> Bool # length :: Pixel CMYKA a -> Int # elem :: Eq a => a -> Pixel CMYKA a -> Bool # maximum :: Ord a => Pixel CMYKA a -> a # minimum :: Ord a => Pixel CMYKA a -> a # sum :: Num a => Pixel CMYKA a -> a # product :: Num a => Pixel CMYKA a -> a #
Foldable (Pixel CMYK) #
Methods fold :: Monoid m => Pixel CMYK m -> m # foldMap :: Monoid m => (a -> m) -> Pixel CMYK a -> m # foldr :: (a -> b -> b) -> b -> Pixel CMYK a -> b # foldr' :: (a -> b -> b) -> b -> Pixel CMYK a -> b # foldl :: (b -> a -> b) -> b -> Pixel CMYK a -> b # foldl' :: (b -> a -> b) -> b -> Pixel CMYK a -> b # foldr1 :: (a -> a -> a) -> Pixel CMYK a -> a # foldl1 :: (a -> a -> a) -> Pixel CMYK a -> a # toList :: Pixel CMYK a -> [a] # null :: Pixel CMYK a -> Bool # length :: Pixel CMYK a -> Int # elem :: Eq a => a -> Pixel CMYK a -> Bool # maximum :: Ord a => Pixel CMYK a -> a # minimum :: Ord a => Pixel CMYK a -> a # sum :: Num a => Pixel CMYK a -> a # product :: Num a => Pixel CMYK a -> a #
Array arr X Bit => Thresholding (Image arr) Pixel arr #
Methods (!==!) :: (Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Image arr cs e -> Pixel cs e -> Image arr cs Bit # (!/=!) :: (Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Image arr cs e -> Pixel cs e -> Image arr cs Bit # (!<!) :: (Ord e, Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Image arr cs e -> Pixel cs e -> Image arr cs Bit # (!<=!) :: (Ord e, Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Image arr cs e -> Pixel cs e -> Image arr cs Bit # (!>!) :: (Ord e, Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Image arr cs e -> Pixel cs e -> Image arr cs Bit # (!>=!) :: (Ord e, Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Image arr cs e -> Pixel cs e -> Image arr cs Bit # (.==.) :: (Array arr cs e, Array arr X Bit) => Image arr cs e -> Pixel cs e -> Image arr X Bit # (./=.) :: (Array arr cs e, Array arr X Bit) => Image arr cs e -> Pixel cs e -> Image arr X Bit # (.<.) :: (Ord (Pixel cs e), Array arr cs e, Array arr X Bit) => Image arr cs e -> Pixel cs e -> Image arr X Bit # (.<=.) :: (Ord (Pixel cs e), Array arr cs e, Array arr X Bit) => Image arr cs e -> Pixel cs e -> Image arr X Bit # (.>.) :: (Ord (Pixel cs e), Array arr cs e, Array arr X Bit) => Image arr cs e -> Pixel cs e -> Image arr X Bit # (.>=.) :: (Ord (Pixel cs e), Array arr cs e, Array arr X Bit) => Image arr cs e -> Pixel cs e -> Image arr X Bit #
(ColorSpace cs e, Bounded e) => Bounded (Pixel cs e) #
Methods minBound :: Pixel cs e # maxBound :: Pixel cs e #
Eq e => Eq (Pixel YCbCrA e) #
Methods (==) :: Pixel YCbCrA e -> Pixel YCbCrA e -> Bool # (/=) :: Pixel YCbCrA e -> Pixel YCbCrA e -> Bool #
Eq e => Eq (Pixel YCbCr e) #
Methods (==) :: Pixel YCbCr e -> Pixel YCbCr e -> Bool # (/=) :: Pixel YCbCr e -> Pixel YCbCr e -> Bool #
Eq e => Eq (Pixel YA e) #
Methods (==) :: Pixel YA e -> Pixel YA e -> Bool # (/=) :: Pixel YA e -> Pixel YA e -> Bool #
Eq e => Eq (Pixel Y e) #
Methods (==) :: Pixel Y e -> Pixel Y e -> Bool # (/=) :: Pixel Y e -> Pixel Y e -> Bool #
Eq e => Eq (Pixel X e) #
Methods (==) :: Pixel X e -> Pixel X e -> Bool # (/=) :: Pixel X e -> Pixel X e -> Bool #
Eq e => Eq (Pixel RGBA e) #
Methods (==) :: Pixel RGBA e -> Pixel RGBA e -> Bool # (/=) :: Pixel RGBA e -> Pixel RGBA e -> Bool #
Eq e => Eq (Pixel RGB e) #
Methods (==) :: Pixel RGB e -> Pixel RGB e -> Bool # (/=) :: Pixel RGB e -> Pixel RGB e -> Bool #
Eq e => Eq (Pixel HSIA e) #
Methods (==) :: Pixel HSIA e -> Pixel HSIA e -> Bool # (/=) :: Pixel HSIA e -> Pixel HSIA e -> Bool #
Eq e => Eq (Pixel HSI e) #
Methods (==) :: Pixel HSI e -> Pixel HSI e -> Bool # (/=) :: Pixel HSI e -> Pixel HSI e -> Bool #
Eq e => Eq (Pixel CMYKA e) #
Methods (==) :: Pixel CMYKA e -> Pixel CMYKA e -> Bool # (/=) :: Pixel CMYKA e -> Pixel CMYKA e -> Bool #
Eq e => Eq (Pixel CMYK e) #
Methods (==) :: Pixel CMYK e -> Pixel CMYK e -> Bool # (/=) :: Pixel CMYK e -> Pixel CMYK e -> Bool #
(ColorSpace cs e, Floating e) => Floating (Pixel cs e) #
Methods pi :: Pixel cs e # exp :: Pixel cs e -> Pixel cs e # log :: Pixel cs e -> Pixel cs e # sqrt :: Pixel cs e -> Pixel cs e # (**) :: Pixel cs e -> Pixel cs e -> Pixel cs e # logBase :: Pixel cs e -> Pixel cs e -> Pixel cs e # sin :: Pixel cs e -> Pixel cs e # cos :: Pixel cs e -> Pixel cs e # tan :: Pixel cs e -> Pixel cs e # asin :: Pixel cs e -> Pixel cs e # acos :: Pixel cs e -> Pixel cs e # atan :: Pixel cs e -> Pixel cs e # sinh :: Pixel cs e -> Pixel cs e # cosh :: Pixel cs e -> Pixel cs e # tanh :: Pixel cs e -> Pixel cs e # asinh :: Pixel cs e -> Pixel cs e # acosh :: Pixel cs e -> Pixel cs e # atanh :: Pixel cs e -> Pixel cs e # log1p :: Pixel cs e -> Pixel cs e # expm1 :: Pixel cs e -> Pixel cs e # log1pexp :: Pixel cs e -> Pixel cs e # log1mexp :: Pixel cs e -> Pixel cs e #
(ColorSpace cs e, Fractional e) => Fractional (Pixel cs e) #
Methods (/) :: Pixel cs e -> Pixel cs e -> Pixel cs e # recip :: Pixel cs e -> Pixel cs e # fromRational :: Rational -> Pixel cs e #
ColorSpace cs e => Num (Pixel cs e) #
Methods (+) :: Pixel cs e -> Pixel cs e -> Pixel cs e # (-) :: Pixel cs e -> Pixel cs e -> Pixel cs e # (*) :: Pixel cs e -> Pixel cs e -> Pixel cs e # negate :: Pixel cs e -> Pixel cs e # abs :: Pixel cs e -> Pixel cs e # signum :: Pixel cs e -> Pixel cs e # fromInteger :: Integer -> Pixel cs e #
Ord e => Ord (Pixel Y e) #
Methods compare :: Pixel Y e -> Pixel Y e -> Ordering # (<) :: Pixel Y e -> Pixel Y e -> Bool # (<=) :: Pixel Y e -> Pixel Y e -> Bool # (>) :: Pixel Y e -> Pixel Y e -> Bool # (>=) :: Pixel Y e -> Pixel Y e -> Bool # max :: Pixel Y e -> Pixel Y e -> Pixel Y e # min :: Pixel Y e -> Pixel Y e -> Pixel Y e #
Ord e => Ord (Pixel X e) #
Methods compare :: Pixel X e -> Pixel X e -> Ordering # (<) :: Pixel X e -> Pixel X e -> Bool # (<=) :: Pixel X e -> Pixel X e -> Bool # (>) :: Pixel X e -> Pixel X e -> Bool # (>=) :: Pixel X e -> Pixel X e -> Bool # max :: Pixel X e -> Pixel X e -> Pixel X e # min :: Pixel X e -> Pixel X e -> Pixel X e #
Show e => Show (Pixel YCbCrA e) #
Methods showsPrec :: Int -> Pixel YCbCrA e -> ShowS # show :: Pixel YCbCrA e -> String # showList :: [Pixel YCbCrA e] -> ShowS #
Show e => Show (Pixel YCbCr e) #
Methods showsPrec :: Int -> Pixel YCbCr e -> ShowS # show :: Pixel YCbCr e -> String # showList :: [Pixel YCbCr e] -> ShowS #
Show e => Show (Pixel YA e) #
Methods showsPrec :: Int -> Pixel YA e -> ShowS # show :: Pixel YA e -> String # showList :: [Pixel YA e] -> ShowS #
Show e => Show (Pixel Y e) #
Methods showsPrec :: Int -> Pixel Y e -> ShowS # show :: Pixel Y e -> String # showList :: [Pixel Y e] -> ShowS #
Show e => Show (Pixel X e) #
Methods showsPrec :: Int -> Pixel X e -> ShowS # show :: Pixel X e -> String # showList :: [Pixel X e] -> ShowS #
Show e => Show (Pixel RGBA e) #
Methods showsPrec :: Int -> Pixel RGBA e -> ShowS # show :: Pixel RGBA e -> String # showList :: [Pixel RGBA e] -> ShowS #
Show e => Show (Pixel RGB e) #
Methods showsPrec :: Int -> Pixel RGB e -> ShowS # show :: Pixel RGB e -> String # showList :: [Pixel RGB e] -> ShowS #
Show e => Show (Pixel HSIA e) #
Methods showsPrec :: Int -> Pixel HSIA e -> ShowS # show :: Pixel HSIA e -> String # showList :: [Pixel HSIA e] -> ShowS #
Show e => Show (Pixel HSI e) #
Methods showsPrec :: Int -> Pixel HSI e -> ShowS # show :: Pixel HSI e -> String # showList :: [Pixel HSI e] -> ShowS #
Show e => Show (Pixel CMYKA e) #
Methods showsPrec :: Int -> Pixel CMYKA e -> ShowS # show :: Pixel CMYKA e -> String # showList :: [Pixel CMYKA e] -> ShowS #
Show e => Show (Pixel CMYK e) #
Methods showsPrec :: Int -> Pixel CMYK e -> ShowS # show :: Pixel CMYK e -> String # showList :: [Pixel CMYK e] -> ShowS #
Storable e => Storable (Pixel YCbCrA e) #
Methods sizeOf :: Pixel YCbCrA e -> Int # alignment :: Pixel YCbCrA e -> Int # peekElemOff :: Ptr (Pixel YCbCrA e) -> Int -> IO (Pixel YCbCrA e) # pokeElemOff :: Ptr (Pixel YCbCrA e) -> Int -> Pixel YCbCrA e -> IO () # peekByteOff :: Ptr b -> Int -> IO (Pixel YCbCrA e) # pokeByteOff :: Ptr b -> Int -> Pixel YCbCrA e -> IO () # peek :: Ptr (Pixel YCbCrA e) -> IO (Pixel YCbCrA e) # poke :: Ptr (Pixel YCbCrA e) -> Pixel YCbCrA e -> IO () #
Storable e => Storable (Pixel YCbCr e) #
Methods sizeOf :: Pixel YCbCr e -> Int # alignment :: Pixel YCbCr e -> Int # peekElemOff :: Ptr (Pixel YCbCr e) -> Int -> IO (Pixel YCbCr e) # pokeElemOff :: Ptr (Pixel YCbCr e) -> Int -> Pixel YCbCr e -> IO () # peekByteOff :: Ptr b -> Int -> IO (Pixel YCbCr e) # pokeByteOff :: Ptr b -> Int -> Pixel YCbCr e -> IO () # peek :: Ptr (Pixel YCbCr e) -> IO (Pixel YCbCr e) # poke :: Ptr (Pixel YCbCr e) -> Pixel YCbCr e -> IO () #
Storable e => Storable (Pixel YA e) #
Methods sizeOf :: Pixel YA e -> Int # alignment :: Pixel YA e -> Int # peekElemOff :: Ptr (Pixel YA e) -> Int -> IO (Pixel YA e) # pokeElemOff :: Ptr (Pixel YA e) -> Int -> Pixel YA e -> IO () # peekByteOff :: Ptr b -> Int -> IO (Pixel YA e) # pokeByteOff :: Ptr b -> Int -> Pixel YA e -> IO () # peek :: Ptr (Pixel YA e) -> IO (Pixel YA e) # poke :: Ptr (Pixel YA e) -> Pixel YA e -> IO () #
Storable e => Storable (Pixel Y e) #
Methods sizeOf :: Pixel Y e -> Int # alignment :: Pixel Y e -> Int # peekElemOff :: Ptr (Pixel Y e) -> Int -> IO (Pixel Y e) # pokeElemOff :: Ptr (Pixel Y e) -> Int -> Pixel Y e -> IO () # peekByteOff :: Ptr b -> Int -> IO (Pixel Y e) # pokeByteOff :: Ptr b -> Int -> Pixel Y e -> IO () # peek :: Ptr (Pixel Y e) -> IO (Pixel Y e) # poke :: Ptr (Pixel Y e) -> Pixel Y e -> IO () #
Storable e => Storable (Pixel X e) #
Methods sizeOf :: Pixel X e -> Int # alignment :: Pixel X e -> Int # peekElemOff :: Ptr (Pixel X e) -> Int -> IO (Pixel X e) # pokeElemOff :: Ptr (Pixel X e) -> Int -> Pixel X e -> IO () # peekByteOff :: Ptr b -> Int -> IO (Pixel X e) # pokeByteOff :: Ptr b -> Int -> Pixel X e -> IO () # peek :: Ptr (Pixel X e) -> IO (Pixel X e) # poke :: Ptr (Pixel X e) -> Pixel X e -> IO () #
Storable e => Storable (Pixel RGBA e) #
Methods sizeOf :: Pixel RGBA e -> Int # alignment :: Pixel RGBA e -> Int # peekElemOff :: Ptr (Pixel RGBA e) -> Int -> IO (Pixel RGBA e) # pokeElemOff :: Ptr (Pixel RGBA e) -> Int -> Pixel RGBA e -> IO () # peekByteOff :: Ptr b -> Int -> IO (Pixel RGBA e) # pokeByteOff :: Ptr b -> Int -> Pixel RGBA e -> IO () # peek :: Ptr (Pixel RGBA e) -> IO (Pixel RGBA e) # poke :: Ptr (Pixel RGBA e) -> Pixel RGBA e -> IO () #
Storable e => Storable (Pixel RGB e) #
Methods sizeOf :: Pixel RGB e -> Int # alignment :: Pixel RGB e -> Int # peekElemOff :: Ptr (Pixel RGB e) -> Int -> IO (Pixel RGB e) # pokeElemOff :: Ptr (Pixel RGB e) -> Int -> Pixel RGB e -> IO () # peekByteOff :: Ptr b -> Int -> IO (Pixel RGB e) # pokeByteOff :: Ptr b -> Int -> Pixel RGB e -> IO () # peek :: Ptr (Pixel RGB e) -> IO (Pixel RGB e) # poke :: Ptr (Pixel RGB e) -> Pixel RGB e -> IO () #
Storable e => Storable (Pixel HSIA e) #
Methods sizeOf :: Pixel HSIA e -> Int # alignment :: Pixel HSIA e -> Int # peekElemOff :: Ptr (Pixel HSIA e) -> Int -> IO (Pixel HSIA e) # pokeElemOff :: Ptr (Pixel HSIA e) -> Int -> Pixel HSIA e -> IO () # peekByteOff :: Ptr b -> Int -> IO (Pixel HSIA e) # pokeByteOff :: Ptr b -> Int -> Pixel HSIA e -> IO () # peek :: Ptr (Pixel HSIA e) -> IO (Pixel HSIA e) # poke :: Ptr (Pixel HSIA e) -> Pixel HSIA e -> IO () #
Storable e => Storable (Pixel HSI e) #
Methods sizeOf :: Pixel HSI e -> Int # alignment :: Pixel HSI e -> Int # peekElemOff :: Ptr (Pixel HSI e) -> Int -> IO (Pixel HSI e) # pokeElemOff :: Ptr (Pixel HSI e) -> Int -> Pixel HSI e -> IO () # peekByteOff :: Ptr b -> Int -> IO (Pixel HSI e) # pokeByteOff :: Ptr b -> Int -> Pixel HSI e -> IO () # peek :: Ptr (Pixel HSI e) -> IO (Pixel HSI e) # poke :: Ptr (Pixel HSI e) -> Pixel HSI e -> IO () #
Storable e => Storable (Pixel CMYKA e) #
Methods sizeOf :: Pixel CMYKA e -> Int # alignment :: Pixel CMYKA e -> Int # peekElemOff :: Ptr (Pixel CMYKA e) -> Int -> IO (Pixel CMYKA e) # pokeElemOff :: Ptr (Pixel CMYKA e) -> Int -> Pixel CMYKA e -> IO () # peekByteOff :: Ptr b -> Int -> IO (Pixel CMYKA e) # pokeByteOff :: Ptr b -> Int -> Pixel CMYKA e -> IO () # peek :: Ptr (Pixel CMYKA e) -> IO (Pixel CMYKA e) # poke :: Ptr (Pixel CMYKA e) -> Pixel CMYKA e -> IO () #
Storable e => Storable (Pixel CMYK e) #
Methods sizeOf :: Pixel CMYK e -> Int # alignment :: Pixel CMYK e -> Int # peekElemOff :: Ptr (Pixel CMYK e) -> Int -> IO (Pixel CMYK e) # pokeElemOff :: Ptr (Pixel CMYK e) -> Int -> Pixel CMYK e -> IO () # peekByteOff :: Ptr b -> Int -> IO (Pixel CMYK e) # pokeByteOff :: Ptr b -> Int -> Pixel CMYK e -> IO () # peek :: Ptr (Pixel CMYK e) -> IO (Pixel CMYK e) # poke :: Ptr (Pixel CMYK e) -> Pixel CMYK e -> IO () #
Bits (Pixel X Bit) #
Methods (.&.) :: Pixel X Bit -> Pixel X Bit -> Pixel X Bit # (.\|.) :: Pixel X Bit -> Pixel X Bit -> Pixel X Bit # xor :: Pixel X Bit -> Pixel X Bit -> Pixel X Bit # complement :: Pixel X Bit -> Pixel X Bit # shift :: Pixel X Bit -> Int -> Pixel X Bit # rotate :: Pixel X Bit -> Int -> Pixel X Bit # zeroBits :: Pixel X Bit # bit :: Int -> Pixel X Bit # setBit :: Pixel X Bit -> Int -> Pixel X Bit # clearBit :: Pixel X Bit -> Int -> Pixel X Bit # complementBit :: Pixel X Bit -> Int -> Pixel X Bit # testBit :: Pixel X Bit -> Int -> Bool # bitSizeMaybe :: Pixel X Bit -> Maybe Int # bitSize :: Pixel X Bit -> Int # isSigned :: Pixel X Bit -> Bool # shiftL :: Pixel X Bit -> Int -> Pixel X Bit # unsafeShiftL :: Pixel X Bit -> Int -> Pixel X Bit # shiftR :: Pixel X Bit -> Int -> Pixel X Bit # unsafeShiftR :: Pixel X Bit -> Int -> Pixel X Bit # rotateL :: Pixel X Bit -> Int -> Pixel X Bit # rotateR :: Pixel X Bit -> Int -> Pixel X Bit # popCount :: Pixel X Bit -> Int #
(Foldable (Pixel cs), NFData e) => NFData (Pixel cs e) #
Methods rnf :: Pixel cs e -> () #
data Pixel YCbCrA #
data Pixel YCbCrA = PixelYCbCrA !e !e !e !e
data Pixel YCbCr #
data Pixel YCbCr = PixelYCbCr !e !e !e
data Pixel YA #
data Pixel YA = PixelYA !e !e
data Pixel Y #
data Pixel Y = PixelY e
data Pixel X #
data Pixel X = PixelX { getX :: e }
data Pixel RGBA #
data Pixel RGBA = PixelRGBA !e !e !e !e
data Pixel RGB #
data Pixel RGB = PixelRGB !e !e !e
data Pixel HSIA #
data Pixel HSIA = PixelHSIA !e !e !e !e
data Pixel HSI #
data Pixel HSI = PixelHSI !e !e !e
data Pixel CMYKA #
data Pixel CMYKA = PixelCMYKA !e !e !e !e !e
data Pixel CMYK #
data Pixel CMYK = PixelCMYK !e !e !e !e
data MVector s (Pixel cs e) #
data MVector s (Pixel cs e) = MV_Pixel (MVector s (Components cs e))
data Vector (Pixel cs e) #
data Vector (Pixel cs e) = V_Pixel (Vector (Components cs e))

Luma (gray scale)

Conversion to Luma from other color spaces.

toPixelY :: ToY cs e => Pixel cs e -> Pixel Y Double #

Convert a pixel to Luma pixel.

toImageY :: (ToY cs e, Array arr cs e, Array arr Y Double) => Image arr cs e -> Image arr Y Double #

Convert an image to Luma image.

toPixelYA :: ToYA cs e => Pixel cs e -> Pixel YA Double #

Convert a pixel to Luma pixel with Alpha.

toImageYA :: (ToYA cs e, Array arr cs e, Array arr YA Double) => Image arr cs e -> Image arr YA Double #

Convert an image to Luma image with Alpha.

RGB

Conversion to RGB from other color spaces.

toPixelRGB :: ToRGB cs e => Pixel cs e -> Pixel RGB Double #

Convert to an RGB pixel.

toImageRGB :: (ToRGB cs e, Array arr cs e, Array arr RGB Double) => Image arr cs e -> Image arr RGB Double #

Convert to an RGB image.

toPixelRGBA :: ToRGBA cs e => Pixel cs e -> Pixel RGBA Double #

Convert to an RGBA pixel.

toImageRGBA :: (ToRGBA cs e, Array arr cs e, Array arr RGBA Double) => Image arr cs e -> Image arr RGBA Double #

Convert to an RGBA image.

HSI

Conversion to HSI from other color spaces.

toPixelHSI :: ToHSI cs e => Pixel cs e -> Pixel HSI Double #

Convert to an HSI pixel.

toImageHSI :: (ToHSI cs e, Array arr cs e, Array arr HSI Double) => Image arr cs e -> Image arr HSI Double #

Convert to an HSI image.

toPixelHSIA :: ToHSIA cs e => Pixel cs e -> Pixel HSIA Double #

Convert to an HSIA pixel.

toImageHSIA :: (ToHSIA cs e, Array arr cs e, Array arr HSIA Double) => Image arr cs e -> Image arr HSIA Double #

Convert to an HSIA image.

CMYK

Conversion to CMYK from other color spaces.

toPixelCMYK :: ToCMYK cs e => Pixel cs e -> Pixel CMYK Double #

Convert to a CMYK pixel.

toImageCMYK :: (ToCMYK cs e, Array arr cs e, Array arr CMYK Double) => Image arr cs e -> Image arr CMYK Double #

Convert to a CMYK image.

toPixelCMYKA :: ToCMYKA cs e => Pixel cs e -> Pixel CMYKA Double #

Convert to a CMYKA pixel.

toImageCMYKA :: (ToCMYKA cs e, Array arr cs e, Array arr CMYKA Double) => Image arr cs e -> Image arr CMYKA Double #

Convert to a CMYKA image.

YCbCr

Conversion to YCbCr from other color spaces.

toPixelYCbCr :: ToYCbCr cs e => Pixel cs e -> Pixel YCbCr Double #

Convert to an YCbCr pixel.

toImageYCbCr :: (ToYCbCr cs e, Array arr cs e, Array arr YCbCr Double) => Image arr cs e -> Image arr YCbCr Double #

Convert to an YCbCr image.

toPixelYCbCrA :: ToYCbCrA cs e => Pixel cs e -> Pixel YCbCrA Double #

Convert to an YCbCrA pixel.

toImageYCbCrA :: (ToYCbCrA cs e, Array arr cs e, Array arr YCbCrA Double) => Image arr cs e -> Image arr YCbCrA Double #

Convert to an YCbCrA image.

Binary

This is a Binary colorspace, pixel's of which can be created using these constructors:

on: Represents value 1 or True. It's a foreground pixel and is displayed in black.
off: Represents value 0 or False. It's a background pixel and is displayed in white.

Note, that values are inverted before writing to or reading from file, since grayscale images represent black as a 0 value and white as 1 on a [0,1] scale.

Binary pixels also behave as binary numbers with a size of 1-bit, for instance:

>>> on + on -- equivalent to: 1 .|. 1
<Binary:(1)>
>>> (on + on) * off -- equivalent to: (1 .|. 1) .&. 0
<Binary:(0)>
>>> (on + on) - on
<Binary:(0)>

toPixelBinary :: ColorSpace cs e => Pixel cs e -> Pixel X Bit #

Convert to a Binary pixel.

fromPixelBinary :: Pixel X Bit -> Pixel Y Word8 #

Convert a Binary pixel to Luma pixel

toImageBinary :: (Array arr cs e, Array arr X Bit) => Image arr cs e -> Image arr X Bit #

Convert to a Binary image.

fromImageBinary :: (Array arr X Bit, Array arr Y Word8) => Image arr X Bit -> Image arr Y Word8 #

Convert a Binary image to Luma image

newtype Bit #

Under the hood, binary pixels are represented as Word8, but can only take values of 0 or 1. Use zero/one to construct a bit and on/off to construct a binary pixel.

Constructors

Bit Word8

Instances

Eq Bit #
Methods (==) :: Bit -> Bit -> Bool # (/=) :: Bit -> Bit -> Bool #
Num Bit #
Methods (+) :: Bit -> Bit -> Bit # (-) :: Bit -> Bit -> Bit # (*) :: Bit -> Bit -> Bit # negate :: Bit -> Bit # abs :: Bit -> Bit # signum :: Bit -> Bit # fromInteger :: Integer -> Bit #
Ord Bit #
Methods compare :: Bit -> Bit -> Ordering # (<) :: Bit -> Bit -> Bool # (<=) :: Bit -> Bit -> Bool # (>) :: Bit -> Bit -> Bool # (>=) :: Bit -> Bit -> Bool # max :: Bit -> Bit -> Bit # min :: Bit -> Bit -> Bit #
Show Bit #
Methods showsPrec :: Int -> Bit -> ShowS # show :: Bit -> String # showList :: [Bit] -> ShowS #
Storable Bit #
Methods sizeOf :: Bit -> Int # alignment :: Bit -> Int # peekElemOff :: Ptr Bit -> Int -> IO Bit # pokeElemOff :: Ptr Bit -> Int -> Bit -> IO () # peekByteOff :: Ptr b -> Int -> IO Bit # pokeByteOff :: Ptr b -> Int -> Bit -> IO () # peek :: Ptr Bit -> IO Bit # poke :: Ptr Bit -> Bit -> IO () #
Bits Bit #
Methods (.&.) :: Bit -> Bit -> Bit # (.\|.) :: Bit -> Bit -> Bit # xor :: Bit -> Bit -> Bit # complement :: Bit -> Bit # shift :: Bit -> Int -> Bit # rotate :: Bit -> Int -> Bit # zeroBits :: Bit # bit :: Int -> Bit # setBit :: Bit -> Int -> Bit # clearBit :: Bit -> Int -> Bit # complementBit :: Bit -> Int -> Bit # testBit :: Bit -> Int -> Bool # bitSizeMaybe :: Bit -> Maybe Int # bitSize :: Bit -> Int # isSigned :: Bit -> Bool # shiftL :: Bit -> Int -> Bit # unsafeShiftL :: Bit -> Int -> Bit # shiftR :: Bit -> Int -> Bit # unsafeShiftR :: Bit -> Int -> Bit # rotateL :: Bit -> Int -> Bit # rotateR :: Bit -> Int -> Bit # popCount :: Bit -> Int #
Unbox Bit #	Unboxing of a `Bit`.

Elevator Bit #	Values: `0` and `1`
Methods toWord8 :: Bit -> Word8 # toWord16 :: Bit -> Word16 # toWord32 :: Bit -> Word32 # toWord64 :: Bit -> Word64 # toFloat :: Bit -> Float # toDouble :: Bit -> Double # fromDouble :: Double -> Bit #
Vector Vector Bit #
Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Bit -> m (Vector Bit) # basicUnsafeThaw :: PrimMonad m => Vector Bit -> m (Mutable Vector (PrimState m) Bit) # basicLength :: Vector Bit -> Int # basicUnsafeSlice :: Int -> Int -> Vector Bit -> Vector Bit # basicUnsafeIndexM :: Monad m => Vector Bit -> Int -> m Bit # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Bit -> Vector Bit -> m () # elemseq :: Vector Bit -> Bit -> b -> b #
MVector MVector Bit #
Methods basicLength :: MVector s Bit -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Bit -> MVector s Bit # basicOverlaps :: MVector s Bit -> MVector s Bit -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Bit) # basicInitialize :: PrimMonad m => MVector (PrimState m) Bit -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Bit -> m (MVector (PrimState m) Bit) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Bit -> Int -> m Bit # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Bit -> Int -> Bit -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Bit -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Bit -> Bit -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Bit -> MVector (PrimState m) Bit -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Bit -> MVector (PrimState m) Bit -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Bit -> Int -> m (MVector (PrimState m) Bit) #
ToRGBA X Bit #
Methods toPixelRGBA :: Pixel X Bit -> Pixel RGBA Double #
ToRGB X Bit #
Methods toPixelRGB :: Pixel X Bit -> Pixel RGB Double #
ToYA X Bit #
Methods toPixelYA :: Pixel X Bit -> Pixel YA Double #
Readable [Image VS X Bit] (Seq PBM) #
Methods decode :: Seq PBM -> ByteString -> Either String [Image VS X Bit] #
Bits (Pixel X Bit) #
Methods (.&.) :: Pixel X Bit -> Pixel X Bit -> Pixel X Bit # (.\|.) :: Pixel X Bit -> Pixel X Bit -> Pixel X Bit # xor :: Pixel X Bit -> Pixel X Bit -> Pixel X Bit # complement :: Pixel X Bit -> Pixel X Bit # shift :: Pixel X Bit -> Int -> Pixel X Bit # rotate :: Pixel X Bit -> Int -> Pixel X Bit # zeroBits :: Pixel X Bit # bit :: Int -> Pixel X Bit # setBit :: Pixel X Bit -> Int -> Pixel X Bit # clearBit :: Pixel X Bit -> Int -> Pixel X Bit # complementBit :: Pixel X Bit -> Int -> Pixel X Bit # testBit :: Pixel X Bit -> Int -> Bool # bitSizeMaybe :: Pixel X Bit -> Maybe Int # bitSize :: Pixel X Bit -> Int # isSigned :: Pixel X Bit -> Bool # shiftL :: Pixel X Bit -> Int -> Pixel X Bit # unsafeShiftL :: Pixel X Bit -> Int -> Pixel X Bit # shiftR :: Pixel X Bit -> Int -> Pixel X Bit # unsafeShiftR :: Pixel X Bit -> Int -> Pixel X Bit # rotateL :: Pixel X Bit -> Int -> Pixel X Bit # rotateR :: Pixel X Bit -> Int -> Pixel X Bit # popCount :: Pixel X Bit -> Int #
Writable (Image VS X Bit) TIF #
Methods encode :: TIF -> [SaveOption TIF] -> Image VS X Bit -> ByteString #
Writable (Image VS X Bit) TGA #
Methods encode :: TGA -> [SaveOption TGA] -> Image VS X Bit -> ByteString #
Writable (Image VS X Bit) PNG #
Methods encode :: PNG -> [SaveOption PNG] -> Image VS X Bit -> ByteString #
Writable (Image VS X Bit) BMP #
Methods encode :: BMP -> [SaveOption BMP] -> Image VS X Bit -> ByteString #
Readable (Image VS X Bit) TIF #
Methods decode :: TIF -> ByteString -> Either String (Image VS X Bit) #
Readable (Image VS X Bit) TGA #
Methods decode :: TGA -> ByteString -> Either String (Image VS X Bit) #
Readable (Image VS X Bit) PNG #
Methods decode :: PNG -> ByteString -> Either String (Image VS X Bit) #
Readable (Image VS X Bit) BMP #
Methods decode :: BMP -> ByteString -> Either String (Image VS X Bit) #
Readable (Image VS X Bit) PBM #
Methods decode :: PBM -> ByteString -> Either String (Image VS X Bit) #
data Vector Bit #
data Vector Bit = V_Bit (Vector Word8)
data MVector s Bit #
data MVector s Bit = MV_Bit (MVector s Word8)

on :: Pixel X Bit #

Represents value True or 1 in binary. Often also called a foreground pixel of an object.

off :: Pixel X Bit #

Represents value False or 0 in binary. Often also called a background pixel.

isOn :: Pixel X Bit -> Bool #

Test if Pixel's value is on.

isOff :: Pixel X Bit -> Bool #

Test if Pixel's value is off.

fromBool :: Bool -> Pixel X Bit #

Convert a Bool to a binary pixel.

>>> isOn (fromBool True)
True

zero :: Bit #

one :: Bit #

bit2bool :: Bit -> Bool #

bool2bit :: Bool -> Bit #

toNum :: Num a => Bit -> a #

fromNum :: (Eq a, Num a) => a -> Bit #

Complex

Rectangular form

data Complex a :: * -> * #

Complex numbers are an algebraic type.

For a complex number z, abs z is a number with the magnitude of z, but oriented in the positive real direction, whereas signum z has the phase of z, but unit magnitude.

The Foldable and Traversable instances traverse the real part first.

Constructors

~a :+ ~a infix 6

forms a complex number from its real and imaginary rectangular components.

Instances

Monad Complex
Methods (>>=) :: Complex a -> (a -> Complex b) -> Complex b # (>>) :: Complex a -> Complex b -> Complex b # return :: a -> Complex a # fail :: String -> Complex a #
Functor Complex
Methods fmap :: (a -> b) -> Complex a -> Complex b # (<$) :: a -> Complex b -> Complex a #
Applicative Complex
Methods pure :: a -> Complex a # (<>) :: Complex (a -> b) -> Complex a -> Complex b # (>) :: Complex a -> Complex b -> Complex b # (<*) :: Complex a -> Complex b -> Complex a #
Foldable Complex
Methods fold :: Monoid m => Complex m -> m # foldMap :: Monoid m => (a -> m) -> Complex a -> m # foldr :: (a -> b -> b) -> b -> Complex a -> b # foldr' :: (a -> b -> b) -> b -> Complex a -> b # foldl :: (b -> a -> b) -> b -> Complex a -> b # foldl' :: (b -> a -> b) -> b -> Complex a -> b # foldr1 :: (a -> a -> a) -> Complex a -> a # foldl1 :: (a -> a -> a) -> Complex a -> a # toList :: Complex a -> [a] # null :: Complex a -> Bool # length :: Complex a -> Int # elem :: Eq a => a -> Complex a -> Bool # maximum :: Ord a => Complex a -> a # minimum :: Ord a => Complex a -> a # sum :: Num a => Complex a -> a # product :: Num a => Complex a -> a #
Traversable Complex
Methods traverse :: Applicative f => (a -> f b) -> Complex a -> f (Complex b) # sequenceA :: Applicative f => Complex (f a) -> f (Complex a) # mapM :: Monad m => (a -> m b) -> Complex a -> m (Complex b) # sequence :: Monad m => Complex (m a) -> m (Complex a) #
Generic1 Complex
Associated Types type Rep1 (Complex :: * -> ) :: -> * # Methods from1 :: Complex a -> Rep1 Complex a # to1 :: Rep1 Complex a -> Complex a #
Representable Complex
Associated Types type Rep (Complex :: * -> ) :: # Methods tabulate :: (Rep Complex -> a) -> Complex a # index :: Complex a -> Rep Complex -> a #
Additive Complex
Methods zero :: Num a => Complex a # (^+^) :: Num a => Complex a -> Complex a -> Complex a # (^-^) :: Num a => Complex a -> Complex a -> Complex a # lerp :: Num a => a -> Complex a -> Complex a -> Complex a # liftU2 :: (a -> a -> a) -> Complex a -> Complex a -> Complex a # liftI2 :: (a -> b -> c) -> Complex a -> Complex b -> Complex c #
Affine Complex
Associated Types type Diff (Complex :: * -> ) :: -> * # Methods (.-.) :: Num a => Complex a -> Complex a -> Diff Complex a # (.+^) :: Num a => Complex a -> Diff Complex a -> Complex a # (.-^) :: Num a => Complex a -> Diff Complex a -> Complex a #
Complicated Complex
Methods _e :: Functor f => (a -> f a) -> Complex a -> f (Complex a) # _i :: Functor f => (a -> f a) -> Complex a -> f (Complex a) #
Finite Complex
Associated Types type Size (Complex :: * -> *) :: Nat # Methods toV :: Complex a -> V Nat (Size Complex) a # fromV :: V Nat (Size Complex) a -> Complex a #
Unbox a => Vector Vector (Complex a)
Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Complex a) -> m (Vector (Complex a)) # basicUnsafeThaw :: PrimMonad m => Vector (Complex a) -> m (Mutable Vector (PrimState m) (Complex a)) # basicLength :: Vector (Complex a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Complex a) -> Vector (Complex a) # basicUnsafeIndexM :: Monad m => Vector (Complex a) -> Int -> m (Complex a) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Complex a) -> Vector (Complex a) -> m () # elemseq :: Vector (Complex a) -> Complex a -> b -> b #
Unbox a => MVector MVector (Complex a)
Methods basicLength :: MVector s (Complex a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (Complex a) -> MVector s (Complex a) # basicOverlaps :: MVector s (Complex a) -> MVector s (Complex a) -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Complex a)) # basicInitialize :: PrimMonad m => MVector (PrimState m) (Complex a) -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Complex a -> m (MVector (PrimState m) (Complex a)) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Complex a) -> Int -> m (Complex a) # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Complex a) -> Int -> Complex a -> m () # basicClear :: PrimMonad m => MVector (PrimState m) (Complex a) -> m () # basicSet :: PrimMonad m => MVector (PrimState m) (Complex a) -> Complex a -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Complex a) -> MVector (PrimState m) (Complex a) -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Complex a) -> MVector (PrimState m) (Complex a) -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Complex a) -> Int -> m (MVector (PrimState m) (Complex a)) #
Eq a => Eq (Complex a)
Methods (==) :: Complex a -> Complex a -> Bool # (/=) :: Complex a -> Complex a -> Bool #
RealFloat a => Floating (Complex a)
Methods pi :: Complex a # exp :: Complex a -> Complex a # log :: Complex a -> Complex a # sqrt :: Complex a -> Complex a # (**) :: Complex a -> Complex a -> Complex a # logBase :: Complex a -> Complex a -> Complex a # sin :: Complex a -> Complex a # cos :: Complex a -> Complex a # tan :: Complex a -> Complex a # asin :: Complex a -> Complex a # acos :: Complex a -> Complex a # atan :: Complex a -> Complex a # sinh :: Complex a -> Complex a # cosh :: Complex a -> Complex a # tanh :: Complex a -> Complex a # asinh :: Complex a -> Complex a # acosh :: Complex a -> Complex a # atanh :: Complex a -> Complex a # log1p :: Complex a -> Complex a # expm1 :: Complex a -> Complex a # log1pexp :: Complex a -> Complex a # log1mexp :: Complex a -> Complex a #
RealFloat a => Fractional (Complex a)
Methods (/) :: Complex a -> Complex a -> Complex a # recip :: Complex a -> Complex a # fromRational :: Rational -> Complex a #
Data a => Data (Complex a)
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Complex a -> c (Complex a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Complex a) # toConstr :: Complex a -> Constr # dataTypeOf :: Complex a -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (Complex a)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Complex a)) # gmapT :: (forall b. Data b => b -> b) -> Complex a -> Complex a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Complex a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Complex a -> r # gmapQ :: (forall d. Data d => d -> u) -> Complex a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Complex a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a) #
RealFloat a => Num (Complex a)
Methods (+) :: Complex a -> Complex a -> Complex a # (-) :: Complex a -> Complex a -> Complex a # (*) :: Complex a -> Complex a -> Complex a # negate :: Complex a -> Complex a # abs :: Complex a -> Complex a # signum :: Complex a -> Complex a # fromInteger :: Integer -> Complex a #
Read a => Read (Complex a)
Methods readsPrec :: Int -> ReadS (Complex a) # readList :: ReadS [Complex a] # readPrec :: ReadPrec (Complex a) # readListPrec :: ReadPrec [Complex a] #
Show a => Show (Complex a)
Methods showsPrec :: Int -> Complex a -> ShowS # show :: Complex a -> String # showList :: [Complex a] -> ShowS #
Generic (Complex a)
Associated Types type Rep (Complex a) :: * -> * # Methods from :: Complex a -> Rep (Complex a) x # to :: Rep (Complex a) x -> Complex a #
(Default a, RealFloat a) => Default (Complex a)
Methods def :: Complex a #
Storable a => Storable (Complex a)
Methods sizeOf :: Complex a -> Int # alignment :: Complex a -> Int # peekElemOff :: Ptr (Complex a) -> Int -> IO (Complex a) # pokeElemOff :: Ptr (Complex a) -> Int -> Complex a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Complex a) # pokeByteOff :: Ptr b -> Int -> Complex a -> IO () # peek :: Ptr (Complex a) -> IO (Complex a) # poke :: Ptr (Complex a) -> Complex a -> IO () #
NFData a => NFData (Complex a)
Methods rnf :: Complex a -> () #
Unbox a => Unbox (Complex a)

(Num e, Elevator e, RealFloat e) => Elevator (Complex e) #	Discards imaginary part and changes precision of real part.
Methods toWord8 :: Complex e -> Word8 # toWord16 :: Complex e -> Word16 # toWord32 :: Complex e -> Word32 # toWord64 :: Complex e -> Word64 # toFloat :: Complex e -> Float # toDouble :: Complex e -> Double # fromDouble :: Double -> Complex e #
ComplexWritable format arr cs e => Writable (Image arr cs (Complex e)) format #	Writing Complex images: places real part on the left side of imaginary part.
Methods encode :: format -> [SaveOption format] -> Image arr cs (Complex e) -> ByteString #
type Rep1 Complex
type Rep1 Complex = D1 (MetaData "Complex" "Data.Complex" "base" False) (C1 (MetaCons ":+" (InfixI NotAssociative 6) False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) Par1) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) Par1)))
type Rep Complex
type Rep Complex = Bool
type Diff Complex
type Diff Complex = Complex
type Size Complex
type Size Complex = 2
data MVector s (Complex a)
data MVector s (Complex a) = MV_Complex (MVector s (a, a))
type Rep (Complex a)
type Rep (Complex a) = D1 (MetaData "Complex" "Data.Complex" "base" False) (C1 (MetaCons ":+" (InfixI NotAssociative 6) False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a))))
type Index (Complex a)
type Index (Complex a) = Int
data Vector (Complex a)
data Vector (Complex a) = V_Complex (Vector (a, a))

(+:) :: Applicative (Pixel cs) => Pixel cs e -> Pixel cs e -> Pixel cs (Complex e) infix 6 #

Constrcut a complex pixel from two pixels representing real and imaginary parts.

 PixelRGB 4 8 6 +: PixelRGB 7 1 1 == PixelRGB (4 :+ 7) (8 :+ 1) (6 :+ 1)

realPart :: (Applicative (Pixel cs), RealFloat e) => Pixel cs (Complex e) -> Pixel cs e #

Extracts the real part of a complex pixel.

imagPart :: (Applicative (Pixel cs), RealFloat e) => Pixel cs (Complex e) -> Pixel cs e #

Extracts the imaginary part of a complex pixel.

Polar form

mkPolar :: (Applicative (Pixel cs), RealFloat e) => Pixel cs e -> Pixel cs e -> Pixel cs (Complex e) #

Form a complex pixel from polar components of magnitude and phase.

cis :: (Applicative (Pixel cs), RealFloat e) => Pixel cs e -> Pixel cs (Complex e) #

cis t is a complex pixel with magnitude 1 and phase t (modulo 2*pi).

polar :: (Applicative (Pixel cs), RealFloat e) => Pixel cs (Complex e) -> (Pixel cs e, Pixel cs e) #

The function polar takes a complex pixel and returns a (magnitude, phase) pair of pixels in canonical form: the magnitude is nonnegative, and the phase in the range (-pi, pi]; if the magnitude is zero, then so is the phase.

magnitude :: (Applicative (Pixel cs), RealFloat e) => Pixel cs (Complex e) -> Pixel cs e #

The nonnegative magnitude of a complex pixel.

phase :: (Applicative (Pixel cs), RealFloat e) => Pixel cs (Complex e) -> Pixel cs e #

The phase of a complex pixel, in the range (-pi, pi]. If the magnitude is zero, then so is the phase.

Conjugate

conjugate :: (Applicative (Pixel cs), RealFloat e) => Pixel cs (Complex e) -> Pixel cs (Complex e) #

The conjugate of a complex pixel.

X

squashWith :: (Array arr cs e, Array arr X b) => (b -> e -> b) -> b -> Image arr cs e -> Image arr X b #

Apply a left fold to each of the pixels in the image.

squashWith2 :: (Array arr cs e, Array arr X b) => (b -> e -> e -> b) -> b -> Image arr cs e -> Image arr cs e -> Image arr X b #

Combination of zipWith and simultanious left fold on two pixels at the same time.

toPixelsX :: ColorSpace cs e => Pixel cs e -> [Pixel X e] #

Separate a Pixel into a list of components with X pixels containing every component from the pixel.

>>> toPixelsX (PixelRGB 4 5 6)
[<X:(4)>,<X:(5)>,<X:(6)>]

fromPixelsX :: ColorSpace cs e => [(cs, Pixel X e)] -> Pixel cs e #

Combine a list of X pixels into a Pixel with a specified channel order. Not the most efficient way to construct a pixel, but might prove useful to someone.

>>> fromPixelsX [(RedRGB, 3), (BlueRGB, 5), (GreenRGB, 4)]
<RGB:(3.0|4.0|5.0)>
>>> fromPixelsX $ zip (enumFrom RedRGB) (toPixelsX $ PixelRGB 4 5 6)
<RGB:(4.0|5.0|6.0)>

toImagesX :: (Array arr cs e, Array arr X e) => Image arr cs e -> [Image arr X e] #

Separate an image into a list of images with X pixels containing every channel from the source image.

>>> frog <- readImageRGB "images/frog.jpg"
>>> let [frog_red, frog_green, frog_blue] = toImagesX frog
>>> writeImage "images/frog_red.png" $ toImageY frog_red
>>> writeImage "images/frog_green.jpg" $ toImageY frog_green
>>> writeImage "images/frog_blue.jpg" $ toImageY frog_blue

fromImagesX :: (Array arr X e, Array arr cs e) => [(cs, Image arr X e)] -> Image arr cs e #

Combine a list of images with X pixels into an image of any color space, by supplying an order of color space channels.

For example here is a frog with swapped BlueRGB and GreenRGB channels.

>>> writeImage "images/frog_rbg.jpg" $ fromImagesX [(RedRGB, frog_red), (BlueRGB, frog_green), (GreenRGB, frog_blue)]

It is worth noting though, despite that separating image channels can be sometimes pretty useful, exactly the same effect as in example above can be achieved in a much simpler and a more efficient way:

 map (\(PixelRGB r g b) -> PixelRGB r b g) frog

ColorSpace

Operations on Pixels

eqTolPx :: (ColorSpace cs e, Ord e) => e -> Pixel cs e -> Pixel cs e -> Bool #

Check weather two Pixels are equal within a tolerance. Useful for comparing pixels with Float or Double precision.

Luma

data Y #

Luma or brightness, which is usually denoted as Y'.

Constructors

LumaY

Instances

Bounded Y #
Methods minBound :: Y # maxBound :: Y #
Enum Y #
Methods succ :: Y -> Y # pred :: Y -> Y # toEnum :: Int -> Y # fromEnum :: Y -> Int # enumFrom :: Y -> [Y] # enumFromThen :: Y -> Y -> [Y] # enumFromTo :: Y -> Y -> [Y] # enumFromThenTo :: Y -> Y -> Y -> [Y] #
Eq Y #
Methods (==) :: Y -> Y -> Bool # (/=) :: Y -> Y -> Bool #
Show Y #
Methods showsPrec :: Int -> Y -> ShowS # show :: Y -> String # showList :: [Y] -> ShowS #
ChannelColour Y #
Methods csColour :: Y -> AlphaColour Double #
Elevator e => ColorSpace Y e #
Associated Types type Components Y e :: * # Methods toComponents :: Pixel Y e -> Components Y e # fromComponents :: Components Y e -> Pixel Y e # promote :: e -> Pixel Y e # getPxC :: Pixel Y e -> Y -> e # setPxC :: Pixel Y e -> Y -> e -> Pixel Y e # mapPxC :: (Y -> e -> e) -> Pixel Y e -> Pixel Y e # liftPx :: (e -> e) -> Pixel Y e -> Pixel Y e # liftPx2 :: (e -> e -> e) -> Pixel Y e -> Pixel Y e -> Pixel Y e # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel Y e -> Pixel Y e -> b # foldrPx :: (e -> b -> b) -> b -> Pixel Y e -> b # foldlPx :: (b -> e -> b) -> b -> Pixel Y e -> b # foldl1Px :: (e -> e -> e) -> Pixel Y e -> e # toListPx :: Pixel Y e -> [e] #
ToYCbCr Y e => ToYCbCrA Y e #
Methods toPixelYCbCrA :: Pixel Y e -> Pixel YCbCrA Double #
Elevator e => ToYCbCr Y e #
Methods toPixelYCbCr :: Pixel Y e -> Pixel YCbCr Double #
ToCMYK Y e => ToCMYKA Y e #
Methods toPixelCMYKA :: Pixel Y e -> Pixel CMYKA Double #
Elevator e => ToCMYK Y e #
Methods toPixelCMYK :: Pixel Y e -> Pixel CMYK Double #
ToHSI Y e => ToHSIA Y e #
Methods toPixelHSIA :: Pixel Y e -> Pixel HSIA Double #
Elevator e => ToHSI Y e #
Methods toPixelHSI :: Pixel Y e -> Pixel HSI Double #
ToRGB Y e => ToRGBA Y e #
Methods toPixelRGBA :: Pixel Y e -> Pixel RGBA Double #
Elevator e => ToRGB Y e #
Methods toPixelRGB :: Pixel Y e -> Pixel RGB Double #
ToY Y e => ToYA Y e #
Methods toPixelYA :: Pixel Y e -> Pixel YA Double #
Elevator e => ToY Y e #
Methods toPixelY :: Pixel Y e -> Pixel Y Double #
Convertible Y Double #
Methods convert :: (ToYA cs' e', ToRGBA cs' e', Array arr cs' e', Array arr Y Double) => Image arr cs' e' -> Image arr Y Double #
Monad (Pixel Y) #
Methods (>>=) :: Pixel Y a -> (a -> Pixel Y b) -> Pixel Y b # (>>) :: Pixel Y a -> Pixel Y b -> Pixel Y b # return :: a -> Pixel Y a # fail :: String -> Pixel Y a #
Functor (Pixel Y) #
Methods fmap :: (a -> b) -> Pixel Y a -> Pixel Y b # (<$) :: a -> Pixel Y b -> Pixel Y a #
Applicative (Pixel Y) #
Methods pure :: a -> Pixel Y a # (<>) :: Pixel Y (a -> b) -> Pixel Y a -> Pixel Y b # (>) :: Pixel Y a -> Pixel Y b -> Pixel Y b # (<*) :: Pixel Y a -> Pixel Y b -> Pixel Y a #
Foldable (Pixel Y) #
Methods fold :: Monoid m => Pixel Y m -> m # foldMap :: Monoid m => (a -> m) -> Pixel Y a -> m # foldr :: (a -> b -> b) -> b -> Pixel Y a -> b # foldr' :: (a -> b -> b) -> b -> Pixel Y a -> b # foldl :: (b -> a -> b) -> b -> Pixel Y a -> b # foldl' :: (b -> a -> b) -> b -> Pixel Y a -> b # foldr1 :: (a -> a -> a) -> Pixel Y a -> a # foldl1 :: (a -> a -> a) -> Pixel Y a -> a # toList :: Pixel Y a -> [a] # null :: Pixel Y a -> Bool # length :: Pixel Y a -> Int # elem :: Eq a => a -> Pixel Y a -> Bool # maximum :: Ord a => Pixel Y a -> a # minimum :: Ord a => Pixel Y a -> a # sum :: Num a => Pixel Y a -> a # product :: Num a => Pixel Y a -> a #
Readable [Image VS Y Double] GIFA #
Methods decode :: GIFA -> ByteString -> Either String [Image VS Y Double] #
Readable [Image VS Y Double] (Seq GIF) #
Methods decode :: Seq GIF -> ByteString -> Either String [Image VS Y Double] #
Readable [Image VS Y Word8] (Seq PGM) #
Methods decode :: Seq PGM -> ByteString -> Either String [Image VS Y Word8] #
Readable [Image VS Y Word16] (Seq PGM) #
Methods decode :: Seq PGM -> ByteString -> Either String [Image VS Y Word16] #
Eq e => Eq (Pixel Y e) #
Methods (==) :: Pixel Y e -> Pixel Y e -> Bool # (/=) :: Pixel Y e -> Pixel Y e -> Bool #
Ord e => Ord (Pixel Y e) #
Methods compare :: Pixel Y e -> Pixel Y e -> Ordering # (<) :: Pixel Y e -> Pixel Y e -> Bool # (<=) :: Pixel Y e -> Pixel Y e -> Bool # (>) :: Pixel Y e -> Pixel Y e -> Bool # (>=) :: Pixel Y e -> Pixel Y e -> Bool # max :: Pixel Y e -> Pixel Y e -> Pixel Y e # min :: Pixel Y e -> Pixel Y e -> Pixel Y e #
Show e => Show (Pixel Y e) #
Methods showsPrec :: Int -> Pixel Y e -> ShowS # show :: Pixel Y e -> String # showList :: [Pixel Y e] -> ShowS #
Storable e => Storable (Pixel Y e) #
Methods sizeOf :: Pixel Y e -> Int # alignment :: Pixel Y e -> Int # peekElemOff :: Ptr (Pixel Y e) -> Int -> IO (Pixel Y e) # pokeElemOff :: Ptr (Pixel Y e) -> Int -> Pixel Y e -> IO () # peekByteOff :: Ptr b -> Int -> IO (Pixel Y e) # pokeByteOff :: Ptr b -> Int -> Pixel Y e -> IO () # peek :: Ptr (Pixel Y e) -> IO (Pixel Y e) # poke :: Ptr (Pixel Y e) -> Pixel Y e -> IO () #
Writable (Image VS Y Double) TIF #
Methods encode :: TIF -> [SaveOption TIF] -> Image VS Y Double -> ByteString #
Writable (Image VS Y Double) TGA #
Methods encode :: TGA -> [SaveOption TGA] -> Image VS Y Double -> ByteString #
Writable (Image VS Y Double) PNG #
Methods encode :: PNG -> [SaveOption PNG] -> Image VS Y Double -> ByteString #
Writable (Image VS Y Double) JPG #	Image is converted `YCbCr` color space prior to encoding.
Methods encode :: JPG -> [SaveOption JPG] -> Image VS Y Double -> ByteString #
Writable (Image VS Y Double) HDR #
Methods encode :: HDR -> [SaveOption HDR] -> Image VS Y Double -> ByteString #
Writable (Image VS Y Double) GIF #
Methods encode :: GIF -> [SaveOption GIF] -> Image VS Y Double -> ByteString #
Writable (Image VS Y Double) BMP #
Methods encode :: BMP -> [SaveOption BMP] -> Image VS Y Double -> ByteString #
Writable (Image VS Y Word8) TIF #
Methods encode :: TIF -> [SaveOption TIF] -> Image VS Y Word8 -> ByteString #
Writable (Image VS Y Word8) TGA #
Methods encode :: TGA -> [SaveOption TGA] -> Image VS Y Word8 -> ByteString #
Writable (Image VS Y Word8) PNG #
Methods encode :: PNG -> [SaveOption PNG] -> Image VS Y Word8 -> ByteString #
Writable (Image VS Y Word8) JPG #
Methods encode :: JPG -> [SaveOption JPG] -> Image VS Y Word8 -> ByteString #
Writable (Image VS Y Word8) BMP #
Methods encode :: BMP -> [SaveOption BMP] -> Image VS Y Word8 -> ByteString #
Writable (Image VS Y Word16) TIF #
Methods encode :: TIF -> [SaveOption TIF] -> Image VS Y Word16 -> ByteString #
Writable (Image VS Y Word16) PNG #
Methods encode :: PNG -> [SaveOption PNG] -> Image VS Y Word16 -> ByteString #
Readable (Image VS Y Double) TIF #
Methods decode :: TIF -> ByteString -> Either String (Image VS Y Double) #
Readable (Image VS Y Double) TGA #
Methods decode :: TGA -> ByteString -> Either String (Image VS Y Double) #
Readable (Image VS Y Double) PNG #
Methods decode :: PNG -> ByteString -> Either String (Image VS Y Double) #
Readable (Image VS Y Double) JPG #
Methods decode :: JPG -> ByteString -> Either String (Image VS Y Double) #
Readable (Image VS Y Double) HDR #
Methods decode :: HDR -> ByteString -> Either String (Image VS Y Double) #
Readable (Image VS Y Double) GIF #
Methods decode :: GIF -> ByteString -> Either String (Image VS Y Double) #
Readable (Image VS Y Double) BMP #
Methods decode :: BMP -> ByteString -> Either String (Image VS Y Double) #
Readable (Image VS Y Double) PPM #
Methods decode :: PPM -> ByteString -> Either String (Image VS Y Double) #
Readable (Image VS Y Double) PGM #
Methods decode :: PGM -> ByteString -> Either String (Image VS Y Double) #
Readable (Image VS Y Double) PBM #
Methods decode :: PBM -> ByteString -> Either String (Image VS Y Double) #
Readable (Image VS Y Word8) TIF #
Methods decode :: TIF -> ByteString -> Either String (Image VS Y Word8) #
Readable (Image VS Y Word8) TGA #
Methods decode :: TGA -> ByteString -> Either String (Image VS Y Word8) #
Readable (Image VS Y Word8) PNG #
Methods decode :: PNG -> ByteString -> Either String (Image VS Y Word8) #
Readable (Image VS Y Word8) JPG #
Methods decode :: JPG -> ByteString -> Either String (Image VS Y Word8) #
Readable (Image VS Y Word8) BMP #
Methods decode :: BMP -> ByteString -> Either String (Image VS Y Word8) #
Readable (Image VS Y Word8) PGM #
Methods decode :: PGM -> ByteString -> Either String (Image VS Y Word8) #
Readable (Image VS Y Word16) TIF #
Methods decode :: TIF -> ByteString -> Either String (Image VS Y Word16) #
Readable (Image VS Y Word16) PNG #
Methods decode :: PNG -> ByteString -> Either String (Image VS Y Word16) #
Readable (Image VS Y Word16) PGM #
Methods decode :: PGM -> ByteString -> Either String (Image VS Y Word16) #
data Pixel Y #
data Pixel Y = PixelY e
type Components Y e #
type Components Y e = e

data YA #

Luma with Alpha channel.

Constructors

LumaYA	Luma
AlphaYA	Alpha channel

Instances

Bounded YA #
Methods minBound :: YA # maxBound :: YA #
Enum YA #
Methods succ :: YA -> YA # pred :: YA -> YA # toEnum :: Int -> YA # fromEnum :: YA -> Int # enumFrom :: YA -> [YA] # enumFromThen :: YA -> YA -> [YA] # enumFromTo :: YA -> YA -> [YA] # enumFromThenTo :: YA -> YA -> YA -> [YA] #
Eq YA #
Methods (==) :: YA -> YA -> Bool # (/=) :: YA -> YA -> Bool #
Show YA #
Methods showsPrec :: Int -> YA -> ShowS # show :: YA -> String # showList :: [YA] -> ShowS #
ChannelColour YA #
Methods csColour :: YA -> AlphaColour Double #
Elevator e => AlphaSpace YA e #
Associated Types type Opaque YA :: * # Methods getAlpha :: Pixel YA e -> e # addAlpha :: e -> Pixel (Opaque YA) e -> Pixel YA e # dropAlpha :: Pixel YA e -> Pixel (Opaque YA) e #
Elevator e => ColorSpace YA e #
Associated Types type Components YA e :: * # Methods toComponents :: Pixel YA e -> Components YA e # fromComponents :: Components YA e -> Pixel YA e # promote :: e -> Pixel YA e # getPxC :: Pixel YA e -> YA -> e # setPxC :: Pixel YA e -> YA -> e -> Pixel YA e # mapPxC :: (YA -> e -> e) -> Pixel YA e -> Pixel YA e # liftPx :: (e -> e) -> Pixel YA e -> Pixel YA e # liftPx2 :: (e -> e -> e) -> Pixel YA e -> Pixel YA e -> Pixel YA e # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel YA e -> Pixel YA e -> b # foldrPx :: (e -> b -> b) -> b -> Pixel YA e -> b # foldlPx :: (b -> e -> b) -> b -> Pixel YA e -> b # foldl1Px :: (e -> e -> e) -> Pixel YA e -> e # toListPx :: Pixel YA e -> [e] #
Elevator e => ToYCbCrA YA e #
Methods toPixelYCbCrA :: Pixel YA e -> Pixel YCbCrA Double #
Elevator e => ToYCbCr YA e #
Methods toPixelYCbCr :: Pixel YA e -> Pixel YCbCr Double #
Elevator e => ToCMYKA YA e #
Methods toPixelCMYKA :: Pixel YA e -> Pixel CMYKA Double #
Elevator e => ToCMYK YA e #
Methods toPixelCMYK :: Pixel YA e -> Pixel CMYK Double #
Elevator e => ToHSIA YA e #
Methods toPixelHSIA :: Pixel YA e -> Pixel HSIA Double #
Elevator e => ToHSI YA e #
Methods toPixelHSI :: Pixel YA e -> Pixel HSI Double #
Elevator e => ToRGBA YA e #
Methods toPixelRGBA :: Pixel YA e -> Pixel RGBA Double #
Elevator e => ToRGB YA e #
Methods toPixelRGB :: Pixel YA e -> Pixel RGB Double #
Elevator e => ToYA YA e #
Methods toPixelYA :: Pixel YA e -> Pixel YA Double #
Elevator e => ToY YA e #
Methods toPixelY :: Pixel YA e -> Pixel Y Double #
Convertible YA Double #
Methods convert :: (ToYA cs' e', ToRGBA cs' e', Array arr cs' e', Array arr YA Double) => Image arr cs' e' -> Image arr YA Double #
Functor (Pixel YA) #
Methods fmap :: (a -> b) -> Pixel YA a -> Pixel YA b # (<$) :: a -> Pixel YA b -> Pixel YA a #
Applicative (Pixel YA) #
Methods pure :: a -> Pixel YA a # (<>) :: Pixel YA (a -> b) -> Pixel YA a -> Pixel YA b # (>) :: Pixel YA a -> Pixel YA b -> Pixel YA b # (<*) :: Pixel YA a -> Pixel YA b -> Pixel YA a #
Foldable (Pixel YA) #
Methods fold :: Monoid m => Pixel YA m -> m # foldMap :: Monoid m => (a -> m) -> Pixel YA a -> m # foldr :: (a -> b -> b) -> b -> Pixel YA a -> b # foldr' :: (a -> b -> b) -> b -> Pixel YA a -> b # foldl :: (b -> a -> b) -> b -> Pixel YA a -> b # foldl' :: (b -> a -> b) -> b -> Pixel YA a -> b # foldr1 :: (a -> a -> a) -> Pixel YA a -> a # foldl1 :: (a -> a -> a) -> Pixel YA a -> a # toList :: Pixel YA a -> [a] # null :: Pixel YA a -> Bool # length :: Pixel YA a -> Int # elem :: Eq a => a -> Pixel YA a -> Bool # maximum :: Ord a => Pixel YA a -> a # minimum :: Ord a => Pixel YA a -> a # sum :: Num a => Pixel YA a -> a # product :: Num a => Pixel YA a -> a #
Readable [Image VS YA Double] GIFA #
Methods decode :: GIFA -> ByteString -> Either String [Image VS YA Double] #
Readable [Image VS YA Double] (Seq GIF) #
Methods decode :: Seq GIF -> ByteString -> Either String [Image VS YA Double] #
Eq e => Eq (Pixel YA e) #
Methods (==) :: Pixel YA e -> Pixel YA e -> Bool # (/=) :: Pixel YA e -> Pixel YA e -> Bool #
Show e => Show (Pixel YA e) #
Methods showsPrec :: Int -> Pixel YA e -> ShowS # show :: Pixel YA e -> String # showList :: [Pixel YA e] -> ShowS #
Storable e => Storable (Pixel YA e) #
Methods sizeOf :: Pixel YA e -> Int # alignment :: Pixel YA e -> Int # peekElemOff :: Ptr (Pixel YA e) -> Int -> IO (Pixel YA e) # pokeElemOff :: Ptr (Pixel YA e) -> Int -> Pixel YA e -> IO () # peekByteOff :: Ptr b -> Int -> IO (Pixel YA e) # pokeByteOff :: Ptr b -> Int -> Pixel YA e -> IO () # peek :: Ptr (Pixel YA e) -> IO (Pixel YA e) # poke :: Ptr (Pixel YA e) -> Pixel YA e -> IO () #
Writable (Image VS YA Double) TIF #
Methods encode :: TIF -> [SaveOption TIF] -> Image VS YA Double -> ByteString #
Writable (Image VS YA Double) TGA #
Methods encode :: TGA -> [SaveOption TGA] -> Image VS YA Double -> ByteString #
Writable (Image VS YA Double) PNG #
Methods encode :: PNG -> [SaveOption PNG] -> Image VS YA Double -> ByteString #
Writable (Image VS YA Double) JPG #	Image is converted `YCbCr` color space prior to encoding.
Methods encode :: JPG -> [SaveOption JPG] -> Image VS YA Double -> ByteString #
Writable (Image VS YA Double) HDR #
Methods encode :: HDR -> [SaveOption HDR] -> Image VS YA Double -> ByteString #
Writable (Image VS YA Double) GIF #
Methods encode :: GIF -> [SaveOption GIF] -> Image VS YA Double -> ByteString #
Writable (Image VS YA Double) BMP #
Methods encode :: BMP -> [SaveOption BMP] -> Image VS YA Double -> ByteString #
Writable (Image VS YA Word8) TIF #
Methods encode :: TIF -> [SaveOption TIF] -> Image VS YA Word8 -> ByteString #
Writable (Image VS YA Word8) PNG #
Methods encode :: PNG -> [SaveOption PNG] -> Image VS YA Word8 -> ByteString #
Writable (Image VS YA Word16) TIF #
Methods encode :: TIF -> [SaveOption TIF] -> Image VS YA Word16 -> ByteString #
Writable (Image VS YA Word16) PNG #
Methods encode :: PNG -> [SaveOption PNG] -> Image VS YA Word16 -> ByteString #
Readable (Image VS YA Double) TIF #
Methods decode :: TIF -> ByteString -> Either String (Image VS YA Double) #
Readable (Image VS YA Double) TGA #
Methods decode :: TGA -> ByteString -> Either String (Image VS YA Double) #
Readable (Image VS YA Double) PNG #
Methods decode :: PNG -> ByteString -> Either String (Image VS YA Double) #
Readable (Image VS YA Double) JPG #
Methods decode :: JPG -> ByteString -> Either String (Image VS YA Double) #
Readable (Image VS YA Double) HDR #
Methods decode :: HDR -> ByteString -> Either String (Image VS YA Double) #
Readable (Image VS YA Double) GIF #
Methods decode :: GIF -> ByteString -> Either String (Image VS YA Double) #
Readable (Image VS YA Double) BMP #
Methods decode :: BMP -> ByteString -> Either String (Image VS YA Double) #
Readable (Image VS YA Double) PPM #
Methods decode :: PPM -> ByteString -> Either String (Image VS YA Double) #
Readable (Image VS YA Word8) TIF #
Methods decode :: TIF -> ByteString -> Either String (Image VS YA Word8) #
Readable (Image VS YA Word8) PNG #
Methods decode :: PNG -> ByteString -> Either String (Image VS YA Word8) #
Readable (Image VS YA Word8) JPG #
Methods decode :: JPG -> ByteString -> Either String (Image VS YA Word8) #
Readable (Image VS YA Word16) TIF #
Methods decode :: TIF -> ByteString -> Either String (Image VS YA Word16) #
Readable (Image VS YA Word16) PNG #
Methods decode :: PNG -> ByteString -> Either String (Image VS YA Word16) #
type Opaque YA #
type Opaque YA = Y
data Pixel YA #
data Pixel YA = PixelYA !e !e
type Components YA e #
type Components YA e = (e, e)

class ColorSpace cs e => ToY cs e where #

Conversion to Luma color space.

Minimal complete definition

toPixelY

Methods

toPixelY :: Pixel cs e -> Pixel Y Double #

Convert a pixel to Luma pixel.

Instances

Elevator e => ToY YCbCrA e #
Methods toPixelY :: Pixel YCbCrA e -> Pixel Y Double #
Elevator e => ToY YCbCr e #
Methods toPixelY :: Pixel YCbCr e -> Pixel Y Double #
Elevator e => ToY YA e #
Methods toPixelY :: Pixel YA e -> Pixel Y Double #
Elevator e => ToY Y e #
Methods toPixelY :: Pixel Y e -> Pixel Y Double #
Elevator e => ToY X e #
Methods toPixelY :: Pixel X e -> Pixel Y Double #
Elevator e => ToY RGBA e #
Methods toPixelY :: Pixel RGBA e -> Pixel Y Double #
Elevator e => ToY RGB e #	Computes Luma: `Y' = 0.299 * R' + 0.587 * G' + 0.114 * B'`
Methods toPixelY :: Pixel RGB e -> Pixel Y Double #
Elevator e => ToY HSIA e #
Methods toPixelY :: Pixel HSIA e -> Pixel Y Double #
Elevator e => ToY HSI e #
Methods toPixelY :: Pixel HSI e -> Pixel Y Double #
Elevator e => ToY CMYKA e #
Methods toPixelY :: Pixel CMYKA e -> Pixel Y Double #
Elevator e => ToY CMYK e #
Methods toPixelY :: Pixel CMYK e -> Pixel Y Double #

class ToY cs e => ToYA cs e where #

Conversion to Luma from another color space.

Methods

toPixelYA :: Pixel cs e -> Pixel YA Double #

Convert a pixel to Luma pixel with Alpha.

Instances

Elevator e => ToYA YCbCrA e #
Methods toPixelYA :: Pixel YCbCrA e -> Pixel YA Double #
ToY YCbCr e => ToYA YCbCr e #
Methods toPixelYA :: Pixel YCbCr e -> Pixel YA Double #
Elevator e => ToYA YA e #
Methods toPixelYA :: Pixel YA e -> Pixel YA Double #
ToY Y e => ToYA Y e #
Methods toPixelYA :: Pixel Y e -> Pixel YA Double #
ToYA X Bit #
Methods toPixelYA :: Pixel X Bit -> Pixel YA Double #
Elevator e => ToYA RGBA e #
Methods toPixelYA :: Pixel RGBA e -> Pixel YA Double #
ToY RGB e => ToYA RGB e #
Methods toPixelYA :: Pixel RGB e -> Pixel YA Double #
Elevator e => ToYA HSIA e #
Methods toPixelYA :: Pixel HSIA e -> Pixel YA Double #
ToY HSI e => ToYA HSI e #
Methods toPixelYA :: Pixel HSI e -> Pixel YA Double #
Elevator e => ToYA CMYKA e #
Methods toPixelYA :: Pixel CMYKA e -> Pixel YA Double #
ToY CMYK e => ToYA CMYK e #
Methods toPixelYA :: Pixel CMYK e -> Pixel YA Double #

RGB

data RGB #

Red, Green and Blue color space.

Constructors

RedRGB
GreenRGB
BlueRGB

Instances

Bounded RGB #
Methods minBound :: RGB # maxBound :: RGB #
Enum RGB #
Methods succ :: RGB -> RGB # pred :: RGB -> RGB # toEnum :: Int -> RGB # fromEnum :: RGB -> Int # enumFrom :: RGB -> [RGB] # enumFromThen :: RGB -> RGB -> [RGB] # enumFromTo :: RGB -> RGB -> [RGB] # enumFromThenTo :: RGB -> RGB -> RGB -> [RGB] #
Eq RGB #
Methods (==) :: RGB -> RGB -> Bool # (/=) :: RGB -> RGB -> Bool #
Show RGB #
Methods showsPrec :: Int -> RGB -> ShowS # show :: RGB -> String # showList :: [RGB] -> ShowS #
ChannelColour RGB #
Methods csColour :: RGB -> AlphaColour Double #
Elevator e => ColorSpace RGB e #
Associated Types type Components RGB e :: * # Methods toComponents :: Pixel RGB e -> Components RGB e # fromComponents :: Components RGB e -> Pixel RGB e # promote :: e -> Pixel RGB e # getPxC :: Pixel RGB e -> RGB -> e # setPxC :: Pixel RGB e -> RGB -> e -> Pixel RGB e # mapPxC :: (RGB -> e -> e) -> Pixel RGB e -> Pixel RGB e # liftPx :: (e -> e) -> Pixel RGB e -> Pixel RGB e # liftPx2 :: (e -> e -> e) -> Pixel RGB e -> Pixel RGB e -> Pixel RGB e # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel RGB e -> Pixel RGB e -> b # foldrPx :: (e -> b -> b) -> b -> Pixel RGB e -> b # foldlPx :: (b -> e -> b) -> b -> Pixel RGB e -> b # foldl1Px :: (e -> e -> e) -> Pixel RGB e -> e # toListPx :: Pixel RGB e -> [e] #
ToYCbCr RGB e => ToYCbCrA RGB e #
Methods toPixelYCbCrA :: Pixel RGB e -> Pixel YCbCrA Double #
Elevator e => ToYCbCr RGB e #
Methods toPixelYCbCr :: Pixel RGB e -> Pixel YCbCr Double #
ToCMYK RGB e => ToCMYKA RGB e #
Methods toPixelCMYKA :: Pixel RGB e -> Pixel CMYKA Double #
Elevator e => ToCMYK RGB e #
Methods toPixelCMYK :: Pixel RGB e -> Pixel CMYK Double #
ToHSI RGB e => ToHSIA RGB e #
Methods toPixelHSIA :: Pixel RGB e -> Pixel HSIA Double #
Elevator e => ToHSI RGB e #
Methods toPixelHSI :: Pixel RGB e -> Pixel HSI Double #
ToRGB RGB e => ToRGBA RGB e #
Methods toPixelRGBA :: Pixel RGB e -> Pixel RGBA Double #
Elevator e => ToRGB RGB e #
Methods toPixelRGB :: Pixel RGB e -> Pixel RGB Double #
ToY RGB e => ToYA RGB e #
Methods toPixelYA :: Pixel RGB e -> Pixel YA Double #
Elevator e => ToY RGB e #	Computes Luma: `Y' = 0.299 * R' + 0.587 * G' + 0.114 * B'`
Methods toPixelY :: Pixel RGB e -> Pixel Y Double #
Convertible RGB Double #
Methods convert :: (ToYA cs' e', ToRGBA cs' e', Array arr cs' e', Array arr RGB Double) => Image arr cs' e' -> Image arr RGB Double #
Functor (Pixel RGB) #
Methods fmap :: (a -> b) -> Pixel RGB a -> Pixel RGB b # (<$) :: a -> Pixel RGB b -> Pixel RGB a #
Applicative (Pixel RGB) #
Methods pure :: a -> Pixel RGB a # (<>) :: Pixel RGB (a -> b) -> Pixel RGB a -> Pixel RGB b # (>) :: Pixel RGB a -> Pixel RGB b -> Pixel RGB b # (<*) :: Pixel RGB a -> Pixel RGB b -> Pixel RGB a #
Foldable (Pixel RGB) #
Methods fold :: Monoid m => Pixel RGB m -> m # foldMap :: Monoid m => (a -> m) -> Pixel RGB a -> m # foldr :: (a -> b -> b) -> b -> Pixel RGB a -> b # foldr' :: (a -> b -> b) -> b -> Pixel RGB a -> b # foldl :: (b -> a -> b) -> b -> Pixel RGB a -> b # foldl' :: (b -> a -> b) -> b -> Pixel RGB a -> b # foldr1 :: (a -> a -> a) -> Pixel RGB a -> a # foldl1 :: (a -> a -> a) -> Pixel RGB a -> a # toList :: Pixel RGB a -> [a] # null :: Pixel RGB a -> Bool # length :: Pixel RGB a -> Int # elem :: Eq a => a -> Pixel RGB a -> Bool # maximum :: Ord a => Pixel RGB a -> a # minimum :: Ord a => Pixel RGB a -> a # sum :: Num a => Pixel RGB a -> a # product :: Num a => Pixel RGB a -> a #
Writable [(GifDelay, Image VS RGB Double)] GIFA #
Methods encode :: GIFA -> [SaveOption GIFA] -> [(GifDelay, Image VS RGB Double)] -> ByteString #
Writable [(GifDelay, Image VS RGB Word8)] GIFA #
Methods encode :: GIFA -> [SaveOption GIFA] -> [(GifDelay, Image VS RGB Word8)] -> ByteString #
Readable [(GifDelay, Image VS RGB Word8)] GIFA #
Methods decode :: GIFA -> ByteString -> Either String [(GifDelay, Image VS RGB Word8)] #
Readable [Image VS RGB Double] GIFA #
Methods decode :: GIFA -> ByteString -> Either String [Image VS RGB Double] #
Readable [Image VS RGB Word8] GIFA #
Methods decode :: GIFA -> ByteString -> Either String [Image VS RGB Word8] #
Writable [(GifDelay, Image VS RGB Double)] (Seq GIF) #
Methods encode :: Seq GIF -> [SaveOption (Seq GIF)] -> [(GifDelay, Image VS RGB Double)] -> ByteString #
Writable [(GifDelay, Image VS RGB Word8)] (Seq GIF) #
Methods encode :: Seq GIF -> [SaveOption (Seq GIF)] -> [(GifDelay, Image VS RGB Word8)] -> ByteString #
Readable [(GifDelay, Image VS RGB Word8)] (Seq GIF) #
Methods decode :: Seq GIF -> ByteString -> Either String [(GifDelay, Image VS RGB Word8)] #
Readable [Image VS RGB Double] (Seq GIF) #
Methods decode :: Seq GIF -> ByteString -> Either String [Image VS RGB Double] #
Readable [Image VS RGB Word8] (Seq GIF) #
Methods decode :: Seq GIF -> ByteString -> Either String [Image VS RGB Word8] #
Readable [Image VS RGB Word8] (Seq PPM) #
Methods decode :: Seq PPM -> ByteString -> Either String [Image VS RGB Word8] #
Readable [Image VS RGB Word16] (Seq PPM) #
Methods decode :: Seq PPM -> ByteString -> Either String [Image VS RGB Word16] #
Eq e => Eq (Pixel RGB e) #
Methods (==) :: Pixel RGB e -> Pixel RGB e -> Bool # (/=) :: Pixel RGB e -> Pixel RGB e -> Bool #
Show e => Show (Pixel RGB e) #
Methods showsPrec :: Int -> Pixel RGB e -> ShowS # show :: Pixel RGB e -> String # showList :: [Pixel RGB e] -> ShowS #
Storable e => Storable (Pixel RGB e) #
Methods sizeOf :: Pixel RGB e -> Int # alignment :: Pixel RGB e -> Int # peekElemOff :: Ptr (Pixel RGB e) -> Int -> IO (Pixel RGB e) # pokeElemOff :: Ptr (Pixel RGB e) -> Int -> Pixel RGB e -> IO () # peekByteOff :: Ptr b -> Int -> IO (Pixel RGB e) # pokeByteOff :: Ptr b -> Int -> Pixel RGB e -> IO () # peek :: Ptr (Pixel RGB e) -> IO (Pixel RGB e) # poke :: Ptr (Pixel RGB e) -> Pixel RGB e -> IO () #
Writable (Image VS RGB Double) TIF #
Methods encode :: TIF -> [SaveOption TIF] -> Image VS RGB Double -> ByteString #
Writable (Image VS RGB Double) TGA #
Methods encode :: TGA -> [SaveOption TGA] -> Image VS RGB Double -> ByteString #
Writable (Image VS RGB Double) PNG #
Methods encode :: PNG -> [SaveOption PNG] -> Image VS RGB Double -> ByteString #
Writable (Image VS RGB Double) JPG #	Image is converted `YCbCr` color space prior to encoding.
Methods encode :: JPG -> [SaveOption JPG] -> Image VS RGB Double -> ByteString #
Writable (Image VS RGB Double) HDR #
Methods encode :: HDR -> [SaveOption HDR] -> Image VS RGB Double -> ByteString #
Writable (Image VS RGB Double) GIF #
Methods encode :: GIF -> [SaveOption GIF] -> Image VS RGB Double -> ByteString #
Writable (Image VS RGB Double) BMP #
Methods encode :: BMP -> [SaveOption BMP] -> Image VS RGB Double -> ByteString #
Writable (Image VS RGB Float) HDR #
Methods encode :: HDR -> [SaveOption HDR] -> Image VS RGB Float -> ByteString #
Writable (Image VS RGB Word8) TIF #
Methods encode :: TIF -> [SaveOption TIF] -> Image VS RGB Word8 -> ByteString #
Writable (Image VS RGB Word8) TGA #
Methods encode :: TGA -> [SaveOption TGA] -> Image VS RGB Word8 -> ByteString #
Writable (Image VS RGB Word8) PNG #
Methods encode :: PNG -> [SaveOption PNG] -> Image VS RGB Word8 -> ByteString #
Writable (Image VS RGB Word8) JPG #
Methods encode :: JPG -> [SaveOption JPG] -> Image VS RGB Word8 -> ByteString #
Writable (Image VS RGB Word8) GIF #
Methods encode :: GIF -> [SaveOption GIF] -> Image VS RGB Word8 -> ByteString #
Writable (Image VS RGB Word8) BMP #
Methods encode :: BMP -> [SaveOption BMP] -> Image VS RGB Word8 -> ByteString #
Writable (Image VS RGB Word16) TIF #
Methods encode :: TIF -> [SaveOption TIF] -> Image VS RGB Word16 -> ByteString #
Writable (Image VS RGB Word16) PNG #
Methods encode :: PNG -> [SaveOption PNG] -> Image VS RGB Word16 -> ByteString #
Readable (Image VS RGB Double) TIF #
Methods decode :: TIF -> ByteString -> Either String (Image VS RGB Double) #
Readable (Image VS RGB Double) TGA #
Methods decode :: TGA -> ByteString -> Either String (Image VS RGB Double) #
Readable (Image VS RGB Double) PNG #
Methods decode :: PNG -> ByteString -> Either String (Image VS RGB Double) #
Readable (Image VS RGB Double) JPG #
Methods decode :: JPG -> ByteString -> Either String (Image VS RGB Double) #
Readable (Image VS RGB Double) HDR #
Methods decode :: HDR -> ByteString -> Either String (Image VS RGB Double) #
Readable (Image VS RGB Double) GIF #
Methods decode :: GIF -> ByteString -> Either String (Image VS RGB Double) #
Readable (Image VS RGB Double) BMP #
Methods decode :: BMP -> ByteString -> Either String (Image VS RGB Double) #
Readable (Image VS RGB Double) PPM #
Methods decode :: PPM -> ByteString -> Either String (Image VS RGB Double) #
Readable (Image VS RGB Float) HDR #
Methods decode :: HDR -> ByteString -> Either String (Image VS RGB Float) #
Readable (Image VS RGB Word8) TIF #
Methods decode :: TIF -> ByteString -> Either String (Image VS RGB Word8) #
Readable (Image VS RGB Word8) TGA #
Methods decode :: TGA -> ByteString -> Either String (Image VS RGB Word8) #
Readable (Image VS RGB Word8) PNG #
Methods decode :: PNG -> ByteString -> Either String (Image VS RGB Word8) #
Readable (Image VS RGB Word8) JPG #
Methods decode :: JPG -> ByteString -> Either String (Image VS RGB Word8) #
Readable (Image VS RGB Word8) GIF #
Methods decode :: GIF -> ByteString -> Either String (Image VS RGB Word8) #
Readable (Image VS RGB Word8) BMP #
Methods decode :: BMP -> ByteString -> Either String (Image VS RGB Word8) #
Readable (Image VS RGB Word8) PPM #
Methods decode :: PPM -> ByteString -> Either String (Image VS RGB Word8) #
Readable (Image VS RGB Word16) TIF #
Methods decode :: TIF -> ByteString -> Either String (Image VS RGB Word16) #
Readable (Image VS RGB Word16) PNG #
Methods decode :: PNG -> ByteString -> Either String (Image VS RGB Word16) #
Readable (Image VS RGB Word16) PPM #
Methods decode :: PPM -> ByteString -> Either String (Image VS RGB Word16) #
data Pixel RGB #
data Pixel RGB = PixelRGB !e !e !e
type Components RGB e #
type Components RGB e = (e, e, e)

data RGBA #

Red, Green and Blue color space with Alpha channel.

Constructors

RedRGBA
GreenRGBA
BlueRGBA
AlphaRGBA

Instances

Bounded RGBA #
Methods minBound :: RGBA # maxBound :: RGBA #
Enum RGBA #
Methods succ :: RGBA -> RGBA # pred :: RGBA -> RGBA # toEnum :: Int -> RGBA # fromEnum :: RGBA -> Int # enumFrom :: RGBA -> [RGBA] # enumFromThen :: RGBA -> RGBA -> [RGBA] # enumFromTo :: RGBA -> RGBA -> [RGBA] # enumFromThenTo :: RGBA -> RGBA -> RGBA -> [RGBA] #
Eq RGBA #
Methods (==) :: RGBA -> RGBA -> Bool # (/=) :: RGBA -> RGBA -> Bool #
Show RGBA #
Methods showsPrec :: Int -> RGBA -> ShowS # show :: RGBA -> String # showList :: [RGBA] -> ShowS #
ChannelColour RGBA #
Methods csColour :: RGBA -> AlphaColour Double #
Elevator e => AlphaSpace RGBA e #
Associated Types type Opaque RGBA :: * # Methods getAlpha :: Pixel RGBA e -> e # addAlpha :: e -> Pixel (Opaque RGBA) e -> Pixel RGBA e # dropAlpha :: Pixel RGBA e -> Pixel (Opaque RGBA) e #
Elevator e => ColorSpace RGBA e #
Associated Types type Components RGBA e :: * # Methods toComponents :: Pixel RGBA e -> Components RGBA e # fromComponents :: Components RGBA e -> Pixel RGBA e # promote :: e -> Pixel RGBA e # getPxC :: Pixel RGBA e -> RGBA -> e # setPxC :: Pixel RGBA e -> RGBA -> e -> Pixel RGBA e # mapPxC :: (RGBA -> e -> e) -> Pixel RGBA e -> Pixel RGBA e # liftPx :: (e -> e) -> Pixel RGBA e -> Pixel RGBA e # liftPx2 :: (e -> e -> e) -> Pixel RGBA e -> Pixel RGBA e -> Pixel RGBA e # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel RGBA e -> Pixel RGBA e -> b # foldrPx :: (e -> b -> b) -> b -> Pixel RGBA e -> b # foldlPx :: (b -> e -> b) -> b -> Pixel RGBA e -> b # foldl1Px :: (e -> e -> e) -> Pixel RGBA e -> e # toListPx :: Pixel RGBA e -> [e] #
Elevator e => ToYCbCrA RGBA e #
Methods toPixelYCbCrA :: Pixel RGBA e -> Pixel YCbCrA Double #
Elevator e => ToYCbCr RGBA e #
Methods toPixelYCbCr :: Pixel RGBA e -> Pixel YCbCr Double #
Elevator e => ToCMYKA RGBA e #
Methods toPixelCMYKA :: Pixel RGBA e -> Pixel CMYKA Double #
Elevator e => ToCMYK RGBA e #
Methods toPixelCMYK :: Pixel RGBA e -> Pixel CMYK Double #
Elevator e => ToHSIA RGBA e #
Methods toPixelHSIA :: Pixel RGBA e -> Pixel HSIA Double #
Elevator e => ToHSI RGBA e #
Methods toPixelHSI :: Pixel RGBA e -> Pixel HSI Double #
Elevator e => ToRGBA RGBA e #
Methods toPixelRGBA :: Pixel RGBA e -> Pixel RGBA Double #
Elevator e => ToRGB RGBA e #
Methods toPixelRGB :: Pixel RGBA e -> Pixel RGB Double #
Elevator e => ToYA RGBA e #
Methods toPixelYA :: Pixel RGBA e -> Pixel YA Double #
Elevator e => ToY RGBA e #
Methods toPixelY :: Pixel RGBA e -> Pixel Y Double #
Convertible RGBA Double #
Methods convert :: (ToYA cs' e', ToRGBA cs' e', Array arr cs' e', Array arr RGBA Double) => Image arr cs' e' -> Image arr RGBA Double #
Functor (Pixel RGBA) #
Methods fmap :: (a -> b) -> Pixel RGBA a -> Pixel RGBA b # (<$) :: a -> Pixel RGBA b -> Pixel RGBA a #
Applicative (Pixel RGBA) #
Methods pure :: a -> Pixel RGBA a # (<>) :: Pixel RGBA (a -> b) -> Pixel RGBA a -> Pixel RGBA b # (>) :: Pixel RGBA a -> Pixel RGBA b -> Pixel RGBA b # (<*) :: Pixel RGBA a -> Pixel RGBA b -> Pixel RGBA a #
Foldable (Pixel RGBA) #
Methods fold :: Monoid m => Pixel RGBA m -> m # foldMap :: Monoid m => (a -> m) -> Pixel RGBA a -> m # foldr :: (a -> b -> b) -> b -> Pixel RGBA a -> b # foldr' :: (a -> b -> b) -> b -> Pixel RGBA a -> b # foldl :: (b -> a -> b) -> b -> Pixel RGBA a -> b # foldl' :: (b -> a -> b) -> b -> Pixel RGBA a -> b # foldr1 :: (a -> a -> a) -> Pixel RGBA a -> a # foldl1 :: (a -> a -> a) -> Pixel RGBA a -> a # toList :: Pixel RGBA a -> [a] # null :: Pixel RGBA a -> Bool # length :: Pixel RGBA a -> Int # elem :: Eq a => a -> Pixel RGBA a -> Bool # maximum :: Ord a => Pixel RGBA a -> a # minimum :: Ord a => Pixel RGBA a -> a # sum :: Num a => Pixel RGBA a -> a # product :: Num a => Pixel RGBA a -> a #
Readable [(GifDelay, Image VS RGBA Word8)] GIFA #
Methods decode :: GIFA -> ByteString -> Either String [(GifDelay, Image VS RGBA Word8)] #
Readable [Image VS RGBA Double] GIFA #
Methods decode :: GIFA -> ByteString -> Either String [Image VS RGBA Double] #
Readable [Image VS RGBA Word8] GIFA #
Methods decode :: GIFA -> ByteString -> Either String [Image VS RGBA Word8] #
Readable [(GifDelay, Image VS RGBA Word8)] (Seq GIF) #
Methods decode :: Seq GIF -> ByteString -> Either String [(GifDelay, Image VS RGBA Word8)] #
Readable [Image VS RGBA Double] (Seq GIF) #
Methods decode :: Seq GIF -> ByteString -> Either String [Image VS RGBA Double] #
Readable [Image VS RGBA Word8] (Seq GIF) #
Methods decode :: Seq GIF -> ByteString -> Either String [Image VS RGBA Word8] #
Eq e => Eq (Pixel RGBA e) #
Methods (==) :: Pixel RGBA e -> Pixel RGBA e -> Bool # (/=) :: Pixel RGBA e -> Pixel RGBA e -> Bool #
Show e => Show (Pixel RGBA e) #
Methods showsPrec :: Int -> Pixel RGBA e -> ShowS # show :: Pixel RGBA e -> String # showList :: [Pixel RGBA e] -> ShowS #
Storable e => Storable (Pixel RGBA e) #
Methods sizeOf :: Pixel RGBA e -> Int # alignment :: Pixel RGBA e -> Int # peekElemOff :: Ptr (Pixel RGBA e) -> Int -> IO (Pixel RGBA e) # pokeElemOff :: Ptr (Pixel RGBA e) -> Int -> Pixel RGBA e -> IO () # peekByteOff :: Ptr b -> Int -> IO (Pixel RGBA e) # pokeByteOff :: Ptr b -> Int -> Pixel RGBA e -> IO () # peek :: Ptr (Pixel RGBA e) -> IO (Pixel RGBA e) # poke :: Ptr (Pixel RGBA e) -> Pixel RGBA e -> IO () #
Writable (Image VS RGBA Double) TIF #
Methods encode :: TIF -> [SaveOption TIF] -> Image VS RGBA Double -> ByteString #
Writable (Image VS RGBA Double) TGA #
Methods encode :: TGA -> [SaveOption TGA] -> Image VS RGBA Double -> ByteString #
Writable (Image VS RGBA Double) PNG #
Methods encode :: PNG -> [SaveOption PNG] -> Image VS RGBA Double -> ByteString #
Writable (Image VS RGBA Double) JPG #	Image is converted `YCbCr` color space prior to encoding.
Methods encode :: JPG -> [SaveOption JPG] -> Image VS RGBA Double -> ByteString #
Writable (Image VS RGBA Double) HDR #
Methods encode :: HDR -> [SaveOption HDR] -> Image VS RGBA Double -> ByteString #
Writable (Image VS RGBA Double) GIF #
Methods encode :: GIF -> [SaveOption GIF] -> Image VS RGBA Double -> ByteString #
Writable (Image VS RGBA Double) BMP #
Methods encode :: BMP -> [SaveOption BMP] -> Image VS RGBA Double -> ByteString #
Writable (Image VS RGBA Word8) TIF #
Methods encode :: TIF -> [SaveOption TIF] -> Image VS RGBA Word8 -> ByteString #
Writable (Image VS RGBA Word8) TGA #
Methods encode :: TGA -> [SaveOption TGA] -> Image VS RGBA Word8 -> ByteString #
Writable (Image VS RGBA Word8) PNG #
Methods encode :: PNG -> [SaveOption PNG] -> Image VS RGBA Word8 -> ByteString #
Writable (Image VS RGBA Word8) BMP #
Methods encode :: BMP -> [SaveOption BMP] -> Image VS RGBA Word8 -> ByteString #
Writable (Image VS RGBA Word16) TIF #
Methods encode :: TIF -> [SaveOption TIF] -> Image VS RGBA Word16 -> ByteString #
Writable (Image VS RGBA Word16) PNG #
Methods encode :: PNG -> [SaveOption PNG] -> Image VS RGBA Word16 -> ByteString #
Readable (Image VS RGBA Double) TIF #
Methods decode :: TIF -> ByteString -> Either String (Image VS RGBA Double) #
Readable (Image VS RGBA Double) TGA #
Methods decode :: TGA -> ByteString -> Either String (Image VS RGBA Double) #
Readable (Image VS RGBA Double) PNG #
Methods decode :: PNG -> ByteString -> Either String (Image VS RGBA Double) #
Readable (Image VS RGBA Double) JPG #
Methods decode :: JPG -> ByteString -> Either String (Image VS RGBA Double) #
Readable (Image VS RGBA Double) HDR #
Methods decode :: HDR -> ByteString -> Either String (Image VS RGBA Double) #
Readable (Image VS RGBA Double) GIF #
Methods decode :: GIF -> ByteString -> Either String (Image VS RGBA Double) #
Readable (Image VS RGBA Double) BMP #
Methods decode :: BMP -> ByteString -> Either String (Image VS RGBA Double) #
Readable (Image VS RGBA Double) PPM #
Methods decode :: PPM -> ByteString -> Either String (Image VS RGBA Double) #
Readable (Image VS RGBA Word8) TIF #
Methods decode :: TIF -> ByteString -> Either String (Image VS RGBA Word8) #
Readable (Image VS RGBA Word8) TGA #
Methods decode :: TGA -> ByteString -> Either String (Image VS RGBA Word8) #
Readable (Image VS RGBA Word8) PNG #
Methods decode :: PNG -> ByteString -> Either String (Image VS RGBA Word8) #
Readable (Image VS RGBA Word8) GIF #
Methods decode :: GIF -> ByteString -> Either String (Image VS RGBA Word8) #
Readable (Image VS RGBA Word8) BMP #
Methods decode :: BMP -> ByteString -> Either String (Image VS RGBA Word8) #
Readable (Image VS RGBA Word16) TIF #
Methods decode :: TIF -> ByteString -> Either String (Image VS RGBA Word16) #
Readable (Image VS RGBA Word16) PNG #
Methods decode :: PNG -> ByteString -> Either String (Image VS RGBA Word16) #
type Opaque RGBA #
type Opaque RGBA = RGB
data Pixel RGBA #
data Pixel RGBA = PixelRGBA !e !e !e !e
type Components RGBA e #
type Components RGBA e = (e, e, e, e)

class ColorSpace cs e => ToRGB cs e where #

Conversion to RGB color space.

Minimal complete definition

toPixelRGB

Methods

toPixelRGB :: Pixel cs e -> Pixel RGB Double #

Convert to an RGB pixel.

Instances

Elevator e => ToRGB YCbCrA e #
Methods toPixelRGB :: Pixel YCbCrA e -> Pixel RGB Double #
Elevator e => ToRGB YCbCr e #
Methods toPixelRGB :: Pixel YCbCr e -> Pixel RGB Double #
Elevator e => ToRGB YA e #
Methods toPixelRGB :: Pixel YA e -> Pixel RGB Double #
Elevator e => ToRGB Y e #
Methods toPixelRGB :: Pixel Y e -> Pixel RGB Double #
ToRGB X Bit #
Methods toPixelRGB :: Pixel X Bit -> Pixel RGB Double #
Elevator e => ToRGB RGBA e #
Methods toPixelRGB :: Pixel RGBA e -> Pixel RGB Double #
Elevator e => ToRGB RGB e #
Methods toPixelRGB :: Pixel RGB e -> Pixel RGB Double #
Elevator e => ToRGB HSIA e #
Methods toPixelRGB :: Pixel HSIA e -> Pixel RGB Double #
Elevator e => ToRGB HSI e #
Methods toPixelRGB :: Pixel HSI e -> Pixel RGB Double #
Elevator e => ToRGB CMYKA e #
Methods toPixelRGB :: Pixel CMYKA e -> Pixel RGB Double #
Elevator e => ToRGB CMYK e #
Methods toPixelRGB :: Pixel CMYK e -> Pixel RGB Double #

class ToRGB cs e => ToRGBA cs e where #

Conversion to RGBA from another color space with Alpha channel.

Methods

toPixelRGBA :: Pixel cs e -> Pixel RGBA Double #

Convert to an RGBA pixel.

Instances

Elevator e => ToRGBA YCbCrA e #
Methods toPixelRGBA :: Pixel YCbCrA e -> Pixel RGBA Double #
ToRGB YCbCr e => ToRGBA YCbCr e #
Methods toPixelRGBA :: Pixel YCbCr e -> Pixel RGBA Double #
Elevator e => ToRGBA YA e #
Methods toPixelRGBA :: Pixel YA e -> Pixel RGBA Double #
ToRGB Y e => ToRGBA Y e #
Methods toPixelRGBA :: Pixel Y e -> Pixel RGBA Double #
ToRGBA X Bit #
Methods toPixelRGBA :: Pixel X Bit -> Pixel RGBA Double #
Elevator e => ToRGBA RGBA e #
Methods toPixelRGBA :: Pixel RGBA e -> Pixel RGBA Double #
ToRGB RGB e => ToRGBA RGB e #
Methods toPixelRGBA :: Pixel RGB e -> Pixel RGBA Double #
Elevator e => ToRGBA HSIA e #
Methods toPixelRGBA :: Pixel HSIA e -> Pixel RGBA Double #
ToRGB HSI e => ToRGBA HSI e #
Methods toPixelRGBA :: Pixel HSI e -> Pixel RGBA Double #
Elevator e => ToRGBA CMYKA e #
Methods toPixelRGBA :: Pixel CMYKA e -> Pixel RGBA Double #
ToRGB CMYK e => ToRGBA CMYK e #
Methods toPixelRGBA :: Pixel CMYK e -> Pixel RGBA Double #

HSI

data HSI #

Hue, Saturation and Intensity color space.

Constructors

HueHSI	Hue
SatHSI	Saturation
IntHSI	Intensity

Instances

Bounded HSI #
Methods minBound :: HSI # maxBound :: HSI #
Enum HSI #
Methods succ :: HSI -> HSI # pred :: HSI -> HSI # toEnum :: Int -> HSI # fromEnum :: HSI -> Int # enumFrom :: HSI -> [HSI] # enumFromThen :: HSI -> HSI -> [HSI] # enumFromTo :: HSI -> HSI -> [HSI] # enumFromThenTo :: HSI -> HSI -> HSI -> [HSI] #
Eq HSI #
Methods (==) :: HSI -> HSI -> Bool # (/=) :: HSI -> HSI -> Bool #
Show HSI #
Methods showsPrec :: Int -> HSI -> ShowS # show :: HSI -> String # showList :: [HSI] -> ShowS #
ChannelColour HSI #
Methods csColour :: HSI -> AlphaColour Double #
Elevator e => ColorSpace HSI e #
Associated Types type Components HSI e :: * # Methods toComponents :: Pixel HSI e -> Components HSI e # fromComponents :: Components HSI e -> Pixel HSI e # promote :: e -> Pixel HSI e # getPxC :: Pixel HSI e -> HSI -> e # setPxC :: Pixel HSI e -> HSI -> e -> Pixel HSI e # mapPxC :: (HSI -> e -> e) -> Pixel HSI e -> Pixel HSI e # liftPx :: (e -> e) -> Pixel HSI e -> Pixel HSI e # liftPx2 :: (e -> e -> e) -> Pixel HSI e -> Pixel HSI e -> Pixel HSI e # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel HSI e -> Pixel HSI e -> b # foldrPx :: (e -> b -> b) -> b -> Pixel HSI e -> b # foldlPx :: (b -> e -> b) -> b -> Pixel HSI e -> b # foldl1Px :: (e -> e -> e) -> Pixel HSI e -> e # toListPx :: Pixel HSI e -> [e] #
ToYCbCr HSI e => ToYCbCrA HSI e #
Methods toPixelYCbCrA :: Pixel HSI e -> Pixel YCbCrA Double #
Elevator e => ToYCbCr HSI e #
Methods toPixelYCbCr :: Pixel HSI e -> Pixel YCbCr Double #
ToCMYK HSI e => ToCMYKA HSI e #
Methods toPixelCMYKA :: Pixel HSI e -> Pixel CMYKA Double #
Elevator e => ToCMYK HSI e #
Methods toPixelCMYK :: Pixel HSI e -> Pixel CMYK Double #
ToHSI HSI e => ToHSIA HSI e #
Methods toPixelHSIA :: Pixel HSI e -> Pixel HSIA Double #
Elevator e => ToHSI HSI e #
Methods toPixelHSI :: Pixel HSI e -> Pixel HSI Double #
ToRGB HSI e => ToRGBA HSI e #
Methods toPixelRGBA :: Pixel HSI e -> Pixel RGBA Double #
Elevator e => ToRGB HSI e #
Methods toPixelRGB :: Pixel HSI e -> Pixel RGB Double #
ToY HSI e => ToYA HSI e #
Methods toPixelYA :: Pixel HSI e -> Pixel YA Double #
Elevator e => ToY HSI e #
Methods toPixelY :: Pixel HSI e -> Pixel Y Double #
Functor (Pixel HSI) #
Methods fmap :: (a -> b) -> Pixel HSI a -> Pixel HSI b # (<$) :: a -> Pixel HSI b -> Pixel HSI a #
Applicative (Pixel HSI) #
Methods pure :: a -> Pixel HSI a # (<>) :: Pixel HSI (a -> b) -> Pixel HSI a -> Pixel HSI b # (>) :: Pixel HSI a -> Pixel HSI b -> Pixel HSI b # (<*) :: Pixel HSI a -> Pixel HSI b -> Pixel HSI a #
Foldable (Pixel HSI) #
Methods fold :: Monoid m => Pixel HSI m -> m # foldMap :: Monoid m => (a -> m) -> Pixel HSI a -> m # foldr :: (a -> b -> b) -> b -> Pixel HSI a -> b # foldr' :: (a -> b -> b) -> b -> Pixel HSI a -> b # foldl :: (b -> a -> b) -> b -> Pixel HSI a -> b # foldl' :: (b -> a -> b) -> b -> Pixel HSI a -> b # foldr1 :: (a -> a -> a) -> Pixel HSI a -> a # foldl1 :: (a -> a -> a) -> Pixel HSI a -> a # toList :: Pixel HSI a -> [a] # null :: Pixel HSI a -> Bool # length :: Pixel HSI a -> Int # elem :: Eq a => a -> Pixel HSI a -> Bool # maximum :: Ord a => Pixel HSI a -> a # minimum :: Ord a => Pixel HSI a -> a # sum :: Num a => Pixel HSI a -> a # product :: Num a => Pixel HSI a -> a #
Eq e => Eq (Pixel HSI e) #
Methods (==) :: Pixel HSI e -> Pixel HSI e -> Bool # (/=) :: Pixel HSI e -> Pixel HSI e -> Bool #
Show e => Show (Pixel HSI e) #
Methods showsPrec :: Int -> Pixel HSI e -> ShowS # show :: Pixel HSI e -> String # showList :: [Pixel HSI e] -> ShowS #
Storable e => Storable (Pixel HSI e) #
Methods sizeOf :: Pixel HSI e -> Int # alignment :: Pixel HSI e -> Int # peekElemOff :: Ptr (Pixel HSI e) -> Int -> IO (Pixel HSI e) # pokeElemOff :: Ptr (Pixel HSI e) -> Int -> Pixel HSI e -> IO () # peekByteOff :: Ptr b -> Int -> IO (Pixel HSI e) # pokeByteOff :: Ptr b -> Int -> Pixel HSI e -> IO () # peek :: Ptr (Pixel HSI e) -> IO (Pixel HSI e) # poke :: Ptr (Pixel HSI e) -> Pixel HSI e -> IO () #
data Pixel HSI #
data Pixel HSI = PixelHSI !e !e !e
type Components HSI e #
type Components HSI e = (e, e, e)

data HSIA #

Hue, Saturation and Intensity color space with Alpha channel.

Constructors

HueHSIA	Hue
SatHSIA	Saturation
IntHSIA	Intensity
AlphaHSIA	Alpha

Instances

Bounded HSIA #
Methods minBound :: HSIA # maxBound :: HSIA #
Enum HSIA #
Methods succ :: HSIA -> HSIA # pred :: HSIA -> HSIA # toEnum :: Int -> HSIA # fromEnum :: HSIA -> Int # enumFrom :: HSIA -> [HSIA] # enumFromThen :: HSIA -> HSIA -> [HSIA] # enumFromTo :: HSIA -> HSIA -> [HSIA] # enumFromThenTo :: HSIA -> HSIA -> HSIA -> [HSIA] #
Eq HSIA #
Methods (==) :: HSIA -> HSIA -> Bool # (/=) :: HSIA -> HSIA -> Bool #
Show HSIA #
Methods showsPrec :: Int -> HSIA -> ShowS # show :: HSIA -> String # showList :: [HSIA] -> ShowS #
ChannelColour HSIA #
Methods csColour :: HSIA -> AlphaColour Double #
Elevator e => AlphaSpace HSIA e #
Associated Types type Opaque HSIA :: * # Methods getAlpha :: Pixel HSIA e -> e # addAlpha :: e -> Pixel (Opaque HSIA) e -> Pixel HSIA e # dropAlpha :: Pixel HSIA e -> Pixel (Opaque HSIA) e #
Elevator e => ColorSpace HSIA e #
Associated Types type Components HSIA e :: * # Methods toComponents :: Pixel HSIA e -> Components HSIA e # fromComponents :: Components HSIA e -> Pixel HSIA e # promote :: e -> Pixel HSIA e # getPxC :: Pixel HSIA e -> HSIA -> e # setPxC :: Pixel HSIA e -> HSIA -> e -> Pixel HSIA e # mapPxC :: (HSIA -> e -> e) -> Pixel HSIA e -> Pixel HSIA e # liftPx :: (e -> e) -> Pixel HSIA e -> Pixel HSIA e # liftPx2 :: (e -> e -> e) -> Pixel HSIA e -> Pixel HSIA e -> Pixel HSIA e # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel HSIA e -> Pixel HSIA e -> b # foldrPx :: (e -> b -> b) -> b -> Pixel HSIA e -> b # foldlPx :: (b -> e -> b) -> b -> Pixel HSIA e -> b # foldl1Px :: (e -> e -> e) -> Pixel HSIA e -> e # toListPx :: Pixel HSIA e -> [e] #
Elevator e => ToYCbCrA HSIA e #
Methods toPixelYCbCrA :: Pixel HSIA e -> Pixel YCbCrA Double #
Elevator e => ToYCbCr HSIA e #
Methods toPixelYCbCr :: Pixel HSIA e -> Pixel YCbCr Double #
Elevator e => ToCMYKA HSIA e #
Methods toPixelCMYKA :: Pixel HSIA e -> Pixel CMYKA Double #
Elevator e => ToCMYK HSIA e #
Methods toPixelCMYK :: Pixel HSIA e -> Pixel CMYK Double #
Elevator e => ToHSIA HSIA e #
Methods toPixelHSIA :: Pixel HSIA e -> Pixel HSIA Double #
Elevator e => ToHSI HSIA e #
Methods toPixelHSI :: Pixel HSIA e -> Pixel HSI Double #
Elevator e => ToRGBA HSIA e #
Methods toPixelRGBA :: Pixel HSIA e -> Pixel RGBA Double #
Elevator e => ToRGB HSIA e #
Methods toPixelRGB :: Pixel HSIA e -> Pixel RGB Double #
Elevator e => ToYA HSIA e #
Methods toPixelYA :: Pixel HSIA e -> Pixel YA Double #
Elevator e => ToY HSIA e #
Methods toPixelY :: Pixel HSIA e -> Pixel Y Double #
Functor (Pixel HSIA) #
Methods fmap :: (a -> b) -> Pixel HSIA a -> Pixel HSIA b # (<$) :: a -> Pixel HSIA b -> Pixel HSIA a #
Applicative (Pixel HSIA) #
Methods pure :: a -> Pixel HSIA a # (<>) :: Pixel HSIA (a -> b) -> Pixel HSIA a -> Pixel HSIA b # (>) :: Pixel HSIA a -> Pixel HSIA b -> Pixel HSIA b # (<*) :: Pixel HSIA a -> Pixel HSIA b -> Pixel HSIA a #
Foldable (Pixel HSIA) #
Methods fold :: Monoid m => Pixel HSIA m -> m # foldMap :: Monoid m => (a -> m) -> Pixel HSIA a -> m # foldr :: (a -> b -> b) -> b -> Pixel HSIA a -> b # foldr' :: (a -> b -> b) -> b -> Pixel HSIA a -> b # foldl :: (b -> a -> b) -> b -> Pixel HSIA a -> b # foldl' :: (b -> a -> b) -> b -> Pixel HSIA a -> b # foldr1 :: (a -> a -> a) -> Pixel HSIA a -> a # foldl1 :: (a -> a -> a) -> Pixel HSIA a -> a # toList :: Pixel HSIA a -> [a] # null :: Pixel HSIA a -> Bool # length :: Pixel HSIA a -> Int # elem :: Eq a => a -> Pixel HSIA a -> Bool # maximum :: Ord a => Pixel HSIA a -> a # minimum :: Ord a => Pixel HSIA a -> a # sum :: Num a => Pixel HSIA a -> a # product :: Num a => Pixel HSIA a -> a #
Eq e => Eq (Pixel HSIA e) #
Methods (==) :: Pixel HSIA e -> Pixel HSIA e -> Bool # (/=) :: Pixel HSIA e -> Pixel HSIA e -> Bool #
Show e => Show (Pixel HSIA e) #
Methods showsPrec :: Int -> Pixel HSIA e -> ShowS # show :: Pixel HSIA e -> String # showList :: [Pixel HSIA e] -> ShowS #
Storable e => Storable (Pixel HSIA e) #
Methods sizeOf :: Pixel HSIA e -> Int # alignment :: Pixel HSIA e -> Int # peekElemOff :: Ptr (Pixel HSIA e) -> Int -> IO (Pixel HSIA e) # pokeElemOff :: Ptr (Pixel HSIA e) -> Int -> Pixel HSIA e -> IO () # peekByteOff :: Ptr b -> Int -> IO (Pixel HSIA e) # pokeByteOff :: Ptr b -> Int -> Pixel HSIA e -> IO () # peek :: Ptr (Pixel HSIA e) -> IO (Pixel HSIA e) # poke :: Ptr (Pixel HSIA e) -> Pixel HSIA e -> IO () #
type Opaque HSIA #
type Opaque HSIA = HSI
data Pixel HSIA #
data Pixel HSIA = PixelHSIA !e !e !e !e
type Components HSIA e #
type Components HSIA e = (e, e, e, e)

class ColorSpace cs e => ToHSI cs e where #

Conversion to HSI color space.

Minimal complete definition

toPixelHSI

Methods

toPixelHSI :: Pixel cs e -> Pixel HSI Double #

Convert to an HSI pixel.

Instances

Elevator e => ToHSI YCbCrA e #
Methods toPixelHSI :: Pixel YCbCrA e -> Pixel HSI Double #
Elevator e => ToHSI YCbCr e #
Methods toPixelHSI :: Pixel YCbCr e -> Pixel HSI Double #
Elevator e => ToHSI YA e #
Methods toPixelHSI :: Pixel YA e -> Pixel HSI Double #
Elevator e => ToHSI Y e #
Methods toPixelHSI :: Pixel Y e -> Pixel HSI Double #
Elevator e => ToHSI RGBA e #
Methods toPixelHSI :: Pixel RGBA e -> Pixel HSI Double #
Elevator e => ToHSI RGB e #
Methods toPixelHSI :: Pixel RGB e -> Pixel HSI Double #
Elevator e => ToHSI HSIA e #
Methods toPixelHSI :: Pixel HSIA e -> Pixel HSI Double #
Elevator e => ToHSI HSI e #
Methods toPixelHSI :: Pixel HSI e -> Pixel HSI Double #
Elevator e => ToHSI CMYKA e #
Methods toPixelHSI :: Pixel CMYKA e -> Pixel HSI Double #
Elevator e => ToHSI CMYK e #
Methods toPixelHSI :: Pixel CMYK e -> Pixel HSI Double #

class ToHSI cs e => ToHSIA cs e where #

Conversion to HSIA from another color space with Alpha channel.

Methods

toPixelHSIA :: Pixel cs e -> Pixel HSIA Double #

Convert to an HSIA pixel.

Instances

Elevator e => ToHSIA YCbCrA e #
Methods toPixelHSIA :: Pixel YCbCrA e -> Pixel HSIA Double #
ToHSI YCbCr e => ToHSIA YCbCr e #
Methods toPixelHSIA :: Pixel YCbCr e -> Pixel HSIA Double #
Elevator e => ToHSIA YA e #
Methods toPixelHSIA :: Pixel YA e -> Pixel HSIA Double #
ToHSI Y e => ToHSIA Y e #
Methods toPixelHSIA :: Pixel Y e -> Pixel HSIA Double #
Elevator e => ToHSIA RGBA e #
Methods toPixelHSIA :: Pixel RGBA e -> Pixel HSIA Double #
ToHSI RGB e => ToHSIA RGB e #
Methods toPixelHSIA :: Pixel RGB e -> Pixel HSIA Double #
Elevator e => ToHSIA HSIA e #
Methods toPixelHSIA :: Pixel HSIA e -> Pixel HSIA Double #
ToHSI HSI e => ToHSIA HSI e #
Methods toPixelHSIA :: Pixel HSI e -> Pixel HSIA Double #
Elevator e => ToHSIA CMYKA e #
Methods toPixelHSIA :: Pixel CMYKA e -> Pixel HSIA Double #
ToHSI CMYK e => ToHSIA CMYK e #
Methods toPixelHSIA :: Pixel CMYK e -> Pixel HSIA Double #

CMYK

data CMYK #

Cyan, Magenta, Yellow and Black color space.

Constructors

CyanCMYK	Cyan
MagCMYK	Magenta
YelCMYK	Yellow
KeyCMYK	Key (Black)

Instances

Bounded CMYK #
Methods minBound :: CMYK # maxBound :: CMYK #
Enum CMYK #
Methods succ :: CMYK -> CMYK # pred :: CMYK -> CMYK # toEnum :: Int -> CMYK # fromEnum :: CMYK -> Int # enumFrom :: CMYK -> [CMYK] # enumFromThen :: CMYK -> CMYK -> [CMYK] # enumFromTo :: CMYK -> CMYK -> [CMYK] # enumFromThenTo :: CMYK -> CMYK -> CMYK -> [CMYK] #
Eq CMYK #
Methods (==) :: CMYK -> CMYK -> Bool # (/=) :: CMYK -> CMYK -> Bool #
Show CMYK #
Methods showsPrec :: Int -> CMYK -> ShowS # show :: CMYK -> String # showList :: [CMYK] -> ShowS #
ChannelColour CMYK #
Methods csColour :: CMYK -> AlphaColour Double #
Elevator e => ColorSpace CMYK e #
Associated Types type Components CMYK e :: * # Methods toComponents :: Pixel CMYK e -> Components CMYK e # fromComponents :: Components CMYK e -> Pixel CMYK e # promote :: e -> Pixel CMYK e # getPxC :: Pixel CMYK e -> CMYK -> e # setPxC :: Pixel CMYK e -> CMYK -> e -> Pixel CMYK e # mapPxC :: (CMYK -> e -> e) -> Pixel CMYK e -> Pixel CMYK e # liftPx :: (e -> e) -> Pixel CMYK e -> Pixel CMYK e # liftPx2 :: (e -> e -> e) -> Pixel CMYK e -> Pixel CMYK e -> Pixel CMYK e # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel CMYK e -> Pixel CMYK e -> b # foldrPx :: (e -> b -> b) -> b -> Pixel CMYK e -> b # foldlPx :: (b -> e -> b) -> b -> Pixel CMYK e -> b # foldl1Px :: (e -> e -> e) -> Pixel CMYK e -> e # toListPx :: Pixel CMYK e -> [e] #
ToYCbCr CMYK e => ToYCbCrA CMYK e #
Methods toPixelYCbCrA :: Pixel CMYK e -> Pixel YCbCrA Double #
Elevator e => ToYCbCr CMYK e #
Methods toPixelYCbCr :: Pixel CMYK e -> Pixel YCbCr Double #
ToCMYK CMYK e => ToCMYKA CMYK e #
Methods toPixelCMYKA :: Pixel CMYK e -> Pixel CMYKA Double #
Elevator e => ToCMYK CMYK e #
Methods toPixelCMYK :: Pixel CMYK e -> Pixel CMYK Double #
ToHSI CMYK e => ToHSIA CMYK e #
Methods toPixelHSIA :: Pixel CMYK e -> Pixel HSIA Double #
Elevator e => ToHSI CMYK e #
Methods toPixelHSI :: Pixel CMYK e -> Pixel HSI Double #
ToRGB CMYK e => ToRGBA CMYK e #
Methods toPixelRGBA :: Pixel CMYK e -> Pixel RGBA Double #
Elevator e => ToRGB CMYK e #
Methods toPixelRGB :: Pixel CMYK e -> Pixel RGB Double #
ToY CMYK e => ToYA CMYK e #
Methods toPixelYA :: Pixel CMYK e -> Pixel YA Double #
Elevator e => ToY CMYK e #
Methods toPixelY :: Pixel CMYK e -> Pixel Y Double #
Functor (Pixel CMYK) #
Methods fmap :: (a -> b) -> Pixel CMYK a -> Pixel CMYK b # (<$) :: a -> Pixel CMYK b -> Pixel CMYK a #
Applicative (Pixel CMYK) #
Methods pure :: a -> Pixel CMYK a # (<>) :: Pixel CMYK (a -> b) -> Pixel CMYK a -> Pixel CMYK b # (>) :: Pixel CMYK a -> Pixel CMYK b -> Pixel CMYK b # (<*) :: Pixel CMYK a -> Pixel CMYK b -> Pixel CMYK a #
Foldable (Pixel CMYK) #
Methods fold :: Monoid m => Pixel CMYK m -> m # foldMap :: Monoid m => (a -> m) -> Pixel CMYK a -> m # foldr :: (a -> b -> b) -> b -> Pixel CMYK a -> b # foldr' :: (a -> b -> b) -> b -> Pixel CMYK a -> b # foldl :: (b -> a -> b) -> b -> Pixel CMYK a -> b # foldl' :: (b -> a -> b) -> b -> Pixel CMYK a -> b # foldr1 :: (a -> a -> a) -> Pixel CMYK a -> a # foldl1 :: (a -> a -> a) -> Pixel CMYK a -> a # toList :: Pixel CMYK a -> [a] # null :: Pixel CMYK a -> Bool # length :: Pixel CMYK a -> Int # elem :: Eq a => a -> Pixel CMYK a -> Bool # maximum :: Ord a => Pixel CMYK a -> a # minimum :: Ord a => Pixel CMYK a -> a # sum :: Num a => Pixel CMYK a -> a # product :: Num a => Pixel CMYK a -> a #
Eq e => Eq (Pixel CMYK e) #
Methods (==) :: Pixel CMYK e -> Pixel CMYK e -> Bool # (/=) :: Pixel CMYK e -> Pixel CMYK e -> Bool #
Show e => Show (Pixel CMYK e) #
Methods showsPrec :: Int -> Pixel CMYK e -> ShowS # show :: Pixel CMYK e -> String # showList :: [Pixel CMYK e] -> ShowS #
Storable e => Storable (Pixel CMYK e) #
Methods sizeOf :: Pixel CMYK e -> Int # alignment :: Pixel CMYK e -> Int # peekElemOff :: Ptr (Pixel CMYK e) -> Int -> IO (Pixel CMYK e) # pokeElemOff :: Ptr (Pixel CMYK e) -> Int -> Pixel CMYK e -> IO () # peekByteOff :: Ptr b -> Int -> IO (Pixel CMYK e) # pokeByteOff :: Ptr b -> Int -> Pixel CMYK e -> IO () # peek :: Ptr (Pixel CMYK e) -> IO (Pixel CMYK e) # poke :: Ptr (Pixel CMYK e) -> Pixel CMYK e -> IO () #
Writable (Image VS CMYK Double) TIF #
Methods encode :: TIF -> [SaveOption TIF] -> Image VS CMYK Double -> ByteString #
Writable (Image VS CMYK Word8) TIF #
Methods encode :: TIF -> [SaveOption TIF] -> Image VS CMYK Word8 -> ByteString #
Writable (Image VS CMYK Word8) JPG #
Methods encode :: JPG -> [SaveOption JPG] -> Image VS CMYK Word8 -> ByteString #
Writable (Image VS CMYK Word16) TIF #
Methods encode :: TIF -> [SaveOption TIF] -> Image VS CMYK Word16 -> ByteString #
Readable (Image VS CMYK Word8) TIF #
Methods decode :: TIF -> ByteString -> Either String (Image VS CMYK Word8) #
Readable (Image VS CMYK Word8) JPG #
Methods decode :: JPG -> ByteString -> Either String (Image VS CMYK Word8) #
Readable (Image VS CMYK Word16) TIF #
Methods decode :: TIF -> ByteString -> Either String (Image VS CMYK Word16) #
data Pixel CMYK #
data Pixel CMYK = PixelCMYK !e !e !e !e
type Components CMYK e #
type Components CMYK e = (e, e, e, e)

data CMYKA #

Cyan, Magenta, Yellow and Black color space with Alpha channel.

Constructors

CyanCMYKA	Cyan
MagCMYKA	Magenta
YelCMYKA	Yellow
KeyCMYKA	Key (Black)
AlphaCMYKA	Alpha

Instances

Bounded CMYKA #
Methods minBound :: CMYKA # maxBound :: CMYKA #
Enum CMYKA #
Methods succ :: CMYKA -> CMYKA # pred :: CMYKA -> CMYKA # toEnum :: Int -> CMYKA # fromEnum :: CMYKA -> Int # enumFrom :: CMYKA -> [CMYKA] # enumFromThen :: CMYKA -> CMYKA -> [CMYKA] # enumFromTo :: CMYKA -> CMYKA -> [CMYKA] # enumFromThenTo :: CMYKA -> CMYKA -> CMYKA -> [CMYKA] #
Eq CMYKA #
Methods (==) :: CMYKA -> CMYKA -> Bool # (/=) :: CMYKA -> CMYKA -> Bool #
Show CMYKA #
Methods showsPrec :: Int -> CMYKA -> ShowS # show :: CMYKA -> String # showList :: [CMYKA] -> ShowS #
ChannelColour CMYKA #
Methods csColour :: CMYKA -> AlphaColour Double #
Elevator e => AlphaSpace CMYKA e #
Associated Types type Opaque CMYKA :: * # Methods getAlpha :: Pixel CMYKA e -> e # addAlpha :: e -> Pixel (Opaque CMYKA) e -> Pixel CMYKA e # dropAlpha :: Pixel CMYKA e -> Pixel (Opaque CMYKA) e #
Elevator e => ColorSpace CMYKA e #
Associated Types type Components CMYKA e :: * # Methods toComponents :: Pixel CMYKA e -> Components CMYKA e # fromComponents :: Components CMYKA e -> Pixel CMYKA e # promote :: e -> Pixel CMYKA e # getPxC :: Pixel CMYKA e -> CMYKA -> e # setPxC :: Pixel CMYKA e -> CMYKA -> e -> Pixel CMYKA e # mapPxC :: (CMYKA -> e -> e) -> Pixel CMYKA e -> Pixel CMYKA e # liftPx :: (e -> e) -> Pixel CMYKA e -> Pixel CMYKA e # liftPx2 :: (e -> e -> e) -> Pixel CMYKA e -> Pixel CMYKA e -> Pixel CMYKA e # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel CMYKA e -> Pixel CMYKA e -> b # foldrPx :: (e -> b -> b) -> b -> Pixel CMYKA e -> b # foldlPx :: (b -> e -> b) -> b -> Pixel CMYKA e -> b # foldl1Px :: (e -> e -> e) -> Pixel CMYKA e -> e # toListPx :: Pixel CMYKA e -> [e] #
Elevator e => ToYCbCrA CMYKA e #
Methods toPixelYCbCrA :: Pixel CMYKA e -> Pixel YCbCrA Double #
Elevator e => ToYCbCr CMYKA e #
Methods toPixelYCbCr :: Pixel CMYKA e -> Pixel YCbCr Double #
Elevator e => ToCMYKA CMYKA e #
Methods toPixelCMYKA :: Pixel CMYKA e -> Pixel CMYKA Double #
Elevator e => ToCMYK CMYKA e #
Methods toPixelCMYK :: Pixel CMYKA e -> Pixel CMYK Double #
Elevator e => ToHSIA CMYKA e #
Methods toPixelHSIA :: Pixel CMYKA e -> Pixel HSIA Double #
Elevator e => ToHSI CMYKA e #
Methods toPixelHSI :: Pixel CMYKA e -> Pixel HSI Double #
Elevator e => ToRGBA CMYKA e #
Methods toPixelRGBA :: Pixel CMYKA e -> Pixel RGBA Double #
Elevator e => ToRGB CMYKA e #
Methods toPixelRGB :: Pixel CMYKA e -> Pixel RGB Double #
Elevator e => ToYA CMYKA e #
Methods toPixelYA :: Pixel CMYKA e -> Pixel YA Double #
Elevator e => ToY CMYKA e #
Methods toPixelY :: Pixel CMYKA e -> Pixel Y Double #
Functor (Pixel CMYKA) #
Methods fmap :: (a -> b) -> Pixel CMYKA a -> Pixel CMYKA b # (<$) :: a -> Pixel CMYKA b -> Pixel CMYKA a #
Applicative (Pixel CMYKA) #
Methods pure :: a -> Pixel CMYKA a # (<>) :: Pixel CMYKA (a -> b) -> Pixel CMYKA a -> Pixel CMYKA b # (>) :: Pixel CMYKA a -> Pixel CMYKA b -> Pixel CMYKA b # (<*) :: Pixel CMYKA a -> Pixel CMYKA b -> Pixel CMYKA a #
Foldable (Pixel CMYKA) #
Methods fold :: Monoid m => Pixel CMYKA m -> m # foldMap :: Monoid m => (a -> m) -> Pixel CMYKA a -> m # foldr :: (a -> b -> b) -> b -> Pixel CMYKA a -> b # foldr' :: (a -> b -> b) -> b -> Pixel CMYKA a -> b # foldl :: (b -> a -> b) -> b -> Pixel CMYKA a -> b # foldl' :: (b -> a -> b) -> b -> Pixel CMYKA a -> b # foldr1 :: (a -> a -> a) -> Pixel CMYKA a -> a # foldl1 :: (a -> a -> a) -> Pixel CMYKA a -> a # toList :: Pixel CMYKA a -> [a] # null :: Pixel CMYKA a -> Bool # length :: Pixel CMYKA a -> Int # elem :: Eq a => a -> Pixel CMYKA a -> Bool # maximum :: Ord a => Pixel CMYKA a -> a # minimum :: Ord a => Pixel CMYKA a -> a # sum :: Num a => Pixel CMYKA a -> a # product :: Num a => Pixel CMYKA a -> a #
Eq e => Eq (Pixel CMYKA e) #
Methods (==) :: Pixel CMYKA e -> Pixel CMYKA e -> Bool # (/=) :: Pixel CMYKA e -> Pixel CMYKA e -> Bool #
Show e => Show (Pixel CMYKA e) #
Methods showsPrec :: Int -> Pixel CMYKA e -> ShowS # show :: Pixel CMYKA e -> String # showList :: [Pixel CMYKA e] -> ShowS #
Storable e => Storable (Pixel CMYKA e) #
Methods sizeOf :: Pixel CMYKA e -> Int # alignment :: Pixel CMYKA e -> Int # peekElemOff :: Ptr (Pixel CMYKA e) -> Int -> IO (Pixel CMYKA e) # pokeElemOff :: Ptr (Pixel CMYKA e) -> Int -> Pixel CMYKA e -> IO () # peekByteOff :: Ptr b -> Int -> IO (Pixel CMYKA e) # pokeByteOff :: Ptr b -> Int -> Pixel CMYKA e -> IO () # peek :: Ptr (Pixel CMYKA e) -> IO (Pixel CMYKA e) # poke :: Ptr (Pixel CMYKA e) -> Pixel CMYKA e -> IO () #
type Opaque CMYKA #
type Opaque CMYKA = CMYK
data Pixel CMYKA #
data Pixel CMYKA = PixelCMYKA !e !e !e !e !e
type Components CMYKA e #
type Components CMYKA e = (e, e, e, e, e)

class ColorSpace cs e => ToCMYK cs e where #

Conversion to CMYK color space.

Minimal complete definition

toPixelCMYK

Methods

toPixelCMYK :: Pixel cs e -> Pixel CMYK Double #

Convert to a CMYK pixel.

Instances

Elevator e => ToCMYK YCbCrA e #
Methods toPixelCMYK :: Pixel YCbCrA e -> Pixel CMYK Double #
Elevator e => ToCMYK YCbCr e #
Methods toPixelCMYK :: Pixel YCbCr e -> Pixel CMYK Double #
Elevator e => ToCMYK YA e #
Methods toPixelCMYK :: Pixel YA e -> Pixel CMYK Double #
Elevator e => ToCMYK Y e #
Methods toPixelCMYK :: Pixel Y e -> Pixel CMYK Double #
Elevator e => ToCMYK RGBA e #
Methods toPixelCMYK :: Pixel RGBA e -> Pixel CMYK Double #
Elevator e => ToCMYK RGB e #
Methods toPixelCMYK :: Pixel RGB e -> Pixel CMYK Double #
Elevator e => ToCMYK HSIA e #
Methods toPixelCMYK :: Pixel HSIA e -> Pixel CMYK Double #
Elevator e => ToCMYK HSI e #
Methods toPixelCMYK :: Pixel HSI e -> Pixel CMYK Double #
Elevator e => ToCMYK CMYKA e #
Methods toPixelCMYK :: Pixel CMYKA e -> Pixel CMYK Double #
Elevator e => ToCMYK CMYK e #
Methods toPixelCMYK :: Pixel CMYK e -> Pixel CMYK Double #

class ToCMYK cs e => ToCMYKA cs e where #

Conversion to CMYKA.

Methods

toPixelCMYKA :: Pixel cs e -> Pixel CMYKA Double #

Convert to a CMYKA pixel.

Instances

Elevator e => ToCMYKA YCbCrA e #
Methods toPixelCMYKA :: Pixel YCbCrA e -> Pixel CMYKA Double #
ToCMYK YCbCr e => ToCMYKA YCbCr e #
Methods toPixelCMYKA :: Pixel YCbCr e -> Pixel CMYKA Double #
Elevator e => ToCMYKA YA e #
Methods toPixelCMYKA :: Pixel YA e -> Pixel CMYKA Double #
ToCMYK Y e => ToCMYKA Y e #
Methods toPixelCMYKA :: Pixel Y e -> Pixel CMYKA Double #
Elevator e => ToCMYKA RGBA e #
Methods toPixelCMYKA :: Pixel RGBA e -> Pixel CMYKA Double #
ToCMYK RGB e => ToCMYKA RGB e #
Methods toPixelCMYKA :: Pixel RGB e -> Pixel CMYKA Double #
Elevator e => ToCMYKA HSIA e #
Methods toPixelCMYKA :: Pixel HSIA e -> Pixel CMYKA Double #
ToCMYK HSI e => ToCMYKA HSI e #
Methods toPixelCMYKA :: Pixel HSI e -> Pixel CMYKA Double #
Elevator e => ToCMYKA CMYKA e #
Methods toPixelCMYKA :: Pixel CMYKA e -> Pixel CMYKA Double #
ToCMYK CMYK e => ToCMYKA CMYK e #
Methods toPixelCMYKA :: Pixel CMYK e -> Pixel CMYKA Double #

YCbCr

data YCbCr #

Color space is used to encode RGB information and is used in JPEG compression.

Constructors

LumaYCbCr	Luma component (commonly denoted as Y')
CBlueYCbCr	Blue difference chroma component
CRedYCbCr	Red difference chroma component

Instances

Bounded YCbCr #
Methods minBound :: YCbCr # maxBound :: YCbCr #
Enum YCbCr #
Methods succ :: YCbCr -> YCbCr # pred :: YCbCr -> YCbCr # toEnum :: Int -> YCbCr # fromEnum :: YCbCr -> Int # enumFrom :: YCbCr -> [YCbCr] # enumFromThen :: YCbCr -> YCbCr -> [YCbCr] # enumFromTo :: YCbCr -> YCbCr -> [YCbCr] # enumFromThenTo :: YCbCr -> YCbCr -> YCbCr -> [YCbCr] #
Eq YCbCr #
Methods (==) :: YCbCr -> YCbCr -> Bool # (/=) :: YCbCr -> YCbCr -> Bool #
Show YCbCr #
Methods showsPrec :: Int -> YCbCr -> ShowS # show :: YCbCr -> String # showList :: [YCbCr] -> ShowS #
ChannelColour YCbCr #
Methods csColour :: YCbCr -> AlphaColour Double #
Elevator e => ColorSpace YCbCr e #
Associated Types type Components YCbCr e :: * # Methods toComponents :: Pixel YCbCr e -> Components YCbCr e # fromComponents :: Components YCbCr e -> Pixel YCbCr e # promote :: e -> Pixel YCbCr e # getPxC :: Pixel YCbCr e -> YCbCr -> e # setPxC :: Pixel YCbCr e -> YCbCr -> e -> Pixel YCbCr e # mapPxC :: (YCbCr -> e -> e) -> Pixel YCbCr e -> Pixel YCbCr e # liftPx :: (e -> e) -> Pixel YCbCr e -> Pixel YCbCr e # liftPx2 :: (e -> e -> e) -> Pixel YCbCr e -> Pixel YCbCr e -> Pixel YCbCr e # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel YCbCr e -> Pixel YCbCr e -> b # foldrPx :: (e -> b -> b) -> b -> Pixel YCbCr e -> b # foldlPx :: (b -> e -> b) -> b -> Pixel YCbCr e -> b # foldl1Px :: (e -> e -> e) -> Pixel YCbCr e -> e # toListPx :: Pixel YCbCr e -> [e] #
ToYCbCr YCbCr e => ToYCbCrA YCbCr e #
Methods toPixelYCbCrA :: Pixel YCbCr e -> Pixel YCbCrA Double #
Elevator e => ToYCbCr YCbCr e #
Methods toPixelYCbCr :: Pixel YCbCr e -> Pixel YCbCr Double #
ToCMYK YCbCr e => ToCMYKA YCbCr e #
Methods toPixelCMYKA :: Pixel YCbCr e -> Pixel CMYKA Double #
Elevator e => ToCMYK YCbCr e #
Methods toPixelCMYK :: Pixel YCbCr e -> Pixel CMYK Double #
ToHSI YCbCr e => ToHSIA YCbCr e #
Methods toPixelHSIA :: Pixel YCbCr e -> Pixel HSIA Double #
Elevator e => ToHSI YCbCr e #
Methods toPixelHSI :: Pixel YCbCr e -> Pixel HSI Double #
ToRGB YCbCr e => ToRGBA YCbCr e #
Methods toPixelRGBA :: Pixel YCbCr e -> Pixel RGBA Double #
Elevator e => ToRGB YCbCr e #
Methods toPixelRGB :: Pixel YCbCr e -> Pixel RGB Double #
ToY YCbCr e => ToYA YCbCr e #
Methods toPixelYA :: Pixel YCbCr e -> Pixel YA Double #
Elevator e => ToY YCbCr e #
Methods toPixelY :: Pixel YCbCr e -> Pixel Y Double #
Functor (Pixel YCbCr) #
Methods fmap :: (a -> b) -> Pixel YCbCr a -> Pixel YCbCr b # (<$) :: a -> Pixel YCbCr b -> Pixel YCbCr a #
Applicative (Pixel YCbCr) #
Methods pure :: a -> Pixel YCbCr a # (<>) :: Pixel YCbCr (a -> b) -> Pixel YCbCr a -> Pixel YCbCr b # (>) :: Pixel YCbCr a -> Pixel YCbCr b -> Pixel YCbCr b # (<*) :: Pixel YCbCr a -> Pixel YCbCr b -> Pixel YCbCr a #
Foldable (Pixel YCbCr) #
Methods fold :: Monoid m => Pixel YCbCr m -> m # foldMap :: Monoid m => (a -> m) -> Pixel YCbCr a -> m # foldr :: (a -> b -> b) -> b -> Pixel YCbCr a -> b # foldr' :: (a -> b -> b) -> b -> Pixel YCbCr a -> b # foldl :: (b -> a -> b) -> b -> Pixel YCbCr a -> b # foldl' :: (b -> a -> b) -> b -> Pixel YCbCr a -> b # foldr1 :: (a -> a -> a) -> Pixel YCbCr a -> a # foldl1 :: (a -> a -> a) -> Pixel YCbCr a -> a # toList :: Pixel YCbCr a -> [a] # null :: Pixel YCbCr a -> Bool # length :: Pixel YCbCr a -> Int # elem :: Eq a => a -> Pixel YCbCr a -> Bool # maximum :: Ord a => Pixel YCbCr a -> a # minimum :: Ord a => Pixel YCbCr a -> a # sum :: Num a => Pixel YCbCr a -> a # product :: Num a => Pixel YCbCr a -> a #
Eq e => Eq (Pixel YCbCr e) #
Methods (==) :: Pixel YCbCr e -> Pixel YCbCr e -> Bool # (/=) :: Pixel YCbCr e -> Pixel YCbCr e -> Bool #
Show e => Show (Pixel YCbCr e) #
Methods showsPrec :: Int -> Pixel YCbCr e -> ShowS # show :: Pixel YCbCr e -> String # showList :: [Pixel YCbCr e] -> ShowS #
Storable e => Storable (Pixel YCbCr e) #
Methods sizeOf :: Pixel YCbCr e -> Int # alignment :: Pixel YCbCr e -> Int # peekElemOff :: Ptr (Pixel YCbCr e) -> Int -> IO (Pixel YCbCr e) # pokeElemOff :: Ptr (Pixel YCbCr e) -> Int -> Pixel YCbCr e -> IO () # peekByteOff :: Ptr b -> Int -> IO (Pixel YCbCr e) # pokeByteOff :: Ptr b -> Int -> Pixel YCbCr e -> IO () # peek :: Ptr (Pixel YCbCr e) -> IO (Pixel YCbCr e) # poke :: Ptr (Pixel YCbCr e) -> Pixel YCbCr e -> IO () #
Writable (Image VS YCbCr Double) TIF #
Methods encode :: TIF -> [SaveOption TIF] -> Image VS YCbCr Double -> ByteString #
Writable (Image VS YCbCr Word8) TIF #
Methods encode :: TIF -> [SaveOption TIF] -> Image VS YCbCr Word8 -> ByteString #
Writable (Image VS YCbCr Word8) JPG #
Methods encode :: JPG -> [SaveOption JPG] -> Image VS YCbCr Word8 -> ByteString #
Readable (Image VS YCbCr Word8) JPG #
Methods decode :: JPG -> ByteString -> Either String (Image VS YCbCr Word8) #
data Pixel YCbCr #
data Pixel YCbCr = PixelYCbCr !e !e !e
type Components YCbCr e #
type Components YCbCr e = (e, e, e)

data YCbCrA #

YCbCr color space with Alpha channel.

Constructors

LumaYCbCrA	Luma component (commonly denoted as Y')
CBlueYCbCrA	Blue difference chroma component
CRedYCbCrA	Red difference chroma component
AlphaYCbCrA	Alpha component.

Instances

Bounded YCbCrA #
Methods minBound :: YCbCrA # maxBound :: YCbCrA #
Enum YCbCrA #
Methods succ :: YCbCrA -> YCbCrA # pred :: YCbCrA -> YCbCrA # toEnum :: Int -> YCbCrA # fromEnum :: YCbCrA -> Int # enumFrom :: YCbCrA -> [YCbCrA] # enumFromThen :: YCbCrA -> YCbCrA -> [YCbCrA] # enumFromTo :: YCbCrA -> YCbCrA -> [YCbCrA] # enumFromThenTo :: YCbCrA -> YCbCrA -> YCbCrA -> [YCbCrA] #
Eq YCbCrA #
Methods (==) :: YCbCrA -> YCbCrA -> Bool # (/=) :: YCbCrA -> YCbCrA -> Bool #
Show YCbCrA #
Methods showsPrec :: Int -> YCbCrA -> ShowS # show :: YCbCrA -> String # showList :: [YCbCrA] -> ShowS #
ChannelColour YCbCrA #
Methods csColour :: YCbCrA -> AlphaColour Double #
Elevator e => AlphaSpace YCbCrA e #
Associated Types type Opaque YCbCrA :: * # Methods getAlpha :: Pixel YCbCrA e -> e # addAlpha :: e -> Pixel (Opaque YCbCrA) e -> Pixel YCbCrA e # dropAlpha :: Pixel YCbCrA e -> Pixel (Opaque YCbCrA) e #
Elevator e => ColorSpace YCbCrA e #
Associated Types type Components YCbCrA e :: * # Methods toComponents :: Pixel YCbCrA e -> Components YCbCrA e # fromComponents :: Components YCbCrA e -> Pixel YCbCrA e # promote :: e -> Pixel YCbCrA e # getPxC :: Pixel YCbCrA e -> YCbCrA -> e # setPxC :: Pixel YCbCrA e -> YCbCrA -> e -> Pixel YCbCrA e # mapPxC :: (YCbCrA -> e -> e) -> Pixel YCbCrA e -> Pixel YCbCrA e # liftPx :: (e -> e) -> Pixel YCbCrA e -> Pixel YCbCrA e # liftPx2 :: (e -> e -> e) -> Pixel YCbCrA e -> Pixel YCbCrA e -> Pixel YCbCrA e # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel YCbCrA e -> Pixel YCbCrA e -> b # foldrPx :: (e -> b -> b) -> b -> Pixel YCbCrA e -> b # foldlPx :: (b -> e -> b) -> b -> Pixel YCbCrA e -> b # foldl1Px :: (e -> e -> e) -> Pixel YCbCrA e -> e # toListPx :: Pixel YCbCrA e -> [e] #
Elevator e => ToYCbCrA YCbCrA e #
Methods toPixelYCbCrA :: Pixel YCbCrA e -> Pixel YCbCrA Double #
Elevator e => ToYCbCr YCbCrA e #
Methods toPixelYCbCr :: Pixel YCbCrA e -> Pixel YCbCr Double #
Elevator e => ToCMYKA YCbCrA e #
Methods toPixelCMYKA :: Pixel YCbCrA e -> Pixel CMYKA Double #
Elevator e => ToCMYK YCbCrA e #
Methods toPixelCMYK :: Pixel YCbCrA e -> Pixel CMYK Double #
Elevator e => ToHSIA YCbCrA e #
Methods toPixelHSIA :: Pixel YCbCrA e -> Pixel HSIA Double #
Elevator e => ToHSI YCbCrA e #
Methods toPixelHSI :: Pixel YCbCrA e -> Pixel HSI Double #
Elevator e => ToRGBA YCbCrA e #
Methods toPixelRGBA :: Pixel YCbCrA e -> Pixel RGBA Double #
Elevator e => ToRGB YCbCrA e #
Methods toPixelRGB :: Pixel YCbCrA e -> Pixel RGB Double #
Elevator e => ToYA YCbCrA e #
Methods toPixelYA :: Pixel YCbCrA e -> Pixel YA Double #
Elevator e => ToY YCbCrA e #
Methods toPixelY :: Pixel YCbCrA e -> Pixel Y Double #
Functor (Pixel YCbCrA) #
Methods fmap :: (a -> b) -> Pixel YCbCrA a -> Pixel YCbCrA b # (<$) :: a -> Pixel YCbCrA b -> Pixel YCbCrA a #
Applicative (Pixel YCbCrA) #
Methods pure :: a -> Pixel YCbCrA a # (<>) :: Pixel YCbCrA (a -> b) -> Pixel YCbCrA a -> Pixel YCbCrA b # (>) :: Pixel YCbCrA a -> Pixel YCbCrA b -> Pixel YCbCrA b # (<*) :: Pixel YCbCrA a -> Pixel YCbCrA b -> Pixel YCbCrA a #
Foldable (Pixel YCbCrA) #
Methods fold :: Monoid m => Pixel YCbCrA m -> m # foldMap :: Monoid m => (a -> m) -> Pixel YCbCrA a -> m # foldr :: (a -> b -> b) -> b -> Pixel YCbCrA a -> b # foldr' :: (a -> b -> b) -> b -> Pixel YCbCrA a -> b # foldl :: (b -> a -> b) -> b -> Pixel YCbCrA a -> b # foldl' :: (b -> a -> b) -> b -> Pixel YCbCrA a -> b # foldr1 :: (a -> a -> a) -> Pixel YCbCrA a -> a # foldl1 :: (a -> a -> a) -> Pixel YCbCrA a -> a # toList :: Pixel YCbCrA a -> [a] # null :: Pixel YCbCrA a -> Bool # length :: Pixel YCbCrA a -> Int # elem :: Eq a => a -> Pixel YCbCrA a -> Bool # maximum :: Ord a => Pixel YCbCrA a -> a # minimum :: Ord a => Pixel YCbCrA a -> a # sum :: Num a => Pixel YCbCrA a -> a # product :: Num a => Pixel YCbCrA a -> a #
Eq e => Eq (Pixel YCbCrA e) #
Methods (==) :: Pixel YCbCrA e -> Pixel YCbCrA e -> Bool # (/=) :: Pixel YCbCrA e -> Pixel YCbCrA e -> Bool #
Show e => Show (Pixel YCbCrA e) #
Methods showsPrec :: Int -> Pixel YCbCrA e -> ShowS # show :: Pixel YCbCrA e -> String # showList :: [Pixel YCbCrA e] -> ShowS #
Storable e => Storable (Pixel YCbCrA e) #
Methods sizeOf :: Pixel YCbCrA e -> Int # alignment :: Pixel YCbCrA e -> Int # peekElemOff :: Ptr (Pixel YCbCrA e) -> Int -> IO (Pixel YCbCrA e) # pokeElemOff :: Ptr (Pixel YCbCrA e) -> Int -> Pixel YCbCrA e -> IO () # peekByteOff :: Ptr b -> Int -> IO (Pixel YCbCrA e) # pokeByteOff :: Ptr b -> Int -> Pixel YCbCrA e -> IO () # peek :: Ptr (Pixel YCbCrA e) -> IO (Pixel YCbCrA e) # poke :: Ptr (Pixel YCbCrA e) -> Pixel YCbCrA e -> IO () #
type Opaque YCbCrA #
type Opaque YCbCrA = YCbCr
data Pixel YCbCrA #
data Pixel YCbCrA = PixelYCbCrA !e !e !e !e
type Components YCbCrA e #
type Components YCbCrA e = (e, e, e, e)

class ColorSpace cs e => ToYCbCr cs e where #

Conversion to YCbCr color space.

Minimal complete definition

toPixelYCbCr

Methods

toPixelYCbCr :: Pixel cs e -> Pixel YCbCr Double #

Convert to an YCbCr pixel.

Instances

Elevator e => ToYCbCr YCbCrA e #
Methods toPixelYCbCr :: Pixel YCbCrA e -> Pixel YCbCr Double #
Elevator e => ToYCbCr YCbCr e #
Methods toPixelYCbCr :: Pixel YCbCr e -> Pixel YCbCr Double #
Elevator e => ToYCbCr YA e #
Methods toPixelYCbCr :: Pixel YA e -> Pixel YCbCr Double #
Elevator e => ToYCbCr Y e #
Methods toPixelYCbCr :: Pixel Y e -> Pixel YCbCr Double #
Elevator e => ToYCbCr RGBA e #
Methods toPixelYCbCr :: Pixel RGBA e -> Pixel YCbCr Double #
Elevator e => ToYCbCr RGB e #
Methods toPixelYCbCr :: Pixel RGB e -> Pixel YCbCr Double #
Elevator e => ToYCbCr HSIA e #
Methods toPixelYCbCr :: Pixel HSIA e -> Pixel YCbCr Double #
Elevator e => ToYCbCr HSI e #
Methods toPixelYCbCr :: Pixel HSI e -> Pixel YCbCr Double #
Elevator e => ToYCbCr CMYKA e #
Methods toPixelYCbCr :: Pixel CMYKA e -> Pixel YCbCr Double #
Elevator e => ToYCbCr CMYK e #
Methods toPixelYCbCr :: Pixel CMYK e -> Pixel YCbCr Double #

class ToYCbCr cs e => ToYCbCrA cs e where #

Conversion to YCbCrA from another color space with Alpha channel.

Methods

toPixelYCbCrA :: Pixel cs e -> Pixel YCbCrA Double #

Convert to an YCbCrA pixel.

Instances

Elevator e => ToYCbCrA YCbCrA e #
Methods toPixelYCbCrA :: Pixel YCbCrA e -> Pixel YCbCrA Double #
ToYCbCr YCbCr e => ToYCbCrA YCbCr e #
Methods toPixelYCbCrA :: Pixel YCbCr e -> Pixel YCbCrA Double #
Elevator e => ToYCbCrA YA e #
Methods toPixelYCbCrA :: Pixel YA e -> Pixel YCbCrA Double #
ToYCbCr Y e => ToYCbCrA Y e #
Methods toPixelYCbCrA :: Pixel Y e -> Pixel YCbCrA Double #
Elevator e => ToYCbCrA RGBA e #
Methods toPixelYCbCrA :: Pixel RGBA e -> Pixel YCbCrA Double #
ToYCbCr RGB e => ToYCbCrA RGB e #
Methods toPixelYCbCrA :: Pixel RGB e -> Pixel YCbCrA Double #
Elevator e => ToYCbCrA HSIA e #
Methods toPixelYCbCrA :: Pixel HSIA e -> Pixel YCbCrA Double #
ToYCbCr HSI e => ToYCbCrA HSI e #
Methods toPixelYCbCrA :: Pixel HSI e -> Pixel YCbCrA Double #
Elevator e => ToYCbCrA CMYKA e #
Methods toPixelYCbCrA :: Pixel CMYKA e -> Pixel YCbCrA Double #
ToYCbCr CMYK e => ToYCbCrA CMYK e #
Methods toPixelYCbCrA :: Pixel CMYK e -> Pixel YCbCrA Double #

X

data X #

This is a single channel colorspace, that is designed to separate Gray level values from other types of colorspace, hence it is not convertible to or from, but rather is here to allow operation on arbirtary single channel images. If you are looking for a true grayscale colorspace Y should be used instead.

Constructors

X

Instances

Bounded X #
Methods minBound :: X # maxBound :: X #
Enum X #
Methods succ :: X -> X # pred :: X -> X # toEnum :: Int -> X # fromEnum :: X -> Int # enumFrom :: X -> [X] # enumFromThen :: X -> X -> [X] # enumFromTo :: X -> X -> [X] # enumFromThenTo :: X -> X -> X -> [X] #
Eq X #
Methods (==) :: X -> X -> Bool # (/=) :: X -> X -> Bool #
Show X #
Methods showsPrec :: Int -> X -> ShowS # show :: X -> String # showList :: [X] -> ShowS #
ChannelColour X #
Methods csColour :: X -> AlphaColour Double #
Elevator e => ColorSpace X e #
Associated Types type Components X e :: * # Methods toComponents :: Pixel X e -> Components X e # fromComponents :: Components X e -> Pixel X e # promote :: e -> Pixel X e # getPxC :: Pixel X e -> X -> e # setPxC :: Pixel X e -> X -> e -> Pixel X e # mapPxC :: (X -> e -> e) -> Pixel X e -> Pixel X e # liftPx :: (e -> e) -> Pixel X e -> Pixel X e # liftPx2 :: (e -> e -> e) -> Pixel X e -> Pixel X e -> Pixel X e # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel X e -> Pixel X e -> b # foldrPx :: (e -> b -> b) -> b -> Pixel X e -> b # foldlPx :: (b -> e -> b) -> b -> Pixel X e -> b # foldl1Px :: (e -> e -> e) -> Pixel X e -> e # toListPx :: Pixel X e -> [e] #
ToRGBA X Bit #
Methods toPixelRGBA :: Pixel X Bit -> Pixel RGBA Double #
ToRGB X Bit #
Methods toPixelRGB :: Pixel X Bit -> Pixel RGB Double #
ToYA X Bit #
Methods toPixelYA :: Pixel X Bit -> Pixel YA Double #
Elevator e => ToY X e #
Methods toPixelY :: Pixel X e -> Pixel Y Double #
Monad (Pixel X) #
Methods (>>=) :: Pixel X a -> (a -> Pixel X b) -> Pixel X b # (>>) :: Pixel X a -> Pixel X b -> Pixel X b # return :: a -> Pixel X a # fail :: String -> Pixel X a #
Functor (Pixel X) #
Methods fmap :: (a -> b) -> Pixel X a -> Pixel X b # (<$) :: a -> Pixel X b -> Pixel X a #
Applicative (Pixel X) #
Methods pure :: a -> Pixel X a # (<>) :: Pixel X (a -> b) -> Pixel X a -> Pixel X b # (>) :: Pixel X a -> Pixel X b -> Pixel X b # (<*) :: Pixel X a -> Pixel X b -> Pixel X a #
Foldable (Pixel X) #
Methods fold :: Monoid m => Pixel X m -> m # foldMap :: Monoid m => (a -> m) -> Pixel X a -> m # foldr :: (a -> b -> b) -> b -> Pixel X a -> b # foldr' :: (a -> b -> b) -> b -> Pixel X a -> b # foldl :: (b -> a -> b) -> b -> Pixel X a -> b # foldl' :: (b -> a -> b) -> b -> Pixel X a -> b # foldr1 :: (a -> a -> a) -> Pixel X a -> a # foldl1 :: (a -> a -> a) -> Pixel X a -> a # toList :: Pixel X a -> [a] # null :: Pixel X a -> Bool # length :: Pixel X a -> Int # elem :: Eq a => a -> Pixel X a -> Bool # maximum :: Ord a => Pixel X a -> a # minimum :: Ord a => Pixel X a -> a # sum :: Num a => Pixel X a -> a # product :: Num a => Pixel X a -> a #
Readable [Image VS X Bit] (Seq PBM) #
Methods decode :: Seq PBM -> ByteString -> Either String [Image VS X Bit] #
Eq e => Eq (Pixel X e) #
Methods (==) :: Pixel X e -> Pixel X e -> Bool # (/=) :: Pixel X e -> Pixel X e -> Bool #
Ord e => Ord (Pixel X e) #
Methods compare :: Pixel X e -> Pixel X e -> Ordering # (<) :: Pixel X e -> Pixel X e -> Bool # (<=) :: Pixel X e -> Pixel X e -> Bool # (>) :: Pixel X e -> Pixel X e -> Bool # (>=) :: Pixel X e -> Pixel X e -> Bool # max :: Pixel X e -> Pixel X e -> Pixel X e # min :: Pixel X e -> Pixel X e -> Pixel X e #
Show e => Show (Pixel X e) #
Methods showsPrec :: Int -> Pixel X e -> ShowS # show :: Pixel X e -> String # showList :: [Pixel X e] -> ShowS #
Storable e => Storable (Pixel X e) #
Methods sizeOf :: Pixel X e -> Int # alignment :: Pixel X e -> Int # peekElemOff :: Ptr (Pixel X e) -> Int -> IO (Pixel X e) # pokeElemOff :: Ptr (Pixel X e) -> Int -> Pixel X e -> IO () # peekByteOff :: Ptr b -> Int -> IO (Pixel X e) # pokeByteOff :: Ptr b -> Int -> Pixel X e -> IO () # peek :: Ptr (Pixel X e) -> IO (Pixel X e) # poke :: Ptr (Pixel X e) -> Pixel X e -> IO () #
Bits (Pixel X Bit) #
Methods (.&.) :: Pixel X Bit -> Pixel X Bit -> Pixel X Bit # (.\|.) :: Pixel X Bit -> Pixel X Bit -> Pixel X Bit # xor :: Pixel X Bit -> Pixel X Bit -> Pixel X Bit # complement :: Pixel X Bit -> Pixel X Bit # shift :: Pixel X Bit -> Int -> Pixel X Bit # rotate :: Pixel X Bit -> Int -> Pixel X Bit # zeroBits :: Pixel X Bit # bit :: Int -> Pixel X Bit # setBit :: Pixel X Bit -> Int -> Pixel X Bit # clearBit :: Pixel X Bit -> Int -> Pixel X Bit # complementBit :: Pixel X Bit -> Int -> Pixel X Bit # testBit :: Pixel X Bit -> Int -> Bool # bitSizeMaybe :: Pixel X Bit -> Maybe Int # bitSize :: Pixel X Bit -> Int # isSigned :: Pixel X Bit -> Bool # shiftL :: Pixel X Bit -> Int -> Pixel X Bit # unsafeShiftL :: Pixel X Bit -> Int -> Pixel X Bit # shiftR :: Pixel X Bit -> Int -> Pixel X Bit # unsafeShiftR :: Pixel X Bit -> Int -> Pixel X Bit # rotateL :: Pixel X Bit -> Int -> Pixel X Bit # rotateR :: Pixel X Bit -> Int -> Pixel X Bit # popCount :: Pixel X Bit -> Int #
Writable (Image VS X Bit) TIF #
Methods encode :: TIF -> [SaveOption TIF] -> Image VS X Bit -> ByteString #
Writable (Image VS X Bit) TGA #
Methods encode :: TGA -> [SaveOption TGA] -> Image VS X Bit -> ByteString #
Writable (Image VS X Bit) PNG #
Methods encode :: PNG -> [SaveOption PNG] -> Image VS X Bit -> ByteString #
Writable (Image VS X Bit) BMP #
Methods encode :: BMP -> [SaveOption BMP] -> Image VS X Bit -> ByteString #
Readable (Image VS X Bit) TIF #
Methods decode :: TIF -> ByteString -> Either String (Image VS X Bit) #
Readable (Image VS X Bit) TGA #
Methods decode :: TGA -> ByteString -> Either String (Image VS X Bit) #
Readable (Image VS X Bit) PNG #
Methods decode :: PNG -> ByteString -> Either String (Image VS X Bit) #
Readable (Image VS X Bit) BMP #
Methods decode :: BMP -> ByteString -> Either String (Image VS X Bit) #
Readable (Image VS X Bit) PBM #
Methods decode :: PBM -> ByteString -> Either String (Image VS X Bit) #
data Pixel X #
data Pixel X = PixelX { getX :: e }
type Components X e #
type Components X e = e

Precision

Image

toWord8I :: (Functor (Pixel cs), Array arr cs e, Array arr cs Word8) => Image arr cs e -> Image arr cs Word8 #

Change image precision to Word8.

toWord16I :: (Functor (Pixel cs), Array arr cs e, Array arr cs Word16) => Image arr cs e -> Image arr cs Word16 #

Change image precision to Word16.

toWord32I :: (Functor (Pixel cs), Array arr cs e, Array arr cs Word32) => Image arr cs e -> Image arr cs Word32 #

Change image precision to Word32.

toFloatI :: (Functor (Pixel cs), Array arr cs e, Array arr cs Float) => Image arr cs e -> Image arr cs Float #

Change image precision to Float.

toDoubleI :: (Functor (Pixel cs), Array arr cs e, Array arr cs Double) => Image arr cs e -> Image arr cs Double #

Change image precision to Double.

Pixel

toWord8Px :: (Functor (Pixel cs), Elevator e) => Pixel cs e -> Pixel cs Word8 #

Change pixel precision to Word8.

Componenet

data Word8 :: * #

8-bit unsigned integer type

Instances

Bounded Word8
Methods minBound :: Word8 # maxBound :: Word8 #
Enum Word8
Methods succ :: Word8 -> Word8 # pred :: Word8 -> Word8 # toEnum :: Int -> Word8 # fromEnum :: Word8 -> Int # enumFrom :: Word8 -> [Word8] # enumFromThen :: Word8 -> Word8 -> [Word8] # enumFromTo :: Word8 -> Word8 -> [Word8] # enumFromThenTo :: Word8 -> Word8 -> Word8 -> [Word8] #
Eq Word8
Methods (==) :: Word8 -> Word8 -> Bool # (/=) :: Word8 -> Word8 -> Bool #
Integral Word8
Methods quot :: Word8 -> Word8 -> Word8 # rem :: Word8 -> Word8 -> Word8 # div :: Word8 -> Word8 -> Word8 # mod :: Word8 -> Word8 -> Word8 # quotRem :: Word8 -> Word8 -> (Word8, Word8) # divMod :: Word8 -> Word8 -> (Word8, Word8) # toInteger :: Word8 -> Integer #
Num Word8
Methods (+) :: Word8 -> Word8 -> Word8 # (-) :: Word8 -> Word8 -> Word8 # (*) :: Word8 -> Word8 -> Word8 # negate :: Word8 -> Word8 # abs :: Word8 -> Word8 # signum :: Word8 -> Word8 # fromInteger :: Integer -> Word8 #
Ord Word8
Methods compare :: Word8 -> Word8 -> Ordering # (<) :: Word8 -> Word8 -> Bool # (<=) :: Word8 -> Word8 -> Bool # (>) :: Word8 -> Word8 -> Bool # (>=) :: Word8 -> Word8 -> Bool # max :: Word8 -> Word8 -> Word8 # min :: Word8 -> Word8 -> Word8 #
Read Word8
Methods readsPrec :: Int -> ReadS Word8 # readList :: ReadS [Word8] # readPrec :: ReadPrec Word8 # readListPrec :: ReadPrec [Word8] #
Real Word8
Methods toRational :: Word8 -> Rational #
Show Word8
Methods showsPrec :: Int -> Word8 -> ShowS # show :: Word8 -> String # showList :: [Word8] -> ShowS #
Ix Word8
Methods range :: (Word8, Word8) -> [Word8] # index :: (Word8, Word8) -> Word8 -> Int # unsafeIndex :: (Word8, Word8) -> Word8 -> Int inRange :: (Word8, Word8) -> Word8 -> Bool # rangeSize :: (Word8, Word8) -> Int # unsafeRangeSize :: (Word8, Word8) -> Int
Lift Word8
Methods lift :: Word8 -> Q Exp #
Default Word8
Methods def :: Word8 #
Unpackable Word8	The Word8 instance is just a passthrough, to avoid copying memory twice
Associated Types type StorageType Word8 :: * Methods outAlloc :: Word8 -> Int -> ST s (STVector s (StorageType Word8)) allocTempBuffer :: Word8 -> STVector s (StorageType Word8) -> Int -> ST s (STVector s Word8) offsetStride :: Word8 -> Int -> Int -> (Int, Int) mergeBackTempBuffer :: Word8 -> Endianness -> STVector s Word8 -> Int -> Int -> Word32 -> Int -> STVector s (StorageType Word8) -> ST s ()
TiffSaveable Pixel8
Methods colorSpaceOfPixel :: Pixel8 -> TiffColorspace extraSampleCodeOfPixel :: Pixel8 -> Maybe ExtraSample subSamplingInfo :: Pixel8 -> Vector Word32
JpgEncodable Pixel8
Methods additionalBlocks :: Image Pixel8 -> [JpgFrame] componentsOfColorSpace :: Image Pixel8 -> [JpgComponent] encodingState :: Int -> Image Pixel8 -> Vector EncoderState imageHuffmanTables :: Image Pixel8 -> [(JpgHuffmanTableSpec, HuffmanPackedTree)] scanSpecificationOfColorSpace :: Image Pixel8 -> [JpgScanSpecification] quantTableSpec :: Image Pixel8 -> Int -> [JpgQuantTableSpec] maximumSubSamplingOf :: Image Pixel8 -> Int
BmpEncodable Pixel8
Methods bitsPerPixel :: Pixel8 -> Int bmpEncode :: Image Pixel8 -> Put defaultPalette :: Pixel8 -> BmpPalette
TgaSaveable Pixel8
Methods tgaDataOfImage :: Image Pixel8 -> ByteString tgaPixelDepthOfImage :: Image Pixel8 -> Word8 tgaTypeOfImage :: Image Pixel8 -> TgaImageType
PngSavable Pixel8
Methods encodePng :: Image Pixel8 -> ByteString # encodePngWithMetadata :: Metadatas -> Image Pixel8 -> ByteString #
Pixel Pixel8
Associated Types type PixelBaseComponent Pixel8 :: * # Methods mixWith :: (Int -> PixelBaseComponent Pixel8 -> PixelBaseComponent Pixel8 -> PixelBaseComponent Pixel8) -> Pixel8 -> Pixel8 -> Pixel8 # mixWithAlpha :: (Int -> PixelBaseComponent Pixel8 -> PixelBaseComponent Pixel8 -> PixelBaseComponent Pixel8) -> (PixelBaseComponent Pixel8 -> PixelBaseComponent Pixel8 -> PixelBaseComponent Pixel8) -> Pixel8 -> Pixel8 -> Pixel8 # pixelOpacity :: Pixel8 -> PixelBaseComponent Pixel8 # componentCount :: Pixel8 -> Int # colorMap :: (PixelBaseComponent Pixel8 -> PixelBaseComponent Pixel8) -> Pixel8 -> Pixel8 # pixelBaseIndex :: Image Pixel8 -> Int -> Int -> Int # mutablePixelBaseIndex :: MutableImage s Pixel8 -> Int -> Int -> Int # pixelAt :: Image Pixel8 -> Int -> Int -> Pixel8 # readPixel :: PrimMonad m => MutableImage (PrimState m) Pixel8 -> Int -> Int -> m Pixel8 # writePixel :: PrimMonad m => MutableImage (PrimState m) Pixel8 -> Int -> Int -> Pixel8 -> m () # unsafePixelAt :: Vector (PixelBaseComponent Pixel8) -> Int -> Pixel8 # unsafeReadPixel :: PrimMonad m => STVector (PrimState m) (PixelBaseComponent Pixel8) -> Int -> m Pixel8 # unsafeWritePixel :: PrimMonad m => STVector (PrimState m) (PixelBaseComponent Pixel8) -> Int -> Pixel8 -> m () #
LumaPlaneExtractable Pixel8
Methods computeLuma :: Pixel8 -> PixelBaseComponent Pixel8 # extractLumaPlane :: Image Pixel8 -> Image (PixelBaseComponent Pixel8) #
PackeablePixel Pixel8
Associated Types type PackedRepresentation Pixel8 :: * # Methods packPixel :: Pixel8 -> PackedRepresentation Pixel8 # unpackPixel :: PackedRepresentation Pixel8 -> Pixel8 #
Storable Word8
Methods sizeOf :: Word8 -> Int # alignment :: Word8 -> Int # peekElemOff :: Ptr Word8 -> Int -> IO Word8 # pokeElemOff :: Ptr Word8 -> Int -> Word8 -> IO () # peekByteOff :: Ptr b -> Int -> IO Word8 # pokeByteOff :: Ptr b -> Int -> Word8 -> IO () # peek :: Ptr Word8 -> IO Word8 # poke :: Ptr Word8 -> Word8 -> IO () #
Bits Word8
Methods (.&.) :: Word8 -> Word8 -> Word8 # (.\|.) :: Word8 -> Word8 -> Word8 # xor :: Word8 -> Word8 -> Word8 # complement :: Word8 -> Word8 # shift :: Word8 -> Int -> Word8 # rotate :: Word8 -> Int -> Word8 # zeroBits :: Word8 # bit :: Int -> Word8 # setBit :: Word8 -> Int -> Word8 # clearBit :: Word8 -> Int -> Word8 # complementBit :: Word8 -> Int -> Word8 # testBit :: Word8 -> Int -> Bool # bitSizeMaybe :: Word8 -> Maybe Int # bitSize :: Word8 -> Int # isSigned :: Word8 -> Bool # shiftL :: Word8 -> Int -> Word8 # unsafeShiftL :: Word8 -> Int -> Word8 # shiftR :: Word8 -> Int -> Word8 # unsafeShiftR :: Word8 -> Int -> Word8 # rotateL :: Word8 -> Int -> Word8 # rotateR :: Word8 -> Int -> Word8 # popCount :: Word8 -> Int #
FiniteBits Word8
Methods finiteBitSize :: Word8 -> Int # countLeadingZeros :: Word8 -> Int # countTrailingZeros :: Word8 -> Int #
NFData Word8
Methods rnf :: Word8 -> () #
Prim Word8
Methods sizeOf# :: Word8 -> Int# # alignment# :: Word8 -> Int# # indexByteArray# :: ByteArray# -> Int# -> Word8 # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Word8#) # writeByteArray# :: MutableByteArray# s -> Int# -> Word8 -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word8 -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Word8 # readOffAddr# :: Addr# -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Word8#) # writeOffAddr# :: Addr# -> Int# -> Word8 -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Word8 -> State# s -> State# s #
Unbox Word8

Elt Word8
Methods touch :: Word8 -> IO () # zero :: Word8 # one :: Word8 #
Elevator Word8 #	Values between `[0, 255]]`
Methods toWord8 :: Word8 -> Word8 # toWord16 :: Word8 -> Word16 # toWord32 :: Word8 -> Word32 # toWord64 :: Word8 -> Word64 # toFloat :: Word8 -> Float # toDouble :: Word8 -> Double # fromDouble :: Double -> Word8 #
Decimable Pixel16 Pixel8
Methods decimateBitDepth :: Image Pixel16 -> Image Pixel8
Decimable PixelF Pixel8
Methods decimateBitDepth :: Image PixelF -> Image Pixel8
TransparentPixel PixelYA8 Pixel8
Methods dropTransparency :: PixelYA8 -> Pixel8 # getTransparency :: PixelYA8 -> PixelBaseComponent PixelYA8 #
ColorConvertible Pixel8 Pixel16
Methods promotePixel :: Pixel8 -> Pixel16 # promoteImage :: Image Pixel8 -> Image Pixel16 #
ColorConvertible Pixel8 PixelF
Methods promotePixel :: Pixel8 -> PixelF # promoteImage :: Image Pixel8 -> Image PixelF #
ColorConvertible Pixel8 PixelYA8
Methods promotePixel :: Pixel8 -> PixelYA8 # promoteImage :: Image Pixel8 -> Image PixelYA8 #
ColorConvertible Pixel8 PixelRGB8
Methods promotePixel :: Pixel8 -> PixelRGB8 # promoteImage :: Image Pixel8 -> Image PixelRGB8 #
ColorConvertible Pixel8 PixelRGBA8
Methods promotePixel :: Pixel8 -> PixelRGBA8 # promoteImage :: Image Pixel8 -> Image PixelRGBA8 #
IArray UArray Word8
Methods bounds :: Ix i => UArray i Word8 -> (i, i) # numElements :: Ix i => UArray i Word8 -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Word8)] -> UArray i Word8 unsafeAt :: Ix i => UArray i Word8 -> Int -> Word8 unsafeReplace :: Ix i => UArray i Word8 -> [(Int, Word8)] -> UArray i Word8 unsafeAccum :: Ix i => (Word8 -> e' -> Word8) -> UArray i Word8 -> [(Int, e')] -> UArray i Word8 unsafeAccumArray :: Ix i => (Word8 -> e' -> Word8) -> Word8 -> (i, i) -> [(Int, e')] -> UArray i Word8
Vector Vector Word8
Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word8 -> m (Vector Word8) # basicUnsafeThaw :: PrimMonad m => Vector Word8 -> m (Mutable Vector (PrimState m) Word8) # basicLength :: Vector Word8 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Word8 -> Vector Word8 # basicUnsafeIndexM :: Monad m => Vector Word8 -> Int -> m Word8 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word8 -> Vector Word8 -> m () # elemseq :: Vector Word8 -> Word8 -> b -> b #
Source B Word8	Read elements from a `ByteString`.
Associated Types data Array B sh Word8 :: * # Methods extent :: Shape sh => Array B sh Word8 -> sh # index :: Shape sh => Array B sh Word8 -> sh -> Word8 # unsafeIndex :: Shape sh => Array B sh Word8 -> sh -> Word8 # linearIndex :: Shape sh => Array B sh Word8 -> Int -> Word8 # unsafeLinearIndex :: Shape sh => Array B sh Word8 -> Int -> Word8 # deepSeqArray :: Shape sh => Array B sh Word8 -> b -> b #
MVector MVector Word8
Methods basicLength :: MVector s Word8 -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Word8 -> MVector s Word8 # basicOverlaps :: MVector s Word8 -> MVector s Word8 -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word8) # basicInitialize :: PrimMonad m => MVector (PrimState m) Word8 -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Word8 -> m (MVector (PrimState m) Word8) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> m Word8 # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> Word8 -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Word8 -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Word8 -> Word8 -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word8 -> MVector (PrimState m) Word8 -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word8 -> MVector (PrimState m) Word8 -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> m (MVector (PrimState m) Word8) #
Structured B Word8 b
Associated Types type TR B :: * # Methods smap :: Shape sh => (Word8 -> b) -> Array B sh Word8 -> Array (TR B) sh b # szipWith :: (Shape sh, Source r c) => (c -> Word8 -> b) -> Array r sh c -> Array B sh Word8 -> Array (TR B) sh b #
Writable [(GifDelay, Image VS RGB Word8)] GIFA #
Methods encode :: GIFA -> [SaveOption GIFA] -> [(GifDelay, Image VS RGB Word8)] -> ByteString #
Readable [(GifDelay, Image VS RGBA Word8)] GIFA #
Methods decode :: GIFA -> ByteString -> Either String [(GifDelay, Image VS RGBA Word8)] #
Readable [(GifDelay, Image VS RGB Word8)] GIFA #
Methods decode :: GIFA -> ByteString -> Either String [(GifDelay, Image VS RGB Word8)] #
Readable [Image VS RGBA Word8] GIFA #
Methods decode :: GIFA -> ByteString -> Either String [Image VS RGBA Word8] #
Readable [Image VS RGB Word8] GIFA #
Methods decode :: GIFA -> ByteString -> Either String [Image VS RGB Word8] #
MArray (STUArray s) Word8 (ST s)
Methods getBounds :: Ix i => STUArray s i Word8 -> ST s (i, i) # getNumElements :: Ix i => STUArray s i Word8 -> ST s Int newArray :: Ix i => (i, i) -> Word8 -> ST s (STUArray s i Word8) # newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word8) # unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word8) unsafeRead :: Ix i => STUArray s i Word8 -> Int -> ST s Word8 unsafeWrite :: Ix i => STUArray s i Word8 -> Int -> Word8 -> ST s ()
Writable [(GifDelay, Image VS RGB Word8)] (Seq GIF) #
Methods encode :: Seq GIF -> [SaveOption (Seq GIF)] -> [(GifDelay, Image VS RGB Word8)] -> ByteString #
Readable [(GifDelay, Image VS RGBA Word8)] (Seq GIF) #
Methods decode :: Seq GIF -> ByteString -> Either String [(GifDelay, Image VS RGBA Word8)] #
Readable [(GifDelay, Image VS RGB Word8)] (Seq GIF) #
Methods decode :: Seq GIF -> ByteString -> Either String [(GifDelay, Image VS RGB Word8)] #
Readable [Image VS Y Word8] (Seq PGM) #
Methods decode :: Seq PGM -> ByteString -> Either String [Image VS Y Word8] #
Readable [Image VS RGBA Word8] (Seq GIF) #
Methods decode :: Seq GIF -> ByteString -> Either String [Image VS RGBA Word8] #
Readable [Image VS RGB Word8] (Seq GIF) #
Methods decode :: Seq GIF -> ByteString -> Either String [Image VS RGB Word8] #
Readable [Image VS RGB Word8] (Seq PPM) #
Methods decode :: Seq PPM -> ByteString -> Either String [Image VS RGB Word8] #
Read sh => Read (Array B sh Word8)
Methods readsPrec :: Int -> ReadS (Array B sh Word8) # readList :: ReadS [Array B sh Word8] # readPrec :: ReadPrec (Array B sh Word8) # readListPrec :: ReadPrec [Array B sh Word8] #
Show sh => Show (Array B sh Word8)
Methods showsPrec :: Int -> Array B sh Word8 -> ShowS # show :: Array B sh Word8 -> String # showList :: [Array B sh Word8] -> ShowS #
Writable (Image VS YCbCr Word8) TIF #
Methods encode :: TIF -> [SaveOption TIF] -> Image VS YCbCr Word8 -> ByteString #
Writable (Image VS YCbCr Word8) JPG #
Methods encode :: JPG -> [SaveOption JPG] -> Image VS YCbCr Word8 -> ByteString #
Writable (Image VS YA Word8) TIF #
Methods encode :: TIF -> [SaveOption TIF] -> Image VS YA Word8 -> ByteString #
Writable (Image VS YA Word8) PNG #
Methods encode :: PNG -> [SaveOption PNG] -> Image VS YA Word8 -> ByteString #
Writable (Image VS Y Word8) TIF #
Methods encode :: TIF -> [SaveOption TIF] -> Image VS Y Word8 -> ByteString #
Writable (Image VS Y Word8) TGA #
Methods encode :: TGA -> [SaveOption TGA] -> Image VS Y Word8 -> ByteString #
Writable (Image VS Y Word8) PNG #
Methods encode :: PNG -> [SaveOption PNG] -> Image VS Y Word8 -> ByteString #
Writable (Image VS Y Word8) JPG #
Methods encode :: JPG -> [SaveOption JPG] -> Image VS Y Word8 -> ByteString #
Writable (Image VS Y Word8) BMP #
Methods encode :: BMP -> [SaveOption BMP] -> Image VS Y Word8 -> ByteString #
Writable (Image VS RGBA Word8) TIF #
Methods encode :: TIF -> [SaveOption TIF] -> Image VS RGBA Word8 -> ByteString #
Writable (Image VS RGBA Word8) TGA #
Methods encode :: TGA -> [SaveOption TGA] -> Image VS RGBA Word8 -> ByteString #
Writable (Image VS RGBA Word8) PNG #
Methods encode :: PNG -> [SaveOption PNG] -> Image VS RGBA Word8 -> ByteString #
Writable (Image VS RGBA Word8) BMP #
Methods encode :: BMP -> [SaveOption BMP] -> Image VS RGBA Word8 -> ByteString #
Writable (Image VS RGB Word8) TIF #
Methods encode :: TIF -> [SaveOption TIF] -> Image VS RGB Word8 -> ByteString #
Writable (Image VS RGB Word8) TGA #
Methods encode :: TGA -> [SaveOption TGA] -> Image VS RGB Word8 -> ByteString #
Writable (Image VS RGB Word8) PNG #
Methods encode :: PNG -> [SaveOption PNG] -> Image VS RGB Word8 -> ByteString #
Writable (Image VS RGB Word8) JPG #
Methods encode :: JPG -> [SaveOption JPG] -> Image VS RGB Word8 -> ByteString #
Writable (Image VS RGB Word8) GIF #
Methods encode :: GIF -> [SaveOption GIF] -> Image VS RGB Word8 -> ByteString #
Writable (Image VS RGB Word8) BMP #
Methods encode :: BMP -> [SaveOption BMP] -> Image VS RGB Word8 -> ByteString #
Writable (Image VS CMYK Word8) TIF #
Methods encode :: TIF -> [SaveOption TIF] -> Image VS CMYK Word8 -> ByteString #
Writable (Image VS CMYK Word8) JPG #
Methods encode :: JPG -> [SaveOption JPG] -> Image VS CMYK Word8 -> ByteString #
Readable (Image VS YCbCr Word8) JPG #
Methods decode :: JPG -> ByteString -> Either String (Image VS YCbCr Word8) #
Readable (Image VS YA Word8) TIF #
Methods decode :: TIF -> ByteString -> Either String (Image VS YA Word8) #
Readable (Image VS YA Word8) PNG #
Methods decode :: PNG -> ByteString -> Either String (Image VS YA Word8) #
Readable (Image VS YA Word8) JPG #
Methods decode :: JPG -> ByteString -> Either String (Image VS YA Word8) #
Readable (Image VS Y Word8) TIF #
Methods decode :: TIF -> ByteString -> Either String (Image VS Y Word8) #
Readable (Image VS Y Word8) TGA #
Methods decode :: TGA -> ByteString -> Either String (Image VS Y Word8) #
Readable (Image VS Y Word8) PNG #
Methods decode :: PNG -> ByteString -> Either String (Image VS Y Word8) #
Readable (Image VS Y Word8) JPG #
Methods decode :: JPG -> ByteString -> Either String (Image VS Y Word8) #
Readable (Image VS Y Word8) BMP #
Methods decode :: BMP -> ByteString -> Either String (Image VS Y Word8) #
Readable (Image VS Y Word8) PGM #
Methods decode :: PGM -> ByteString -> Either String (Image VS Y Word8) #
Readable (Image VS RGBA Word8) TIF #
Methods decode :: TIF -> ByteString -> Either String (Image VS RGBA Word8) #
Readable (Image VS RGBA Word8) TGA #
Methods decode :: TGA -> ByteString -> Either String (Image VS RGBA Word8) #
Readable (Image VS RGBA Word8) PNG #
Methods decode :: PNG -> ByteString -> Either String (Image VS RGBA Word8) #
Readable (Image VS RGBA Word8) GIF #
Methods decode :: GIF -> ByteString -> Either String (Image VS RGBA Word8) #
Readable (Image VS RGBA Word8) BMP #
Methods decode :: BMP -> ByteString -> Either String (Image VS RGBA Word8) #
Readable (Image VS RGB Word8) TIF #
Methods decode :: TIF -> ByteString -> Either String (Image VS RGB Word8) #
Readable (Image VS RGB Word8) TGA #
Methods decode :: TGA -> ByteString -> Either String (Image VS RGB Word8) #
Readable (Image VS RGB Word8) PNG #
Methods decode :: PNG -> ByteString -> Either String (Image VS RGB Word8) #
Readable (Image VS RGB Word8) JPG #
Methods decode :: JPG -> ByteString -> Either String (Image VS RGB Word8) #
Readable (Image VS RGB Word8) GIF #
Methods decode :: GIF -> ByteString -> Either String (Image VS RGB Word8) #
Readable (Image VS RGB Word8) BMP #
Methods decode :: BMP -> ByteString -> Either String (Image VS RGB Word8) #
Readable (Image VS RGB Word8) PPM #
Methods decode :: PPM -> ByteString -> Either String (Image VS RGB Word8) #
Readable (Image VS CMYK Word8) TIF #
Methods decode :: TIF -> ByteString -> Either String (Image VS CMYK Word8) #
Readable (Image VS CMYK Word8) JPG #
Methods decode :: JPG -> ByteString -> Either String (Image VS CMYK Word8) #
type StorageType Word8
type StorageType Word8 = Word8
type PixelBaseComponent Pixel8
type PixelBaseComponent Pixel8 = Word8
type PackedRepresentation Pixel8
type PackedRepresentation Pixel8 = Pixel8
type Unsigned Word8
type Unsigned Word8 = Word8
type Signed Word8
type Signed Word8 = Int8
data Vector Word8
data Vector Word8 = V_Word8 (Vector Word8)
data MVector s Word8
data MVector s Word8 = MV_Word8 (MVector s Word8)
data Array B sh Word8
data Array B sh Word8 = AByteString ~sh ~ByteString

data Word16 :: * #

16-bit unsigned integer type

Instances

Bounded Word16
Methods minBound :: Word16 # maxBound :: Word16 #
Enum Word16
Methods succ :: Word16 -> Word16 # pred :: Word16 -> Word16 # toEnum :: Int -> Word16 # fromEnum :: Word16 -> Int # enumFrom :: Word16 -> [Word16] # enumFromThen :: Word16 -> Word16 -> [Word16] # enumFromTo :: Word16 -> Word16 -> [Word16] # enumFromThenTo :: Word16 -> Word16 -> Word16 -> [Word16] #
Eq Word16
Methods (==) :: Word16 -> Word16 -> Bool # (/=) :: Word16 -> Word16 -> Bool #
Integral Word16
Methods quot :: Word16 -> Word16 -> Word16 # rem :: Word16 -> Word16 -> Word16 # div :: Word16 -> Word16 -> Word16 # mod :: Word16 -> Word16 -> Word16 # quotRem :: Word16 -> Word16 -> (Word16, Word16) # divMod :: Word16 -> Word16 -> (Word16, Word16) # toInteger :: Word16 -> Integer #
Num Word16
Methods (+) :: Word16 -> Word16 -> Word16 # (-) :: Word16 -> Word16 -> Word16 # (*) :: Word16 -> Word16 -> Word16 # negate :: Word16 -> Word16 # abs :: Word16 -> Word16 # signum :: Word16 -> Word16 # fromInteger :: Integer -> Word16 #
Ord Word16
Methods compare :: Word16 -> Word16 -> Ordering # (<) :: Word16 -> Word16 -> Bool # (<=) :: Word16 -> Word16 -> Bool # (>) :: Word16 -> Word16 -> Bool # (>=) :: Word16 -> Word16 -> Bool # max :: Word16 -> Word16 -> Word16 # min :: Word16 -> Word16 -> Word16 #
Read Word16
Methods readsPrec :: Int -> ReadS Word16 # readList :: ReadS [Word16] # readPrec :: ReadPrec Word16 # readListPrec :: ReadPrec [Word16] #
Real Word16
Methods toRational :: Word16 -> Rational #
Show Word16
Methods showsPrec :: Int -> Word16 -> ShowS # show :: Word16 -> String # showList :: [Word16] -> ShowS #
Ix Word16
Methods range :: (Word16, Word16) -> [Word16] # index :: (Word16, Word16) -> Word16 -> Int # unsafeIndex :: (Word16, Word16) -> Word16 -> Int inRange :: (Word16, Word16) -> Word16 -> Bool # rangeSize :: (Word16, Word16) -> Int # unsafeRangeSize :: (Word16, Word16) -> Int
Lift Word16
Methods lift :: Word16 -> Q Exp #
Default Word16
Methods def :: Word16 #
Unpackable Word16
Associated Types type StorageType Word16 :: * Methods outAlloc :: Word16 -> Int -> ST s (STVector s (StorageType Word16)) allocTempBuffer :: Word16 -> STVector s (StorageType Word16) -> Int -> ST s (STVector s Word8) offsetStride :: Word16 -> Int -> Int -> (Int, Int) mergeBackTempBuffer :: Word16 -> Endianness -> STVector s Word8 -> Int -> Int -> Word32 -> Int -> STVector s (StorageType Word16) -> ST s ()
TiffSaveable Pixel16
Methods colorSpaceOfPixel :: Pixel16 -> TiffColorspace extraSampleCodeOfPixel :: Pixel16 -> Maybe ExtraSample subSamplingInfo :: Pixel16 -> Vector Word32
PngSavable Pixel16
Methods encodePng :: Image Pixel16 -> ByteString # encodePngWithMetadata :: Metadatas -> Image Pixel16 -> ByteString #
Pixel Pixel16
Associated Types type PixelBaseComponent Pixel16 :: * # Methods mixWith :: (Int -> PixelBaseComponent Pixel16 -> PixelBaseComponent Pixel16 -> PixelBaseComponent Pixel16) -> Pixel16 -> Pixel16 -> Pixel16 # mixWithAlpha :: (Int -> PixelBaseComponent Pixel16 -> PixelBaseComponent Pixel16 -> PixelBaseComponent Pixel16) -> (PixelBaseComponent Pixel16 -> PixelBaseComponent Pixel16 -> PixelBaseComponent Pixel16) -> Pixel16 -> Pixel16 -> Pixel16 # pixelOpacity :: Pixel16 -> PixelBaseComponent Pixel16 # componentCount :: Pixel16 -> Int # colorMap :: (PixelBaseComponent Pixel16 -> PixelBaseComponent Pixel16) -> Pixel16 -> Pixel16 # pixelBaseIndex :: Image Pixel16 -> Int -> Int -> Int # mutablePixelBaseIndex :: MutableImage s Pixel16 -> Int -> Int -> Int # pixelAt :: Image Pixel16 -> Int -> Int -> Pixel16 # readPixel :: PrimMonad m => MutableImage (PrimState m) Pixel16 -> Int -> Int -> m Pixel16 # writePixel :: PrimMonad m => MutableImage (PrimState m) Pixel16 -> Int -> Int -> Pixel16 -> m () # unsafePixelAt :: Vector (PixelBaseComponent Pixel16) -> Int -> Pixel16 # unsafeReadPixel :: PrimMonad m => STVector (PrimState m) (PixelBaseComponent Pixel16) -> Int -> m Pixel16 # unsafeWritePixel :: PrimMonad m => STVector (PrimState m) (PixelBaseComponent Pixel16) -> Int -> Pixel16 -> m () #
LumaPlaneExtractable Pixel16
Methods computeLuma :: Pixel16 -> PixelBaseComponent Pixel16 # extractLumaPlane :: Image Pixel16 -> Image (PixelBaseComponent Pixel16) #
PackeablePixel Pixel16
Associated Types type PackedRepresentation Pixel16 :: * # Methods packPixel :: Pixel16 -> PackedRepresentation Pixel16 # unpackPixel :: PackedRepresentation Pixel16 -> Pixel16 #
Storable Word16
Methods sizeOf :: Word16 -> Int # alignment :: Word16 -> Int # peekElemOff :: Ptr Word16 -> Int -> IO Word16 # pokeElemOff :: Ptr Word16 -> Int -> Word16 -> IO () # peekByteOff :: Ptr b -> Int -> IO Word16 # pokeByteOff :: Ptr b -> Int -> Word16 -> IO () # peek :: Ptr Word16 -> IO Word16 # poke :: Ptr Word16 -> Word16 -> IO () #
Bits Word16
Methods (.&.) :: Word16 -> Word16 -> Word16 # (.\|.) :: Word16 -> Word16 -> Word16 # xor :: Word16 -> Word16 -> Word16 # complement :: Word16 -> Word16 # shift :: Word16 -> Int -> Word16 # rotate :: Word16 -> Int -> Word16 # zeroBits :: Word16 # bit :: Int -> Word16 # setBit :: Word16 -> Int -> Word16 # clearBit :: Word16 -> Int -> Word16 # complementBit :: Word16 -> Int -> Word16 # testBit :: Word16 -> Int -> Bool # bitSizeMaybe :: Word16 -> Maybe Int # bitSize :: Word16 -> Int # isSigned :: Word16 -> Bool # shiftL :: Word16 -> Int -> Word16 # unsafeShiftL :: Word16 -> Int -> Word16 # shiftR :: Word16 -> Int -> Word16 # unsafeShiftR :: Word16 -> Int -> Word16 # rotateL :: Word16 -> Int -> Word16 # rotateR :: Word16 -> Int -> Word16 # popCount :: Word16 -> Int #
FiniteBits Word16
Methods finiteBitSize :: Word16 -> Int # countLeadingZeros :: Word16 -> Int # countTrailingZeros :: Word16 -> Int #
NFData Word16
Methods rnf :: Word16 -> () #
Prim Word16
Methods sizeOf# :: Word16 -> Int# # alignment# :: Word16 -> Int# # indexByteArray# :: ByteArray# -> Int# -> Word16 # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Word16#) # writeByteArray# :: MutableByteArray# s -> Int# -> Word16 -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word16 -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Word16 # readOffAddr# :: Addr# -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Word16#) # writeOffAddr# :: Addr# -> Int# -> Word16 -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Word16 -> State# s -> State# s #
Unbox Word16

Elt Word16
Methods touch :: Word16 -> IO () # zero :: Word16 # one :: Word16 #
Elevator Word16 #	Values between `[0, 65535]]`
Methods toWord8 :: Word16 -> Word8 # toWord16 :: Word16 -> Word16 # toWord32 :: Word16 -> Word32 # toWord64 :: Word16 -> Word64 # toFloat :: Word16 -> Float # toDouble :: Word16 -> Double # fromDouble :: Double -> Word16 #
Decimable Pixel16 Pixel8
Methods decimateBitDepth :: Image Pixel16 -> Image Pixel8
TransparentPixel PixelYA16 Pixel16
Methods dropTransparency :: PixelYA16 -> Pixel16 # getTransparency :: PixelYA16 -> PixelBaseComponent PixelYA16 #
ColorConvertible Pixel8 Pixel16
Methods promotePixel :: Pixel8 -> Pixel16 # promoteImage :: Image Pixel8 -> Image Pixel16 #
ColorConvertible Pixel16 PixelYA16
Methods promotePixel :: Pixel16 -> PixelYA16 # promoteImage :: Image Pixel16 -> Image PixelYA16 #
ColorConvertible Pixel16 PixelRGB16
Methods promotePixel :: Pixel16 -> PixelRGB16 # promoteImage :: Image Pixel16 -> Image PixelRGB16 #
ColorConvertible Pixel16 PixelRGBA16
Methods promotePixel :: Pixel16 -> PixelRGBA16 # promoteImage :: Image Pixel16 -> Image PixelRGBA16 #
IArray UArray Word16
Methods bounds :: Ix i => UArray i Word16 -> (i, i) # numElements :: Ix i => UArray i Word16 -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Word16)] -> UArray i Word16 unsafeAt :: Ix i => UArray i Word16 -> Int -> Word16 unsafeReplace :: Ix i => UArray i Word16 -> [(Int, Word16)] -> UArray i Word16 unsafeAccum :: Ix i => (Word16 -> e' -> Word16) -> UArray i Word16 -> [(Int, e')] -> UArray i Word16 unsafeAccumArray :: Ix i => (Word16 -> e' -> Word16) -> Word16 -> (i, i) -> [(Int, e')] -> UArray i Word16
Vector Vector Word16
Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word16 -> m (Vector Word16) # basicUnsafeThaw :: PrimMonad m => Vector Word16 -> m (Mutable Vector (PrimState m) Word16) # basicLength :: Vector Word16 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Word16 -> Vector Word16 # basicUnsafeIndexM :: Monad m => Vector Word16 -> Int -> m Word16 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word16 -> Vector Word16 -> m () # elemseq :: Vector Word16 -> Word16 -> b -> b #
MVector MVector Word16
Methods basicLength :: MVector s Word16 -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Word16 -> MVector s Word16 # basicOverlaps :: MVector s Word16 -> MVector s Word16 -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word16) # basicInitialize :: PrimMonad m => MVector (PrimState m) Word16 -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Word16 -> m (MVector (PrimState m) Word16) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word16 -> Int -> m Word16 # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word16 -> Int -> Word16 -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Word16 -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Word16 -> Word16 -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word16 -> MVector (PrimState m) Word16 -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word16 -> MVector (PrimState m) Word16 -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word16 -> Int -> m (MVector (PrimState m) Word16) #
MArray (STUArray s) Word16 (ST s)
Methods getBounds :: Ix i => STUArray s i Word16 -> ST s (i, i) # getNumElements :: Ix i => STUArray s i Word16 -> ST s Int newArray :: Ix i => (i, i) -> Word16 -> ST s (STUArray s i Word16) # newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word16) # unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word16) unsafeRead :: Ix i => STUArray s i Word16 -> Int -> ST s Word16 unsafeWrite :: Ix i => STUArray s i Word16 -> Int -> Word16 -> ST s ()
Readable [Image VS Y Word16] (Seq PGM) #
Methods decode :: Seq PGM -> ByteString -> Either String [Image VS Y Word16] #
Readable [Image VS RGB Word16] (Seq PPM) #
Methods decode :: Seq PPM -> ByteString -> Either String [Image VS RGB Word16] #
Writable (Image VS YA Word16) TIF #
Methods encode :: TIF -> [SaveOption TIF] -> Image VS YA Word16 -> ByteString #
Writable (Image VS YA Word16) PNG #
Methods encode :: PNG -> [SaveOption PNG] -> Image VS YA Word16 -> ByteString #
Writable (Image VS Y Word16) TIF #
Methods encode :: TIF -> [SaveOption TIF] -> Image VS Y Word16 -> ByteString #
Writable (Image VS Y Word16) PNG #
Methods encode :: PNG -> [SaveOption PNG] -> Image VS Y Word16 -> ByteString #
Writable (Image VS RGBA Word16) TIF #
Methods encode :: TIF -> [SaveOption TIF] -> Image VS RGBA Word16 -> ByteString #
Writable (Image VS RGBA Word16) PNG #
Methods encode :: PNG -> [SaveOption PNG] -> Image VS RGBA Word16 -> ByteString #
Writable (Image VS RGB Word16) TIF #
Methods encode :: TIF -> [SaveOption TIF] -> Image VS RGB Word16 -> ByteString #
Writable (Image VS RGB Word16) PNG #
Methods encode :: PNG -> [SaveOption PNG] -> Image VS RGB Word16 -> ByteString #
Writable (Image VS CMYK Word16) TIF #
Methods encode :: TIF -> [SaveOption TIF] -> Image VS CMYK Word16 -> ByteString #
Readable (Image VS YA Word16) TIF #
Methods decode :: TIF -> ByteString -> Either String (Image VS YA Word16) #
Readable (Image VS YA Word16) PNG #
Methods decode :: PNG -> ByteString -> Either String (Image VS YA Word16) #
Readable (Image VS Y Word16) TIF #
Methods decode :: TIF -> ByteString -> Either String (Image VS Y Word16) #
Readable (Image VS Y Word16) PNG #
Methods decode :: PNG -> ByteString -> Either String (Image VS Y Word16) #
Readable (Image VS Y Word16) PGM #
Methods decode :: PGM -> ByteString -> Either String (Image VS Y Word16) #
Readable (Image VS RGBA Word16) TIF #
Methods decode :: TIF -> ByteString -> Either String (Image VS RGBA Word16) #
Readable (Image VS RGBA Word16) PNG #
Methods decode :: PNG -> ByteString -> Either String (Image VS RGBA Word16) #
Readable (Image VS RGB Word16) TIF #
Methods decode :: TIF -> ByteString -> Either String (Image VS RGB Word16) #
Readable (Image VS RGB Word16) PNG #
Methods decode :: PNG -> ByteString -> Either String (Image VS RGB Word16) #
Readable (Image VS RGB Word16) PPM #
Methods decode :: PPM -> ByteString -> Either String (Image VS RGB Word16) #
Readable (Image VS CMYK Word16) TIF #
Methods decode :: TIF -> ByteString -> Either String (Image VS CMYK Word16) #
type StorageType Word16
type StorageType Word16 = Word16
type PixelBaseComponent Pixel16
type PixelBaseComponent Pixel16 = Word16
type PackedRepresentation Pixel16
type PackedRepresentation Pixel16 = Pixel16
type Unsigned Word16
type Unsigned Word16 = Word16
type Signed Word16
type Signed Word16 = Int16
data Vector Word16
data Vector Word16 = V_Word16 (Vector Word16)
data MVector s Word16
data MVector s Word16 = MV_Word16 (MVector s Word16)

data Word32 :: * #

32-bit unsigned integer type

Instances

Bounded Word32
Methods minBound :: Word32 # maxBound :: Word32 #
Enum Word32
Methods succ :: Word32 -> Word32 # pred :: Word32 -> Word32 # toEnum :: Int -> Word32 # fromEnum :: Word32 -> Int # enumFrom :: Word32 -> [Word32] # enumFromThen :: Word32 -> Word32 -> [Word32] # enumFromTo :: Word32 -> Word32 -> [Word32] # enumFromThenTo :: Word32 -> Word32 -> Word32 -> [Word32] #
Eq Word32
Methods (==) :: Word32 -> Word32 -> Bool # (/=) :: Word32 -> Word32 -> Bool #
Integral Word32
Methods quot :: Word32 -> Word32 -> Word32 # rem :: Word32 -> Word32 -> Word32 # div :: Word32 -> Word32 -> Word32 # mod :: Word32 -> Word32 -> Word32 # quotRem :: Word32 -> Word32 -> (Word32, Word32) # divMod :: Word32 -> Word32 -> (Word32, Word32) # toInteger :: Word32 -> Integer #
Num Word32
Methods (+) :: Word32 -> Word32 -> Word32 # (-) :: Word32 -> Word32 -> Word32 # (*) :: Word32 -> Word32 -> Word32 # negate :: Word32 -> Word32 # abs :: Word32 -> Word32 # signum :: Word32 -> Word32 # fromInteger :: Integer -> Word32 #
Ord Word32
Methods compare :: Word32 -> Word32 -> Ordering # (<) :: Word32 -> Word32 -> Bool # (<=) :: Word32 -> Word32 -> Bool # (>) :: Word32 -> Word32 -> Bool # (>=) :: Word32 -> Word32 -> Bool # max :: Word32 -> Word32 -> Word32 # min :: Word32 -> Word32 -> Word32 #
Read Word32
Methods readsPrec :: Int -> ReadS Word32 # readList :: ReadS [Word32] # readPrec :: ReadPrec Word32 # readListPrec :: ReadPrec [Word32] #
Real Word32
Methods toRational :: Word32 -> Rational #
Show Word32
Methods showsPrec :: Int -> Word32 -> ShowS # show :: Word32 -> String # showList :: [Word32] -> ShowS #
Ix Word32
Methods range :: (Word32, Word32) -> [Word32] # index :: (Word32, Word32) -> Word32 -> Int # unsafeIndex :: (Word32, Word32) -> Word32 -> Int inRange :: (Word32, Word32) -> Word32 -> Bool # rangeSize :: (Word32, Word32) -> Int # unsafeRangeSize :: (Word32, Word32) -> Int
Lift Word32
Methods lift :: Word32 -> Q Exp #
Default Word32
Methods def :: Word32 #
Unpackable Word32
Associated Types type StorageType Word32 :: * Methods outAlloc :: Word32 -> Int -> ST s (STVector s (StorageType Word32)) allocTempBuffer :: Word32 -> STVector s (StorageType Word32) -> Int -> ST s (STVector s Word8) offsetStride :: Word32 -> Int -> Int -> (Int, Int) mergeBackTempBuffer :: Word32 -> Endianness -> STVector s Word8 -> Int -> Int -> Word32 -> Int -> STVector s (StorageType Word32) -> ST s ()
Pixel Pixel32
Associated Types type PixelBaseComponent Pixel32 :: * # Methods mixWith :: (Int -> PixelBaseComponent Pixel32 -> PixelBaseComponent Pixel32 -> PixelBaseComponent Pixel32) -> Pixel32 -> Pixel32 -> Pixel32 # mixWithAlpha :: (Int -> PixelBaseComponent Pixel32 -> PixelBaseComponent Pixel32 -> PixelBaseComponent Pixel32) -> (PixelBaseComponent Pixel32 -> PixelBaseComponent Pixel32 -> PixelBaseComponent Pixel32) -> Pixel32 -> Pixel32 -> Pixel32 # pixelOpacity :: Pixel32 -> PixelBaseComponent Pixel32 # componentCount :: Pixel32 -> Int # colorMap :: (PixelBaseComponent Pixel32 -> PixelBaseComponent Pixel32) -> Pixel32 -> Pixel32 # pixelBaseIndex :: Image Pixel32 -> Int -> Int -> Int # mutablePixelBaseIndex :: MutableImage s Pixel32 -> Int -> Int -> Int # pixelAt :: Image Pixel32 -> Int -> Int -> Pixel32 # readPixel :: PrimMonad m => MutableImage (PrimState m) Pixel32 -> Int -> Int -> m Pixel32 # writePixel :: PrimMonad m => MutableImage (PrimState m) Pixel32 -> Int -> Int -> Pixel32 -> m () # unsafePixelAt :: Vector (PixelBaseComponent Pixel32) -> Int -> Pixel32 # unsafeReadPixel :: PrimMonad m => STVector (PrimState m) (PixelBaseComponent Pixel32) -> Int -> m Pixel32 # unsafeWritePixel :: PrimMonad m => STVector (PrimState m) (PixelBaseComponent Pixel32) -> Int -> Pixel32 -> m () #
LumaPlaneExtractable Pixel32
Methods computeLuma :: Pixel32 -> PixelBaseComponent Pixel32 # extractLumaPlane :: Image Pixel32 -> Image (PixelBaseComponent Pixel32) #
PackeablePixel Pixel32
Associated Types type PackedRepresentation Pixel32 :: * # Methods packPixel :: Pixel32 -> PackedRepresentation Pixel32 # unpackPixel :: PackedRepresentation Pixel32 -> Pixel32 #
Storable Word32
Methods sizeOf :: Word32 -> Int # alignment :: Word32 -> Int # peekElemOff :: Ptr Word32 -> Int -> IO Word32 # pokeElemOff :: Ptr Word32 -> Int -> Word32 -> IO () # peekByteOff :: Ptr b -> Int -> IO Word32 # pokeByteOff :: Ptr b -> Int -> Word32 -> IO () # peek :: Ptr Word32 -> IO Word32 # poke :: Ptr Word32 -> Word32 -> IO () #
Bits Word32
Methods (.&.) :: Word32 -> Word32 -> Word32 # (.\|.) :: Word32 -> Word32 -> Word32 # xor :: Word32 -> Word32 -> Word32 # complement :: Word32 -> Word32 # shift :: Word32 -> Int -> Word32 # rotate :: Word32 -> Int -> Word32 # zeroBits :: Word32 # bit :: Int -> Word32 # setBit :: Word32 -> Int -> Word32 # clearBit :: Word32 -> Int -> Word32 # complementBit :: Word32 -> Int -> Word32 # testBit :: Word32 -> Int -> Bool # bitSizeMaybe :: Word32 -> Maybe Int # bitSize :: Word32 -> Int # isSigned :: Word32 -> Bool # shiftL :: Word32 -> Int -> Word32 # unsafeShiftL :: Word32 -> Int -> Word32 # shiftR :: Word32 -> Int -> Word32 # unsafeShiftR :: Word32 -> Int -> Word32 # rotateL :: Word32 -> Int -> Word32 # rotateR :: Word32 -> Int -> Word32 # popCount :: Word32 -> Int #
FiniteBits Word32
Methods finiteBitSize :: Word32 -> Int # countLeadingZeros :: Word32 -> Int # countTrailingZeros :: Word32 -> Int #
NFData Word32
Methods rnf :: Word32 -> () #
Prim Word32
Methods sizeOf# :: Word32 -> Int# # alignment# :: Word32 -> Int# # indexByteArray# :: ByteArray# -> Int# -> Word32 # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Word32#) # writeByteArray# :: MutableByteArray# s -> Int# -> Word32 -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word32 -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Word32 # readOffAddr# :: Addr# -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Word32#) # writeOffAddr# :: Addr# -> Int# -> Word32 -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Word32 -> State# s -> State# s #
Unbox Word32

Elt Word32
Methods touch :: Word32 -> IO () # zero :: Word32 # one :: Word32 #
Elevator Word32 #	Values between `[0, 4294967295]`
Methods toWord8 :: Word32 -> Word8 # toWord16 :: Word32 -> Word16 # toWord32 :: Word32 -> Word32 # toWord64 :: Word32 -> Word64 # toFloat :: Word32 -> Float # toDouble :: Word32 -> Double # fromDouble :: Double -> Word32 #
IArray UArray Word32
Methods bounds :: Ix i => UArray i Word32 -> (i, i) # numElements :: Ix i => UArray i Word32 -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Word32)] -> UArray i Word32 unsafeAt :: Ix i => UArray i Word32 -> Int -> Word32 unsafeReplace :: Ix i => UArray i Word32 -> [(Int, Word32)] -> UArray i Word32 unsafeAccum :: Ix i => (Word32 -> e' -> Word32) -> UArray i Word32 -> [(Int, e')] -> UArray i Word32 unsafeAccumArray :: Ix i => (Word32 -> e' -> Word32) -> Word32 -> (i, i) -> [(Int, e')] -> UArray i Word32
Vector Vector Word32
Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word32 -> m (Vector Word32) # basicUnsafeThaw :: PrimMonad m => Vector Word32 -> m (Mutable Vector (PrimState m) Word32) # basicLength :: Vector Word32 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Word32 -> Vector Word32 # basicUnsafeIndexM :: Monad m => Vector Word32 -> Int -> m Word32 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word32 -> Vector Word32 -> m () # elemseq :: Vector Word32 -> Word32 -> b -> b #
MVector MVector Word32
Methods basicLength :: MVector s Word32 -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Word32 -> MVector s Word32 # basicOverlaps :: MVector s Word32 -> MVector s Word32 -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word32) # basicInitialize :: PrimMonad m => MVector (PrimState m) Word32 -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Word32 -> m (MVector (PrimState m) Word32) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word32 -> Int -> m Word32 # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word32 -> Int -> Word32 -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Word32 -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Word32 -> Word32 -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word32 -> MVector (PrimState m) Word32 -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word32 -> MVector (PrimState m) Word32 -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word32 -> Int -> m (MVector (PrimState m) Word32) #
MArray (STUArray s) Word32 (ST s)
Methods getBounds :: Ix i => STUArray s i Word32 -> ST s (i, i) # getNumElements :: Ix i => STUArray s i Word32 -> ST s Int newArray :: Ix i => (i, i) -> Word32 -> ST s (STUArray s i Word32) # newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word32) # unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word32) unsafeRead :: Ix i => STUArray s i Word32 -> Int -> ST s Word32 unsafeWrite :: Ix i => STUArray s i Word32 -> Int -> Word32 -> ST s ()
type StorageType Word32
type StorageType Word32 = Word32
type PixelBaseComponent Pixel32
type PixelBaseComponent Pixel32 = Word32
type PackedRepresentation Pixel32
type PackedRepresentation Pixel32 = Pixel32
type Unsigned Word32
type Unsigned Word32 = Word32
type Signed Word32
type Signed Word32 = Int32
data Vector Word32
data Vector Word32 = V_Word32 (Vector Word32)
data MVector s Word32
data MVector s Word32 = MV_Word32 (MVector s Word32)

data Word64 :: * #

64-bit unsigned integer type

Instances

Bounded Word64
Methods minBound :: Word64 # maxBound :: Word64 #
Enum Word64
Methods succ :: Word64 -> Word64 # pred :: Word64 -> Word64 # toEnum :: Int -> Word64 # fromEnum :: Word64 -> Int # enumFrom :: Word64 -> [Word64] # enumFromThen :: Word64 -> Word64 -> [Word64] # enumFromTo :: Word64 -> Word64 -> [Word64] # enumFromThenTo :: Word64 -> Word64 -> Word64 -> [Word64] #
Eq Word64
Methods (==) :: Word64 -> Word64 -> Bool # (/=) :: Word64 -> Word64 -> Bool #
Integral Word64
Methods quot :: Word64 -> Word64 -> Word64 # rem :: Word64 -> Word64 -> Word64 # div :: Word64 -> Word64 -> Word64 # mod :: Word64 -> Word64 -> Word64 # quotRem :: Word64 -> Word64 -> (Word64, Word64) # divMod :: Word64 -> Word64 -> (Word64, Word64) # toInteger :: Word64 -> Integer #
Num Word64
Methods (+) :: Word64 -> Word64 -> Word64 # (-) :: Word64 -> Word64 -> Word64 # (*) :: Word64 -> Word64 -> Word64 # negate :: Word64 -> Word64 # abs :: Word64 -> Word64 # signum :: Word64 -> Word64 # fromInteger :: Integer -> Word64 #
Ord Word64
Methods compare :: Word64 -> Word64 -> Ordering # (<) :: Word64 -> Word64 -> Bool # (<=) :: Word64 -> Word64 -> Bool # (>) :: Word64 -> Word64 -> Bool # (>=) :: Word64 -> Word64 -> Bool # max :: Word64 -> Word64 -> Word64 # min :: Word64 -> Word64 -> Word64 #
Read Word64
Methods readsPrec :: Int -> ReadS Word64 # readList :: ReadS [Word64] # readPrec :: ReadPrec Word64 # readListPrec :: ReadPrec [Word64] #
Real Word64
Methods toRational :: Word64 -> Rational #
Show Word64
Methods showsPrec :: Int -> Word64 -> ShowS # show :: Word64 -> String # showList :: [Word64] -> ShowS #
Ix Word64
Methods range :: (Word64, Word64) -> [Word64] # index :: (Word64, Word64) -> Word64 -> Int # unsafeIndex :: (Word64, Word64) -> Word64 -> Int inRange :: (Word64, Word64) -> Word64 -> Bool # rangeSize :: (Word64, Word64) -> Int # unsafeRangeSize :: (Word64, Word64) -> Int
Lift Word64
Methods lift :: Word64 -> Q Exp #
Default Word64
Methods def :: Word64 #
Storable Word64
Methods sizeOf :: Word64 -> Int # alignment :: Word64 -> Int # peekElemOff :: Ptr Word64 -> Int -> IO Word64 # pokeElemOff :: Ptr Word64 -> Int -> Word64 -> IO () # peekByteOff :: Ptr b -> Int -> IO Word64 # pokeByteOff :: Ptr b -> Int -> Word64 -> IO () # peek :: Ptr Word64 -> IO Word64 # poke :: Ptr Word64 -> Word64 -> IO () #
Bits Word64
Methods (.&.) :: Word64 -> Word64 -> Word64 # (.\|.) :: Word64 -> Word64 -> Word64 # xor :: Word64 -> Word64 -> Word64 # complement :: Word64 -> Word64 # shift :: Word64 -> Int -> Word64 # rotate :: Word64 -> Int -> Word64 # zeroBits :: Word64 # bit :: Int -> Word64 # setBit :: Word64 -> Int -> Word64 # clearBit :: Word64 -> Int -> Word64 # complementBit :: Word64 -> Int -> Word64 # testBit :: Word64 -> Int -> Bool # bitSizeMaybe :: Word64 -> Maybe Int # bitSize :: Word64 -> Int # isSigned :: Word64 -> Bool # shiftL :: Word64 -> Int -> Word64 # unsafeShiftL :: Word64 -> Int -> Word64 # shiftR :: Word64 -> Int -> Word64 # unsafeShiftR :: Word64 -> Int -> Word64 # rotateL :: Word64 -> Int -> Word64 # rotateR :: Word64 -> Int -> Word64 # popCount :: Word64 -> Int #
FiniteBits Word64
Methods finiteBitSize :: Word64 -> Int # countLeadingZeros :: Word64 -> Int # countTrailingZeros :: Word64 -> Int #
NFData Word64
Methods rnf :: Word64 -> () #
Prim Word64
Methods sizeOf# :: Word64 -> Int# # alignment# :: Word64 -> Int# # indexByteArray# :: ByteArray# -> Int# -> Word64 # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Word64#) # writeByteArray# :: MutableByteArray# s -> Int# -> Word64 -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word64 -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Word64 # readOffAddr# :: Addr# -> Int# -> State# s -> (#VoidRep, PtrRepLifted, State# s, Word64#) # writeOffAddr# :: Addr# -> Int# -> Word64 -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Word64 -> State# s -> State# s #
Unbox Word64

Elt Word64
Methods touch :: Word64 -> IO () # zero :: Word64 # one :: Word64 #
Elevator Word64 #	Values between `[0, 18446744073709551615]`
Methods toWord8 :: Word64 -> Word8 # toWord16 :: Word64 -> Word16 # toWord32 :: Word64 -> Word32 # toWord64 :: Word64 -> Word64 # toFloat :: Word64 -> Float # toDouble :: Word64 -> Double # fromDouble :: Double -> Word64 #
IArray UArray Word64
Methods bounds :: Ix i => UArray i Word64 -> (i, i) # numElements :: Ix i => UArray i Word64 -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Word64)] -> UArray i Word64 unsafeAt :: Ix i => UArray i Word64 -> Int -> Word64 unsafeReplace :: Ix i => UArray i Word64 -> [(Int, Word64)] -> UArray i Word64 unsafeAccum :: Ix i => (Word64 -> e' -> Word64) -> UArray i Word64 -> [(Int, e')] -> UArray i Word64 unsafeAccumArray :: Ix i => (Word64 -> e' -> Word64) -> Word64 -> (i, i) -> [(Int, e')] -> UArray i Word64
Vector Vector Word64
Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word64 -> m (Vector Word64) # basicUnsafeThaw :: PrimMonad m => Vector Word64 -> m (Mutable Vector (PrimState m) Word64) # basicLength :: Vector Word64 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Word64 -> Vector Word64 # basicUnsafeIndexM :: Monad m => Vector Word64 -> Int -> m Word64 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word64 -> Vector Word64 -> m () # elemseq :: Vector Word64 -> Word64 -> b -> b #
MVector MVector Word64
Methods basicLength :: MVector s Word64 -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Word64 -> MVector s Word64 # basicOverlaps :: MVector s Word64 -> MVector s Word64 -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word64) # basicInitialize :: PrimMonad m => MVector (PrimState m) Word64 -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Word64 -> m (MVector (PrimState m) Word64) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word64 -> Int -> m Word64 # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word64 -> Int -> Word64 -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Word64 -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Word64 -> Word64 -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word64 -> MVector (PrimState m) Word64 -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word64 -> MVector (PrimState m) Word64 -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word64 -> Int -> m (MVector (PrimState m) Word64) #
MArray (STUArray s) Word64 (ST s)
Methods getBounds :: Ix i => STUArray s i Word64 -> ST s (i, i) # getNumElements :: Ix i => STUArray s i Word64 -> ST s Int newArray :: Ix i => (i, i) -> Word64 -> ST s (STUArray s i Word64) # newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word64) # unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word64) unsafeRead :: Ix i => STUArray s i Word64 -> Int -> ST s Word64 unsafeWrite :: Ix i => STUArray s i Word64 -> Int -> Word64 -> ST s ()
type Unsigned Word64
type Unsigned Word64 = Word64
type Signed Word64
type Signed Word64 = Int64
data Vector Word64
data Vector Word64 = V_Word64 (Vector Word64)
data MVector s Word64
data MVector s Word64 = MV_Word64 (MVector s Word64)