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

Graphics.ColorSpace

Contents

Pixels
ColorSpace
Precision
- Pixel
- Componenet

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

ColorSpace cs e => Vector Vector (Pixel cs e) #
Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Pixel cs e) -> m (Vector (Pixel cs e)) # basicUnsafeThaw :: PrimMonad m => Vector (Pixel cs e) -> m (Mutable Vector (PrimState m) (Pixel cs e)) # basicLength :: Vector (Pixel cs e) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Pixel cs e) -> Vector (Pixel cs e) # basicUnsafeIndexM :: Monad m => Vector (Pixel cs e) -> Int -> m (Pixel cs e) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Pixel cs e) -> Vector (Pixel cs e) -> m () # elemseq :: Vector (Pixel cs e) -> Pixel cs e -> b -> b #
ColorSpace cs e => MVector MVector (Pixel cs e) #
Methods basicLength :: MVector s (Pixel cs e) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (Pixel cs e) -> MVector s (Pixel cs e) # basicOverlaps :: MVector s (Pixel cs e) -> MVector s (Pixel cs e) -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Pixel cs e)) # basicInitialize :: PrimMonad m => MVector (PrimState m) (Pixel cs e) -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Pixel cs e -> m (MVector (PrimState m) (Pixel cs e)) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Pixel cs e) -> Int -> m (Pixel cs e) # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Pixel cs e) -> Int -> Pixel cs e -> m () # basicClear :: PrimMonad m => MVector (PrimState m) (Pixel cs e) -> m () # basicSet :: PrimMonad m => MVector (PrimState m) (Pixel cs e) -> Pixel cs e -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Pixel cs e) -> MVector (PrimState m) (Pixel cs e) -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Pixel cs e) -> MVector (PrimState m) (Pixel cs e) -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Pixel cs e) -> Int -> m (MVector (PrimState m) (Pixel cs e)) #
(ColorSpace cs e, Source r Ix2 (Pixel cs e)) => Writable TIF (Image r cs e) #
Methods encode :: TIF -> WriteOptions TIF -> Image r cs e -> ByteString #
(ColorSpace cs e, Source r Ix2 (Pixel cs e)) => Writable TGA (Image r cs e) #
Methods encode :: TGA -> WriteOptions TGA -> Image r cs e -> ByteString #
(ColorSpace cs e, Source r Ix2 (Pixel cs e)) => Writable JPG (Image r cs e) #
Methods encode :: JPG -> WriteOptions JPG -> Image r cs e -> ByteString #
(ColorSpace cs e, Source r Ix2 (Pixel cs e)) => Writable HDR (Image r cs e) #
Methods encode :: HDR -> WriteOptions HDR -> Image r cs e -> ByteString #
(ColorSpace cs e, Source r Ix2 (Pixel cs e)) => Writable GIF (Image r cs e) #
Methods encode :: GIF -> WriteOptions GIF -> Image r cs e -> ByteString #
(ColorSpace cs e, Source r Ix2 (Pixel cs e)) => Writable PNG (Image r cs e) #
Methods encode :: PNG -> WriteOptions PNG -> Image r cs e -> ByteString #
(ColorSpace cs e, Source r Ix2 (Pixel cs e)) => Writable BMP (Image r cs e) #
Methods encode :: BMP -> WriteOptions BMP -> Image r cs e -> ByteString #
ColorSpace cs e => Readable TIF (Image S cs e) #
Methods decode :: TIF -> ReadOptions TIF -> ByteString -> Image S cs e #
ColorSpace cs e => Readable TGA (Image S cs e) #
Methods decode :: TGA -> ReadOptions TGA -> ByteString -> Image S cs e #
ColorSpace cs e => Readable JPG (Image S cs e) #
Methods decode :: JPG -> ReadOptions JPG -> ByteString -> Image S cs e #
ColorSpace cs e => Readable HDR (Image S cs e) #
Methods decode :: HDR -> ReadOptions HDR -> ByteString -> Image S cs e #
ColorSpace cs e => Readable GIF (Image S cs e) #
Methods decode :: GIF -> ReadOptions GIF -> ByteString -> Image S cs e #
ColorSpace cs e => Readable PNG (Image S cs e) #
Methods decode :: PNG -> ReadOptions PNG -> ByteString -> Image S cs e #
ColorSpace cs e => Readable BMP (Image S cs e) #
Methods decode :: BMP -> ReadOptions BMP -> ByteString -> Image S cs e #
ColorSpace cs e => Readable PPM (Image S cs e) #
Methods decode :: PPM -> ReadOptions PPM -> ByteString -> Image S cs e #
ColorSpace cs e => Readable PGM (Image S cs e) #
Methods decode :: PGM -> ReadOptions PGM -> ByteString -> Image S cs e #
ColorSpace cs e => Readable PBM (Image S cs e) #
Methods decode :: PBM -> ReadOptions PBM -> ByteString -> Image S cs e #
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 #
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 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 #
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 X) #
Methods fmap :: (a -> b) -> Pixel X a -> Pixel X b # (<$) :: a -> Pixel X b -> Pixel X 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 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 #
Applicative (Pixel HSIA) #
Methods pure :: a -> Pixel HSIA a # (<>) :: Pixel HSIA (a -> b) -> Pixel HSIA a -> Pixel HSIA b # liftA2 :: (a -> b -> c) -> Pixel HSIA a -> Pixel HSIA b -> Pixel HSIA c # (>) :: 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 # liftA2 :: (a -> b -> c) -> Pixel HSI a -> Pixel HSI b -> Pixel HSI c # (>) :: 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 # liftA2 :: (a -> b -> c) -> Pixel CMYKA a -> Pixel CMYKA b -> Pixel CMYKA c # (>) :: 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 # liftA2 :: (a -> b -> c) -> Pixel CMYK a -> Pixel CMYK b -> Pixel CMYK c # (>) :: Pixel CMYK a -> Pixel CMYK b -> Pixel CMYK b # (<*) :: Pixel CMYK a -> Pixel CMYK b -> Pixel CMYK a #
Applicative (Pixel RGBA) #
Methods pure :: a -> Pixel RGBA a # (<>) :: Pixel RGBA (a -> b) -> Pixel RGBA a -> Pixel RGBA b # liftA2 :: (a -> b -> c) -> Pixel RGBA a -> Pixel RGBA b -> Pixel RGBA c # (>) :: 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 # liftA2 :: (a -> b -> c) -> Pixel RGB a -> Pixel RGB b -> Pixel RGB c # (>) :: Pixel RGB a -> Pixel RGB b -> Pixel RGB b # (<*) :: Pixel RGB a -> Pixel RGB b -> Pixel RGB a #
Applicative (Pixel X) #
Methods pure :: a -> Pixel X a # (<>) :: Pixel X (a -> b) -> Pixel X a -> Pixel X b # liftA2 :: (a -> b -> c) -> Pixel X a -> Pixel X b -> Pixel X c # (>) :: Pixel X a -> Pixel X b -> Pixel X b # (<*) :: Pixel X a -> Pixel X b -> Pixel X a #
Applicative (Pixel YA) #
Methods pure :: a -> Pixel YA a # (<>) :: Pixel YA (a -> b) -> Pixel YA a -> Pixel YA b # liftA2 :: (a -> b -> c) -> Pixel YA a -> Pixel YA b -> Pixel YA c # (>) :: 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 # liftA2 :: (a -> b -> c) -> Pixel Y a -> Pixel Y b -> Pixel Y c # (>) :: Pixel Y a -> Pixel Y b -> Pixel Y b # (<*) :: Pixel Y a -> Pixel Y b -> Pixel Y a #
Applicative (Pixel YCbCrA) #
Methods pure :: a -> Pixel YCbCrA a # (<>) :: Pixel YCbCrA (a -> b) -> Pixel YCbCrA a -> Pixel YCbCrA b # liftA2 :: (a -> b -> c) -> Pixel YCbCrA a -> Pixel YCbCrA b -> Pixel YCbCrA c # (>) :: 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 # liftA2 :: (a -> b -> c) -> Pixel YCbCr a -> Pixel YCbCr b -> Pixel YCbCr c # (>) :: Pixel YCbCr a -> Pixel YCbCr b -> Pixel YCbCr b # (<*) :: Pixel YCbCr a -> Pixel YCbCr b -> Pixel YCbCr 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 #
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 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 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 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 #
FileFormat (Decode (Image r cs e)) #
Associated Types type ReadOptions (Decode (Image r cs e)) :: * # type WriteOptions (Decode (Image r cs e)) :: * # Methods ext :: Decode (Image r cs e) -> String # exts :: Decode (Image r cs e) -> [String] # isFormat :: String -> Decode (Image r cs e) -> Bool #
FileFormat (Encode (Image r cs e)) #
Associated Types type ReadOptions (Encode (Image r cs e)) :: * # type WriteOptions (Encode (Image r cs e)) :: * # Methods ext :: Encode (Image r cs e) -> String # exts :: Encode (Image r cs e) -> [String] # isFormat :: String -> Encode (Image r cs e) -> Bool #
(ColorSpace cs e, ToRGBA cs e, Source r Ix2 (Pixel cs e)) => Writable (Auto TIF) (Image r cs e) #
Methods encode :: Auto TIF -> WriteOptions (Auto TIF) -> Image r cs e -> ByteString #
(ColorSpace cs e, ToRGBA cs e, Source r Ix2 (Pixel cs e)) => Writable (Auto TGA) (Image r cs e) #
Methods encode :: Auto TGA -> WriteOptions (Auto TGA) -> Image r cs e -> ByteString #
(ColorSpace cs e, ToYCbCr cs e, Source r Ix2 (Pixel cs e)) => Writable (Auto JPG) (Image r cs e) #
Methods encode :: Auto JPG -> WriteOptions (Auto JPG) -> Image r cs e -> ByteString #
(ColorSpace cs e, ToRGB cs e, Source r Ix2 (Pixel cs e)) => Writable (Auto HDR) (Image r cs e) #
Methods encode :: Auto HDR -> WriteOptions (Auto HDR) -> Image r cs e -> ByteString #
(ColorSpace cs e, ToY cs e, ToRGB cs e, Source r Ix2 (Pixel cs e)) => Writable (Auto GIF) (Image r cs e) #
Methods encode :: Auto GIF -> WriteOptions (Auto GIF) -> Image r cs e -> ByteString #
(ColorSpace cs e, ToYA cs e, ToRGBA cs e, Source r Ix2 (Pixel cs e)) => Writable (Auto PNG) (Image r cs e) #
Methods encode :: Auto PNG -> WriteOptions (Auto PNG) -> Image r cs e -> ByteString #
(ColorSpace cs e, ToRGBA cs e, Source r Ix2 (Pixel cs e)) => Writable (Auto BMP) (Image r cs e) #
Methods encode :: Auto BMP -> WriteOptions (Auto BMP) -> Image r cs e -> ByteString #
(ColorSpace cs e, Source r Ix2 (Pixel cs e)) => Writable (Sequence GIF) (Array B Ix1 (GifDelay, Image r cs e)) #
Methods encode :: Sequence GIF -> WriteOptions (Sequence GIF) -> Array B Ix1 (GifDelay, Image r cs e) -> ByteString #
Writable (Encode (Image r cs e)) (Image r cs e) #
Methods encode :: Encode (Image r cs e) -> WriteOptions (Encode (Image r cs e)) -> Image r cs e -> ByteString #
(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Auto TIF) (Image r cs e) #
Methods decode :: Auto TIF -> ReadOptions (Auto TIF) -> ByteString -> Image r cs e #
(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Auto TGA) (Image r cs e) #
Methods decode :: Auto TGA -> ReadOptions (Auto TGA) -> ByteString -> Image r cs e #
(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Auto JPG) (Image r cs e) #
Methods decode :: Auto JPG -> ReadOptions (Auto JPG) -> ByteString -> Image r cs e #
(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Auto HDR) (Image r cs e) #
Methods decode :: Auto HDR -> ReadOptions (Auto HDR) -> ByteString -> Image r cs e #
(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Auto GIF) (Image r cs e) #
Methods decode :: Auto GIF -> ReadOptions (Auto GIF) -> ByteString -> Image r cs e #
(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Auto PNG) (Image r cs e) #
Methods decode :: Auto PNG -> ReadOptions (Auto PNG) -> ByteString -> Image r cs e #
(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Auto BMP) (Image r cs e) #
Methods decode :: Auto BMP -> ReadOptions (Auto BMP) -> ByteString -> Image r cs e #
(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Auto PPM) (Image r cs e) #
Methods decode :: Auto PPM -> ReadOptions (Auto PPM) -> ByteString -> Image r cs e #
(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Auto PGM) (Image r cs e) #
Methods decode :: Auto PGM -> ReadOptions (Auto PGM) -> ByteString -> Image r cs e #
(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Auto PBM) (Image r cs e) #
Methods decode :: Auto PBM -> ReadOptions (Auto PBM) -> ByteString -> Image r cs e #
(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Sequence (Auto GIF)) (Array B Ix1 (Image r cs e)) #
Methods decode :: Sequence (Auto GIF) -> ReadOptions (Sequence (Auto GIF)) -> ByteString -> Array B Ix1 (Image r cs e) #
(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Sequence (Auto PPM)) (Array B Ix1 (Image r cs e)) #
Methods decode :: Sequence (Auto PPM) -> ReadOptions (Sequence (Auto PPM)) -> ByteString -> Array B Ix1 (Image r cs e) #
(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Sequence (Auto PGM)) (Array B Ix1 (Image r cs e)) #
Methods decode :: Sequence (Auto PGM) -> ReadOptions (Sequence (Auto PGM)) -> ByteString -> Array B Ix1 (Image r cs e) #
(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Sequence (Auto PBM)) (Array B Ix1 (Image r cs e)) #
Methods decode :: Sequence (Auto PBM) -> ReadOptions (Sequence (Auto PBM)) -> ByteString -> Array B Ix1 (Image r cs e) #
ColorSpace cs e => Readable (Sequence GIF) (Array B Ix1 (GifDelay, Image S cs e)) #
Methods decode :: Sequence GIF -> ReadOptions (Sequence GIF) -> ByteString -> Array B Ix1 (GifDelay, Image S cs e) #
ColorSpace cs e => Readable (Sequence GIF) (Array B Ix1 (Image S cs e)) #
Methods decode :: Sequence GIF -> ReadOptions (Sequence GIF) -> ByteString -> Array B Ix1 (Image S cs e) #
ColorSpace cs e => Readable (Sequence PPM) (Array B Ix1 (Image S cs e)) #
Methods decode :: Sequence PPM -> ReadOptions (Sequence PPM) -> ByteString -> Array B Ix1 (Image S cs e) #
ColorSpace cs e => Readable (Sequence PGM) (Array B Ix1 (Image S cs e)) #
Methods decode :: Sequence PGM -> ReadOptions (Sequence PGM) -> ByteString -> Array B Ix1 (Image S cs e) #
ColorSpace cs e => Readable (Sequence PBM) (Array B Ix1 (Image S cs e)) #
Methods decode :: Sequence PBM -> ReadOptions (Sequence PBM) -> ByteString -> Array B Ix1 (Image S cs e) #
Readable (Decode (Image r cs e)) (Image r cs e) #
Methods decode :: Decode (Image r cs e) -> ReadOptions (Decode (Image r cs e)) -> ByteString -> Image r cs e #
(ColorSpace cs e, Bounded e) => Bounded (Pixel cs e) #
Methods minBound :: Pixel cs e # maxBound :: Pixel cs e #
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 #
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 X e) #
Methods (==) :: Pixel X e -> Pixel X e -> Bool # (/=) :: Pixel X e -> Pixel X 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 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 #
(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 HSIA e) #
Methods compare :: Pixel HSIA e -> Pixel HSIA e -> Ordering # (<) :: Pixel HSIA e -> Pixel HSIA e -> Bool # (<=) :: Pixel HSIA e -> Pixel HSIA e -> Bool # (>) :: Pixel HSIA e -> Pixel HSIA e -> Bool # (>=) :: Pixel HSIA e -> Pixel HSIA e -> Bool # max :: Pixel HSIA e -> Pixel HSIA e -> Pixel HSIA e # min :: Pixel HSIA e -> Pixel HSIA e -> Pixel HSIA e #
Ord e => Ord (Pixel HSI e) #
Methods compare :: Pixel HSI e -> Pixel HSI e -> Ordering # (<) :: Pixel HSI e -> Pixel HSI e -> Bool # (<=) :: Pixel HSI e -> Pixel HSI e -> Bool # (>) :: Pixel HSI e -> Pixel HSI e -> Bool # (>=) :: Pixel HSI e -> Pixel HSI e -> Bool # max :: Pixel HSI e -> Pixel HSI e -> Pixel HSI e # min :: Pixel HSI e -> Pixel HSI e -> Pixel HSI e #
Ord e => Ord (Pixel CMYKA e) #
Methods compare :: Pixel CMYKA e -> Pixel CMYKA e -> Ordering # (<) :: Pixel CMYKA e -> Pixel CMYKA e -> Bool # (<=) :: Pixel CMYKA e -> Pixel CMYKA e -> Bool # (>) :: Pixel CMYKA e -> Pixel CMYKA e -> Bool # (>=) :: Pixel CMYKA e -> Pixel CMYKA e -> Bool # max :: Pixel CMYKA e -> Pixel CMYKA e -> Pixel CMYKA e # min :: Pixel CMYKA e -> Pixel CMYKA e -> Pixel CMYKA e #
Ord e => Ord (Pixel CMYK e) #
Methods compare :: Pixel CMYK e -> Pixel CMYK e -> Ordering # (<) :: Pixel CMYK e -> Pixel CMYK e -> Bool # (<=) :: Pixel CMYK e -> Pixel CMYK e -> Bool # (>) :: Pixel CMYK e -> Pixel CMYK e -> Bool # (>=) :: Pixel CMYK e -> Pixel CMYK e -> Bool # max :: Pixel CMYK e -> Pixel CMYK e -> Pixel CMYK e # min :: Pixel CMYK e -> Pixel CMYK e -> Pixel CMYK e #
Ord e => Ord (Pixel RGBA e) #
Methods compare :: Pixel RGBA e -> Pixel RGBA e -> Ordering # (<) :: Pixel RGBA e -> Pixel RGBA e -> Bool # (<=) :: Pixel RGBA e -> Pixel RGBA e -> Bool # (>) :: Pixel RGBA e -> Pixel RGBA e -> Bool # (>=) :: Pixel RGBA e -> Pixel RGBA e -> Bool # max :: Pixel RGBA e -> Pixel RGBA e -> Pixel RGBA e # min :: Pixel RGBA e -> Pixel RGBA e -> Pixel RGBA e #
Ord e => Ord (Pixel RGB e) #
Methods compare :: Pixel RGB e -> Pixel RGB e -> Ordering # (<) :: Pixel RGB e -> Pixel RGB e -> Bool # (<=) :: Pixel RGB e -> Pixel RGB e -> Bool # (>) :: Pixel RGB e -> Pixel RGB e -> Bool # (>=) :: Pixel RGB e -> Pixel RGB e -> Bool # max :: Pixel RGB e -> Pixel RGB e -> Pixel RGB e # min :: Pixel RGB e -> Pixel RGB e -> Pixel RGB 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 #
Ord e => Ord (Pixel YA e) #
Methods compare :: Pixel YA e -> Pixel YA e -> Ordering # (<) :: Pixel YA e -> Pixel YA e -> Bool # (<=) :: Pixel YA e -> Pixel YA e -> Bool # (>) :: Pixel YA e -> Pixel YA e -> Bool # (>=) :: Pixel YA e -> Pixel YA e -> Bool # max :: Pixel YA e -> Pixel YA e -> Pixel YA e # min :: Pixel YA e -> Pixel YA e -> Pixel YA 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 YCbCrA e) #
Methods compare :: Pixel YCbCrA e -> Pixel YCbCrA e -> Ordering # (<) :: Pixel YCbCrA e -> Pixel YCbCrA e -> Bool # (<=) :: Pixel YCbCrA e -> Pixel YCbCrA e -> Bool # (>) :: Pixel YCbCrA e -> Pixel YCbCrA e -> Bool # (>=) :: Pixel YCbCrA e -> Pixel YCbCrA e -> Bool # max :: Pixel YCbCrA e -> Pixel YCbCrA e -> Pixel YCbCrA e # min :: Pixel YCbCrA e -> Pixel YCbCrA e -> Pixel YCbCrA e #
Ord e => Ord (Pixel YCbCr e) #
Methods compare :: Pixel YCbCr e -> Pixel YCbCr e -> Ordering # (<) :: Pixel YCbCr e -> Pixel YCbCr e -> Bool # (<=) :: Pixel YCbCr e -> Pixel YCbCr e -> Bool # (>) :: Pixel YCbCr e -> Pixel YCbCr e -> Bool # (>=) :: Pixel YCbCr e -> Pixel YCbCr e -> Bool # max :: Pixel YCbCr e -> Pixel YCbCr e -> Pixel YCbCr e # min :: Pixel YCbCr e -> Pixel YCbCr e -> Pixel YCbCr e #
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 #
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 X e) #
Methods showsPrec :: Int -> Pixel X e -> ShowS # show :: Pixel X e -> String # showList :: [Pixel X 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 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 #
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 () #
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 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 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 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 () #
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 #
ColorSpace cs e => Default (Pixel cs e) #
Methods def :: Pixel cs e #
(ColorSpace cs e, NFData e) => NFData (Pixel cs e) #
Methods rnf :: Pixel cs e -> () #
ColorSpace cs e => Unbox (Pixel cs e) #	Unboxing of a `Pixel`.

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 Pixel RGBA #
data Pixel RGBA = PixelRGBA !e !e !e !e
data Pixel RGB #
data Pixel RGB = PixelRGB !e !e !e
data Pixel X #
data Pixel X = PixelX { getX :: e }
data Pixel YA #
data Pixel YA = PixelYA !e !e
data Pixel Y #
data Pixel Y = PixelY e
data Pixel YCbCrA #
data Pixel YCbCrA = PixelYCbCrA !e !e !e !e
data Pixel YCbCr #
data Pixel YCbCr = PixelYCbCr !e !e !e
data MVector s (Pixel cs e) #
data MVector s (Pixel cs e) = MV_Pixel (MVector s (Components cs e))
type ReadOptions (Decode (Image r cs e)) #
type ReadOptions (Decode (Image r cs e)) = ()
type ReadOptions (Encode (Image r cs e)) #
type ReadOptions (Encode (Image r cs e)) = ()
type WriteOptions (Decode (Image r cs e)) #
type WriteOptions (Decode (Image r cs e)) = ()
type WriteOptions (Encode (Image r cs e)) #
type WriteOptions (Encode (Image r cs e)) = ()
data Vector (Pixel cs e) #
data Vector (Pixel cs e) = V_Pixel (Vector (Components cs e))

