Graphics.Image.Interface

Pixel and ColorSpace

data family Pixel cs e :: *

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

Instances

Array arr X Bit => Thresholding Pixel (Image arr) arr

Defined in Graphics.Image.Processing.Binary

Methods

(!==!) :: (Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Pixel cs e -> Image arr cs e -> Image arr cs Bit

(!/=!) :: (Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Pixel cs e -> Image arr cs e -> Image arr cs Bit

(!<!) :: (Ord e, Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Pixel cs e -> Image arr cs e -> Image arr cs Bit

(!<=!) :: (Ord e, Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Pixel cs e -> Image arr cs e -> Image arr cs Bit

(!>!) :: (Ord e, Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Pixel cs e -> Image arr cs e -> Image arr cs Bit

(!>=!) :: (Ord e, Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Pixel cs e -> Image arr cs e -> Image arr cs Bit

(.==.) :: (Array arr cs e, Array arr X Bit) => Pixel cs e -> Image arr cs e -> Image arr X Bit

(./=.) :: (Array arr cs e, Array arr X Bit) => Pixel cs e -> Image arr cs e -> Image arr X Bit

(.<.) :: (Ord (Pixel cs e), Array arr cs e, Array arr X Bit) => Pixel cs e -> Image arr cs e -> Image arr X Bit

(.<=.) :: (Ord (Pixel cs e), Array arr cs e, Array arr X Bit) => Pixel cs e -> Image arr cs e -> Image arr X Bit

(.>.) :: (Ord (Pixel cs e), Array arr cs e, Array arr X Bit) => Pixel cs e -> Image arr cs e -> Image arr X Bit

(.>=.) :: (Ord (Pixel cs e), Array arr cs e, Array arr X Bit) => Pixel cs e -> Image arr cs e -> Image arr X Bit

ColorSpace cs e => Vector Vector (Pixel cs e)

Defined in Graphics.Image.Interface.Vector.Unboxing

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)

Defined in Graphics.Image.Interface.Vector.Unboxing

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

Monad (Pixel Y)

Defined in Graphics.Image.ColorSpace.Y

Methods

(>>=) :: Pixel Y a -> (a -> Pixel Y b) -> Pixel Y b

(>>) :: Pixel Y a -> Pixel Y b -> Pixel Y b

return :: a -> Pixel Y a

fail :: String -> Pixel Y a

Monad (Pixel X)

Defined in Graphics.Image.ColorSpace.X

Methods

(>>=) :: Pixel X a -> (a -> Pixel X b) -> Pixel X b

(>>) :: Pixel X a -> Pixel X b -> Pixel X b

return :: a -> Pixel X a

fail :: String -> Pixel X a

Functor (Pixel YCbCrA)

Defined in Graphics.Image.ColorSpace.YCbCr

Methods

fmap :: (a -> b) -> Pixel YCbCrA a -> Pixel YCbCrA b

(<$) :: a -> Pixel YCbCrA b -> Pixel YCbCrA a

Functor (Pixel YCbCr)

Defined in Graphics.Image.ColorSpace.YCbCr

Methods

fmap :: (a -> b) -> Pixel YCbCr a -> Pixel YCbCr b

(<$) :: a -> Pixel YCbCr b -> Pixel YCbCr a

Functor (Pixel YA)

Defined in Graphics.Image.ColorSpace.Y

Methods

fmap :: (a -> b) -> Pixel YA a -> Pixel YA b

(<$) :: a -> Pixel YA b -> Pixel YA a

Functor (Pixel Y)

Defined in Graphics.Image.ColorSpace.Y

Methods

fmap :: (a -> b) -> Pixel Y a -> Pixel Y b

(<$) :: a -> Pixel Y b -> Pixel Y a

Functor (Pixel RGBA)

Defined in Graphics.Image.ColorSpace.RGB

Methods

fmap :: (a -> b) -> Pixel RGBA a -> Pixel RGBA b

(<$) :: a -> Pixel RGBA b -> Pixel RGBA a

Functor (Pixel RGB)

Defined in Graphics.Image.ColorSpace.RGB

Methods

fmap :: (a -> b) -> Pixel RGB a -> Pixel RGB b

(<$) :: a -> Pixel RGB b -> Pixel RGB a

Functor (Pixel HSIA)

Defined in Graphics.Image.ColorSpace.HSI

Methods

fmap :: (a -> b) -> Pixel HSIA a -> Pixel HSIA b

(<$) :: a -> Pixel HSIA b -> Pixel HSIA a

Functor (Pixel HSI)

Defined in Graphics.Image.ColorSpace.HSI

Methods

fmap :: (a -> b) -> Pixel HSI a -> Pixel HSI b

(<$) :: a -> Pixel HSI b -> Pixel HSI a

Functor (Pixel CMYKA)

Defined in Graphics.Image.ColorSpace.CMYK

Methods

fmap :: (a -> b) -> Pixel CMYKA a -> Pixel CMYKA b

(<$) :: a -> Pixel CMYKA b -> Pixel CMYKA a

Functor (Pixel CMYK)

Defined in Graphics.Image.ColorSpace.CMYK

Methods

fmap :: (a -> b) -> Pixel CMYK a -> Pixel CMYK b

(<$) :: a -> Pixel CMYK b -> Pixel CMYK a

Functor (Pixel X)

Defined in Graphics.Image.ColorSpace.X

Methods

fmap :: (a -> b) -> Pixel X a -> Pixel X b

(<$) :: a -> Pixel X b -> Pixel X a

Applicative (Pixel YCbCrA)

Defined in Graphics.Image.ColorSpace.YCbCr

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)

Defined in Graphics.Image.ColorSpace.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

Applicative (Pixel YA)

Defined in Graphics.Image.ColorSpace.Y

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)

Defined in Graphics.Image.ColorSpace.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 RGBA)

Defined in Graphics.Image.ColorSpace.RGB

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)

Defined in Graphics.Image.ColorSpace.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 HSIA)

Defined in Graphics.Image.ColorSpace.HSI

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)

Defined in Graphics.Image.ColorSpace.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)

Defined in Graphics.Image.ColorSpace.CMYK

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)

Defined in Graphics.Image.ColorSpace.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 X)

Defined in Graphics.Image.ColorSpace.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 YCbCrA)

Defined in Graphics.Image.ColorSpace.YCbCr

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)

Defined in Graphics.Image.ColorSpace.YCbCr

Methods

fold :: Monoid m => Pixel YCbCr m -> m

foldMap :: Monoid m => (a -> m) -> Pixel YCbCr a -> m

foldr :: (a -> b -> b) -> b -> Pixel YCbCr a -> b

foldr' :: (a -> b -> b) -> b -> Pixel YCbCr a -> b

foldl :: (b -> a -> b) -> b -> Pixel YCbCr a -> b

foldl' :: (b -> a -> b) -> b -> Pixel YCbCr a -> b

foldr1 :: (a -> a -> a) -> Pixel YCbCr a -> a

foldl1 :: (a -> a -> a) -> Pixel YCbCr a -> a

toList :: Pixel YCbCr a -> [a]

null :: Pixel YCbCr a -> Bool

length :: Pixel YCbCr a -> Int

elem :: Eq a => a -> Pixel YCbCr a -> Bool

maximum :: Ord a => Pixel YCbCr a -> a

minimum :: Ord a => Pixel YCbCr a -> a

sum :: Num a => Pixel YCbCr a -> a

product :: Num a => Pixel YCbCr a -> a

Foldable (Pixel YA)

Defined in Graphics.Image.ColorSpace.Y

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)

Defined in Graphics.Image.ColorSpace.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 RGBA)

Defined in Graphics.Image.ColorSpace.RGB

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)

Defined in Graphics.Image.ColorSpace.RGB

Methods

fold :: Monoid m => Pixel RGB m -> m

foldMap :: Monoid m => (a -> m) -> Pixel RGB a -> m

foldr :: (a -> b -> b) -> b -> Pixel RGB a -> b

foldr' :: (a -> b -> b) -> b -> Pixel RGB a -> b

foldl :: (b -> a -> b) -> b -> Pixel RGB a -> b

foldl' :: (b -> a -> b) -> b -> Pixel RGB a -> b

foldr1 :: (a -> a -> a) -> Pixel RGB a -> a

foldl1 :: (a -> a -> a) -> Pixel RGB a -> a

toList :: Pixel RGB a -> [a]

null :: Pixel RGB a -> Bool

length :: Pixel RGB a -> Int

elem :: Eq a => a -> Pixel RGB a -> Bool

maximum :: Ord a => Pixel RGB a -> a

minimum :: Ord a => Pixel RGB a -> a

sum :: Num a => Pixel RGB a -> a

product :: Num a => Pixel RGB a -> a

Foldable (Pixel HSIA)

Defined in Graphics.Image.ColorSpace.HSI

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)

Defined in Graphics.Image.ColorSpace.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)

Defined in Graphics.Image.ColorSpace.CMYK

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)

Defined in Graphics.Image.ColorSpace.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 X)

Defined in Graphics.Image.ColorSpace.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

Array arr X Bit => Thresholding (Image arr) Pixel arr

Defined in Graphics.Image.Processing.Binary

Methods

