Graphics.Image.Types

Documentation

module Graphics.Image.ColorSpace

module Graphics.Image.IO.Formats

class (Show arr, ColorSpace cs, Num (Pixel cs e), Functor (Pixel cs), Applicative (Pixel cs), Foldable (Pixel cs), Num e, Typeable e, Elt arr cs e) => Array arr cs e

Base array like representation for an image.

Minimal complete definition

makeImage, singleton, dims, map, imap, zipWith, izipWith, traverse, traverse2, transpose, backpermute, fromLists

Associated Types

data Image arr cs e

Underlying image representation.

Instances

Elt VU cs e => Array VU cs e

Associated Types

type Elt VU cs e :: Constraint

data Image VU cs e :: *

Methods

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

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

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

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

Elt RS cs e => Array RS cs e

Associated Types

type Elt RS cs e :: Constraint

data Image RS cs e :: *

Methods

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

singleton :: Pixel cs e -> Image RS cs e

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

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

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

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

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

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

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

transpose :: Image RS cs e -> Image RS cs e

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

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

Elt RP cs e => Array RP cs e

Associated Types

type Elt RP cs e :: Constraint

data Image RP cs e :: *

Methods

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

singleton :: Pixel cs e -> Image RP cs e

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

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

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

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

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

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

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

transpose :: Image RP cs e -> Image RP cs e

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

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

Elt RD cs e => Array RD cs e

Associated Types

type Elt RD cs e :: Constraint

data Image RD cs e :: *

Methods

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

singleton :: Pixel cs e -> Image RD cs e

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

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

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

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

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

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

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

transpose :: Image RD cs e -> Image RD cs e

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

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

class Array arr cs e => ManifestArray arr cs e

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

index, deepSeqImage, (|*|), fold, eq

Instances

Array VU cs e => ManifestArray VU cs e

Methods

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

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

(|*|) :: 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

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

Array RS cs e => ManifestArray RS cs e

Methods

index :: Image RS cs e -> (Int, Int) -> Pixel cs e

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

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

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

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

Array RP cs e => ManifestArray RP cs e

Methods

index :: Image RP cs e -> (Int, Int) -> Pixel cs e

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

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

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

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

class ManifestArray arr cs e => SequentialArray arr cs e

Array representation that allows computation, which depends on some specific order, consequently making it possible to be computed only sequentially.

Minimal complete definition

foldl, foldr, mapM, mapM_, foldM, foldM_

Instances

ManifestArray VU cs e => SequentialArray VU cs e

Methods

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

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