class (Eq cs, Enum cs, Show cs, Bounded cs, Typeable cs, Functor (Pixel cs), Applicative (Pixel cs), Foldable (Pixel cs), Eq (Pixel cs e), Unbox (Components cs e), Storable (Pixel cs e), Elevator e) => ColorSpace cs e where #

Minimal complete definition

toComponents, fromComponents, getPxC, setPxC, mapPxC, foldlPx2

Associated Types

type Components cs e #

Methods

toComponents :: Pixel cs e -> Components cs e #

Convert a Pixel to a representation suitable for storage as an unboxed element, usually a tuple of channels.

fromComponents :: Components cs e -> Pixel cs e #

Convert from an elemnt representation back to a Pixel.

promote :: e -> Pixel cs e #

Deprecated: Use pure from Applicative instead

Construt a Pixel by replicating the same value across all of the components.

getPxC :: Pixel cs e -> cs -> e #

Retrieve Pixel's component value

setPxC :: Pixel cs e -> cs -> e -> Pixel cs e #

Set Pixel's component value

mapPxC :: (cs -> e -> e) -> Pixel cs e -> Pixel cs e #

Map a channel aware function over all Pixel's components.

foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel cs e -> Pixel cs e -> b #

Left fold on two pixels a the same time. If accumulator is nutrual to the folding funciton then it's equivalent to foldlPx2 f acc px1 px2 == foldl' acc (liftA2 (f acc) px1 px2)