(!==!) :: (Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Image arr cs e -> Pixel cs e -> Image arr cs Bit

(!/=!) :: (Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Image arr cs e -> Pixel cs e -> Image arr cs Bit

(!<!) :: (Ord e, Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Image arr cs e -> Pixel cs e -> Image arr cs Bit

(!<=!) :: (Ord e, Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Image arr cs e -> Pixel cs e -> Image arr cs Bit

(!>!) :: (Ord e, Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Image arr cs e -> Pixel cs e -> Image arr cs Bit

(!>=!) :: (Ord e, Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Image arr cs e -> Pixel cs e -> Image arr cs Bit

(.==.) :: (Array arr cs e, Array arr X Bit) => Image arr cs e -> Pixel cs e -> Image arr X Bit

(./=.) :: (Array arr cs e, Array arr X Bit) => Image arr cs e -> Pixel cs e -> Image arr X Bit

(.<.) :: (Ord (Pixel cs e), Array arr cs e, Array arr X Bit) => Image arr cs e -> Pixel cs e -> Image arr X Bit

(.<=.) :: (Ord (Pixel cs e), Array arr cs e, Array arr X Bit) => Image arr cs e -> Pixel cs e -> Image arr X Bit

(.>.) :: (Ord (Pixel cs e), Array arr cs e, Array arr X Bit) => Image arr cs e -> Pixel cs e -> Image arr X Bit

(.>=.) :: (Ord (Pixel cs e), Array arr cs e, Array arr X Bit) => Image arr cs e -> Pixel cs e -> Image arr X Bit

(ColorSpace cs e, Bounded e) => Bounded (Pixel cs e)

Defined in Graphics.Image.Interface

Methods

minBound :: Pixel cs e

maxBound :: Pixel cs e

Eq e => Eq (Pixel YCbCrA e)

Defined in Graphics.Image.ColorSpace.YCbCr

Methods

(==) :: Pixel YCbCrA e -> Pixel YCbCrA e -> Bool

(/=) :: Pixel YCbCrA e -> Pixel YCbCrA e -> Bool

Eq e => Eq (Pixel YCbCr e)

Defined in Graphics.Image.ColorSpace.YCbCr

Methods

(==) :: Pixel YCbCr e -> Pixel YCbCr e -> Bool

(/=) :: Pixel YCbCr e -> Pixel YCbCr e -> Bool

Eq e => Eq (Pixel YA e)

Defined in Graphics.Image.ColorSpace.Y

Methods

(==) :: Pixel YA e -> Pixel YA e -> Bool

(/=) :: Pixel YA e -> Pixel YA e -> Bool

Eq e => Eq (Pixel Y e)

Defined in Graphics.Image.ColorSpace.Y

Methods

(==) :: Pixel Y e -> Pixel Y e -> Bool

(/=) :: Pixel Y e -> Pixel Y e -> Bool

Eq e => Eq (Pixel RGBA e)

Defined in Graphics.Image.ColorSpace.RGB

Methods

(==) :: Pixel RGBA e -> Pixel RGBA e -> Bool

(/=) :: Pixel RGBA e -> Pixel RGBA e -> Bool

Eq e => Eq (Pixel RGB e)

Defined in Graphics.Image.ColorSpace.RGB

Methods

(==) :: Pixel RGB e -> Pixel RGB e -> Bool

(/=) :: Pixel RGB e -> Pixel RGB e -> Bool

Eq e => Eq (Pixel HSIA e)

Defined in Graphics.Image.ColorSpace.HSI

Methods

(==) :: Pixel HSIA e -> Pixel HSIA e -> Bool

(/=) :: Pixel HSIA e -> Pixel HSIA e -> Bool

Eq e => Eq (Pixel HSI e)

Defined in Graphics.Image.ColorSpace.HSI

Methods

(==) :: Pixel HSI e -> Pixel HSI e -> Bool

(/=) :: Pixel HSI e -> Pixel HSI e -> Bool

Eq e => Eq (Pixel CMYKA e)

Defined in Graphics.Image.ColorSpace.CMYK

Methods

(==) :: Pixel CMYKA e -> Pixel CMYKA e -> Bool

(/=) :: Pixel CMYKA e -> Pixel CMYKA e -> Bool

Eq e => Eq (Pixel CMYK e)

Defined in Graphics.Image.ColorSpace.CMYK

Methods

(==) :: Pixel CMYK e -> Pixel CMYK e -> Bool

(/=) :: Pixel CMYK e -> Pixel CMYK e -> Bool

Eq e => Eq (Pixel X e)

Defined in Graphics.Image.ColorSpace.X

Methods

(==) :: Pixel X e -> Pixel X e -> Bool

(/=) :: Pixel X e -> Pixel X e -> Bool

(ColorSpace cs e, Floating e) => Floating (Pixel cs e)

Defined in Graphics.Image.Interface

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)

Defined in Graphics.Image.Interface

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)

Defined in Graphics.Image.Interface

Methods

(+) :: Pixel cs e -> Pixel cs e -> Pixel cs e

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

(*) :: Pixel cs e -> Pixel cs e -> Pixel cs e

negate :: Pixel cs e -> Pixel cs e

abs :: Pixel cs e -> Pixel cs e

signum :: Pixel cs e -> Pixel cs e

fromInteger :: Integer -> Pixel cs e

Ord e => Ord (Pixel Y e)

Defined in Graphics.Image.ColorSpace.Y

Methods

compare :: Pixel Y e -> Pixel Y e -> Ordering

(<) :: Pixel Y e -> Pixel Y e -> Bool

(<=) :: Pixel Y e -> Pixel Y e -> Bool

(>) :: Pixel Y e -> Pixel Y e -> Bool

(>=) :: Pixel Y e -> Pixel Y e -> Bool

max :: Pixel Y e -> Pixel Y e -> Pixel Y e

min :: Pixel Y e -> Pixel Y e -> Pixel Y e

Ord e => Ord (Pixel X e)

Defined in Graphics.Image.ColorSpace.X

Methods

compare :: Pixel X e -> Pixel X e -> Ordering

(<) :: Pixel X e -> Pixel X e -> Bool

(<=) :: Pixel X e -> Pixel X e -> Bool

(>) :: Pixel X e -> Pixel X e -> Bool

(>=) :: Pixel X e -> Pixel X e -> Bool

max :: Pixel X e -> Pixel X e -> Pixel X e

min :: Pixel X e -> Pixel X e -> Pixel X e

Show e => Show (Pixel YCbCrA e)

Defined in Graphics.Image.ColorSpace.YCbCr

Methods

showsPrec :: Int -> Pixel YCbCrA e -> ShowS

show :: Pixel YCbCrA e -> String

showList :: [Pixel YCbCrA e] -> ShowS

Show e => Show (Pixel YCbCr e)

Defined in Graphics.Image.ColorSpace.YCbCr

Methods

showsPrec :: Int -> Pixel YCbCr e -> ShowS

show :: Pixel YCbCr e -> String

showList :: [Pixel YCbCr e] -> ShowS

Show e => Show (Pixel YA e)

Defined in Graphics.Image.ColorSpace.Y

Methods

showsPrec :: Int -> Pixel YA e -> ShowS

show :: Pixel YA e -> String

showList :: [Pixel YA e] -> ShowS

Show e => Show (Pixel Y e)

Defined in Graphics.Image.ColorSpace.Y

Methods

showsPrec :: Int -> Pixel Y e -> ShowS

show :: Pixel Y e -> String

showList :: [Pixel Y e] -> ShowS

Show e => Show (Pixel RGBA e)

Defined in Graphics.Image.ColorSpace.RGB

Methods

showsPrec :: Int -> Pixel RGBA e -> ShowS

show :: Pixel RGBA e -> String

showList :: [Pixel RGBA e] -> ShowS

Show e => Show (Pixel RGB e)

Defined in Graphics.Image.ColorSpace.RGB

Methods

showsPrec :: Int -> Pixel RGB e -> ShowS

show :: Pixel RGB e -> String

showList :: [Pixel RGB e] -> ShowS

Show e => Show (Pixel HSIA e)

Defined in Graphics.Image.ColorSpace.HSI

Methods

showsPrec :: Int -> Pixel HSIA e -> ShowS

show :: Pixel HSIA e -> String

showList :: [Pixel HSIA e] -> ShowS

Show e => Show (Pixel HSI e)

Defined in Graphics.Image.ColorSpace.HSI

Methods

showsPrec :: Int -> Pixel HSI e -> ShowS

show :: Pixel HSI e -> String

showList :: [Pixel HSI e] -> ShowS

Show e => Show (Pixel CMYKA e)

Defined in Graphics.Image.ColorSpace.CMYK

Methods

showsPrec :: Int -> Pixel CMYKA e -> ShowS

show :: Pixel CMYKA e -> String

showList :: [Pixel CMYKA e] -> ShowS

Show e => Show (Pixel CMYK e)

Defined in Graphics.Image.ColorSpace.CMYK

Methods

showsPrec :: Int -> Pixel CMYK e -> ShowS

show :: Pixel CMYK e -> String

showList :: [Pixel CMYK e] -> ShowS

Show e => Show (Pixel X e)

Defined in Graphics.Image.ColorSpace.X

Methods

showsPrec :: Int -> Pixel X e -> ShowS

show :: Pixel X e -> String

showList :: [Pixel X e] -> ShowS

Storable e => Storable (Pixel YCbCrA e)

Defined in Graphics.Image.ColorSpace.YCbCr

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)

Defined in Graphics.Image.ColorSpace.YCbCr

Methods

sizeOf :: Pixel YCbCr e -> Int

alignment :: Pixel YCbCr e -> Int

peekElemOff :: Ptr (Pixel YCbCr e) -> Int -> IO (Pixel YCbCr e)

pokeElemOff :: Ptr (Pixel YCbCr e) -> Int -> Pixel YCbCr e -> IO ()

peekByteOff :: Ptr b -> Int -> IO (Pixel YCbCr e)

pokeByteOff :: Ptr b -> Int -> Pixel YCbCr e -> IO ()

peek :: Ptr (Pixel YCbCr e) -> IO (Pixel YCbCr e)

poke :: Ptr (Pixel YCbCr e) -> Pixel YCbCr e -> IO ()

Storable e => Storable (Pixel YA e)

Defined in Graphics.Image.ColorSpace.Y

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)

Defined in Graphics.Image.ColorSpace.Y

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

Defined in Graphics.Image.ColorSpace.RGB

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)

Defined in Graphics.Image.ColorSpace.RGB

Methods

sizeOf :: Pixel RGB e -> Int

alignment :: Pixel RGB e -> Int

peekElemOff :: Ptr (Pixel RGB e) -> Int -> IO (Pixel RGB e)

pokeElemOff :: Ptr (Pixel RGB e) -> Int -> Pixel RGB e -> IO ()

peekByteOff :: Ptr b -> Int -> IO (Pixel RGB e)

pokeByteOff :: Ptr b -> Int -> Pixel RGB e -> IO ()

peek :: Ptr (Pixel RGB e) -> IO (Pixel RGB e)

poke :: Ptr (Pixel RGB e) -> Pixel RGB e -> IO ()

Storable e => Storable (Pixel HSIA e)

Defined in Graphics.Image.ColorSpace.HSI

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)

Defined in Graphics.Image.ColorSpace.HSI

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)

Defined in Graphics.Image.ColorSpace.CMYK

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)

Defined in Graphics.Image.ColorSpace.CMYK

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

Defined in Graphics.Image.ColorSpace.X

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)

Defined in Graphics.Image.ColorSpace.Binary

