hip-1.5.0.0: Haskell Image Processing (HIP) Library.

Copyright(c) Alexey Kuleshevich 2017
LicenseBSD3
MaintainerAlexey Kuleshevich <[email protected]>
Stabilityexperimental
Portabilitynon-portable
Safe HaskellNone
LanguageHaskell2010

Graphics.Image.Interface

Description

 

Synopsis

Documentation

data family Pixel cs e :: * Source #

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

Instances

Array arr Binary Bit => Thresholding Pixel (Image arr) arr Source # 

Methods

(.==.) :: (Eq (Pixel cs e), Array arr cs e) => Pixel cs e -> Image arr cs e -> Image arr Binary Bit Source #

(./=.) :: (Eq (Pixel cs e), Array arr cs e) => Pixel cs e -> Image arr cs e -> Image arr Binary Bit Source #

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

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

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

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

Monad (Pixel Y) # 

Methods

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

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

return :: a -> Pixel Y a #

fail :: String -> Pixel Y a #

Monad (Pixel X) # 

Methods

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

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

return :: a -> Pixel X a #

fail :: String -> Pixel X a #

Functor (Pixel YCbCrA) # 

Methods

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

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

Functor (Pixel YCbCr) # 

Methods

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

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

Functor (Pixel YA) # 

Methods

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

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

Functor (Pixel Y) # 

Methods

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

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

Functor (Pixel X) # 

Methods

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

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

Functor (Pixel RGBA) # 

Methods

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

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

Functor (Pixel RGB) # 

Methods

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

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

Functor (Pixel HSIA) # 

Methods

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

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

Functor (Pixel HSI) # 

Methods

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

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

Functor (Pixel CMYKA) # 

Methods

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

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

Functor (Pixel CMYK) # 

Methods

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

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

Applicative (Pixel YCbCrA) # 

Methods

pure :: a -> Pixel YCbCrA a #

(<*>) :: Pixel YCbCrA (a -> b) -> Pixel YCbCrA a -> Pixel YCbCrA b #

(*>) :: Pixel YCbCrA a -> Pixel YCbCrA b -> Pixel YCbCrA b #

(<*) :: Pixel YCbCrA a -> Pixel YCbCrA b -> Pixel YCbCrA a #

Applicative (Pixel YCbCr) # 

Methods

pure :: a -> Pixel YCbCr a #

(<*>) :: Pixel YCbCr (a -> b) -> Pixel YCbCr a -> Pixel YCbCr b #

(*>) :: Pixel YCbCr a -> Pixel YCbCr b -> Pixel YCbCr b #

(<*) :: Pixel YCbCr a -> Pixel YCbCr b -> Pixel YCbCr a #

Applicative (Pixel YA) # 

Methods

pure :: a -> Pixel YA a #

(<*>) :: Pixel YA (a -> b) -> Pixel YA a -> Pixel YA b #

(*>) :: Pixel YA a -> Pixel YA b -> Pixel YA b #

(<*) :: Pixel YA a -> Pixel YA b -> Pixel YA a #

Applicative (Pixel Y) # 

Methods

pure :: a -> Pixel Y a #

(<*>) :: Pixel Y (a -> b) -> Pixel Y a -> Pixel Y b #

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

(<*) :: Pixel Y a -> Pixel Y b -> Pixel Y a #

Applicative (Pixel X) # 

Methods

pure :: a -> Pixel X a #

(<*>) :: Pixel X (a -> b) -> Pixel X a -> Pixel X b #

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

(<*) :: Pixel X a -> Pixel X b -> Pixel X a #

Applicative (Pixel RGBA) # 

Methods

pure :: a -> Pixel RGBA a #

(<*>) :: Pixel RGBA (a -> b) -> Pixel RGBA a -> Pixel RGBA b #

(*>) :: Pixel RGBA a -> Pixel RGBA b -> Pixel RGBA b #

(<*) :: Pixel RGBA a -> Pixel RGBA b -> Pixel RGBA a #

Applicative (Pixel RGB) # 

Methods

pure :: a -> Pixel RGB a #

(<*>) :: Pixel RGB (a -> b) -> Pixel RGB a -> Pixel RGB b #

(*>) :: Pixel RGB a -> Pixel RGB b -> Pixel RGB b #

(<*) :: Pixel RGB a -> Pixel RGB b -> Pixel RGB a #

Applicative (Pixel HSIA) # 

Methods

pure :: a -> Pixel HSIA a #

(<*>) :: Pixel HSIA (a -> b) -> Pixel HSIA a -> Pixel HSIA b #

(*>) :: Pixel HSIA a -> Pixel HSIA b -> Pixel HSIA b #

(<*) :: Pixel HSIA a -> Pixel HSIA b -> Pixel HSIA a #

Applicative (Pixel HSI) # 

Methods

pure :: a -> Pixel HSI a #

(<*>) :: Pixel HSI (a -> b) -> Pixel HSI a -> Pixel HSI b #

(*>) :: Pixel HSI a -> Pixel HSI b -> Pixel HSI b #

(<*) :: Pixel HSI a -> Pixel HSI b -> Pixel HSI a #

Applicative (Pixel CMYKA) # 

Methods

pure :: a -> Pixel CMYKA a #

(<*>) :: Pixel CMYKA (a -> b) -> Pixel CMYKA a -> Pixel CMYKA b #

(*>) :: Pixel CMYKA a -> Pixel CMYKA b -> Pixel CMYKA b #

(<*) :: Pixel CMYKA a -> Pixel CMYKA b -> Pixel CMYKA a #

Applicative (Pixel CMYK) # 

Methods

pure :: a -> Pixel CMYK a #

(<*>) :: Pixel CMYK (a -> b) -> Pixel CMYK a -> Pixel CMYK b #

(*>) :: Pixel CMYK a -> Pixel CMYK b -> Pixel CMYK b #

(<*) :: Pixel CMYK a -> Pixel CMYK b -> Pixel CMYK a #

Foldable (Pixel YCbCrA) # 

Methods

fold :: Monoid m => Pixel YCbCrA m -> m #

foldMap :: Monoid m => (a -> m) -> Pixel YCbCrA a -> m #

foldr :: (a -> b -> b) -> b -> Pixel YCbCrA a -> b #

foldr' :: (a -> b -> b) -> b -> Pixel YCbCrA a -> b #

foldl :: (b -> a -> b) -> b -> Pixel YCbCrA a -> b #

foldl' :: (b -> a -> b) -> b -> Pixel YCbCrA a -> b #

foldr1 :: (a -> a -> a) -> Pixel YCbCrA a -> a #

foldl1 :: (a -> a -> a) -> Pixel YCbCrA a -> a #

toList :: Pixel YCbCrA a -> [a] #

null :: Pixel YCbCrA a -> Bool #

length :: Pixel YCbCrA a -> Int #

elem :: Eq a => a -> Pixel YCbCrA a -> Bool #

maximum :: Ord a => Pixel YCbCrA a -> a #

minimum :: Ord a => Pixel YCbCrA a -> a #

sum :: Num a => Pixel YCbCrA a -> a #

product :: Num a => Pixel YCbCrA a -> a #

Foldable (Pixel YCbCr) # 

Methods

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

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

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

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

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

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

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

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

toList :: Pixel YCbCr a -> [a] #

null :: Pixel YCbCr a -> Bool #