liftPx :: (e -> e) -> Pixel cs e -> Pixel cs e #

Deprecated: Use fmap from Functor instead

Map a function over all Pixel's componenets.

liftPx2 :: (e -> e -> e) -> Pixel cs e -> Pixel cs e -> Pixel cs e #

Deprecated: Use liftA2 from Applicative instead

Zip two Pixels with a function.

foldrPx :: (e -> b -> b) -> b -> Pixel cs e -> b #

Deprecated: Use foldr' from Foldable instead

Right fold over all Pixel's components.

foldlPx :: (b -> e -> b) -> b -> Pixel cs e -> b #

Deprecated: Use foldl' from Foldable instead

Left strict fold over all Pixel's components.

foldl1Px :: (e -> e -> e) -> Pixel cs e -> e #

Deprecated: Use foldl1 from Foldable instead

Instances

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 # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel HSIA e -> Pixel HSIA e -> b # liftPx :: (e -> e) -> Pixel HSIA e -> Pixel HSIA e # liftPx2 :: (e -> e -> e) -> Pixel HSIA e -> Pixel HSIA e -> Pixel HSIA e # 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 #
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 # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel HSI e -> Pixel HSI e -> b # liftPx :: (e -> e) -> Pixel HSI e -> Pixel HSI e # liftPx2 :: (e -> e -> e) -> Pixel HSI e -> Pixel HSI e -> Pixel HSI e # 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 #
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 # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel CMYKA e -> Pixel CMYKA e -> b # liftPx :: (e -> e) -> Pixel CMYKA e -> Pixel CMYKA e # liftPx2 :: (e -> e -> e) -> Pixel CMYKA e -> Pixel CMYKA e -> Pixel CMYKA e # 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 #
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 # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel CMYK e -> Pixel CMYK e -> b # liftPx :: (e -> e) -> Pixel CMYK e -> Pixel CMYK e # liftPx2 :: (e -> e -> e) -> Pixel CMYK e -> Pixel CMYK e -> Pixel CMYK e # 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 #
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 # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel RGBA e -> Pixel RGBA e -> b # liftPx :: (e -> e) -> Pixel RGBA e -> Pixel RGBA e # liftPx2 :: (e -> e -> e) -> Pixel RGBA e -> Pixel RGBA e -> Pixel RGBA e # 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 #
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 # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel RGB e -> Pixel RGB e -> b # liftPx :: (e -> e) -> Pixel RGB e -> Pixel RGB e # liftPx2 :: (e -> e -> e) -> Pixel RGB e -> Pixel RGB e -> Pixel RGB e # 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 #
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 # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel X e -> Pixel X e -> b # liftPx :: (e -> e) -> Pixel X e -> Pixel X e # liftPx2 :: (e -> e -> e) -> Pixel X e -> Pixel X e -> Pixel X e # 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 #
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 # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel YA e -> Pixel YA e -> b # liftPx :: (e -> e) -> Pixel YA e -> Pixel YA e # liftPx2 :: (e -> e -> e) -> Pixel YA e -> Pixel YA e -> Pixel YA e # 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 #
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 # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel Y e -> Pixel Y e -> b # liftPx :: (e -> e) -> Pixel Y e -> Pixel Y e # liftPx2 :: (e -> e -> e) -> Pixel Y e -> Pixel Y e -> Pixel Y e # 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 #
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 # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel YCbCrA e -> Pixel YCbCrA e -> b # liftPx :: (e -> e) -> Pixel YCbCrA e -> Pixel YCbCrA e # liftPx2 :: (e -> e -> e) -> Pixel YCbCrA e -> Pixel YCbCrA e -> Pixel YCbCrA e # 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 #
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 # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel YCbCr e -> Pixel YCbCr e -> b # liftPx :: (e -> e) -> Pixel YCbCr e -> Pixel YCbCr e # liftPx2 :: (e -> e -> e) -> Pixel YCbCr e -> Pixel YCbCr e -> Pixel YCbCr e # 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 #