Methods

(.&.) :: Pixel X Bit -> Pixel X Bit -> Pixel X Bit

(.|.) :: Pixel X Bit -> Pixel X Bit -> Pixel X Bit

xor :: Pixel X Bit -> Pixel X Bit -> Pixel X Bit

complement :: Pixel X Bit -> Pixel X Bit

shift :: Pixel X Bit -> Int -> Pixel X Bit

rotate :: Pixel X Bit -> Int -> Pixel X Bit

zeroBits :: Pixel X Bit

bit :: Int -> Pixel X Bit

setBit :: Pixel X Bit -> Int -> Pixel X Bit

clearBit :: Pixel X Bit -> Int -> Pixel X Bit

complementBit :: Pixel X Bit -> Int -> Pixel X Bit

testBit :: Pixel X Bit -> Int -> Bool

bitSizeMaybe :: Pixel X Bit -> Maybe Int

bitSize :: Pixel X Bit -> Int

isSigned :: Pixel X Bit -> Bool

shiftL :: Pixel X Bit -> Int -> Pixel X Bit

unsafeShiftL :: Pixel X Bit -> Int -> Pixel X Bit

shiftR :: Pixel X Bit -> Int -> Pixel X Bit

unsafeShiftR :: Pixel X Bit -> Int -> Pixel X Bit

rotateL :: Pixel X Bit -> Int -> Pixel X Bit

rotateR :: Pixel X Bit -> Int -> Pixel X Bit

popCount :: Pixel X Bit -> Int

(Foldable (Pixel cs), NFData e) => NFData (Pixel cs e)

Defined in Graphics.Image.Interface

Methods

rnf :: Pixel cs e -> ()

ColorSpace cs e => Unbox (Pixel cs e)

Unboxing of a Pixel.

Defined in Graphics.Image.Interface.Vector.Unboxing

(ColorSpace cs e, Elt e, Num (Pixel cs e)) => Elt (Pixel cs e)

Defined in Graphics.Image.Interface.Repa.Generic

Methods

touch :: Pixel cs e -> IO ()

zero :: Pixel cs e

one :: Pixel cs e

data Pixel YCbCrA e

Defined in Graphics.Image.ColorSpace.YCbCr

data Pixel YCbCrA e = PixelYCbCrA !e !e !e !e

data Pixel YCbCr e

Defined in Graphics.Image.ColorSpace.YCbCr

data Pixel YCbCr e = PixelYCbCr !e !e !e

data Pixel YA e

Defined in Graphics.Image.ColorSpace.Y

data Pixel YA e = PixelYA !e !e

newtype Pixel Y e

Defined in Graphics.Image.ColorSpace.Y

newtype Pixel Y e = PixelY e

data Pixel RGBA e

Defined in Graphics.Image.ColorSpace.RGB

data Pixel RGBA e = PixelRGBA !e !e !e !e

data Pixel RGB e

Defined in Graphics.Image.ColorSpace.RGB

data Pixel RGB e = PixelRGB !e !e !e

data Pixel HSIA e

Defined in Graphics.Image.ColorSpace.HSI

data Pixel HSIA e = PixelHSIA !e !e !e !e

data Pixel HSI e

Defined in Graphics.Image.ColorSpace.HSI

data Pixel HSI e = PixelHSI !e !e !e

data Pixel CMYKA e

Defined in Graphics.Image.ColorSpace.CMYK

data Pixel CMYKA e = PixelCMYKA !e !e !e !e !e

data Pixel CMYK e

Defined in Graphics.Image.ColorSpace.CMYK

data Pixel CMYK e = PixelCMYK !e !e !e !e

newtype Pixel X e

Defined in Graphics.Image.ColorSpace.X

newtype Pixel X e = PixelX {

• getX :: e

}

newtype MVector s (Pixel cs e)

Defined in Graphics.Image.Interface.Vector.Unboxing

newtype MVector s (Pixel cs e) = MV_Pixel (MVector s (Components cs e))

newtype Vector (Pixel cs e)

Defined in Graphics.Image.Interface.Vector.Unboxing

newtype Vector (Pixel cs e) = V_Pixel (Vector (Components cs e))

class (Eq cs, Enum cs, Show cs, Bounded cs, Typeable cs, Eq (Pixel cs e), Unbox (Components cs e), Elevator e) => ColorSpace cs e where

Minimal complete definition

toComponents, fromComponents, promote, getPxC, setPxC, mapPxC, liftPx, liftPx2, 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

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.

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

Map a function over all Pixel's componenets.

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

Zip two Pixels with a function.

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

Left fold on two pixels a the same time.

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

Right fold over all Pixel's components.

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

Left strict fold over all Pixel's components.

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

toListPx :: Pixel cs e -> [e]

Instances

Elevator e => ColorSpace YCbCrA e

Defined in Graphics.Image.ColorSpace.YCbCr

Associated Types

type Components YCbCrA e :: Type

Methods

toComponents :: Pixel YCbCrA e -> Components YCbCrA e

fromComponents :: Components YCbCrA e -> Pixel YCbCrA e

promote :: e -> Pixel YCbCrA e

getPxC :: Pixel YCbCrA e -> YCbCrA -> e

setPxC :: Pixel YCbCrA e -> YCbCrA -> e -> Pixel YCbCrA e

mapPxC :: (YCbCrA -> e -> e) -> Pixel YCbCrA e -> Pixel YCbCrA e

liftPx :: (e -> e) -> Pixel YCbCrA e -> Pixel YCbCrA e

liftPx2 :: (e -> e -> e) -> Pixel YCbCrA e -> Pixel YCbCrA e -> Pixel YCbCrA e

foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel YCbCrA e -> Pixel YCbCrA e -> b

foldrPx :: (e -> b -> b) -> b -> Pixel YCbCrA e -> b

foldlPx :: (b -> e -> b) -> b -> Pixel YCbCrA e -> b

foldl1Px :: (e -> e -> e) -> Pixel YCbCrA e -> e

toListPx :: Pixel YCbCrA e -> [e]

Elevator e => ColorSpace YCbCr e

Defined in Graphics.Image.ColorSpace.YCbCr

Associated Types

type Components YCbCr e :: Type

Methods

toComponents :: Pixel YCbCr e -> Components YCbCr e

fromComponents :: Components YCbCr e -> Pixel YCbCr e

promote :: e -> Pixel YCbCr e

getPxC :: Pixel YCbCr e -> YCbCr -> e

setPxC :: Pixel YCbCr e -> YCbCr -> e -> Pixel YCbCr e

mapPxC :: (YCbCr -> e -> e) -> Pixel YCbCr e -> Pixel YCbCr e

liftPx :: (e -> e) -> Pixel YCbCr e -> Pixel YCbCr e

liftPx2 :: (e -> e -> e) -> Pixel YCbCr e -> Pixel YCbCr e -> Pixel YCbCr e

foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel YCbCr e -> Pixel YCbCr e -> b

foldrPx :: (e -> b -> b) -> b -> Pixel YCbCr e -> b

foldlPx :: (b -> e -> b) -> b -> Pixel YCbCr e -> b

foldl1Px :: (e -> e -> e) -> Pixel YCbCr e -> e

toListPx :: Pixel YCbCr e -> [e]

Elevator e => ColorSpace YA e

Defined in Graphics.Image.ColorSpace.Y

Associated Types

type Components YA e :: Type

Methods

toComponents :: Pixel YA e -> Components YA e

fromComponents :: Components YA e -> Pixel YA e

promote :: e -> Pixel YA e

getPxC :: Pixel YA e -> YA -> e

setPxC :: Pixel YA e -> YA -> e -> Pixel YA e

mapPxC :: (YA -> e -> e) -> Pixel YA e -> Pixel YA e

liftPx :: (e -> e) -> Pixel YA e -> Pixel YA e

liftPx2 :: (e -> e -> e) -> Pixel YA e -> Pixel YA e -> Pixel YA e

foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel YA e -> Pixel YA e -> b

foldrPx :: (e -> b -> b) -> b -> Pixel YA e -> b

foldlPx :: (b -> e -> b) -> b -> Pixel YA e -> b

foldl1Px :: (e -> e -> e) -> Pixel YA e -> e

toListPx :: Pixel YA e -> [e]

Elevator e => ColorSpace Y e

Defined in Graphics.Image.ColorSpace.Y

Associated Types

type Components Y e :: Type

Methods

toComponents :: Pixel Y e -> Components Y e

fromComponents :: Components Y e -> Pixel Y e

promote :: e -> Pixel Y e

getPxC :: Pixel Y e -> Y -> e

setPxC :: Pixel Y e -> Y -> e -> Pixel Y e

mapPxC :: (Y -> e -> e) -> Pixel Y e -> Pixel Y e

liftPx :: (e -> e) -> Pixel Y e -> Pixel Y e

liftPx2 :: (e -> e -> e) -> Pixel Y e -> Pixel Y e -> Pixel Y e

foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel Y e -> Pixel Y e -> b

foldrPx :: (e -> b -> b) -> b -> Pixel Y e -> b

foldlPx :: (b -> e -> b) -> b -> Pixel Y e -> b

foldl1Px :: (e -> e -> e) -> Pixel Y e -> e

toListPx :: Pixel Y e -> [e]

Elevator e => ColorSpace RGBA e

Defined in Graphics.Image.ColorSpace.RGB

Associated Types

type Components RGBA e :: Type

Methods

toComponents :: Pixel RGBA e -> Components RGBA e

fromComponents :: Components RGBA e -> Pixel RGBA e

promote :: e -> Pixel RGBA e

getPxC :: Pixel RGBA e -> RGBA -> e

setPxC :: Pixel RGBA e -> RGBA -> e -> Pixel RGBA e

mapPxC :: (RGBA -> e -> e) -> Pixel RGBA e -> Pixel RGBA e

liftPx :: (e -> e) -> Pixel RGBA e -> Pixel RGBA e

liftPx2 :: (e -> e -> e) -> Pixel RGBA e -> Pixel RGBA e -> Pixel RGBA e

foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel RGBA e -> Pixel RGBA e -> b

foldrPx :: (e -> b -> b) -> b -> Pixel RGBA e -> b

foldlPx :: (b -> e -> b) -> b -> Pixel RGBA e -> b

foldl1Px :: (e -> e -> e) -> Pixel RGBA e -> e