length :: Pixel YCbCr a -> Int #

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

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

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

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

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

Foldable (Pixel YA) # 

Methods

fold :: Monoid m => Pixel YA m -> m #

foldMap :: Monoid m => (a -> m) -> Pixel YA a -> m #

foldr :: (a -> b -> b) -> b -> Pixel YA a -> b #

foldr' :: (a -> b -> b) -> b -> Pixel YA a -> b #

foldl :: (b -> a -> b) -> b -> Pixel YA a -> b #

foldl' :: (b -> a -> b) -> b -> Pixel YA a -> b #

foldr1 :: (a -> a -> a) -> Pixel YA a -> a #

foldl1 :: (a -> a -> a) -> Pixel YA a -> a #

toList :: Pixel YA a -> [a] #

null :: Pixel YA a -> Bool #

length :: Pixel YA a -> Int #

elem :: Eq a => a -> Pixel YA a -> Bool #

maximum :: Ord a => Pixel YA a -> a #

minimum :: Ord a => Pixel YA a -> a #

sum :: Num a => Pixel YA a -> a #

product :: Num a => Pixel YA a -> a #

Foldable (Pixel Y) # 

Methods

fold :: Monoid m => Pixel Y m -> m #

foldMap :: Monoid m => (a -> m) -> Pixel Y a -> m #

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

foldr' :: (a -> b -> b) -> b -> Pixel Y a -> b #

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

foldl' :: (b -> a -> b) -> b -> Pixel Y a -> b #

foldr1 :: (a -> a -> a) -> Pixel Y a -> a #

foldl1 :: (a -> a -> a) -> Pixel Y a -> a #

toList :: Pixel Y a -> [a] #

null :: Pixel Y a -> Bool #

length :: Pixel Y a -> Int #

elem :: Eq a => a -> Pixel Y a -> Bool #

maximum :: Ord a => Pixel Y a -> a #

minimum :: Ord a => Pixel Y a -> a #

sum :: Num a => Pixel Y a -> a #

product :: Num a => Pixel Y a -> a #

Foldable (Pixel X) # 

Methods

fold :: Monoid m => Pixel X m -> m #

foldMap :: Monoid m => (a -> m) -> Pixel X a -> m #

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

foldr' :: (a -> b -> b) -> b -> Pixel X a -> b #

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

foldl' :: (b -> a -> b) -> b -> Pixel X a -> b #

foldr1 :: (a -> a -> a) -> Pixel X a -> a #

foldl1 :: (a -> a -> a) -> Pixel X a -> a #

toList :: Pixel X a -> [a] #

null :: Pixel X a -> Bool #

length :: Pixel X a -> Int #

elem :: Eq a => a -> Pixel X a -> Bool #

maximum :: Ord a => Pixel X a -> a #

minimum :: Ord a => Pixel X a -> a #

sum :: Num a => Pixel X a -> a #

product :: Num a => Pixel X a -> a #

Foldable (Pixel RGBA) # 

Methods

fold :: Monoid m => Pixel RGBA m -> m #

foldMap :: Monoid m => (a -> m) -> Pixel RGBA a -> m #

foldr :: (a -> b -> b) -> b -> Pixel RGBA a -> b #

foldr' :: (a -> b -> b) -> b -> Pixel RGBA a -> b #

foldl :: (b -> a -> b) -> b -> Pixel RGBA a -> b #

foldl' :: (b -> a -> b) -> b -> Pixel RGBA a -> b #

foldr1 :: (a -> a -> a) -> Pixel RGBA a -> a #

foldl1 :: (a -> a -> a) -> Pixel RGBA a -> a #

toList :: Pixel RGBA a -> [a] #

null :: Pixel RGBA a -> Bool #

length :: Pixel RGBA a -> Int #

elem :: Eq a => a -> Pixel RGBA a -> Bool #

maximum :: Ord a => Pixel RGBA a -> a #

minimum :: Ord a => Pixel RGBA a -> a #

sum :: Num a => Pixel RGBA a -> a #

product :: Num a => Pixel RGBA a -> a #

Foldable (Pixel RGB) # 

Methods

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

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

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

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

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

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

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

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

toList :: Pixel RGB a -> [a] #

null :: Pixel RGB a -> Bool #

length :: Pixel RGB a -> Int #

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

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

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

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

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

Foldable (Pixel HSIA) # 

Methods

fold :: Monoid m => Pixel HSIA m -> m #

foldMap :: Monoid m => (a -> m) -> Pixel HSIA a -> m #

foldr :: (a -> b -> b) -> b -> Pixel HSIA a -> b #

foldr' :: (a -> b -> b) -> b -> Pixel HSIA a -> b #

foldl :: (b -> a -> b) -> b -> Pixel HSIA a -> b #

foldl' :: (b -> a -> b) -> b -> Pixel HSIA a -> b #

foldr1 :: (a -> a -> a) -> Pixel HSIA a -> a #

foldl1 :: (a -> a -> a) -> Pixel HSIA a -> a #

toList :: Pixel HSIA a -> [a] #

null :: Pixel HSIA a -> Bool #

length :: Pixel HSIA a -> Int #

elem :: Eq a => a -> Pixel HSIA a -> Bool #

maximum :: Ord a => Pixel HSIA a -> a #

minimum :: Ord a => Pixel HSIA a -> a #

sum :: Num a => Pixel HSIA a -> a #

product :: Num a => Pixel HSIA a -> a #

Foldable (Pixel HSI) # 

Methods

fold :: Monoid m => Pixel HSI m -> m #

foldMap :: Monoid m => (a -> m) -> Pixel HSI a -> m #

foldr :: (a -> b -> b) -> b -> Pixel HSI a -> b #

foldr' :: (a -> b -> b) -> b -> Pixel HSI a -> b #

foldl :: (b -> a -> b) -> b -> Pixel HSI a -> b #

foldl' :: (b -> a -> b) -> b -> Pixel HSI a -> b #

foldr1 :: (a -> a -> a) -> Pixel HSI a -> a #

foldl1 :: (a -> a -> a) -> Pixel HSI a -> a #

toList :: Pixel HSI a -> [a] #

null :: Pixel HSI a -> Bool #

length :: Pixel HSI a -> Int #

elem :: Eq a => a -> Pixel HSI a -> Bool #

maximum :: Ord a => Pixel HSI a -> a #

minimum :: Ord a => Pixel HSI a -> a #

sum :: Num a => Pixel HSI a -> a #

product :: Num a => Pixel HSI a -> a #

Foldable (Pixel CMYKA) # 

Methods

fold :: Monoid m => Pixel CMYKA m -> m #

foldMap :: Monoid m => (a -> m) -> Pixel CMYKA a -> m #

foldr :: (a -> b -> b) -> b -> Pixel CMYKA a -> b #

foldr' :: (a -> b -> b) -> b -> Pixel CMYKA a -> b #

foldl :: (b -> a -> b) -> b -> Pixel CMYKA a -> b #

foldl' :: (b -> a -> b) -> b -> Pixel CMYKA a -> b #

foldr1 :: (a -> a -> a) -> Pixel CMYKA a -> a #

foldl1 :: (a -> a -> a) -> Pixel CMYKA a -> a #

toList :: Pixel CMYKA a -> [a] #

null :: Pixel CMYKA a -> Bool #

length :: Pixel CMYKA a -> Int #