class (ColorSpace (Opaque cs) e, ColorSpace cs e) => AlphaSpace cs e where #

A color space that supports transparency.

Minimal complete definition

getAlpha, addAlpha, dropAlpha

Associated Types

type Opaque cs #

A corresponding opaque version of this color space.

Methods

getAlpha :: Pixel cs e -> e #

Get an alpha channel of a transparant pixel.

addAlpha :: e -> Pixel (Opaque cs) e -> Pixel cs e #

Add an alpha channel to an opaque pixel.

 addAlpha 0 (PixelHSI 1 2 3) == PixelHSIA 1 2 3 0

dropAlpha :: Pixel cs e -> Pixel (Opaque cs) e #

Convert a transparent pixel to an opaque one by dropping the alpha channel.

 dropAlpha (PixelRGBA 1 2 3 4) == PixelRGB 1 2 3

Instances

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 => 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 => 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 => 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 => 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 #

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.

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

Convert a pixel to Luma pixel 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.

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

Convert to an RGBA pixel.

HSI

Conversion to HSI from other color spaces.

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

Convert to an HSI pixel.

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

Convert to an HSIA pixel.

CMYK

Conversion to CMYK from other color spaces.

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

Convert to a CMYK pixel.

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

Convert to a CMYKA pixel.

YCbCr

Conversion to YCbCr from other color spaces.

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

Convert to an YCbCr pixel.

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

Convert to an YCbCrA pixel.

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

module Graphics.ColorSpace.Binary

Complex

module Graphics.ColorSpace.Complex