toListPx :: Pixel RGBA e -> [e]

Elevator e => ColorSpace RGB e

Defined in Graphics.Image.ColorSpace.RGB

Associated Types

type Components RGB e :: Type

Methods

toComponents :: Pixel RGB e -> Components RGB e

fromComponents :: Components RGB e -> Pixel RGB e

promote :: e -> Pixel RGB e

getPxC :: Pixel RGB e -> RGB -> e

setPxC :: Pixel RGB e -> RGB -> e -> Pixel RGB e

mapPxC :: (RGB -> e -> e) -> Pixel RGB e -> Pixel RGB e

liftPx :: (e -> e) -> Pixel RGB e -> Pixel RGB e

liftPx2 :: (e -> e -> e) -> Pixel RGB e -> Pixel RGB e -> Pixel RGB e

foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel RGB e -> Pixel RGB e -> b

foldrPx :: (e -> b -> b) -> b -> Pixel RGB e -> b

foldlPx :: (b -> e -> b) -> b -> Pixel RGB e -> b

foldl1Px :: (e -> e -> e) -> Pixel RGB e -> e

toListPx :: Pixel RGB e -> [e]

Elevator e => ColorSpace HSIA e

Defined in Graphics.Image.ColorSpace.HSI

Associated Types

type Components HSIA e :: Type

Methods

toComponents :: Pixel HSIA e -> Components HSIA e

fromComponents :: Components HSIA e -> Pixel HSIA e

promote :: e -> Pixel HSIA e

getPxC :: Pixel HSIA e -> HSIA -> e

setPxC :: Pixel HSIA e -> HSIA -> e -> Pixel HSIA e

mapPxC :: (HSIA -> e -> e) -> Pixel HSIA e -> Pixel HSIA e

liftPx :: (e -> e) -> Pixel HSIA e -> Pixel HSIA e

liftPx2 :: (e -> e -> e) -> Pixel HSIA e -> Pixel HSIA e -> Pixel HSIA e

foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel HSIA e -> Pixel HSIA e -> b

foldrPx :: (e -> b -> b) -> b -> Pixel HSIA e -> b

foldlPx :: (b -> e -> b) -> b -> Pixel HSIA e -> b

foldl1Px :: (e -> e -> e) -> Pixel HSIA e -> e

toListPx :: Pixel HSIA e -> [e]

Elevator e => ColorSpace HSI e

Defined in Graphics.Image.ColorSpace.HSI

Associated Types

type Components HSI e :: Type

Methods

toComponents :: Pixel HSI e -> Components HSI e

fromComponents :: Components HSI e -> Pixel HSI e

promote :: e -> Pixel HSI e

getPxC :: Pixel HSI e -> HSI -> e

setPxC :: Pixel HSI e -> HSI -> e -> Pixel HSI e

mapPxC :: (HSI -> e -> e) -> Pixel HSI e -> Pixel HSI e

liftPx :: (e -> e) -> Pixel HSI e -> Pixel HSI e

liftPx2 :: (e -> e -> e) -> Pixel HSI e -> Pixel HSI e -> Pixel HSI e

foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel HSI e -> Pixel HSI e -> b

foldrPx :: (e -> b -> b) -> b -> Pixel HSI e -> b

foldlPx :: (b -> e -> b) -> b -> Pixel HSI e -> b

foldl1Px :: (e -> e -> e) -> Pixel HSI e -> e

toListPx :: Pixel HSI e -> [e]

Elevator e => ColorSpace CMYKA e

Defined in Graphics.Image.ColorSpace.CMYK

Associated Types

type Components CMYKA e :: Type

Methods

toComponents :: Pixel CMYKA e -> Components CMYKA e

fromComponents :: Components CMYKA e -> Pixel CMYKA e

promote :: e -> Pixel CMYKA e

getPxC :: Pixel CMYKA e -> CMYKA -> e

setPxC :: Pixel CMYKA e -> CMYKA -> e -> Pixel CMYKA e

mapPxC :: (CMYKA -> e -> e) -> Pixel CMYKA e -> Pixel CMYKA e

liftPx :: (e -> e) -> Pixel CMYKA e -> Pixel CMYKA e

liftPx2 :: (e -> e -> e) -> Pixel CMYKA e -> Pixel CMYKA e -> Pixel CMYKA e

foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel CMYKA e -> Pixel CMYKA e -> b

foldrPx :: (e -> b -> b) -> b -> Pixel CMYKA e -> b

foldlPx :: (b -> e -> b) -> b -> Pixel CMYKA e -> b

foldl1Px :: (e -> e -> e) -> Pixel CMYKA e -> e

toListPx :: Pixel CMYKA e -> [e]

Elevator e => ColorSpace CMYK e

Defined in Graphics.Image.ColorSpace.CMYK

Associated Types

type Components CMYK e :: Type

Methods

toComponents :: Pixel CMYK e -> Components CMYK e

fromComponents :: Components CMYK e -> Pixel CMYK e

promote :: e -> Pixel CMYK e

getPxC :: Pixel CMYK e -> CMYK -> e

setPxC :: Pixel CMYK e -> CMYK -> e -> Pixel CMYK e

mapPxC :: (CMYK -> e -> e) -> Pixel CMYK e -> Pixel CMYK e

liftPx :: (e -> e) -> Pixel CMYK e -> Pixel CMYK e

liftPx2 :: (e -> e -> e) -> Pixel CMYK e -> Pixel CMYK e -> Pixel CMYK e

foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel CMYK e -> Pixel CMYK e -> b

foldrPx :: (e -> b -> b) -> b -> Pixel CMYK e -> b

foldlPx :: (b -> e -> b) -> b -> Pixel CMYK e -> b

foldl1Px :: (e -> e -> e) -> Pixel CMYK e -> e

toListPx :: Pixel CMYK e -> [e]

Elevator e => ColorSpace X e

Defined in Graphics.Image.ColorSpace.X

Associated Types

type Components X e :: Type

Methods

toComponents :: Pixel X e -> Components X e

fromComponents :: Components X e -> Pixel X e

promote :: e -> Pixel X e

getPxC :: Pixel X e -> X -> e

setPxC :: Pixel X e -> X -> e -> Pixel X e

mapPxC :: (X -> e -> e) -> Pixel X e -> Pixel X e

liftPx :: (e -> e) -> Pixel X e -> Pixel X e

liftPx2 :: (e -> e -> e) -> Pixel X e -> Pixel X e -> Pixel X e

foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel X e -> Pixel X e -> b

foldrPx :: (e -> b -> b) -> b -> Pixel X e -> b

foldlPx :: (b -> e -> b) -> b -> Pixel X e -> b

foldl1Px :: (e -> e -> e) -> Pixel X e -> e

toListPx :: Pixel X e -> [e]

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

A color space that supports transparency.

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 YCbCrA e

Defined in Graphics.Image.ColorSpace.YCbCr

Associated Types

type Opaque YCbCrA :: Type

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 => AlphaSpace YA e

Defined in Graphics.Image.ColorSpace.Y

Associated Types

type Opaque YA :: Type

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 RGBA e

Defined in Graphics.Image.ColorSpace.RGB

Associated Types

type Opaque RGBA :: Type

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 HSIA e

Defined in Graphics.Image.ColorSpace.HSI

Associated Types

type Opaque HSIA :: Type

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

Defined in Graphics.Image.ColorSpace.CMYK

Associated Types

type Opaque CMYKA :: Type

Methods

getAlpha :: Pixel CMYKA e -> e

addAlpha :: e -> Pixel (Opaque CMYKA) e -> Pixel CMYKA e

dropAlpha :: Pixel CMYKA e -> Pixel (Opaque CMYKA) e

class (Eq e, Num e, Typeable e, Unbox 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
>>> toWord8 <$> rgb
<RGB:(0|128|255)>
>>> toWord16 <$> rgb
<RGB:(0|32768|65535)>

Methods

toWord8 :: e -> Word8

Values are scaled to [0, 255] range.

toWord16 :: e -> Word16

Values are scaled to [0, 65535] range.

toWord32 :: e -> Word32

Values are scaled to [0, 4294967295] range.

toWord64 :: e -> Word64

Values are scaled to [0, 18446744073709551615] range.

toFloat :: e -> Float

Values are scaled to [0.0, 1.0] range.

toDouble :: e -> Double

Values are scaled to [0.0, 1.0] range.

fromDouble :: Double -> e

Values are scaled from [0.0, 1.0] range.

Instances

Elevator Double

Values between [0.0, 1.0]

Defined in Graphics.Image.Interface.Elevator

Methods

toWord8 :: Double -> Word8

toWord16 :: Double -> Word16

toWord32 :: Double -> Word32

toWord64 :: Double -> Word64

toFloat :: Double -> Float

toDouble :: Double -> Double

fromDouble :: Double -> Double

Elevator Float

Values between [0.0, 1.0]

Defined in Graphics.Image.Interface.Elevator

Methods

toWord8 :: Float -> Word8

toWord16 :: Float -> Word16

toWord32 :: Float -> Word32

toWord64 :: Float -> Word64

toFloat :: Float -> Float

toDouble :: Float -> Double

fromDouble :: Double -> Float

Elevator Int

Values between [0, 9223372036854775807] on 64bit

Defined in Graphics.Image.Interface.Elevator

Methods

toWord8 :: Int -> Word8

toWord16 :: Int -> Word16

toWord32 :: Int -> Word32

toWord64 :: Int -> Word64

toFloat :: Int -> Float

toDouble :: Int -> Double

fromDouble :: Double -> Int

Elevator Int8

Values between [0, 127]

Defined in Graphics.Image.Interface.Elevator

Methods

toWord8 :: Int8 -> Word8

toWord16 :: Int8 -> Word16

toWord32 :: Int8 -> Word32

toWord64 :: Int8 -> Word64

toFloat :: Int8 -> Float

toDouble :: Int8 -> Double

fromDouble :: Double -> Int8

Elevator Int16

Values between [0, 32767]

Defined in Graphics.Image.Interface.Elevator

Methods

toWord8 :: Int16 -> Word8

toWord16 :: Int16 -> Word16

toWord32 :: Int16 -> Word32

toWord64 :: Int16 -> Word64

toFloat :: Int16 -> Float

toDouble :: Int16 -> Double

fromDouble :: Double -> Int16

Elevator Int32

Values between [0, 2147483647]

Defined in Graphics.Image.Interface.Elevator

Methods

toWord8 :: Int32 -> Word8

toWord16 :: Int32 -> Word16

toWord32 :: Int32 -> Word32

toWord64 :: Int32 -> Word64

toFloat :: Int32 -> Float

toDouble :: Int32 -> Double

fromDouble :: Double -> Int32

Elevator Int64

Values between [0, 9223372036854775807]

Defined in Graphics.Image.Interface.Elevator

Methods

toWord8 :: Int64 -> Word8

toWord16 :: Int64 -> Word16

toWord32 :: Int64 -> Word32

toWord64 :: Int64 -> Word64

toFloat :: Int64 -> Float

toDouble :: Int64 -> Double

fromDouble :: Double -> Int64

Elevator Word

Values between [0, 18446744073709551615] on 64bit

Defined in Graphics.Image.Interface.Elevator

Methods

toWord8 :: Word -> Word8

toWord16 :: Word -> Word16

toWord32 :: Word -> Word32

toWord64 :: Word -> Word64

toFloat :: Word -> Float

toDouble :: Word -> Double

fromDouble :: Double -> Word

Elevator Word8

Values between [0, 255]]