elem :: Eq a => a -> Pixel CMYKA a -> Bool #

maximum :: Ord a => Pixel CMYKA a -> a #

minimum :: Ord a => Pixel CMYKA a -> a #

sum :: Num a => Pixel CMYKA a -> a #

product :: Num a => Pixel CMYKA a -> a #

Foldable (Pixel CMYK) # 

Methods

fold :: Monoid m => Pixel CMYK m -> m #

foldMap :: Monoid m => (a -> m) -> Pixel CMYK a -> m #

foldr :: (a -> b -> b) -> b -> Pixel CMYK a -> b #

foldr' :: (a -> b -> b) -> b -> Pixel CMYK a -> b #

foldl :: (b -> a -> b) -> b -> Pixel CMYK a -> b #

foldl' :: (b -> a -> b) -> b -> Pixel CMYK a -> b #

foldr1 :: (a -> a -> a) -> Pixel CMYK a -> a #

foldl1 :: (a -> a -> a) -> Pixel CMYK a -> a #

toList :: Pixel CMYK a -> [a] #

null :: Pixel CMYK a -> Bool #

length :: Pixel CMYK a -> Int #

elem :: Eq a => a -> Pixel CMYK a -> Bool #

maximum :: Ord a => Pixel CMYK a -> a #

minimum :: Ord a => Pixel CMYK a -> a #

sum :: Num a => Pixel CMYK a -> a #

product :: Num a => Pixel CMYK a -> a #

Array arr Binary Bit => Thresholding (Image arr) Pixel arr Source # 

Methods

(.==.) :: (Eq (Pixel cs e), Array arr cs e) => Image arr cs e -> Pixel cs e -> Image arr Binary Bit Source #

(./=.) :: (Eq (Pixel cs e), Array arr cs e) => Image arr cs e -> Pixel cs e -> Image arr Binary Bit Source #

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

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

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

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

(Applicative (Pixel cs), Bounded e) => Bounded (Pixel cs e) Source # 

Methods

minBound :: Pixel cs e #

maxBound :: Pixel cs e #

Eq e => Eq (Pixel YCbCrA e) # 

Methods

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

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

Eq e => Eq (Pixel YCbCr e) # 

Methods

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

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

Eq e => Eq (Pixel YA e) # 

Methods

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

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

Eq e => Eq (Pixel Y e) # 

Methods

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

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

Eq e => Eq (Pixel X e) # 

Methods

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

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

Eq e => Eq (Pixel RGBA e) # 

Methods

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

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

Eq e => Eq (Pixel RGB e) # 

Methods

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

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

Eq e => Eq (Pixel HSIA e) # 

Methods

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

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

Eq e => Eq (Pixel HSI e) # 

Methods

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

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

Eq e => Eq (Pixel CMYKA e) # 

Methods

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

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

Eq e => Eq (Pixel CMYK e) # 

Methods

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

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

Eq (Pixel Binary Bit) # 
Floating e => Floating (Pixel YCbCrA e) # 
Floating e => Floating (Pixel YCbCr e) # 
Floating e => Floating (Pixel YA e) # 

Methods

pi :: Pixel YA e #

exp :: Pixel YA e -> Pixel YA e #

log :: Pixel YA e -> Pixel YA e #

sqrt :: Pixel YA e -> Pixel YA e #

(**) :: Pixel YA e -> Pixel YA e -> Pixel YA e #

logBase :: Pixel YA e -> Pixel YA e -> Pixel YA e #

sin :: Pixel YA e -> Pixel YA e #

cos :: Pixel YA e -> Pixel YA e #

tan :: Pixel YA e -> Pixel YA e #

asin :: Pixel YA e -> Pixel YA e #

acos :: Pixel YA e -> Pixel YA e #

atan :: Pixel YA e -> Pixel YA e #

sinh :: Pixel YA e -> Pixel YA e #

cosh :: Pixel YA e -> Pixel YA e #

tanh :: Pixel YA e -> Pixel YA e #

asinh :: Pixel YA e -> Pixel YA e #

acosh :: Pixel YA e -> Pixel YA e #

atanh :: Pixel YA e -> Pixel YA e #

log1p :: Pixel YA e -> Pixel YA e #

expm1 :: Pixel YA e -> Pixel YA e #

log1pexp :: Pixel YA e -> Pixel YA e #

log1mexp :: Pixel YA e -> Pixel YA e #

Floating e => Floating (Pixel Y e) # 

Methods

pi :: Pixel Y e #

exp :: Pixel Y e -> Pixel Y e #

log :: Pixel Y e -> Pixel Y e #

sqrt :: Pixel Y e -> Pixel Y e #

(**) :: Pixel Y e -> Pixel Y e -> Pixel Y e #

logBase :: Pixel Y e -> Pixel Y e -> Pixel Y e #

sin :: Pixel Y e -> Pixel Y e #

cos :: Pixel Y e -> Pixel Y e #

tan :: Pixel Y e -> Pixel Y e #

asin :: Pixel Y e -> Pixel Y e #

acos :: Pixel Y e -> Pixel Y e #

atan :: Pixel Y e -> Pixel Y e #

sinh :: Pixel Y e -> Pixel Y e #

cosh :: Pixel Y e -> Pixel Y e #

tanh :: Pixel Y e -> Pixel Y e #

asinh :: Pixel Y e -> Pixel Y e #

acosh :: Pixel Y e -> Pixel Y e #

atanh :: Pixel Y e -> Pixel Y e #

log1p :: Pixel Y e -> Pixel Y e #

expm1 :: Pixel Y e -> Pixel Y e #

log1pexp :: Pixel Y e -> Pixel Y e #

log1mexp :: Pixel Y e -> Pixel Y e #

Floating e => Floating (Pixel X e) # 

Methods

pi :: Pixel X e #

exp :: Pixel X e -> Pixel X e #

log :: Pixel X e -> Pixel X e #

sqrt :: Pixel X e -> Pixel X e #

(**) :: Pixel X e -> Pixel X e -> Pixel X e #

logBase :: Pixel X e -> Pixel X e -> Pixel X e #

sin :: Pixel X e -> Pixel X e #

cos :: Pixel X e -> Pixel X e #

tan :: Pixel X e -> Pixel X e #

asin :: Pixel X e -> Pixel X e #

acos :: Pixel X e -> Pixel X e #

atan :: Pixel X e -> Pixel X e #

sinh :: Pixel X e -> Pixel X e #

cosh :: Pixel X e -> Pixel X e #

tanh :: Pixel X e -> Pixel X e #

asinh :: Pixel X e -> Pixel X e #

acosh :: Pixel X e -> Pixel X e #

atanh :: Pixel X e -> Pixel X e #

log1p :: Pixel X e -> Pixel X e #

expm1 :: Pixel X e -> Pixel X e #

log1pexp :: Pixel X e -> Pixel X e #

log1mexp :: Pixel X e -> Pixel X e #

Floating e => Floating (Pixel RGBA e) # 
Floating e => Floating (Pixel RGB e) # 

Methods

pi :: Pixel RGB e #

exp :: Pixel RGB e -> Pixel RGB e #

log :: Pixel RGB e -> Pixel RGB e #

sqrt :: Pixel RGB e -> Pixel RGB e #

(**) :: Pixel RGB e -> Pixel RGB e -> Pixel RGB e #