X

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)>

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 #
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 # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel Y e -> Pixel Y e -> b # liftPx :: (e -> e) -> Pixel Y e -> Pixel Y e # liftPx2 :: (e -> e -> e) -> Pixel Y e -> Pixel Y e -> Pixel Y e # 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 #
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 #
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 # liftA2 :: (a -> b -> c) -> Pixel Y a -> Pixel Y b -> Pixel Y c # (>) :: 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 #
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 () #
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 #
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 # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel YA e -> Pixel YA e -> b # liftPx :: (e -> e) -> Pixel YA e -> Pixel YA e # liftPx2 :: (e -> e -> e) -> Pixel YA e -> Pixel YA e -> Pixel YA e # 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 #
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 #
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 # liftA2 :: (a -> b -> c) -> Pixel YA a -> Pixel YA b -> Pixel YA c # (>) :: 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 #
Eq e => Eq (Pixel YA e) #
Methods (==) :: Pixel YA e -> Pixel YA e -> Bool # (/=) :: Pixel YA e -> Pixel YA e -> Bool #
Ord e => Ord (Pixel YA e) #
Methods compare :: Pixel YA e -> Pixel YA e -> Ordering # (<) :: Pixel YA e -> Pixel YA e -> Bool # (<=) :: Pixel YA e -> Pixel YA e -> Bool # (>) :: Pixel YA e -> Pixel YA e -> Bool # (>=) :: Pixel YA e -> Pixel YA e -> Bool # max :: Pixel YA e -> Pixel YA e -> Pixel YA e # min :: Pixel YA e -> Pixel YA e -> Pixel YA e #
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 () #
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 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 #
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 X e #
Methods toPixelY :: Pixel X 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 YCbCrA e #
Methods toPixelY :: Pixel YCbCrA e -> Pixel Y Double #
Elevator e => ToY YCbCr e #
Methods toPixelY :: Pixel YCbCr 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 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 #
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 #
ToYA X Bit #
Methods toPixelYA :: Pixel X Bit -> 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 #
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 #

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 #
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 # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel RGB e -> Pixel RGB e -> b # liftPx :: (e -> e) -> Pixel RGB e -> Pixel RGB e # liftPx2 :: (e -> e -> e) -> Pixel RGB e -> Pixel RGB e -> Pixel RGB e # 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 #
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 #
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 # liftA2 :: (a -> b -> c) -> Pixel RGB a -> Pixel RGB b -> Pixel RGB c # (>) :: 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 #
Eq e => Eq (Pixel RGB e) #
Methods (==) :: Pixel RGB e -> Pixel RGB e -> Bool # (/=) :: Pixel RGB e -> Pixel RGB e -> Bool #
Ord e => Ord (Pixel RGB e) #
Methods compare :: Pixel RGB e -> Pixel RGB e -> Ordering # (<) :: Pixel RGB e -> Pixel RGB e -> Bool # (<=) :: Pixel RGB e -> Pixel RGB e -> Bool # (>) :: Pixel RGB e -> Pixel RGB e -> Bool # (>=) :: Pixel RGB e -> Pixel RGB e -> Bool # max :: Pixel RGB e -> Pixel RGB e -> Pixel RGB e # min :: Pixel RGB e -> Pixel RGB e -> Pixel RGB e #
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 () #
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 #
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 # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel RGBA e -> Pixel RGBA e -> b # liftPx :: (e -> e) -> Pixel RGBA e -> Pixel RGBA e # liftPx2 :: (e -> e -> e) -> Pixel RGBA e -> Pixel RGBA e -> Pixel RGBA e # 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 #
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 #
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 # liftA2 :: (a -> b -> c) -> Pixel RGBA a -> Pixel RGBA b -> Pixel RGBA c # (>) :: 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 #
Eq e => Eq (Pixel RGBA e) #
Methods (==) :: Pixel RGBA e -> Pixel RGBA e -> Bool # (/=) :: Pixel RGBA e -> Pixel RGBA e -> Bool #
Ord e => Ord (Pixel RGBA e) #
Methods compare :: Pixel RGBA e -> Pixel RGBA e -> Ordering # (<) :: Pixel RGBA e -> Pixel RGBA e -> Bool # (<=) :: Pixel RGBA e -> Pixel RGBA e -> Bool # (>) :: Pixel RGBA e -> Pixel RGBA e -> Bool # (>=) :: Pixel RGBA e -> Pixel RGBA e -> Bool # max :: Pixel RGBA e -> Pixel RGBA e -> Pixel RGBA e # min :: Pixel RGBA e -> Pixel RGBA e -> Pixel RGBA e #
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 () #
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 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 #
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 #
ToRGB X Bit #
Methods toPixelRGB :: Pixel X Bit -> 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 #
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 #

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 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 #
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 #
ToRGBA X Bit #
Methods toPixelRGBA :: Pixel X Bit -> 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 #
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 #

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 #
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 # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel HSI e -> Pixel HSI e -> b # liftPx :: (e -> e) -> Pixel HSI e -> Pixel HSI e # liftPx2 :: (e -> e -> e) -> Pixel HSI e -> Pixel HSI e -> Pixel HSI e # 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 #
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 # liftA2 :: (a -> b -> c) -> Pixel HSI a -> Pixel HSI b -> Pixel HSI c # (>) :: 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 #
Ord e => Ord (Pixel HSI e) #
Methods compare :: Pixel HSI e -> Pixel HSI e -> Ordering # (<) :: Pixel HSI e -> Pixel HSI e -> Bool # (<=) :: Pixel HSI e -> Pixel HSI e -> Bool # (>) :: Pixel HSI e -> Pixel HSI e -> Bool # (>=) :: Pixel HSI e -> Pixel HSI e -> Bool # max :: Pixel HSI e -> Pixel HSI e -> Pixel HSI e # min :: Pixel HSI e -> Pixel HSI e -> Pixel HSI e #
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 #
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 # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel HSIA e -> Pixel HSIA e -> b # liftPx :: (e -> e) -> Pixel HSIA e -> Pixel HSIA e # liftPx2 :: (e -> e -> e) -> Pixel HSIA e -> Pixel HSIA e -> Pixel HSIA e # 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 #
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 # liftA2 :: (a -> b -> c) -> Pixel HSIA a -> Pixel HSIA b -> Pixel HSIA c # (>) :: 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 #
Ord e => Ord (Pixel HSIA e) #
Methods compare :: Pixel HSIA e -> Pixel HSIA e -> Ordering # (<) :: Pixel HSIA e -> Pixel HSIA e -> Bool # (<=) :: Pixel HSIA e -> Pixel HSIA e -> Bool # (>) :: Pixel HSIA e -> Pixel HSIA e -> Bool # (>=) :: Pixel HSIA e -> Pixel HSIA e -> Bool # max :: Pixel HSIA e -> Pixel HSIA e -> Pixel HSIA e # min :: Pixel HSIA e -> Pixel HSIA e -> Pixel HSIA e #
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 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 #
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 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 YCbCrA e #
Methods toPixelHSI :: Pixel YCbCrA e -> Pixel HSI Double #
Elevator e => ToHSI YCbCr e #
Methods toPixelHSI :: Pixel YCbCr 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 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 #
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 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 YCbCrA e #
Methods toPixelHSIA :: Pixel YCbCrA e -> Pixel HSIA Double #
ToHSI YCbCr e => ToHSIA YCbCr e #
Methods toPixelHSIA :: Pixel YCbCr 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 #
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 # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel CMYK e -> Pixel CMYK e -> b # liftPx :: (e -> e) -> Pixel CMYK e -> Pixel CMYK e # liftPx2 :: (e -> e -> e) -> Pixel CMYK e -> Pixel CMYK e -> Pixel CMYK e # 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 #
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 # liftA2 :: (a -> b -> c) -> Pixel CMYK a -> Pixel CMYK b -> Pixel CMYK c # (>) :: 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 #
Ord e => Ord (Pixel CMYK e) #
Methods compare :: Pixel CMYK e -> Pixel CMYK e -> Ordering # (<) :: Pixel CMYK e -> Pixel CMYK e -> Bool # (<=) :: Pixel CMYK e -> Pixel CMYK e -> Bool # (>) :: Pixel CMYK e -> Pixel CMYK e -> Bool # (>=) :: Pixel CMYK e -> Pixel CMYK e -> Bool # max :: Pixel CMYK e -> Pixel CMYK e -> Pixel CMYK e # min :: Pixel CMYK e -> Pixel CMYK e -> Pixel CMYK e #
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 () #
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 #
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 # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel CMYKA e -> Pixel CMYKA e -> b # liftPx :: (e -> e) -> Pixel CMYKA e -> Pixel CMYKA e # liftPx2 :: (e -> e -> e) -> Pixel CMYKA e -> Pixel CMYKA e -> Pixel CMYKA e # 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 #
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 # liftA2 :: (a -> b -> c) -> Pixel CMYKA a -> Pixel CMYKA b -> Pixel CMYKA c # (>) :: 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 #
Ord e => Ord (Pixel CMYKA e) #
Methods compare :: Pixel CMYKA e -> Pixel CMYKA e -> Ordering # (<) :: Pixel CMYKA e -> Pixel CMYKA e -> Bool # (<=) :: Pixel CMYKA e -> Pixel CMYKA e -> Bool # (>) :: Pixel CMYKA e -> Pixel CMYKA e -> Bool # (>=) :: Pixel CMYKA e -> Pixel CMYKA e -> Bool # max :: Pixel CMYKA e -> Pixel CMYKA e -> Pixel CMYKA e # min :: Pixel CMYKA e -> Pixel CMYKA e -> Pixel CMYKA e #
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 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 #
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 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 YCbCrA e #
Methods toPixelCMYK :: Pixel YCbCrA e -> Pixel CMYK Double #
Elevator e => ToCMYK YCbCr e #
Methods toPixelCMYK :: Pixel YCbCr 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 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 #
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 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 YCbCrA e #
Methods toPixelCMYKA :: Pixel YCbCrA e -> Pixel CMYKA Double #
ToCMYK YCbCr e => ToCMYKA YCbCr e #
Methods toPixelCMYKA :: Pixel YCbCr 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 #
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 # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel YCbCr e -> Pixel YCbCr e -> b # liftPx :: (e -> e) -> Pixel YCbCr e -> Pixel YCbCr e # liftPx2 :: (e -> e -> e) -> Pixel YCbCr e -> Pixel YCbCr e -> Pixel YCbCr e # 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 #
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 # liftA2 :: (a -> b -> c) -> Pixel YCbCr a -> Pixel YCbCr b -> Pixel YCbCr c # (>) :: 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 #
Ord e => Ord (Pixel YCbCr e) #
Methods compare :: Pixel YCbCr e -> Pixel YCbCr e -> Ordering # (<) :: Pixel YCbCr e -> Pixel YCbCr e -> Bool # (<=) :: Pixel YCbCr e -> Pixel YCbCr e -> Bool # (>) :: Pixel YCbCr e -> Pixel YCbCr e -> Bool # (>=) :: Pixel YCbCr e -> Pixel YCbCr e -> Bool # max :: Pixel YCbCr e -> Pixel YCbCr e -> Pixel YCbCr e # min :: Pixel YCbCr e -> Pixel YCbCr e -> Pixel YCbCr e #
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 () #
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 #
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 # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel YCbCrA e -> Pixel YCbCrA e -> b # liftPx :: (e -> e) -> Pixel YCbCrA e -> Pixel YCbCrA e # liftPx2 :: (e -> e -> e) -> Pixel YCbCrA e -> Pixel YCbCrA e -> Pixel YCbCrA e # 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 #
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 # liftA2 :: (a -> b -> c) -> Pixel YCbCrA a -> Pixel YCbCrA b -> Pixel YCbCrA c # (>) :: 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 #
Ord e => Ord (Pixel YCbCrA e) #
Methods compare :: Pixel YCbCrA e -> Pixel YCbCrA e -> Ordering # (<) :: Pixel YCbCrA e -> Pixel YCbCrA e -> Bool # (<=) :: Pixel YCbCrA e -> Pixel YCbCrA e -> Bool # (>) :: Pixel YCbCrA e -> Pixel YCbCrA e -> Bool # (>=) :: Pixel YCbCrA e -> Pixel YCbCrA e -> Bool # max :: Pixel YCbCrA e -> Pixel YCbCrA e -> Pixel YCbCrA e # min :: Pixel YCbCrA e -> Pixel YCbCrA e -> Pixel YCbCrA e #
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 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 #
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 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 YCbCrA e #
Methods toPixelYCbCr :: Pixel YCbCrA e -> Pixel YCbCr Double #
Elevator e => ToYCbCr YCbCr e #
Methods toPixelYCbCr :: Pixel YCbCr 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 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 #
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 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 YCbCrA e #
Methods toPixelYCbCrA :: Pixel YCbCrA e -> Pixel YCbCrA Double #
ToYCbCr YCbCr e => ToYCbCrA YCbCr e #
Methods toPixelYCbCrA :: Pixel YCbCr 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 #
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 # foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel X e -> Pixel X e -> b # liftPx :: (e -> e) -> Pixel X e -> Pixel X e # liftPx2 :: (e -> e -> e) -> Pixel X e -> Pixel X e -> Pixel X e # 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 #
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 # liftA2 :: (a -> b -> c) -> Pixel X a -> Pixel X b -> Pixel X c # (>) :: 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 #
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 #
data Pixel X #
data Pixel X = PixelX { getX :: e }
type Components X e #
type Components X e = e

