Graphics.Image.Interface.Repa

Construction

makeImage

Arguments

:: Array RD cs Double

=> (Int, Int)

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

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

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

-> Image RD cs Double

Create a delayed representation of an image.

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

Construct an image from a nested rectangular shaped list of pixels.

IO

readImageY :: FilePath -> IO (Image RD Y Double)

Read image as luma (brightness).

readImageYA :: FilePath -> IO (Image RD YA Double)

Read image as luma with Alpha channel.

readImageRGB :: FilePath -> IO (Image RD RGB Double)

Read image in RGB colorspace.

readImageRGBA :: FilePath -> IO (Image RD RGBA Double)

Read image in RGB colorspace with Alpha channel.

Computation

computeS :: (Array arr cs e, Array RS cs e, Exchangable arr RS) => Image arr cs e -> Image RS cs e

Computes an image sequentially and ensures that all elements are evaluated.

computeP :: (Array arr cs e, Array RP cs e, Exchangable arr RP) => Image arr cs e -> Image RP cs e

Computes an image in parallel and ensures that all elements are evaluated.

delay :: (ManifestArray arr cs e, Array RD cs e, Exchangable arr RD) => Image arr cs e -> Image RD cs e

Delays an image, so further operations can be fused together.

Representation

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 VU RD

O(1) - Changes to Repa representation.

Methods

exchange :: (Array VU cs e, Array RD cs e) => RD -> Image VU cs e -> Image RD 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 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

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

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

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

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

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

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

Conversion

fromRepaArray :: Array D DIM2 (Pixel cs e) -> Image RD cs e

Create an image from a 2D Repa delayed array.

toRepaArray :: (ColorSpace cs, Unbox (PixelElt cs e)) => Image RD cs e -> Array D DIM2 (Pixel cs e)

Retrieve an underlying Repa array from RD image type.