logBase :: Pixel RGB e -> Pixel RGB e -> Pixel RGB e #

sin :: Pixel RGB e -> Pixel RGB e #

cos :: Pixel RGB e -> Pixel RGB e #

tan :: Pixel RGB e -> Pixel RGB e #

asin :: Pixel RGB e -> Pixel RGB e #

acos :: Pixel RGB e -> Pixel RGB e #

atan :: Pixel RGB e -> Pixel RGB e #

sinh :: Pixel RGB e -> Pixel RGB e #

cosh :: Pixel RGB e -> Pixel RGB e #

tanh :: Pixel RGB e -> Pixel RGB e #

asinh :: Pixel RGB e -> Pixel RGB e #

acosh :: Pixel RGB e -> Pixel RGB e #

atanh :: Pixel RGB e -> Pixel RGB e #

log1p :: Pixel RGB e -> Pixel RGB e #

expm1 :: Pixel RGB e -> Pixel RGB e #

log1pexp :: Pixel RGB e -> Pixel RGB e #

log1mexp :: Pixel RGB e -> Pixel RGB e #

Floating e => Floating (Pixel HSIA e) # 
Floating e => Floating (Pixel HSI e) # 

Methods

pi :: Pixel HSI e #

exp :: Pixel HSI e -> Pixel HSI e #

log :: Pixel HSI e -> Pixel HSI e #

sqrt :: Pixel HSI e -> Pixel HSI e #

(**) :: Pixel HSI e -> Pixel HSI e -> Pixel HSI e #

logBase :: Pixel HSI e -> Pixel HSI e -> Pixel HSI e #

sin :: Pixel HSI e -> Pixel HSI e #

cos :: Pixel HSI e -> Pixel HSI e #

tan :: Pixel HSI e -> Pixel HSI e #

asin :: Pixel HSI e -> Pixel HSI e #

acos :: Pixel HSI e -> Pixel HSI e #

atan :: Pixel HSI e -> Pixel HSI e #

sinh :: Pixel HSI e -> Pixel HSI e #

cosh :: Pixel HSI e -> Pixel HSI e #

tanh :: Pixel HSI e -> Pixel HSI e #

asinh :: Pixel HSI e -> Pixel HSI e #

acosh :: Pixel HSI e -> Pixel HSI e #

atanh :: Pixel HSI e -> Pixel HSI e #

log1p :: Pixel HSI e -> Pixel HSI e #

expm1 :: Pixel HSI e -> Pixel HSI e #

log1pexp :: Pixel HSI e -> Pixel HSI e #

log1mexp :: Pixel HSI e -> Pixel HSI e #

Floating e => Floating (Pixel CMYKA e) # 
Floating e => Floating (Pixel CMYK e) # 
Fractional e => Fractional (Pixel YCbCrA e) # 
Fractional e => Fractional (Pixel YCbCr e) # 
Fractional e => Fractional (Pixel YA e) # 

Methods

(/) :: Pixel YA e -> Pixel YA e -> Pixel YA e #

recip :: Pixel YA e -> Pixel YA e #

fromRational :: Rational -> Pixel YA e #

Fractional e => Fractional (Pixel Y e) # 

Methods

(/) :: Pixel Y e -> Pixel Y e -> Pixel Y e #

recip :: Pixel Y e -> Pixel Y e #

fromRational :: Rational -> Pixel Y e #

Fractional e => Fractional (Pixel X e) # 

Methods

(/) :: Pixel X e -> Pixel X e -> Pixel X e #

recip :: Pixel X e -> Pixel X e #

fromRational :: Rational -> Pixel X e #

Fractional e => Fractional (Pixel RGBA e) # 
Fractional e => Fractional (Pixel RGB e) # 

Methods

(/) :: Pixel RGB e -> Pixel RGB e -> Pixel RGB e #

recip :: Pixel RGB e -> Pixel RGB e #

fromRational :: Rational -> Pixel RGB e #

Fractional e => Fractional (Pixel HSIA e) # 
Fractional e => Fractional (Pixel HSI e) # 

Methods

(/) :: Pixel HSI e -> Pixel HSI e -> Pixel HSI e #

recip :: Pixel HSI e -> Pixel HSI e #

fromRational :: Rational -> Pixel HSI e #

Fractional e => Fractional (Pixel CMYKA e) # 
Fractional e => Fractional (Pixel CMYK e) # 
Num e => Num (Pixel YCbCrA e) # 
Num e => Num (Pixel YCbCr e) # 
Num e => Num (Pixel YA e) # 

Methods

(+) :: Pixel YA e -> Pixel YA e -> Pixel YA e #

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

(*) :: Pixel YA e -> Pixel YA e -> Pixel YA e #

negate :: Pixel YA e -> Pixel YA e #

abs :: Pixel YA e -> Pixel YA e #

signum :: Pixel YA e -> Pixel YA e #

fromInteger :: Integer -> Pixel YA e #

Num e => Num (Pixel Y e) # 

Methods

(+) :: Pixel Y e -> Pixel Y e -> Pixel Y e #

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

(*) :: Pixel Y e -> Pixel Y e -> Pixel Y e #

negate :: Pixel Y e -> Pixel Y e #

abs :: Pixel Y e -> Pixel Y e #

signum :: Pixel Y e -> Pixel Y e #

fromInteger :: Integer -> Pixel Y e #

Num e => Num (Pixel X e) # 

Methods

(+) :: Pixel X e -> Pixel X e -> Pixel X e #

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

(*) :: Pixel X e -> Pixel X e -> Pixel X e #

negate :: Pixel X e -> Pixel X e #

abs :: Pixel X e -> Pixel X e #

signum :: Pixel X e -> Pixel X e #

fromInteger :: Integer -> Pixel X e #

Num e => Num (Pixel RGBA e) # 

Methods

(+) :: Pixel RGBA e -> Pixel RGBA e -> Pixel RGBA e #

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

(*) :: Pixel RGBA e -> Pixel RGBA e -> Pixel RGBA e #

negate :: Pixel RGBA e -> Pixel RGBA e #

abs :: Pixel RGBA e -> Pixel RGBA e #

signum :: Pixel RGBA e -> Pixel RGBA e #

fromInteger :: Integer -> Pixel RGBA e #

Num e => Num (Pixel RGB e) # 

Methods

(+) :: Pixel RGB e -> Pixel RGB e -> Pixel RGB e #

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

(*) :: Pixel RGB e -> Pixel RGB e -> Pixel RGB e #

negate :: Pixel RGB e -> Pixel RGB e #

abs :: Pixel RGB e -> Pixel RGB e #

signum :: Pixel RGB e -> Pixel RGB e #

fromInteger :: Integer -> Pixel RGB e #

Num e => Num (Pixel HSIA e) # 

Methods

(+) :: Pixel HSIA e -> Pixel HSIA e -> Pixel HSIA e #

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

(*) :: Pixel HSIA e -> Pixel HSIA e -> Pixel HSIA e #

negate :: Pixel HSIA e -> Pixel HSIA e #

abs :: Pixel HSIA e -> Pixel HSIA e #

signum :: Pixel HSIA e -> Pixel HSIA e #

fromInteger :: Integer -> Pixel HSIA e #

Num e => Num (Pixel HSI e) # 

Methods

(+) :: Pixel HSI e -> Pixel HSI e -> Pixel HSI e #

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