Precision

Pixel

class (Eq e, Num e, Typeable e, Unbox e, Storable e) => Elevator e where #

A class with a set of convenient functions that allow for changing precision of channels within pixels, while scaling the values to keep them in an appropriate range.

>>> let rgb = PixelRGB 0.0 0.5 1.0 :: Pixel RGB Double
>>> eToWord8 <$> rgb
<RGB:(0|128|255)>
>>> eToWord16 <$> rgb
<RGB:(0|32768|65535)>

Minimal complete definition

eToWord8, eToWord16, eToWord32, eToWord64, eToFloat, eToDouble, eFromDouble

Methods

eToWord8 :: e -> Word8 #

Values are scaled to [0, 255] range.

eToWord16 :: e -> Word16 #

Values are scaled to [0, 65535] range.

eToWord32 :: e -> Word32 #

Values are scaled to [0, 4294967295] range.

eToWord64 :: e -> Word64 #

Values are scaled to [0, 18446744073709551615] range.

eToFloat :: e -> Float #

Values are scaled to [0.0, 1.0] range.

eToDouble :: e -> Double #

Values are scaled to [0.0, 1.0] range.

eFromDouble :: Double -> e #

Values are scaled from [0.0, 1.0] range.

Instances

Elevator Double #	Values between `[0.0, 1.0]`
Methods eToWord8 :: Double -> Word8 # eToWord16 :: Double -> Word16 # eToWord32 :: Double -> Word32 # eToWord64 :: Double -> Word64 # eToFloat :: Double -> Float # eToDouble :: Double -> Double # eFromDouble :: Double -> Double #
Elevator Float #	Values between `[0.0, 1.0]`
Methods eToWord8 :: Float -> Word8 # eToWord16 :: Float -> Word16 # eToWord32 :: Float -> Word32 # eToWord64 :: Float -> Word64 # eToFloat :: Float -> Float # eToDouble :: Float -> Double # eFromDouble :: Double -> Float #
Elevator Int #	Values between `[0, 9223372036854775807]` on 64bit
Methods eToWord8 :: Int -> Word8 # eToWord16 :: Int -> Word16 # eToWord32 :: Int -> Word32 # eToWord64 :: Int -> Word64 # eToFloat :: Int -> Float # eToDouble :: Int -> Double # eFromDouble :: Double -> Int #
Elevator Int8 #	Values between `[0, 127]`
Methods eToWord8 :: Int8 -> Word8 # eToWord16 :: Int8 -> Word16 # eToWord32 :: Int8 -> Word32 # eToWord64 :: Int8 -> Word64 # eToFloat :: Int8 -> Float # eToDouble :: Int8 -> Double # eFromDouble :: Double -> Int8 #
Elevator Int16 #	Values between `[0, 32767]`
Methods eToWord8 :: Int16 -> Word8 # eToWord16 :: Int16 -> Word16 # eToWord32 :: Int16 -> Word32 # eToWord64 :: Int16 -> Word64 # eToFloat :: Int16 -> Float # eToDouble :: Int16 -> Double # eFromDouble :: Double -> Int16 #
Elevator Int32 #	Values between `[0, 2147483647]`
Methods eToWord8 :: Int32 -> Word8 # eToWord16 :: Int32 -> Word16 # eToWord32 :: Int32 -> Word32 # eToWord64 :: Int32 -> Word64 # eToFloat :: Int32 -> Float # eToDouble :: Int32 -> Double # eFromDouble :: Double -> Int32 #
Elevator Int64 #	Values between `[0, 9223372036854775807]`
Methods eToWord8 :: Int64 -> Word8 # eToWord16 :: Int64 -> Word16 # eToWord32 :: Int64 -> Word32 # eToWord64 :: Int64 -> Word64 # eToFloat :: Int64 -> Float # eToDouble :: Int64 -> Double # eFromDouble :: Double -> Int64 #
Elevator Word #	Values between `[0, 18446744073709551615]` on 64bit
Methods eToWord8 :: Word -> Word8 # eToWord16 :: Word -> Word16 # eToWord32 :: Word -> Word32 # eToWord64 :: Word -> Word64 # eToFloat :: Word -> Float # eToDouble :: Word -> Double # eFromDouble :: Double -> Word #
Elevator Word8 #	Values between `[0, 255]]`
Methods eToWord8 :: Word8 -> Word8 # eToWord16 :: Word8 -> Word16 # eToWord32 :: Word8 -> Word32 # eToWord64 :: Word8 -> Word64 # eToFloat :: Word8 -> Float # eToDouble :: Word8 -> Double # eFromDouble :: Double -> Word8 #
Elevator Word16 #	Values between `[0, 65535]]`
Methods eToWord8 :: Word16 -> Word8 # eToWord16 :: Word16 -> Word16 # eToWord32 :: Word16 -> Word32 # eToWord64 :: Word16 -> Word64 # eToFloat :: Word16 -> Float # eToDouble :: Word16 -> Double # eFromDouble :: Double -> Word16 #
Elevator Word32 #	Values between `[0, 4294967295]`
Methods eToWord8 :: Word32 -> Word8 # eToWord16 :: Word32 -> Word16 # eToWord32 :: Word32 -> Word32 # eToWord64 :: Word32 -> Word64 # eToFloat :: Word32 -> Float # eToDouble :: Word32 -> Double # eFromDouble :: Double -> Word32 #
Elevator Word64 #	Values between `[0, 18446744073709551615]`
Methods eToWord8 :: Word64 -> Word8 # eToWord16 :: Word64 -> Word16 # eToWord32 :: Word64 -> Word32 # eToWord64 :: Word64 -> Word64 # eToFloat :: Word64 -> Float # eToDouble :: Word64 -> Double # eFromDouble :: Double -> Word64 #
Elevator Bit #	Values: `0` and `1`
Methods eToWord8 :: Bit -> Word8 # eToWord16 :: Bit -> Word16 # eToWord32 :: Bit -> Word32 # eToWord64 :: Bit -> Word64 # eToFloat :: Bit -> Float # eToDouble :: Bit -> Double # eFromDouble :: Double -> Bit #
(Num e, Elevator e, RealFloat e) => Elevator (Complex e) #	Discards imaginary part and changes precision of real part.
Methods eToWord8 :: Complex e -> Word8 # eToWord16 :: Complex e -> Word16 # eToWord32 :: Complex e -> Word32 # eToWord64 :: Complex e -> Word64 # eToFloat :: Complex e -> Float # eToDouble :: Complex e -> Double # eFromDouble :: Double -> Complex e #

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