Defined in Graphics.Image.Interface.Elevator

Methods

toWord8 :: Word8 -> Word8

toWord16 :: Word8 -> Word16

toWord32 :: Word8 -> Word32

toWord64 :: Word8 -> Word64

toFloat :: Word8 -> Float

toDouble :: Word8 -> Double

fromDouble :: Double -> Word8

Elevator Word16

Values between [0, 65535]]

Defined in Graphics.Image.Interface.Elevator

Methods

toWord8 :: Word16 -> Word8

toWord16 :: Word16 -> Word16

toWord32 :: Word16 -> Word32

toWord64 :: Word16 -> Word64

toFloat :: Word16 -> Float

toDouble :: Word16 -> Double

fromDouble :: Double -> Word16

Elevator Word32

Values between [0, 4294967295]

Defined in Graphics.Image.Interface.Elevator

Methods

toWord8 :: Word32 -> Word8

toWord16 :: Word32 -> Word16

toWord32 :: Word32 -> Word32

toWord64 :: Word32 -> Word64

toFloat :: Word32 -> Float

toDouble :: Word32 -> Double

fromDouble :: Double -> Word32

Elevator Word64

Values between [0, 18446744073709551615]

Defined in Graphics.Image.Interface.Elevator

Methods

toWord8 :: Word64 -> Word8

toWord16 :: Word64 -> Word16

toWord32 :: Word64 -> Word32

toWord64 :: Word64 -> Word64

toFloat :: Word64 -> Float

toDouble :: Word64 -> Double

fromDouble :: Double -> Word64

Elevator Bit

Values: 0 and 1

Defined in Graphics.Image.ColorSpace.Binary

Methods

toWord8 :: Bit -> Word8

toWord16 :: Bit -> Word16

toWord32 :: Bit -> Word32

toWord64 :: Bit -> Word64

toFloat :: Bit -> Float

toDouble :: Bit -> Double

fromDouble :: Double -> Bit

(Num e, Elevator e, RealFloat e) => Elevator (Complex e)

Discards imaginary part and changes precision of real part.

Defined in Graphics.Image.Interface.Elevator

Methods

toWord8 :: Complex e -> Word8

toWord16 :: Complex e -> Word16

toWord32 :: Complex e -> Word32

toWord64 :: Complex e -> Word64

toFloat :: Complex e -> Float

toDouble :: Complex e -> Double

fromDouble :: Double -> Complex e

Array and Image

class (Typeable arr, ColorSpace cs e, SuperClass arr cs e) => BaseArray arr cs e where

Base array like representation for an image.

Associated Types

type SuperClass arr cs e :: Constraint

Required array specific constraints for an array element.

data Image arr cs e

Underlying image representation.

Methods

dims :: Image arr cs e -> (Int, Int)

Get dimensions of an image.

>>> frog <- readImageRGB VU "images/frog.jpg"
>>> frog
<Image VectorUnboxed RGB (Double): 200x320>
>>> dims frog
(200,320)

Instances

SuperClass VU cs e => BaseArray VU cs e

Defined in Graphics.Image.Interface.Vector.Unboxed

Associated Types

type SuperClass VU cs e :: Constraint

data Image VU cs e :: Type

Methods

dims :: Image VU cs e -> (Int, Int)

SuperClass VS cs e => BaseArray VS cs e

Defined in Graphics.Image.Interface.Vector.Storable

Associated Types

type SuperClass VS cs e :: Constraint

data Image VS cs e :: Type

Methods

dims :: Image VS cs e -> (Int, Int)

SuperClass RPU cs e => BaseArray RPU cs e

Defined in Graphics.Image.Interface.Repa.Unboxed

Associated Types

type SuperClass RPU cs e :: Constraint

data Image RPU cs e :: Type

Methods

dims :: Image RPU cs e -> (Int, Int)

SuperClass RSU cs e => BaseArray RSU cs e

Defined in Graphics.Image.Interface.Repa.Unboxed

Associated Types

type SuperClass RSU cs e :: Constraint

data Image RSU cs e :: Type

Methods

dims :: Image RSU cs e -> (Int, Int)

SuperClass RPS cs e => BaseArray RPS cs e

Defined in Graphics.Image.Interface.Repa.Storable

Associated Types

type SuperClass RPS cs e :: Constraint

data Image RPS cs e :: Type

Methods

dims :: Image RPS cs e -> (Int, Int)

SuperClass RSS cs e => BaseArray RSS cs e

Defined in Graphics.Image.Interface.Repa.Storable

Associated Types

type SuperClass RSS cs e :: Constraint

data Image RSS cs e :: Type

Methods

dims :: Image RSS cs e -> (Int, Int)

class (Vector (Vector arr) (Pixel cs e), MArray (Manifest arr) cs e, BaseArray arr cs e) => Array arr cs e where

Associated Types

type Manifest arr :: *

type Vector arr :: * -> *

Methods

makeImage

Arguments

:: (Int, Int)

(m rows, n columns) - dimensions of a new image.

-> ((Int, Int) -> Pixel cs e)

A function that takes (i-th row, and j-th column) as an argument and returns a pixel for that location.

-> Image arr cs e

Create an Image by supplying it's dimensions and a pixel generating function.

makeImageWindowed

Arguments

:: (Int, Int)

(m rows, n columns) - dimensions of a new image.

-> (Int, Int)

Starting index

-> (Int, Int)

Size of the window

-> ((Int, Int) -> Pixel cs e)

Function that generates inner pixels.

-> ((Int, Int) -> Pixel cs e)

Function that generates border pixels

-> Image arr cs e

scalar :: Pixel cs e -> Image arr cs e

Create a scalar image, required for various operations on images with a scalar.

index00 :: Image arr cs e -> Pixel cs e

Retrieves a pixel at (0, 0) index. Useful together with Array, when arbitrary initial pixel is needed.

map

Arguments

:: Array arr cs' e'

=> (Pixel cs' e' -> Pixel cs e)

A function that takes a pixel of a source image and returns a pixel for the result image a the same location.

-> Image arr cs' e'

Source image.

-> Image arr cs e

Result image.

Map a function over a an image.

imap

Arguments

:: Array arr cs' e'

=> ((Int, Int) -> Pixel cs' e' -> Pixel cs e)

A function that takes an index (i, j), a pixel at that location and returns a new pixel at the same location for the result image.

-> Image arr cs' e'

Source image.

-> Image arr cs e

Result image.

Map an index aware function over each pixel in an image.

zipWith :: (Array arr cs1 e1, Array arr cs2 e2) => (Pixel cs1 e1 -> Pixel cs2 e2 -> Pixel cs e) -> Image arr cs1 e1 -> Image arr cs2 e2 -> Image arr cs e

Zip two images with a function

izipWith :: (Array arr cs1 e1, Array arr cs2 e2) => ((Int, Int) -> Pixel cs1 e1 -> Pixel cs2 e2 -> Pixel cs e) -> Image arr cs1 e1 -> Image arr cs2 e2 -> Image arr cs e

Zip two images with an index aware function

traverse

Arguments

:: Array arr cs' e'

=> Image arr cs' e'

Source image.

-> ((Int, Int) -> (Int, Int))

Function that takes dimensions of a source image and returns dimensions of a new image.

-> (((Int, Int) -> Pixel cs' e') -> (Int, Int) -> Pixel cs e)

Function that receives a pixel getter (a source image index function), a location (i, j) in a new image and returns a pixel for that location.

-> Image arr cs e

Traverse an image

traverse2

Arguments

:: (Array arr cs1 e1, Array arr cs2 e2)

=> Image arr cs1 e1

First source image.

-> Image arr cs2 e2

Second source image.

-> ((Int, Int) -> (Int, Int) -> (Int, Int))

Function that produces dimensions for the new image.

-> (((Int, Int) -> Pixel cs1 e1) -> ((Int, Int) -> Pixel cs2 e2) -> (Int, Int) -> Pixel cs e)

Function that produces pixels for the new image.

-> Image arr cs e

Traverse two images.

transpose :: Image arr cs e -> Image arr cs e

Transpose an image

backpermute

Arguments

:: (Int, Int)

Dimensions of a result image.

-> ((Int, Int) -> (Int, Int))

Function that maps an index of a result image to an index of a source image.

-> Image arr cs e

Source image.

-> Image arr cs e

Result image.

Backwards permutation of an image.

fromLists :: [[Pixel cs e]] -> Image arr cs e

Construct an image from a nested rectangular shaped list of pixels. Length of an outer list will constitute m rows, while the length of inner lists - n columns. All of the inner lists must be the same length and greater than 0.

>>> fromLists [[PixelY (fromIntegral (i*j) / 60000) | j <- [1..300]] | i <- [1..200]]
<Image VectorUnboxed Y (Double): 200x300>

(|*|) :: Image arr cs e -> Image arr cs e -> Image arr cs e

Perform matrix multiplication on two images. Inner dimensions must agree.

fold

Arguments

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

An associative folding function.

-> Pixel cs e

Initial element, that is neutral with respect to the folding function.

-> Image arr cs e

Source image.

-> Pixel cs e

Undirected reduction of an image.

foldIx

Arguments

:: (Pixel cs e -> (Int, Int) -> Pixel cs e -> Pixel cs e)