(*) :: Pixel HSI e -> Pixel HSI e -> Pixel HSI e #

negate :: Pixel HSI e -> Pixel HSI e #

abs :: Pixel HSI e -> Pixel HSI e #

signum :: Pixel HSI e -> Pixel HSI e #

fromInteger :: Integer -> Pixel HSI e #

Num e => Num (Pixel CMYKA e) # 
Num e => Num (Pixel CMYK e) # 

Methods

(+) :: Pixel CMYK e -> Pixel CMYK e -> Pixel CMYK e #

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

(*) :: Pixel CMYK e -> Pixel CMYK e -> Pixel CMYK e #

negate :: Pixel CMYK e -> Pixel CMYK e #

abs :: Pixel CMYK e -> Pixel CMYK e #

signum :: Pixel CMYK e -> Pixel CMYK e #

fromInteger :: Integer -> Pixel CMYK e #

Num (Pixel Binary Bit) # 
Ord e => Ord (Pixel Y e) # 

Methods

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

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

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

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

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

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

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

Ord e => Ord (Pixel X e) # 

Methods

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

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

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

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

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

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

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

Ord (Pixel Binary Bit) # 
Show e => Show (Pixel YCbCrA e) # 
Show e => Show (Pixel YCbCr e) # 

Methods

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

show :: Pixel YCbCr e -> String #

showList :: [Pixel YCbCr e] -> ShowS #

Show e => Show (Pixel Y e) # 

Methods

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

show :: Pixel Y e -> String #

showList :: [Pixel Y e] -> ShowS #

Show e => Show (Pixel X e) # 

Methods

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

show :: Pixel X e -> String #

showList :: [Pixel X e] -> ShowS #

Show e => Show (Pixel RGBA e) # 

Methods

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

show :: Pixel RGBA e -> String #

showList :: [Pixel RGBA e] -> ShowS #

Show e => Show (Pixel RGB e) # 

Methods

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

show :: Pixel RGB e -> String #

showList :: [Pixel RGB e] -> ShowS #

Show e => Show (Pixel HSIA e) # 

Methods

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

show :: Pixel HSIA e -> String #

showList :: [Pixel HSIA e] -> ShowS #

Show e => Show (Pixel HSI e) # 

Methods

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

show :: Pixel HSI e -> String #

showList :: [Pixel HSI e] -> ShowS #

Show e => Show (Pixel CMYKA e) # 

Methods

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

show :: Pixel CMYKA e -> String #

showList :: [Pixel CMYKA e] -> ShowS #

Show e => Show (Pixel CMYK e) # 

Methods

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

show :: Pixel CMYK e -> String #

showList :: [Pixel CMYK e] -> ShowS #

Show (Pixel Binary Bit) # 
Storable e => Storable (Pixel YCbCrA e) # 

Methods

sizeOf :: Pixel YCbCrA e -> Int #

alignment :: Pixel YCbCrA e -> Int #

peekElemOff :: Ptr (Pixel YCbCrA e) -> Int -> IO (Pixel YCbCrA e) #

pokeElemOff :: Ptr (Pixel YCbCrA e) -> Int -> Pixel YCbCrA e -> IO () #

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

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

peek :: Ptr (Pixel YCbCrA e) -> IO (Pixel YCbCrA e) #

poke :: Ptr (Pixel YCbCrA e) -> Pixel YCbCrA e -> IO () #

Storable e => Storable (Pixel YCbCr e) # 

Methods

sizeOf :: Pixel YCbCr e -> Int #

alignment :: Pixel YCbCr e -> Int #

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

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

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

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

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

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

Storable e => Storable (Pixel YA e) # 

Methods

sizeOf :: Pixel YA e -> Int #

alignment :: Pixel YA e -> Int #

peekElemOff :: Ptr (Pixel YA e) -> Int -> IO (Pixel YA e) #

pokeElemOff :: Ptr (Pixel YA e) -> Int -> Pixel YA e -> IO () #

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

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

peek :: Ptr (Pixel YA e) -> IO (Pixel YA e) #

poke :: Ptr (Pixel YA e) -> Pixel YA e -> IO () #

Storable e => Storable (Pixel Y e) # 

Methods

sizeOf :: Pixel Y e -> Int #

alignment :: Pixel Y e -> Int #

peekElemOff :: Ptr (Pixel Y e) -> Int -> IO (Pixel Y e) #

pokeElemOff :: Ptr (Pixel Y e) -> Int -> Pixel Y e -> IO () #

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

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

peek :: Ptr (Pixel Y e) -> IO (Pixel Y e) #

poke :: Ptr (Pixel Y e) -> Pixel Y e -> IO () #

Storable e => Storable (Pixel X e) # 

Methods

sizeOf :: Pixel X e -> Int #

alignment :: Pixel X e -> Int #

peekElemOff :: Ptr (Pixel X e) -> Int -> IO (Pixel X e) #

pokeElemOff :: Ptr (Pixel X e) -> Int -> Pixel X e -> IO () #

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

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

peek :: Ptr (Pixel X e) -> IO (Pixel X e) #

poke :: Ptr (Pixel X e) -> Pixel X e -> IO () #

Storable e => Storable (Pixel RGBA e) # 

Methods

sizeOf :: Pixel RGBA e -> Int #

alignment :: Pixel RGBA e -> Int #

peekElemOff :: Ptr (Pixel RGBA e) -> Int -> IO (Pixel RGBA e) #

pokeElemOff :: Ptr (Pixel RGBA e) -> Int -> Pixel RGBA e -> IO () #

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

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

peek :: Ptr (Pixel RGBA e) -> IO (Pixel RGBA e) #

poke :: Ptr (Pixel RGBA e) -> Pixel RGBA e -> IO () #

Storable e => Storable (Pixel RGB e) # 

Methods

sizeOf :: Pixel RGB e -> Int #

alignment :: Pixel RGB e -> Int #

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

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

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

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

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

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

Storable e => Storable (Pixel HSIA e) # 

Methods

sizeOf :: Pixel HSIA e -> Int #

alignment :: Pixel HSIA e -> Int #

peekElemOff :: Ptr (Pixel HSIA e) -> Int -> IO (Pixel HSIA e) #

pokeElemOff :: Ptr (Pixel HSIA e) -> Int -> Pixel HSIA e -> IO () #

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

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

peek :: Ptr (Pixel HSIA e) -> IO (Pixel HSIA e) #

poke :: Ptr (Pixel HSIA e) -> Pixel HSIA e -> IO () #

Storable e => Storable (Pixel HSI e) # 

Methods

sizeOf :: Pixel HSI e -> Int #

alignment :: Pixel HSI e -> Int #

peekElemOff :: Ptr (Pixel HSI e) -> Int -> IO (Pixel HSI e) #

pokeElemOff :: Ptr (Pixel HSI e) -> Int -> Pixel HSI e -> IO () #

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

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

peek :: Ptr (Pixel HSI e) -> IO (Pixel HSI e) #

poke :: Ptr (Pixel HSI e) -> Pixel HSI e -> IO () #

Storable e => Storable (Pixel CMYKA e) # 

Methods

sizeOf :: Pixel CMYKA e -> Int #

alignment :: Pixel CMYKA e -> Int #

peekElemOff :: Ptr (Pixel CMYKA e) -> Int -> IO (Pixel CMYKA e) #