Change pixel precision to Word8.

toWord16 :: (Functor (Pixel cs), Elevator e) => Pixel cs e -> Pixel cs Word16 #

Change pixel precision to Word16.

toWord32 :: (Functor (Pixel cs), Elevator e) => Pixel cs e -> Pixel cs Word32 #

Change pixel precision to Word32.

toWord64 :: (Functor (Pixel cs), Elevator e) => Pixel cs e -> Pixel cs Word64 #

Change pixel precision to Word64.

toFloat :: (Functor (Pixel cs), Elevator e) => Pixel cs e -> Pixel cs Float #

Change pixel precision to Float.

toDouble :: (Functor (Pixel cs), Elevator e) => Pixel cs e -> Pixel cs Double #

Change pixel precision to Double.

fromDouble :: (Functor (Pixel cs), Elevator e) => Pixel cs Double -> Pixel cs e #

Change pixel precision from Double.

Componenet

data Word8 :: * #

8-bit unsigned integer type

Instances

Bounded Word8	Since: 2.1
Methods minBound :: Word8 # maxBound :: Word8 #
Enum Word8	Since: 2.1
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	Since: 2.1
Methods (==) :: Word8 -> Word8 -> Bool # (/=) :: Word8 -> Word8 -> Bool #
Integral Word8	Since: 2.1
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	Since: 2.1
Methods (+) :: Word8 -> Word8 -> Word8 # (-) :: Word8 -> Word8 -> Word8 # (*) :: Word8 -> Word8 -> Word8 # negate :: Word8 -> Word8 # abs :: Word8 -> Word8 # signum :: Word8 -> Word8 # fromInteger :: Integer -> Word8 #
Ord Word8	Since: 2.1
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	Since: 2.1
Methods readsPrec :: Int -> ReadS Word8 # readList :: ReadS [Word8] # readPrec :: ReadPrec Word8 # readListPrec :: ReadPrec [Word8] #
Real Word8	Since: 2.1
Methods toRational :: Word8 -> Rational #
Show Word8	Since: 2.1
Methods showsPrec :: Int -> Word8 -> ShowS # show :: Word8 -> String # showList :: [Word8] -> ShowS #
Ix Word8	Since: 2.1
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 #
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
PngSavable Pixel8
Methods encodePng :: Image Pixel8 -> ByteString # encodePngWithMetadata :: Metadatas -> Image Pixel8 -> ByteString #
TgaSaveable Pixel8
Methods tgaDataOfImage :: Image Pixel8 -> ByteString tgaPixelDepthOfImage :: Image Pixel8 -> Word8 tgaTypeOfImage :: Image Pixel8 -> TgaImageType
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	Since: 2.1
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	Since: 2.1
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	Since: 4.6.0.0
Methods finiteBitSize :: Word8 -> Int # countLeadingZeros :: Word8 -> Int # countTrailingZeros :: Word8 -> Int #
Default Word8
Methods def :: Word8 #
NFData Word8
Methods rnf :: Word8 -> () #
Unbox Word8

Prim Word8
Methods sizeOf# :: Word8 -> Int# # alignment# :: Word8 -> Int# # indexByteArray# :: ByteArray# -> Int# -> Word8 # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, 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 -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word8#) # writeOffAddr# :: Addr# -> Int# -> Word8 -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Word8 -> State# s -> State# s #
Elevator Word8 #	Values between `[0, 255]]`
Methods eToWord8 :: Word8 -> Word8 # eToWord16 :: Word8 -> Word16 # eToWord32 :: Word8 -> Word32 # eToWord64 :: Word8 -> Word64 # eToFloat :: Word8 -> Float # eToDouble :: Word8 -> Double # eFromDouble :: 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 #
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 #
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) #
type StorageType Word8
type StorageType Word8 = Word8
type PixelBaseComponent Pixel8
type PixelBaseComponent Pixel8 = Word8
type PackedRepresentation Pixel8
type PackedRepresentation Pixel8 = Pixel8
data Vector Word8
data Vector Word8 = V_Word8 (Vector Word8)
data MVector s Word8
data MVector s Word8 = MV_Word8 (MVector s Word8)