mapM :: (SequentialArray 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 ()

ManifestArray RS cs e => SequentialArray RS cs e

Methods

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

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

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

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

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

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

class ManifestArray arr cs e => MutableArray arr cs e

Array representation that supports mutation.

Minimal complete definition

mdims, thaw, freeze, new, read, write, swap

Associated Types

data MImage st arr cs e

Instances

ManifestArray VU cs e => MutableArray VU cs e

Associated Types

data MImage st VU cs e :: *

Methods

mdims :: MImage st 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 ()

ManifestArray RS cs e => MutableArray RS cs e

Associated Types

data MImage st RS cs e :: *

Methods

mdims :: MImage st RS cs e -> (Int, Int)

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

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

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

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

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

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

class Exchangable arr' arr

Allows for changing an underlying image representation.

Minimal complete definition

exchange

Instances

Exchangable arr arr

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

Exchangable VU RS

O(1) - Changes to Repa representation.

Methods

exchange :: (Array VU cs e, Array RS cs e) => RS -> Image VU cs e -> Image RS cs e

Exchangable VU RP

O(1) - Changes to Repa representation.

Methods

exchange :: (Array VU cs e, Array RP cs e) => RP -> Image VU cs e -> Image RP cs e

Exchangable RS VU

O(1) - Changes to Vector representation.

Methods

exchange :: (Array RS cs e, Array VU cs e) => VU -> Image RS cs e -> Image VU cs e

Exchangable RS RP

O(1) - Changes computation strategy.

Methods

exchange :: (Array RS cs e, Array RP cs e) => RP -> Image RS cs e -> Image RP cs e

Exchangable RS RD

O(1) - Delays manifest array.

Methods

exchange :: (Array RS cs e, Array RD cs e) => RD -> Image RS cs e -> Image RD cs e

Exchangable RP VU

O(1) - Changes to Vector representation.

Methods

exchange :: (Array RP cs e, Array VU cs e) => VU -> Image RP cs e -> Image VU cs e

Exchangable RP RS

O(1) - Changes computation strategy.

Methods

exchange :: (Array RP cs e, Array RS cs e) => RS -> Image RP cs e -> Image RS cs e

Exchangable RP RD

O(1) - Delays manifest array.

Methods

exchange :: (Array RP cs e, Array RD cs e) => RD -> Image RP cs e -> Image RD cs e

Exchangable RD RS

Computes delayed array sequentially.

Methods

exchange :: (Array RD cs e, Array RS cs e) => RS -> Image RD cs e -> Image RS cs e

Exchangable RD RP

Computes delayed array in parallel.

Methods

exchange :: (Array RD cs e, Array RP cs e) => RP -> Image RD cs e -> Image RP cs e

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

data VU

Unboxed Vector representation.

Constructors

VU

Instances

Show VU

Methods

showsPrec :: Int -> VU -> ShowS

show :: VU -> String

showList :: [VU] -> ShowS

Exchangable VU RS

O(1) - Changes to Repa representation.

Methods

exchange :: (Array VU cs e, Array RS cs e) => RS -> Image VU cs e -> Image RS cs e

Exchangable VU RP

O(1) - Changes to Repa representation.

Methods

exchange :: (Array VU cs e, Array RP cs e) => RP -> Image VU cs e -> Image RP cs e

Exchangable RS VU

O(1) - Changes to Vector representation.

Methods

exchange :: (Array RS cs e, Array VU cs e) => VU -> Image RS cs e -> Image VU cs e

Exchangable RP VU

O(1) - Changes to Vector representation.

Methods

exchange :: (Array RP cs e, Array VU cs e) => VU -> Image RP cs e -> Image VU cs e

ManifestArray VU cs e => MutableArray VU cs e

Associated Types

data MImage st VU cs e :: *

Methods

mdims :: MImage st 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 ()

ManifestArray VU cs e => SequentialArray VU cs e

Methods

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

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

mapM :: (SequentialArray 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 ()

Array VU cs e => ManifestArray VU cs e

Methods

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

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

(|*|) :: 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

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

Elt VU cs e => Array VU cs e

Associated Types

type Elt VU cs e :: Constraint

data Image VU cs e :: *

Methods

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

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

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

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

data Image VU

data Image VU

• = VScalar !(Pixel cs e)
• | VUImage !Int !Int !(Vector (Pixel cs e))

data MImage st VU

data MImage st VU

• = MVImage !Int !Int (MVector st (Pixel cs e))
• | MVScalar (MVector st (Pixel cs e))

type Elt VU cs e

type Elt VU cs e = (ColorSpace cs, Num e, Unbox e, Typeable * e, Unbox (PixelElt cs e), Unbox (Pixel cs e))

data RD

Repa Delayed Array representation, which allows for fusion of computation.

Constructors

RD

Instances

Show RD

Methods

showsPrec :: Int -> RD -> ShowS

show :: RD -> String

showList :: [RD] -> ShowS

Exchangable RS RD

O(1) - Delays manifest array.

Methods

exchange :: (Array RS cs e, Array RD cs e) => RD -> Image RS cs e -> Image RD cs e

Exchangable RP RD

O(1) - Delays manifest array.

Methods

exchange :: (Array RP cs e, Array RD cs e) => RD -> Image RP cs e -> Image RD cs e

Exchangable RD RS

Computes delayed array sequentially.

Methods

exchange :: (Array RD cs e, Array RS cs e) => RS -> Image RD cs e -> Image RS cs e

Exchangable RD RP

Computes delayed array in parallel.

Methods

exchange :: (Array RD cs e, Array RP cs e) => RP -> Image RD cs e -> Image RP cs e

Elt RD cs e => Array RD cs e

Associated Types

type Elt RD cs e :: Constraint

data Image RD cs e :: *

Methods

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

singleton :: Pixel cs e -> Image RD cs e

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

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

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

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

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

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

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

transpose :: Image RD cs e -> Image RD cs e

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

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

data Image RD

data Image RD

• = RScalar !(Pixel cs e)
• | RUImage !(Array U DIM2 (Pixel cs e))
• | RDImage !(Array D DIM2 (Pixel cs e))

type Elt RD cs e

type Elt RD cs e = (ColorSpace cs, Num e, Typeable * e, Elt e, Unbox e, Elt (PixelElt cs e), Unbox (PixelElt cs e), Elt (Pixel cs e), Unbox (Pixel cs e))

data RS

Repa Unboxed Array representation, which is computed sequentially.

Constructors

RS

Instances

Show RS

Methods

showsPrec :: Int -> RS -> ShowS

show :: RS -> String

showList :: [RS] -> ShowS

Exchangable VU RS

O(1) - Changes to Repa representation.

Methods

exchange :: (Array VU cs e, Array RS cs e) => RS -> Image VU cs e -> Image RS cs e

Exchangable RS VU

O(1) - Changes to Vector representation.

Methods

exchange :: (Array RS cs e, Array VU cs e) => VU -> Image RS cs e -> Image VU cs e

Exchangable RS RP

O(1) - Changes computation strategy.

Methods

exchange :: (Array RS cs e, Array RP cs e) => RP -> Image RS cs e -> Image RP cs e

Exchangable RS RD

O(1) - Delays manifest array.

Methods

exchange :: (Array RS cs e, Array RD cs e) => RD -> Image RS cs e -> Image RD cs e

Exchangable RP RS

O(1) - Changes computation strategy.

Methods

exchange :: (Array RP cs e, Array RS cs e) => RS -> Image RP cs e -> Image RS cs e

Exchangable RD RS

Computes delayed array sequentially.

Methods

exchange :: (Array RD cs e, Array RS cs e) => RS -> Image RD cs e -> Image RS cs e

ManifestArray RS cs e => MutableArray RS cs e

Associated Types

data MImage st RS cs e :: *

Methods

mdims :: MImage st RS cs e -> (Int, Int)

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

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

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

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

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

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

ManifestArray RS cs e => SequentialArray RS cs e

Methods

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

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

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

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

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

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

Array RS cs e => ManifestArray RS cs e

Methods

index :: Image RS cs e -> (Int, Int) -> Pixel cs e

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

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

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

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

Elt RS cs e => Array RS cs e

Associated Types

type Elt RS cs e :: Constraint

data Image RS cs e :: *

Methods

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

singleton :: Pixel cs e -> Image RS cs e

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

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

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

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

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

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

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

transpose :: Image RS cs e -> Image RS cs e

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

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

data Image RS

data Image RS = RSImage !(Image RD cs e)

data MImage st RS

data MImage st RS = MRSImage !(MImage st VU cs e)

type Elt RS cs e

type Elt RS cs e = (ColorSpace cs, Elt e, Unbox e, Num e, Typeable * e, Elt (PixelElt cs e), Unbox (PixelElt cs e), Elt (Pixel cs e), Unbox (Pixel cs e))

data RP

Repa Unboxed Array representation, which is computed in parallel.

Constructors

RP

Instances

Show RP

Methods

showsPrec :: Int -> RP -> ShowS

show :: RP -> String

showList :: [RP] -> ShowS

Exchangable VU RP

O(1) - Changes to Repa representation.

Methods

exchange :: (Array VU cs e, Array RP cs e) => RP -> Image VU cs e -> Image RP cs e

Exchangable RS RP

O(1) - Changes computation strategy.

Methods

exchange :: (Array RS cs e, Array RP cs e) => RP -> Image RS cs e -> Image RP cs e

Exchangable RP VU

O(1) - Changes to Vector representation.

Methods

exchange :: (Array RP cs e, Array VU cs e) => VU -> Image RP cs e -> Image VU cs e

Exchangable RP RS

O(1) - Changes computation strategy.

Methods

exchange :: (Array RP cs e, Array RS cs e) => RS -> Image RP cs e -> Image RS cs e

Exchangable RP RD

O(1) - Delays manifest array.

Methods

exchange :: (Array RP cs e, Array RD cs e) => RD -> Image RP cs e -> Image RD cs e

Exchangable RD RP

Computes delayed array in parallel.

Methods

exchange :: (Array RD cs e, Array RP cs e) => RP -> Image RD cs e -> Image RP cs e

Array RP cs e => ManifestArray RP cs e

Methods

index :: Image RP cs e -> (Int, Int) -> Pixel cs e

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

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

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

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

Elt RP cs e => Array RP cs e

Associated Types

type Elt RP cs e :: Constraint

data Image RP cs e :: *

Methods

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

singleton :: Pixel cs e -> Image RP cs e

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

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

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

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

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

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

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

transpose :: Image RP cs e -> Image RP cs e

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

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

data Image RP

data Image RP = RPImage !(Image RD cs e)

type Elt RP cs e

type Elt RP cs e = (ColorSpace cs, Elt e, Unbox e, Num e, Typeable * e, Elt (PixelElt cs e), Unbox (PixelElt cs e), Elt (Pixel cs e), Unbox (Pixel cs e))