pokeElemOff :: Ptr (Pixel CMYKA e) -> Int -> Pixel CMYKA e -> IO () #

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

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

peek :: Ptr (Pixel CMYKA e) -> IO (Pixel CMYKA e) #

poke :: Ptr (Pixel CMYKA e) -> Pixel CMYKA e -> IO () #

Storable e => Storable (Pixel CMYK e) # 

Methods

sizeOf :: Pixel CMYK e -> Int #

alignment :: Pixel CMYK e -> Int #

peekElemOff :: Ptr (Pixel CMYK e) -> Int -> IO (Pixel CMYK e) #

pokeElemOff :: Ptr (Pixel CMYK e) -> Int -> Pixel CMYK e -> IO () #

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

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

peek :: Ptr (Pixel CMYK e) -> IO (Pixel CMYK e) #

poke :: Ptr (Pixel CMYK e) -> Pixel CMYK e -> IO () #

Storable (Pixel Binary Bit) # 
Bits (Pixel Binary Bit) # 
(Foldable (Pixel cs), NFData e) => NFData (Pixel cs e) Source # 

Methods

rnf :: Pixel cs e -> () #

data Pixel YCbCrA Source # 
data Pixel YCbCrA = PixelYCbCrA !e !e !e !e
data Pixel YCbCr Source # 
data Pixel YCbCr = PixelYCbCr !e !e !e
data Pixel YA Source # 
data Pixel YA = PixelYA !e !e
data Pixel Y Source # 
data Pixel Y = PixelY !e
data Pixel X Source # 
data Pixel X = PixelX !e
data Pixel RGBA Source # 
data Pixel RGBA = PixelRGBA !e !e !e !e
data Pixel RGB Source # 
data Pixel RGB = PixelRGB !e !e !e
data Pixel HSIA Source # 
data Pixel HSIA = PixelHSIA !e !e !e !e
data Pixel HSI Source # 
data Pixel HSI = PixelHSI !e !e !e
data Pixel CMYKA Source # 
data Pixel CMYKA = PixelCMYKA !e !e !e !e !e
data Pixel CMYK Source # 
data Pixel CMYK = PixelCMYK !e !e !e !e
data Pixel Binary Bit Source # 
data MVector s (Pixel cs e) # 
data MVector s (Pixel cs e) = MV_Pixel (MVector s (Components cs e))
data Vector (Pixel cs e) # 
data Vector (Pixel cs e) = V_Pixel (Vector (Components cs e))

class (Eq cs, Enum cs, Show cs, Bounded cs, Typeable cs, Elevator e, Typeable e) => ColorSpace cs e where Source #

Minimal complete definition

toComponents, fromComponents, promote, getPxC, setPxC, mapPxC, liftPx, liftPx2, foldlPx2

Associated Types

type Components cs e Source #

Methods

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

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

Convert from an elemnt representation back to a Pixel.

promote :: e -> Pixel cs e Source #

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

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

Retrieve Pixel's component value

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

Set Pixel's component value

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

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

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

Map a function over all Pixel's componenets.

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

Zip two Pixels with a function.

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

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

Right fold over all Pixel's components.

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

Left strict fold over all Pixel's components.

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

toListPx :: Pixel cs e -> [e] Source #

Instances

(Elevator e, Typeable * e) => ColorSpace YCbCrA e Source # 

Associated Types

type Components YCbCrA e :: * Source #

Methods

toComponents :: Pixel YCbCrA e -> Components YCbCrA e Source #

fromComponents :: Components YCbCrA e -> Pixel YCbCrA e Source #

promote :: e -> Pixel YCbCrA e Source #

getPxC :: Pixel YCbCrA e -> YCbCrA -> e Source #

setPxC :: Pixel YCbCrA e -> YCbCrA -> e -> Pixel YCbCrA e Source #

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

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

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

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

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

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

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

toListPx :: Pixel YCbCrA e -> [e] Source #

(Elevator e, Typeable * e) => ColorSpace YCbCr e Source # 

Associated Types

type Components YCbCr e :: * Source #

Methods

toComponents :: Pixel YCbCr e -> Components YCbCr e Source #

fromComponents :: Components YCbCr e -> Pixel YCbCr e Source #

promote :: e -> Pixel YCbCr e Source #

getPxC :: Pixel YCbCr e -> YCbCr -> e Source #

setPxC :: Pixel YCbCr e -> YCbCr -> e -> Pixel YCbCr e Source #

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

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

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

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

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

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

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

toListPx :: Pixel YCbCr e -> [e] Source #

(Elevator e, Typeable * e) => ColorSpace YA e Source # 

Associated Types

type Components YA e :: * Source #

Methods

toComponents :: Pixel YA e -> Components YA e Source #

fromComponents :: Components YA e -> Pixel YA e Source #

promote :: e -> Pixel YA e Source #

getPxC :: Pixel YA e -> YA -> e Source #

setPxC :: Pixel YA e -> YA -> e -> Pixel YA e Source #

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

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

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

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

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

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

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

toListPx :: Pixel YA e -> [e] Source #

(Elevator e, Typeable * e) => ColorSpace Y e Source # 

Associated Types

type Components Y e :: * Source #

Methods

toComponents :: Pixel Y e -> Components Y e Source #

fromComponents :: Components Y e -> Pixel Y e Source #

promote :: e -> Pixel Y e Source #

getPxC :: Pixel Y e -> Y -> e Source #

setPxC :: Pixel Y e -> Y -> e -> Pixel Y e Source #

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

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

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

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

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

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

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

toListPx :: Pixel Y e -> [e] Source #

(Elevator e, Typeable * e) => ColorSpace X e Source # 

Associated Types

type Components X e :: * Source #

Methods

toComponents :: Pixel X e -> Components X e Source #

fromComponents :: Components X e -> Pixel X e Source #

promote :: e -> Pixel X e Source #

getPxC :: Pixel X e -> X -> e Source #

setPxC :: Pixel X e -> X -> e -> Pixel X e Source #

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

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

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

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

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

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

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

toListPx :: Pixel X e -> [e] Source #

(Elevator e, Typeable * e) => ColorSpace RGBA e Source # 

Associated Types

type Components RGBA e :: * Source #

Methods

toComponents :: Pixel RGBA e -> Components RGBA e Source #

fromComponents :: Components RGBA e -> Pixel RGBA e Source #

promote :: e -> Pixel RGBA e Source #

getPxC :: Pixel RGBA e -> RGBA -> e Source #

setPxC :: Pixel RGBA e -> RGBA -> e -> Pixel RGBA e Source #

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

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

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

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

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

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

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

toListPx :: Pixel RGBA e -> [e] Source #

(Elevator e, Typeable * e) => ColorSpace RGB e Source # 

Associated Types

type Components RGB e :: * Source #

Methods

toComponents :: Pixel RGB e -> Components RGB e Source #

fromComponents :: Components RGB e -> Pixel RGB e Source #

promote :: e -> Pixel RGB e Source #

getPxC :: Pixel RGB e -> RGB -> e Source #

setPxC :: Pixel RGB e -> RGB -> e -> Pixel RGB e Source #

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

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

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

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

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

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

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

toListPx :: Pixel RGB e -> [e] Source #

(Elevator e, Typeable * e) => ColorSpace HSIA e Source # 

Associated Types

type Components HSIA e :: * Source #

Methods