Function that takes an accumulator, index, a pixel at that index and returns a new accumulator pixel.

-> Pixel cs e

Initial element, that is neutral with respect to the folding function.

-> Image arr cs e

Source image.

-> Pixel cs e

Undirected reduction of an image with an index aware function.

eq :: Image arr cs e -> Image arr cs e -> Bool

Pixelwise equality function of two images. Images are considered distinct if either images' dimensions or at least one pair of corresponding pixels are not the same. Used in defining an in instance for the Eq typeclass.

compute :: Image arr cs e -> Image arr cs e

Array class does not enforce an image to be represented as concrete array of pixels in memory, but if at any time it is desired for the image to be brought to a computed state, this function can be used.

toManifest :: Image arr cs e -> Image (Manifest arr) cs e

Each array has a sibling Manifest array representation, which

toVector :: Image arr cs e -> Vector arr (Pixel cs e)

Convert an image to a flattened Vector. For all current representations it is a O(1) opeartion.

>>> toVector $ makeImage (3, 2) (\(i, j) -> PixelY $ fromIntegral (i+j))
fromList [<Luma:(0.0)>,<Luma:(1.0)>,<Luma:(1.0)>,<Luma:(2.0)>,<Luma:(2.0)>,<Luma:(3.0)>]

fromVector :: (Int, Int) -> Vector arr (Pixel cs e) -> Image arr cs e

Construct a two dimensional image with m rows and n columns from a flat Vector of length k. For all current representations it is a O(1) opeartion. Make sure that m * n = k.

>>> fromVector (200, 300) $ generate 60000 (\i -> PixelY $ fromIntegral i / 60000)
<Image Vector Luma: 200x300>

Instances

(MArray VU cs e, BaseArray VU cs e) => Array VU cs e

Defined in Graphics.Image.Interface.Vector.Unboxed

Associated Types

type Manifest VU :: Type

type Vector VU :: Type -> Type

Methods

makeImage :: (Int, Int) -> ((Int, Int) -> Pixel cs e) -> Image VU cs e

makeImageWindowed :: (Int, Int) -> (Int, Int) -> (Int, Int) -> ((Int, Int) -> Pixel cs e) -> ((Int, Int) -> Pixel cs e) -> Image VU cs e

scalar :: Pixel cs e -> Image VU cs e

index00 :: Image VU cs e -> Pixel cs e

map :: Array VU cs' e' => (Pixel cs' e' -> Pixel cs e) -> Image VU cs' e' -> Image VU cs e

imap :: Array VU cs' e' => ((Int, Int) -> Pixel cs' e' -> Pixel cs e) -> Image VU cs' e' -> Image VU cs e

zipWith :: (Array VU cs1 e1, Array VU cs2 e2) => (Pixel cs1 e1 -> Pixel cs2 e2 -> Pixel cs e) -> Image VU cs1 e1 -> Image VU cs2 e2 -> Image VU cs e

izipWith :: (Array VU cs1 e1, Array VU cs2 e2) => ((Int, Int) -> Pixel cs1 e1 -> Pixel cs2 e2 -> Pixel cs e) -> Image VU cs1 e1 -> Image VU cs2 e2 -> Image VU cs e

traverse :: Array VU cs' e' => Image VU cs' e' -> ((Int, Int) -> (Int, Int)) -> (((Int, Int) -> Pixel cs' e') -> (Int, Int) -> Pixel cs e) -> Image VU cs e

traverse2 :: (Array VU cs1 e1, Array VU cs2 e2) => Image VU cs1 e1 -> Image VU cs2 e2 -> ((Int, Int) -> (Int, Int) -> (Int, Int)) -> (((Int, Int) -> Pixel cs1 e1) -> ((Int, Int) -> Pixel cs2 e2) -> (Int, Int) -> Pixel cs e) -> Image VU cs e

transpose :: Image VU cs e -> Image VU cs e

backpermute :: (Int, Int) -> ((Int, Int) -> (Int, Int)) -> Image VU cs e -> Image VU cs e

fromLists :: [[Pixel cs e]] -> Image VU cs e

(|*|) :: Image VU cs e -> Image VU cs e -> Image VU cs e

fold :: (Pixel cs e -> Pixel cs e -> Pixel cs e) -> Pixel cs e -> Image VU cs e -> Pixel cs e

foldIx :: (Pixel cs e -> (Int, Int) -> Pixel cs e -> Pixel cs e) -> Pixel cs e -> Image VU cs e -> Pixel cs e

eq :: Image VU cs e -> Image VU cs e -> Bool

compute :: Image VU cs e -> Image VU cs e

toManifest :: Image VU cs e -> Image (Manifest VU) cs e

toVector :: Image VU cs e -> Vector VU (Pixel cs e)

fromVector :: (Int, Int) -> Vector VU (Pixel cs e) -> Image VU cs e

(MArray VS cs e, BaseArray VS cs e) => Array VS cs e

Defined in Graphics.Image.Interface.Vector.Storable

Associated Types

type Manifest VS :: Type

type Vector VS :: Type -> Type

Methods

makeImage :: (Int, Int) -> ((Int, Int) -> Pixel cs e) -> Image VS cs e

makeImageWindowed :: (Int, Int) -> (Int, Int) -> (Int, Int) -> ((Int, Int) -> Pixel cs e) -> ((Int, Int) -> Pixel cs e) -> Image VS cs e

scalar :: Pixel cs e -> Image VS cs e

index00 :: Image VS cs e -> Pixel cs e

map :: Array VS cs' e' => (Pixel cs' e' -> Pixel cs e) -> Image VS cs' e' -> Image VS cs e

imap :: Array VS cs' e' => ((Int, Int) -> Pixel cs' e' -> Pixel cs e) -> Image VS cs' e' -> Image VS cs e

zipWith :: (Array VS cs1 e1, Array VS cs2 e2) => (Pixel cs1 e1 -> Pixel cs2 e2 -> Pixel cs e) -> Image VS cs1 e1 -> Image VS cs2 e2 -> Image VS cs e

izipWith :: (Array VS cs1 e1, Array VS cs2 e2) => ((Int, Int) -> Pixel cs1 e1 -> Pixel cs2 e2 -> Pixel cs e) -> Image VS cs1 e1 -> Image VS cs2 e2 -> Image VS cs e

traverse :: Array VS cs' e' => Image VS cs' e' -> ((Int, Int) -> (Int, Int)) -> (((Int, Int) -> Pixel cs' e') -> (Int, Int) -> Pixel cs e) -> Image VS cs e

traverse2 :: (Array VS cs1 e1, Array VS cs2 e2) => Image VS cs1 e1 -> Image VS cs2 e2 -> ((Int, Int) -> (Int, Int) -> (Int, Int)) -> (((Int, Int) -> Pixel cs1 e1) -> ((Int, Int) -> Pixel cs2 e2) -> (Int, Int) -> Pixel cs e) -> Image VS cs e

transpose :: Image VS cs e -> Image VS cs e

backpermute :: (Int, Int) -> ((Int, Int) -> (Int, Int)) -> Image VS cs e -> Image VS cs e

fromLists :: [[Pixel cs e]] -> Image VS cs e

(|*|) :: Image VS cs e -> Image VS cs e -> Image VS cs e

fold :: (Pixel cs e -> Pixel cs e -> Pixel cs e) -> Pixel cs e -> Image VS cs e -> Pixel cs e

foldIx :: (Pixel cs e -> (Int, Int) -> Pixel cs e -> Pixel cs e) -> Pixel cs e -> Image VS cs e -> Pixel cs e

eq :: Image VS cs e -> Image VS cs e -> Bool

compute :: Image VS cs e -> Image VS cs e

toManifest :: Image VS cs e -> Image (Manifest VS) cs e

toVector :: Image VS cs e -> Vector VS (Pixel cs e)

fromVector :: (Int, Int) -> Vector VS (Pixel cs e) -> Image VS cs e

BaseArray RPU cs e => Array RPU cs e

Defined in Graphics.Image.Interface.Repa.Unboxed

Associated Types

type Manifest RPU :: Type

type Vector RPU :: Type -> Type

Methods

makeImage :: (Int, Int) -> ((Int, Int) -> Pixel cs e) -> Image RPU cs e

makeImageWindowed :: (Int, Int) -> (Int, Int) -> (Int, Int) -> ((Int, Int) -> Pixel cs e) -> ((Int, Int) -> Pixel cs e) -> Image RPU cs e

scalar :: Pixel cs e -> Image RPU cs e

index00 :: Image RPU cs e -> Pixel cs e

map :: Array RPU cs' e' => (Pixel cs' e' -> Pixel cs e) -> Image RPU cs' e' -> Image RPU cs e

imap :: Array RPU cs' e' => ((Int, Int) -> Pixel cs' e' -> Pixel cs e) -> Image RPU cs' e' -> Image RPU cs e

zipWith :: (Array RPU cs1 e1, Array RPU cs2 e2) => (Pixel cs1 e1 -> Pixel cs2 e2 -> Pixel cs e) -> Image RPU cs1 e1 -> Image RPU cs2 e2 -> Image RPU cs e

izipWith :: (Array RPU cs1 e1, Array RPU cs2 e2) => ((Int, Int) -> Pixel cs1 e1 -> Pixel cs2 e2 -> Pixel cs e) -> Image RPU cs1 e1 -> Image RPU cs2 e2 -> Image RPU cs e

traverse :: Array RPU cs' e' => Image RPU cs' e' -> ((Int, Int) -> (Int, Int)) -> (((Int, Int) -> Pixel cs' e') -> (Int, Int) -> Pixel cs e) -> Image RPU cs e

traverse2 :: (Array RPU cs1 e1, Array RPU cs2 e2) => Image RPU cs1 e1 -> Image RPU cs2 e2 -> ((Int, Int) -> (Int, Int) -> (Int, Int)) -> (((Int, Int) -> Pixel cs1 e1) -> ((Int, Int) -> Pixel cs2 e2) -> (Int, Int) -> Pixel cs e) -> Image RPU cs e

transpose :: Image RPU cs e -> Image RPU cs e

backpermute :: (Int, Int) -> ((Int, Int) -> (Int, Int)) -> Image RPU cs e -> Image RPU cs e

fromLists :: [[Pixel cs e]] -> Image RPU cs e

(|*|) :: Image RPU cs e -> Image RPU cs e -> Image RPU cs e