data Word16 :: * #

16-bit unsigned integer type

Instances

Bounded Word16	Since: 2.1
Methods minBound :: Word16 # maxBound :: Word16 #
Enum Word16	Since: 2.1
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	Since: 2.1
Methods (==) :: Word16 -> Word16 -> Bool # (/=) :: Word16 -> Word16 -> Bool #
Integral Word16	Since: 2.1
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	Since: 2.1
Methods (+) :: Word16 -> Word16 -> Word16 # (-) :: Word16 -> Word16 -> Word16 # (*) :: Word16 -> Word16 -> Word16 # negate :: Word16 -> Word16 # abs :: Word16 -> Word16 # signum :: Word16 -> Word16 # fromInteger :: Integer -> Word16 #
Ord Word16	Since: 2.1
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	Since: 2.1
Methods readsPrec :: Int -> ReadS Word16 # readList :: ReadS [Word16] # readPrec :: ReadPrec Word16 # readListPrec :: ReadPrec [Word16] #
Real Word16	Since: 2.1
Methods toRational :: Word16 -> Rational #
Show Word16	Since: 2.1
Methods showsPrec :: Int -> Word16 -> ShowS # show :: Word16 -> String # showList :: [Word16] -> ShowS #
Ix Word16	Since: 2.1
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 #
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	Since: 2.1
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	Since: 2.1
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	Since: 4.6.0.0
Methods finiteBitSize :: Word16 -> Int # countLeadingZeros :: Word16 -> Int # countTrailingZeros :: Word16 -> Int #
Default Word16
Methods def :: Word16 #
NFData Word16
Methods rnf :: Word16 -> () #
Unbox Word16

Prim Word16
Methods sizeOf# :: Word16 -> Int# # alignment# :: Word16 -> Int# # indexByteArray# :: ByteArray# -> Int# -> Word16 # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, 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 -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word16#) # writeOffAddr# :: Addr# -> Int# -> Word16 -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Word16 -> State# s -> State# s #
Elevator Word16 #	Values between `[0, 65535]]`
Methods eToWord8 :: Word16 -> Word8 # eToWord16 :: Word16 -> Word16 # eToWord32 :: Word16 -> Word32 # eToWord64 :: Word16 -> Word64 # eToFloat :: Word16 -> Float # eToDouble :: Word16 -> Double # eFromDouble :: 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 #
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) #
type StorageType Word16
type StorageType Word16 = Word16
type PixelBaseComponent Pixel16
type PixelBaseComponent Pixel16 = Word16
type PackedRepresentation Pixel16
type PackedRepresentation Pixel16 = Pixel16
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	Since: 2.1
Methods minBound :: Word32 # maxBound :: Word32 #
Enum Word32	Since: 2.1
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	Since: 2.1
Methods (==) :: Word32 -> Word32 -> Bool # (/=) :: Word32 -> Word32 -> Bool #
Integral Word32	Since: 2.1
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	Since: 2.1
Methods (+) :: Word32 -> Word32 -> Word32 # (-) :: Word32 -> Word32 -> Word32 # (*) :: Word32 -> Word32 -> Word32 # negate :: Word32 -> Word32 # abs :: Word32 -> Word32 # signum :: Word32 -> Word32 # fromInteger :: Integer -> Word32 #
Ord Word32	Since: 2.1
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	Since: 2.1
Methods readsPrec :: Int -> ReadS Word32 # readList :: ReadS [Word32] # readPrec :: ReadPrec Word32 # readListPrec :: ReadPrec [Word32] #
Real Word32	Since: 2.1
Methods toRational :: Word32 -> Rational #
Show Word32	Since: 2.1
Methods showsPrec :: Int -> Word32 -> ShowS # show :: Word32 -> String # showList :: [Word32] -> ShowS #
Ix Word32	Since: 2.1
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 #
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	Since: 2.1
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	Since: 2.1
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	Since: 4.6.0.0
Methods finiteBitSize :: Word32 -> Int # countLeadingZeros :: Word32 -> Int # countTrailingZeros :: Word32 -> Int #
Default Word32
Methods def :: Word32 #
NFData Word32
Methods rnf :: Word32 -> () #
Unbox Word32

Prim Word32
Methods sizeOf# :: Word32 -> Int# # alignment# :: Word32 -> Int# # indexByteArray# :: ByteArray# -> Int# -> Word32 # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, 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 -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word32#) # writeOffAddr# :: Addr# -> Int# -> Word32 -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Word32 -> State# s -> State# s #
Elevator Word32 #	Values between `[0, 4294967295]`
Methods eToWord8 :: Word32 -> Word8 # eToWord16 :: Word32 -> Word16 # eToWord32 :: Word32 -> Word32 # eToWord64 :: Word32 -> Word64 # eToFloat :: Word32 -> Float # eToDouble :: Word32 -> Double # eFromDouble :: Double -> 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) #
type StorageType Word32
type StorageType Word32 = Word32
type PixelBaseComponent Pixel32
type PixelBaseComponent Pixel32 = Word32
type PackedRepresentation Pixel32
type PackedRepresentation Pixel32 = Pixel32
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	Since: 2.1
Methods minBound :: Word64 # maxBound :: Word64 #
Enum Word64	Since: 2.1
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	Since: 2.1
Methods (==) :: Word64 -> Word64 -> Bool # (/=) :: Word64 -> Word64 -> Bool #
Integral Word64	Since: 2.1
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	Since: 2.1
Methods (+) :: Word64 -> Word64 -> Word64 # (-) :: Word64 -> Word64 -> Word64 # (*) :: Word64 -> Word64 -> Word64 # negate :: Word64 -> Word64 # abs :: Word64 -> Word64 # signum :: Word64 -> Word64 # fromInteger :: Integer -> Word64 #
Ord Word64	Since: 2.1
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	Since: 2.1
Methods readsPrec :: Int -> ReadS Word64 # readList :: ReadS [Word64] # readPrec :: ReadPrec Word64 # readListPrec :: ReadPrec [Word64] #
Real Word64	Since: 2.1
Methods toRational :: Word64 -> Rational #
Show Word64	Since: 2.1
Methods showsPrec :: Int -> Word64 -> ShowS # show :: Word64 -> String # showList :: [Word64] -> ShowS #
Ix Word64	Since: 2.1
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 #
Storable Word64	Since: 2.1
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	Since: 2.1
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	Since: 4.6.0.0
Methods finiteBitSize :: Word64 -> Int # countLeadingZeros :: Word64 -> Int # countTrailingZeros :: Word64 -> Int #
Default Word64
Methods def :: Word64 #
NFData Word64
Methods rnf :: Word64 -> () #
Unbox Word64

Prim Word64
Methods sizeOf# :: Word64 -> Int# # alignment# :: Word64 -> Int# # indexByteArray# :: ByteArray# -> Int# -> Word64 # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, 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 -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word64#) # writeOffAddr# :: Addr# -> Int# -> Word64 -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Word64 -> State# s -> State# s #
Elevator Word64 #	Values between `[0, 18446744073709551615]`
Methods eToWord8 :: Word64 -> Word8 # eToWord16 :: Word64 -> Word16 # eToWord32 :: Word64 -> Word32 # eToWord64 :: Word64 -> Word64 # eToFloat :: Word64 -> Float # eToDouble :: Word64 -> Double # eFromDouble :: Double -> 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) #
data Vector Word64
data Vector Word64 = V_Word64 (Vector Word64)
data MVector s Word64
data MVector s Word64 = MV_Word64 (MVector s Word64)