toComponents :: Pixel HSIA e -> Components HSIA e Source #

fromComponents :: Components HSIA e -> Pixel HSIA e Source #

promote :: e -> Pixel HSIA e Source #

getPxC :: Pixel HSIA e -> HSIA -> e Source #

setPxC :: Pixel HSIA e -> HSIA -> e -> Pixel HSIA e Source #

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

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

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

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

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

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

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

toListPx :: Pixel HSIA e -> [e] Source #

(Elevator e, Typeable * e) => ColorSpace HSI e Source # 

Associated Types

type Components HSI e :: * Source #

Methods

toComponents :: Pixel HSI e -> Components HSI e Source #

fromComponents :: Components HSI e -> Pixel HSI e Source #

promote :: e -> Pixel HSI e Source #

getPxC :: Pixel HSI e -> HSI -> e Source #

setPxC :: Pixel HSI e -> HSI -> e -> Pixel HSI e Source #

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

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

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

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

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

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

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

toListPx :: Pixel HSI e -> [e] Source #

(Elevator e, Typeable * e) => ColorSpace CMYKA e Source # 

Associated Types

type Components CMYKA e :: * Source #

Methods

toComponents :: Pixel CMYKA e -> Components CMYKA e Source #

fromComponents :: Components CMYKA e -> Pixel CMYKA e Source #

promote :: e -> Pixel CMYKA e Source #

getPxC :: Pixel CMYKA e -> CMYKA -> e Source #

setPxC :: Pixel CMYKA e -> CMYKA -> e -> Pixel CMYKA e Source #

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

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

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

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

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

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

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

toListPx :: Pixel CMYKA e -> [e] Source #

(Elevator e, Typeable * e) => ColorSpace CMYK e Source # 

Associated Types

type Components CMYK e :: * Source #

Methods

toComponents :: Pixel CMYK e -> Components CMYK e Source #

fromComponents :: Components CMYK e -> Pixel CMYK e Source #

promote :: e -> Pixel CMYK e Source #

getPxC :: Pixel CMYK e -> CMYK -> e Source #

setPxC :: Pixel CMYK e -> CMYK -> e -> Pixel CMYK e Source #

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

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

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

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

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

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

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

toListPx :: Pixel CMYK e -> [e] Source #

ColorSpace Binary Bit Source # 

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

A color space that supports transparency.

Minimal complete definition

getAlpha, addAlpha, dropAlpha

Associated Types

type Opaque cs Source #

A corresponding opaque version of this color space.

Methods

getAlpha :: Pixel cs e -> e Source #

Get an alpha channel of a transparant pixel.

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

Add an alpha channel of an opaque pixel.

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

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

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, Typeable * e) => AlphaSpace YCbCrA e Source # 

Associated Types

type Opaque YCbCrA :: * Source #

Methods

getAlpha :: Pixel YCbCrA e -> e Source #

addAlpha :: e -> Pixel (Opaque YCbCrA) e -> Pixel YCbCrA e Source #

dropAlpha :: Pixel YCbCrA e -> Pixel (Opaque YCbCrA) e Source #

(Elevator e, Typeable * e) => AlphaSpace YA e Source # 

Associated Types

type Opaque YA :: * Source #

Methods

getAlpha :: Pixel YA e -> e Source #

addAlpha :: e -> Pixel (Opaque YA) e -> Pixel YA e Source #

dropAlpha :: Pixel YA e -> Pixel (Opaque YA) e Source #

(Elevator e, Typeable * e) => AlphaSpace RGBA e Source # 

Associated Types

type Opaque RGBA :: * Source #

Methods

getAlpha :: Pixel RGBA e -> e Source #

addAlpha :: e -> Pixel (Opaque RGBA) e -> Pixel RGBA e Source #

dropAlpha :: Pixel RGBA e -> Pixel (Opaque RGBA) e Source #

(Elevator e, Typeable * e) => AlphaSpace HSIA e Source # 

Associated Types

type Opaque HSIA :: * Source #

Methods

getAlpha :: Pixel HSIA e -> e Source #

addAlpha :: e -> Pixel (Opaque HSIA) e -> Pixel HSIA e Source #

dropAlpha :: Pixel HSIA e -> Pixel (Opaque HSIA) e Source #

(Elevator e, Typeable * e) => AlphaSpace CMYKA e Source # 

Associated Types

type Opaque CMYKA :: * Source #

Methods

getAlpha :: Pixel CMYKA e -> e Source #

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

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

class Elevator e where Source #

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

Minimal complete definition

toWord8, toWord16, toWord32, toWord64, toFloat, toDouble, fromDouble

Methods

toWord8 :: e -> Word8 Source #

Values are scaled to [0, 255] range.

toWord16 :: e -> Word16 Source #

Values are scaled to [0, 65535] range.

toWord32 :: e -> Word32 Source #

Values are scaled to [0, 4294967295] range.

toWord64 :: e -> Word64 Source #

Values are scaled to [0, 18446744073709551615] range.

toFloat :: e -> Float Source #

Values are scaled to [0.0, 1.0] range.

toDouble :: e -> Double Source #

Values are scaled to [0.0, 1.0] range.

fromDouble :: Double -> e Source #

Values are scaled from [0.0, 1.0] range.

Instances

class (Show arr, ColorSpace cs e, Num (Pixel cs e), SuperClass arr cs e) => BaseArray arr cs e where Source #

Base array like representation for an image.

Minimal complete definition

dims

Associated Types

type SuperClass arr cs e :: Constraint Source #

Required array specific constraints for an array element.

data Image arr cs e Source #

Underlying image representation.

Methods

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

Get dimensions of an image.

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

Instances

SuperClass VS cs e => BaseArray VS cs e Source # 

Associated Types

type SuperClass VS cs e :: Constraint Source #

data Image VS cs e :: * Source #

Methods

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

SuperClass VU cs e => BaseArray VU cs e Source # 

Associated Types

type SuperClass VU cs e :: Constraint Source #

data Image VU cs e :: * Source #

Methods

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

SuperClass RPS cs e => BaseArray RPS cs e Source # 

Associated Types

type SuperClass RPS cs e :: Constraint Source #

data Image RPS cs e :: * Source #

Methods

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

SuperClass RSS cs e => BaseArray RSS cs e Source # 

Associated Types

type SuperClass RSS cs e :: Constraint Source #

data Image RSS cs e :: * Source #

Methods

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

SuperClass RPU cs e => BaseArray RPU cs e Source # 

Associated Types

type SuperClass RPU cs e :: Constraint Source #

data Image RPU cs e :: * Source #

Methods

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

SuperClass RSU cs e => BaseArray RSU cs e Source # 

Associated Types

type SuperClass RSU cs e :: Constraint Source #

data Image RSU cs e :: * Source #

Methods

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

class (MArray (Manifest arr) cs e, BaseArray arr cs e) => Array arr cs e where Source #

Minimal complete definition

makeImage, makeImageWindowed, scalar, index00, map, imap, zipWith, izipWith, traverse, traverse2, transpose, backpermute, fromLists, (|*|), fold, foldIx, eq, compute, toManifest

Associated Types

type Manifest arr :: * Source #

Methods

makeImage :: (Int, Int) -> ((Int, Int) -> Pixel cs e) -> Image arr cs e Source #

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