fold :: (Pixel cs e -> Pixel cs e -> Pixel cs e) -> Pixel cs e -> Image RPU cs e -> Pixel cs e

foldIx :: (Pixel cs e -> (Int, Int) -> Pixel cs e -> Pixel cs e) -> Pixel cs e -> Image RPU cs e -> Pixel cs e

eq :: Image RPU cs e -> Image RPU cs e -> Bool

compute :: Image RPU cs e -> Image RPU cs e

toManifest :: Image RPU cs e -> Image (Manifest RPU) cs e

toVector :: Image RPU cs e -> Vector RPU (Pixel cs e)

fromVector :: (Int, Int) -> Vector RPU (Pixel cs e) -> Image RPU cs e

BaseArray RSU cs e => Array RSU cs e

Defined in Graphics.Image.Interface.Repa.Unboxed

Associated Types

type Manifest RSU :: Type

type Vector RSU :: Type -> Type

Methods

makeImage :: (Int, Int) -> ((Int, Int) -> Pixel cs e) -> Image RSU cs e

makeImageWindowed :: (Int, Int) -> (Int, Int) -> (Int, Int) -> ((Int, Int) -> Pixel cs e) -> ((Int, Int) -> Pixel cs e) -> Image RSU cs e

scalar :: Pixel cs e -> Image RSU cs e

index00 :: Image RSU cs e -> Pixel cs e

map :: Array RSU cs' e' => (Pixel cs' e' -> Pixel cs e) -> Image RSU cs' e' -> Image RSU cs e

imap :: Array RSU cs' e' => ((Int, Int) -> Pixel cs' e' -> Pixel cs e) -> Image RSU cs' e' -> Image RSU cs e

zipWith :: (Array RSU cs1 e1, Array RSU cs2 e2) => (Pixel cs1 e1 -> Pixel cs2 e2 -> Pixel cs e) -> Image RSU cs1 e1 -> Image RSU cs2 e2 -> Image RSU cs e

izipWith :: (Array RSU cs1 e1, Array RSU cs2 e2) => ((Int, Int) -> Pixel cs1 e1 -> Pixel cs2 e2 -> Pixel cs e) -> Image RSU cs1 e1 -> Image RSU cs2 e2 -> Image RSU cs e

traverse :: Array RSU cs' e' => Image RSU cs' e' -> ((Int, Int) -> (Int, Int)) -> (((Int, Int) -> Pixel cs' e') -> (Int, Int) -> Pixel cs e) -> Image RSU cs e

traverse2 :: (Array RSU cs1 e1, Array RSU cs2 e2) => Image RSU cs1 e1 -> Image RSU cs2 e2 -> ((Int, Int) -> (Int, Int) -> (Int, Int)) -> (((Int, Int) -> Pixel cs1 e1) -> ((Int, Int) -> Pixel cs2 e2) -> (Int, Int) -> Pixel cs e) -> Image RSU cs e

transpose :: Image RSU cs e -> Image RSU cs e

backpermute :: (Int, Int) -> ((Int, Int) -> (Int, Int)) -> Image RSU cs e -> Image RSU cs e

fromLists :: [[Pixel cs e]] -> Image RSU cs e

(|*|) :: Image RSU cs e -> Image RSU cs e -> Image RSU cs e

fold :: (Pixel cs e -> Pixel cs e -> Pixel cs e) -> Pixel cs e -> Image RSU cs e -> Pixel cs e

foldIx :: (Pixel cs e -> (Int, Int) -> Pixel cs e -> Pixel cs e) -> Pixel cs e -> Image RSU cs e -> Pixel cs e

eq :: Image RSU cs e -> Image RSU cs e -> Bool

compute :: Image RSU cs e -> Image RSU cs e

toManifest :: Image RSU cs e -> Image (Manifest RSU) cs e

toVector :: Image RSU cs e -> Vector RSU (Pixel cs e)

fromVector :: (Int, Int) -> Vector RSU (Pixel cs e) -> Image RSU cs e

BaseArray RPS cs e => Array RPS cs e

Defined in Graphics.Image.Interface.Repa.Storable

Associated Types

type Manifest RPS :: Type

type Vector RPS :: Type -> Type

Methods

makeImage :: (Int, Int) -> ((Int, Int) -> Pixel cs e) -> Image RPS cs e

makeImageWindowed :: (Int, Int) -> (Int, Int) -> (Int, Int) -> ((Int, Int) -> Pixel cs e) -> ((Int, Int) -> Pixel cs e) -> Image RPS cs e

scalar :: Pixel cs e -> Image RPS cs e

index00 :: Image RPS cs e -> Pixel cs e

map :: Array RPS cs' e' => (Pixel cs' e' -> Pixel cs e) -> Image RPS cs' e' -> Image RPS cs e

imap :: Array RPS cs' e' => ((Int, Int) -> Pixel cs' e' -> Pixel cs e) -> Image RPS cs' e' -> Image RPS cs e

zipWith :: (Array RPS cs1 e1, Array RPS cs2 e2) => (Pixel cs1 e1 -> Pixel cs2 e2 -> Pixel cs e) -> Image RPS cs1 e1 -> Image RPS cs2 e2 -> Image RPS cs e

izipWith :: (Array RPS cs1 e1, Array RPS cs2 e2) => ((Int, Int) -> Pixel cs1 e1 -> Pixel cs2 e2 -> Pixel cs e) -> Image RPS cs1 e1 -> Image RPS cs2 e2 -> Image RPS cs e

traverse :: Array RPS cs' e' => Image RPS cs' e' -> ((Int, Int) -> (Int, Int)) -> (((Int, Int) -> Pixel cs' e') -> (Int, Int) -> Pixel cs e) -> Image RPS cs e

traverse2 :: (Array RPS cs1 e1, Array RPS cs2 e2) => Image RPS cs1 e1 -> Image RPS cs2 e2 -> ((Int, Int) -> (Int, Int) -> (Int, Int)) -> (((Int, Int) -> Pixel cs1 e1) -> ((Int, Int) -> Pixel cs2 e2) -> (Int, Int) -> Pixel cs e) -> Image RPS cs e

transpose :: Image RPS cs e -> Image RPS cs e

backpermute :: (Int, Int) -> ((Int, Int) -> (Int, Int)) -> Image RPS cs e -> Image RPS cs e

fromLists :: [[Pixel cs e]] -> Image RPS cs e

(|*|) :: Image RPS cs e -> Image RPS cs e -> Image RPS cs e

fold :: (Pixel cs e -> Pixel cs e -> Pixel cs e) -> Pixel cs e -> Image RPS cs e -> Pixel cs e

foldIx :: (Pixel cs e -> (Int, Int) -> Pixel cs e -> Pixel cs e) -> Pixel cs e -> Image RPS cs e -> Pixel cs e

eq :: Image RPS cs e -> Image RPS cs e -> Bool

compute :: Image RPS cs e -> Image RPS cs e

toManifest :: Image RPS cs e -> Image (Manifest RPS) cs e

toVector :: Image RPS cs e -> Vector RPS (Pixel cs e)

fromVector :: (Int, Int) -> Vector RPS (Pixel cs e) -> Image RPS cs e

BaseArray RSS cs e => Array RSS cs e

Defined in Graphics.Image.Interface.Repa.Storable

Associated Types

type Manifest RSS :: Type

type Vector RSS :: Type -> Type

Methods

makeImage :: (Int, Int) -> ((Int, Int) -> Pixel cs e) -> Image RSS cs e

makeImageWindowed :: (Int, Int) -> (Int, Int) -> (Int, Int) -> ((Int, Int) -> Pixel cs e) -> ((Int, Int) -> Pixel cs e) -> Image RSS cs e

scalar :: Pixel cs e -> Image RSS cs e

index00 :: Image RSS cs e -> Pixel cs e

map :: Array RSS cs' e' => (Pixel cs' e' -> Pixel cs e) -> Image RSS cs' e' -> Image RSS cs e

imap :: Array RSS cs' e' => ((Int, Int) -> Pixel cs' e' -> Pixel cs e) -> Image RSS cs' e' -> Image RSS cs e

zipWith :: (Array RSS cs1 e1, Array RSS cs2 e2) => (Pixel cs1 e1 -> Pixel cs2 e2 -> Pixel cs e) -> Image RSS cs1 e1 -> Image RSS cs2 e2 -> Image RSS cs e

izipWith :: (Array RSS cs1 e1, Array RSS cs2 e2) => ((Int, Int) -> Pixel cs1 e1 -> Pixel cs2 e2 -> Pixel cs e) -> Image RSS cs1 e1 -> Image RSS cs2 e2 -> Image RSS cs e

traverse :: Array RSS cs' e' => Image RSS cs' e' -> ((Int, Int) -> (Int, Int)) -> (((Int, Int) -> Pixel cs' e') -> (Int, Int) -> Pixel cs e) -> Image RSS cs e

traverse2 :: (Array RSS cs1 e1, Array RSS cs2 e2) => Image RSS cs1 e1 -> Image RSS cs2 e2 -> ((Int, Int) -> (Int, Int) -> (Int, Int)) -> (((Int, Int) -> Pixel cs1 e1) -> ((Int, Int) -> Pixel cs2 e2) -> (Int, Int) -> Pixel cs e) -> Image RSS cs e

transpose :: Image RSS cs e -> Image RSS cs e

backpermute :: (Int, Int) -> ((Int, Int) -> (Int, Int)) -> Image RSS cs e -> Image RSS cs e

fromLists :: [[Pixel cs e]] -> Image RSS cs e

(|*|) :: Image RSS cs e -> Image RSS cs e -> Image RSS cs e

fold :: (Pixel cs e -> Pixel cs e -> Pixel cs e) -> Pixel cs e -> Image RSS cs e -> Pixel cs e

foldIx :: (Pixel cs e -> (Int, Int) -> Pixel cs e -> Pixel cs e) -> Pixel cs e -> Image RSS cs e -> Pixel cs e

eq :: Image RSS cs e -> Image RSS cs e -> Bool

compute :: Image RSS cs e -> Image RSS cs e

toManifest :: Image RSS cs e -> Image (Manifest RSS) cs e

toVector :: Image RSS cs e -> Vector RSS (Pixel cs e)

fromVector :: (Int, Int) -> Vector RSS (Pixel cs e) -> Image RSS cs e

MArray and MImage