makeImageWindowed :: (Int, Int) -> ((Int, Int), (Int, Int)) -> ((Int, Int) -> Pixel cs e) -> ((Int, Int) -> Pixel cs e) -> Image arr cs e Source #

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

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

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

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

map :: Array arr cs' e' => (Pixel cs' e' -> Pixel cs e) -> Image arr cs' e' -> Image arr cs e Source #

Map a function over a an image.

imap :: Array arr cs' e' => ((Int, Int) -> Pixel cs' e' -> Pixel cs e) -> Image arr cs' e' -> Image arr cs e Source #

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

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

Zip two images with an index aware function

traverse :: Array arr cs' e' => Image arr cs' e' -> ((Int, Int) -> (Int, Int)) -> (((Int, Int) -> Pixel cs' e') -> (Int, Int) -> Pixel cs e) -> Image arr cs e Source #

Traverse an image

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

Traverse two images.

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

Transpose an image

backpermute :: (Int, Int) -> ((Int, Int) -> (Int, Int)) -> Image arr cs e -> Image arr cs e Source #

Backwards permutation of an image.

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

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

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

fold :: (Pixel cs e -> Pixel cs e -> Pixel cs e) -> Pixel cs e -> Image arr cs e -> Pixel cs e Source #

Undirected reduction of an image.

foldIx :: (Pixel cs e -> (Int, Int) -> Pixel cs e -> Pixel cs e) -> Pixel cs e -> Image arr cs e -> Pixel cs e Source #

Undirected reduction of an image with an index aware function.

eq :: Eq (Pixel cs e) => Image arr cs e -> Image arr cs e -> Bool Source #

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

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

Instances

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

Associated Types

type Manifest VS :: * Source #

Methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Associated Types

type Manifest VU :: * Source #

Methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

BaseArray RPS cs e => Array RPS cs e Source # 

Associated Types

type Manifest RPS :: * Source #

Methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

BaseArray RSS cs e => Array RSS cs e Source # 

Associated Types

type Manifest RSS :: * Source #

Methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

BaseArray RPU cs e => Array RPU cs e Source # 

Associated Types

type Manifest RPU :: * Source #

Methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

BaseArray RSU cs e => Array RSU cs e Source # 

Associated Types

type Manifest RSU :: * Source #

Methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Minimal complete definition

unsafeIndex, deepSeqImage, foldl, foldr, makeImageM, mapM, mapM_, foldM, foldM_, mdims, thaw, freeze, new, read, write, swap

Associated Types

data MImage s arr cs e Source #

Methods

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

index :: Image arr cs e -> (Int, Int) -> Pixel cs e Source #

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

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

Make sure that an image is fully evaluated.

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

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

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

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

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

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

Monading mapping over an image.

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

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

Monadic folding.

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

Monadic folding. Result is discarded.

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

Get dimensions of a mutable image.

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

Yield a mutable copy of an image.

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

Yield an immutable copy of an image.

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

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

Yield the pixel at a given location.

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

Set a pixel at a given location.

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

Swap pixels at given locations.

Instances

BaseArray VS cs e => MArray VS cs e Source # 

Associated Types

data MImage s VS cs e :: * Source #

Methods

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

index :: Image VS cs e -> (Int, Int) -> Pixel cs e Source #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

BaseArray VU cs e => MArray VU cs e Source # 

Associated Types

data MImage s VU cs e :: * Source #

Methods

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

index :: Image VU cs e -> (Int, Int) -> Pixel cs e Source #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class Exchangable arr' arr where Source #

Allows for changing an underlying image representation.

Minimal complete definition

exchange

Methods

exchange :: (Array arr' cs e, Array arr cs e) => arr -> Image arr' cs e -> Image arr cs e Source #

Exchange the underlying array representation of an image.

Instances

Exchangable arr arr Source #

Changing to the same array representation as before is disabled and exchange will behave simply as an identitity function.

Methods

exchange :: (Array arr cs e, Array arr cs e) => arr -> Image arr cs e -> Image arr cs e Source #

Exchangable VS RPS Source #

O(1) - Changes to Repa representation.

Methods

exchange :: (Array VS cs e, Array RPS cs e) => RPS -> Image VS cs e -> Image RPS cs e Source #

Exchangable VS RSS Source #

O(1) - Changes to Repa representation.

Methods

exchange :: (Array VS cs e, Array RSS cs e) => RSS -> Image VS cs e -> Image RSS cs e Source #

Exchangable VU RPU Source #

O(1) - Changes to Repa representation.

Methods

exchange :: (Array VU cs e, Array RPU cs e) => RPU -> Image VU cs e -> Image RPU cs e Source #

Exchangable VU RSU Source #

O(1) - Changes to Repa representation.

Methods

exchange :: (Array VU cs e, Array RSU cs e) => RSU -> Image VU cs e -> Image RSU cs e Source #

Exchangable RPS VS Source #

Changes to Vector representation.

Methods

exchange :: (Array RPS cs e, Array VS cs e) => VS -> Image RPS cs e -> Image VS cs e Source #

Exchangable RPS RSS Source #

Changes computation strategy. Will casue all fused operations to be computed.

Methods

exchange :: (Array RPS cs e, Array RSS cs e) => RSS -> Image RPS cs e -> Image RSS cs e Source #

Exchangable RSS VS Source #

Changes to Vector representation.

Methods

exchange :: (Array RSS cs e, Array VS cs e) => VS -> Image RSS cs e -> Image VS cs e Source #

Exchangable RSS RPS Source #

Changes computation strategy. Will casue all fused operations to be computed.

Methods

exchange :: (Array RSS cs e, Array RPS cs e) => RPS -> Image RSS cs e -> Image RPS cs e Source #

Exchangable RPU VU Source #

Changes to Vector representation.

Methods

exchange :: (Array RPU cs e, Array VU cs e) => VU -> Image RPU cs e -> Image VU cs e Source #

Exchangable RPU RSU Source #

Changes computation strategy. Will casue all fused operations to be computed.

Methods

exchange :: (Array RPU cs e, Array RSU cs e) => RSU -> Image RPU cs e -> Image RSU cs e Source #

Exchangable RSU VU Source #

Changes to Vector representation.

Methods

exchange :: (Array RSU cs e, Array VU cs e) => VU -> Image RSU cs e -> Image VU cs e Source #

Exchangable RSU RPU Source #

Changes computation strategy. Will casue all fused operations to be computed.

Methods

exchange :: (Array RSU cs e, Array RPU cs e) => RPU -> Image RSU cs e -> Image RPU cs e Source #

exchangeFrom Source #

Arguments

:: (Exchangable arr' arr, Array arr' cs e, Array arr cs e) 
=> arr' 
-> arr

New representation of an image.

-> Image arr' cs e

Source image.

-> Image arr cs e 

exchange function that allows restricting representation type of the source image.

exchangeThrough Source #

Arguments

:: (Exchangable arr2 arr1, Exchangable arr1 arr, Array arr2 cs e, Array arr1 cs e, Array arr cs e) 
=> arr1 
-> arr

New representation of an image.

-> Image arr2 cs e

Source image.

-> Image arr cs e 

exchange an image representation through an intermediate one.

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

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

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

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

data Border px Source #

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

Methods

showsPrec :: Int -> Border px -> ShowS #

show :: Border px -> String #

showList :: [Border px] -> ShowS #

handleBorderIndex Source #

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.

fromIx Source #

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

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