class BaseArray arr cs e => MArray arr cs e where

Array representation that is actually has real data stored in memory, hence allowing for image indexing, forcing pixels into computed state etc.

Associated Types

data MImage s arr cs e

Methods

unsafeIndex :: Image arr cs e -> (Int, Int) -> Pixel cs e

Get a pixel at (i, j) location without any bounds checks.

deepSeqImage :: Image arr cs e -> a -> a

Make sure that an image is fully evaluated.

foldl :: (a -> Pixel cs e -> a) -> a -> Image arr cs e -> a

Fold an image from the left in a row major order.

foldr :: (Pixel cs e -> a -> a) -> a -> Image arr cs e -> a

Fold an image from the right in a row major order.

makeImageM

Arguments

:: (Functor m, Monad m)

=> (Int, Int)

(m rows, n columns) - dimensions of a new image.

-> ((Int, Int) -> m (Pixel cs e))

A function that takes (i-th row, and j-th column) as an argument and generates a pixel for that location.

-> m (Image arr cs e)

Create an Image by supplying it's dimensions and a monadic pixel generating action.

mapM :: (MArray arr cs' e', Functor m, Monad m) => (Pixel cs' e' -> m (Pixel cs e)) -> Image arr cs' e' -> m (Image arr cs e)

Monading mapping over an image.

mapM_ :: (Functor m, Monad m) => (Pixel cs e -> m b) -> Image arr cs e -> m ()

Monading mapping over an image. Result is discarded.

foldM :: (Functor m, Monad m) => (a -> Pixel cs e -> m a) -> a -> Image arr cs e -> m a

Monadic folding.

foldM_ :: (Functor m, Monad m) => (a -> Pixel cs e -> m a) -> a -> Image arr cs e -> m ()

Monadic folding. Result is discarded.

mdims :: MImage s arr cs e -> (Int, Int)

Get dimensions of a mutable image.

thaw :: (Functor m, PrimMonad m) => Image arr cs e -> m (MImage (PrimState m) arr cs e)

Yield a mutable copy of an image.

freeze :: (Functor m, PrimMonad m) => MImage (PrimState m) arr cs e -> m (Image arr cs e)

Yield an immutable copy of an image.

new :: (Functor m, PrimMonad m) => (Int, Int) -> m (MImage (PrimState m) arr cs e)

Create a mutable image with given dimensions. Pixels are likely uninitialized.

read :: (Functor m, PrimMonad m) => MImage (PrimState m) arr cs e -> (Int, Int) -> m (Pixel cs e)

Yield the pixel at a given location.

write :: (Functor m, PrimMonad m) => MImage (PrimState m) arr cs e -> (Int, Int) -> Pixel cs e -> m ()

Set a pixel at a given location.

swap :: (Functor m, PrimMonad m) => MImage (PrimState m) arr cs e -> (Int, Int) -> (Int, Int) -> m ()

Swap pixels at given locations.

Instances

BaseArray VU cs e => MArray VU cs e

Defined in Graphics.Image.Interface.Vector.Unboxed

Associated Types

data MImage s VU cs e :: Type

Methods

unsafeIndex :: Image VU cs e -> (Int, Int) -> Pixel cs e

deepSeqImage :: Image VU cs e -> a -> a

foldl :: (a -> Pixel cs e -> a) -> a -> Image VU cs e -> a

foldr :: (Pixel cs e -> a -> a) -> a -> Image VU cs e -> a

makeImageM :: (Functor m, Monad m) => (Int, Int) -> ((Int, Int) -> m (Pixel cs e)) -> m (Image VU cs e)

mapM :: (MArray VU cs' e', Functor m, Monad m) => (Pixel cs' e' -> m (Pixel cs e)) -> Image VU cs' e' -> m (Image VU cs e)

mapM_ :: (Functor m, Monad m) => (Pixel cs e -> m b) -> Image VU cs e -> m ()

foldM :: (Functor m, Monad m) => (a -> Pixel cs e -> m a) -> a -> Image VU cs e -> m a

foldM_ :: (Functor m, Monad m) => (a -> Pixel cs e -> m a) -> a -> Image VU cs e -> m ()

mdims :: MImage s VU cs e -> (Int, Int)

thaw :: (Functor m, PrimMonad m) => Image VU cs e -> m (MImage (PrimState m) VU cs e)

freeze :: (Functor m, PrimMonad m) => MImage (PrimState m) VU cs e -> m (Image VU cs e)

new :: (Functor m, PrimMonad m) => (Int, Int) -> m (MImage (PrimState m) VU cs e)

read :: (Functor m, PrimMonad m) => MImage (PrimState m) VU cs e -> (Int, Int) -> m (Pixel cs e)

write :: (Functor m, PrimMonad m) => MImage (PrimState m) VU cs e -> (Int, Int) -> Pixel cs e -> m ()

swap :: (Functor m, PrimMonad m) => MImage (PrimState m) VU cs e -> (Int, Int) -> (Int, Int) -> m ()

BaseArray VS cs e => MArray VS cs e

Defined in Graphics.Image.Interface.Vector.Storable

Associated Types

data MImage s VS cs e :: Type

Methods

unsafeIndex :: Image VS cs e -> (Int, Int) -> Pixel cs e

deepSeqImage :: Image VS cs e -> a -> a

foldl :: (a -> Pixel cs e -> a) -> a -> Image VS cs e -> a

foldr :: (Pixel cs e -> a -> a) -> a -> Image VS cs e -> a

makeImageM :: (Functor m, Monad m) => (Int, Int) -> ((Int, Int) -> m (Pixel cs e)) -> m (Image VS cs e)

mapM :: (MArray VS cs' e', Functor m, Monad m) => (Pixel cs' e' -> m (Pixel cs e)) -> Image VS cs' e' -> m (Image VS cs e)

mapM_ :: (Functor m, Monad m) => (Pixel cs e -> m b) -> Image VS cs e -> m ()

foldM :: (Functor m, Monad m) => (a -> Pixel cs e -> m a) -> a -> Image VS cs e -> m a

foldM_ :: (Functor m, Monad m) => (a -> Pixel cs e -> m a) -> a -> Image VS cs e -> m ()

mdims :: MImage s VS cs e -> (Int, Int)

thaw :: (Functor m, PrimMonad m) => Image VS cs e -> m (MImage (PrimState m) VS cs e)

freeze :: (Functor m, PrimMonad m) => MImage (PrimState m) VS cs e -> m (Image VS cs e)

new :: (Functor m, PrimMonad m) => (Int, Int) -> m (MImage (PrimState m) VS cs e)

read :: (Functor m, PrimMonad m) => MImage (PrimState m) VS cs e -> (Int, Int) -> m (Pixel cs e)

write :: (Functor m, PrimMonad m) => MImage (PrimState m) VS cs e -> (Int, Int) -> Pixel cs e -> m ()

swap :: (Functor m, PrimMonad m) => MImage (PrimState m) VS cs e -> (Int, Int) -> (Int, Int) -> m ()

createImage :: MArray arr cs e => (forall s. ST s (MImage s arr cs e)) -> Image arr cs e

Run a stateful monadic computation that generates an image.

Exchanging Representation

exchange

Arguments

:: (Array arr' cs e, Array arr cs e)

=> arr

New representation of an image.

-> Image arr' cs e

Source image.

-> Image arr cs e

Exchange the underlying array representation of an image.

Indexing

index :: MArray arr cs e => Image arr cs e -> (Int, Int) -> Pixel cs e

Get a pixel at i-th and j-th location.

>>> let grad_gray = makeImage (200, 200) (\(i, j) -> PixelY $ fromIntegral (i*j)) / (200*200)
>>> index grad_gray (20, 30) == PixelY ((20*30) / (200*200))
True

defaultIndex :: MArray arr cs e => Pixel cs e -> Image arr cs e -> (Int, Int) -> Pixel cs e

Image indexing function that returns a default pixel if index is out of bounds.

borderIndex :: MArray arr cs e => Border (Pixel cs e) -> Image arr cs e -> (Int, Int) -> Pixel cs e

Image indexing function that uses a special border resolutions strategy for out of bounds pixels.

maybeIndex :: MArray arr cs e => Image arr cs e -> (Int, Int) -> Maybe (Pixel cs e)

Image indexing function that returns Nothing if index is out of bounds, Just px otherwise.

data Border px

Approach to be used near the borders during various transformations. Whenever a function needs information not only about a pixel of interest, but also about it's neighbours, it will go out of bounds around the image edges, hence is this set of approaches that can be used in such situtation.

Constructors

Fill !px

Fill in a constant pixel.

           outside |  Image  | outside
(Fill 0) : 0 0 0 0 | 1 2 3 4 | 0 0 0 0

Wrap

Wrap around from the opposite border of the image.

           outside |  Image  | outside
Wrap :     1 2 3 4 | 1 2 3 4 | 1 2 3 4

Edge

Replicate the pixel at the edge.

           outside |  Image  | outside
Edge :     1 1 1 1 | 1 2 3 4 | 4 4 4 4

Reflect

Mirror like reflection.

           outside |  Image  | outside
Reflect :  4 3 2 1 | 1 2 3 4 | 4 3 2 1

Continue

Also mirror like reflection, but without repeating the edge pixel.

           outside |  Image  | outside
Continue : 1 4 3 2 | 1 2 3 4 | 3 2 1 4

Instances

Show px => Show (Border px)

Defined in Graphics.Image.Interface

Methods

showsPrec :: Int -> Border px -> ShowS

show :: Border px -> String

showList :: [Border px] -> ShowS

handleBorderIndex

Arguments

:: Border px

Border handling strategy.

-> (Int, Int)

Image dimensions

-> ((Int, Int) -> px)

Image's indexing function.

-> (Int, Int)

(i, j) location of a pixel lookup.

-> px

Border handling function. If (i, j) location is within bounds, then supplied lookup function will be used, otherwise it will be handled according to a supplied border strategy.

Tools

fromIx

Arguments

:: Int

n columns

-> (Int, Int)

(i, j) row, column index

-> Int

Flat vector index

2D to a flat vector index conversion.

Note: There is an implicit assumption that j < n

toIx

Arguments

:: Int

n columns

-> Int

Flat vector index

-> (Int, Int)

(i, j) row, column index

Flat vector to 2D index conversion.

checkDims :: String -> (Int, Int) -> (Int, Int)