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

Copyright(c) Alexey Kuleshevich 2016
LicenseBSD3
MaintainerAlexey Kuleshevich <lehins@yandex.ru>
Stabilityexperimental
Portabilitynon-portable
Safe HaskellNone
LanguageHaskell2010

Graphics.Image.Types

Description

 

Synopsis

Documentation

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

Instances

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

Associated Types

type Manifest VS :: * Source #

type Vector 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 #

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

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

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

Associated Types

type Manifest VU :: * Source #

type Vector 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 #

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

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

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

Associated Types

type Manifest RPS :: * Source #

type Vector 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 #

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

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

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

Associated Types

type Manifest RSS :: * Source #

type Vector 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 #

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

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

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

Associated Types

type Manifest RPU :: * Source #

type Vector 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 #

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

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

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

Associated Types

type Manifest RSU :: * Source #

type Vector 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 #

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

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

class BaseArray arr cs e => MArray arr cs e Source #

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

Associated Types

data MImage s arr cs e Source #

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 #

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 #

data VU Source #

Unboxed Vector representation.

Constructors

VU 

Instances

Show VU Source # 

Methods

showsPrec :: Int -> VU -> ShowS #

show :: VU -> String #

showList :: [VU] -> ShowS #

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 #

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

Associated Types

type Manifest VU :: * Source #

type Vector 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 #

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

fromVector :: (Int, Int) -> Vector VU (Pixel cs e) -> Image VU cs e 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 #

type Manifest VU Source # 
type Manifest VU = VU
type Vector VU Source # 
data Image VU Source # 
data Image VU = VUImage (Image (G VU) cs e)
data MImage s VU Source # 
data MImage s VU = MVUImage (MImage s (G VU) cs e)
type SuperClass VU cs e Source # 
type SuperClass VU cs e = (ColorSpace cs e, Unbox (Components cs e))

data VS Source #

Storable Vector representation.

Constructors

VS 

Instances

Show VS Source # 

Methods

showsPrec :: Int -> VS -> ShowS #

show :: VS -> String #

showList :: [VS] -> ShowS #

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 #

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

Associated Types

type Manifest VS :: * Source #

type Vector 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 #

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

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

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 #

Readable [Image VS Y Word8] [PGM] Source # 
Readable [Image VS Y Word16] [PGM] Source # 
Readable [Image VS RGB Word8] [PPM] Source # 
Readable [Image VS RGB Word16] [PPM] Source # 
Readable [Image VS Binary Bit] [PBM] Source # 
Readable (Image VS YA Double) PPM Source # 
Readable (Image VS Y Double) PPM Source # 
Readable (Image VS Y Double) PGM Source # 
Readable (Image VS Y Double) PBM Source # 
Readable (Image VS Y Word8) PGM Source # 
Readable (Image VS Y Word16) PGM Source # 
Readable (Image VS RGBA Double) PPM Source # 
Readable (Image VS RGB Double) PPM Source # 
Readable (Image VS RGB Word8) PPM Source # 
Readable (Image VS RGB Word16) PPM Source # 
Readable (Image VS Binary Bit) PBM Source # 
type Manifest VS Source # 
type Manifest VS = VS
type Vector VS Source # 
data Image VS Source # 
data Image VS = VSImage (Image (G VS) cs e)
data MImage s VS Source # 
data MImage s VS = MVSImage (MImage s (G VS) cs e)
type SuperClass VS cs e Source # 
type SuperClass VS cs e = (ColorSpace cs e, Storable (Pixel cs e))

data RSU Source #

Repa Array representation backed by Unboxed Vector, which is computed sequentially.

Constructors

RSU 

Instances

Show RSU Source # 

Methods

showsPrec :: Int -> RSU -> ShowS #

show :: RSU -> String #

showList :: [RSU] -> ShowS #

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

Associated Types

type Manifest RSU :: * Source #

type Vector 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 #

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

fromVector :: (Int, Int) -> Vector RSU (Pixel cs e) -> Image RSU cs e 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 #

type Manifest RSU Source # 
type Manifest RSU = VU
type Vector RSU Source # 
data Image RSU Source # 
data Image RSU = SUImage (Image (RS VU) cs e)
type SuperClass RSU cs e Source # 
type SuperClass RSU cs e = (ColorSpace cs e, Elt e, Elt (Pixel cs e))

data RPU Source #

Repa Array representation backed by Unboxed Vector, which is computed in parallel.

Constructors

RPU 

Instances

Show RPU Source # 

Methods

showsPrec :: Int -> RPU -> ShowS #

show :: RPU -> String #

showList :: [RPU] -> ShowS #

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

Associated Types

type Manifest RPU :: * Source #

type Vector 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 #

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

fromVector :: (Int, Int) -> Vector RPU (Pixel cs e) -> Image RPU cs e 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 #

type Manifest RPU Source # 
type Manifest RPU = VU
type Vector RPU Source # 
data Image RPU Source # 
data Image RPU = PUImage (Image (RP VU) cs e)
type SuperClass RPU cs e Source # 
type SuperClass RPU cs e = (ColorSpace cs e, Elt e, Elt (Pixel cs e))

data RSS Source #

Repa Array representation backed by Storable Vector, which is computed sequentially.

Constructors

RSS 

Instances

Show RSS Source # 

Methods

showsPrec :: Int -> RSS -> ShowS #

show :: RSS -> String #

showList :: [RSS] -> ShowS #

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

Associated Types

type Manifest RSS :: * Source #

type Vector 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 #

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

fromVector :: (Int, Int) -> Vector RSS (Pixel cs e) -> Image RSS cs e 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 #

type Manifest RSS Source # 
type Manifest RSS = VS
type Vector RSS Source # 
data Image RSS Source # 
data Image RSS = SSImage (Image (RS VS) cs e)
type SuperClass RSS cs e Source # 
type SuperClass RSS cs e = (ColorSpace cs e, Storable e, Storable (Pixel cs e), Elt e, Elt (Pixel cs e))

data RPS Source #

Repa Array representation backed by Storable Vector, which is computed in parallel.

Constructors

RPS 

Instances

Show RPS Source # 

Methods

showsPrec :: Int -> RPS -> ShowS #

show :: RPS -> String #

showList :: [RPS] -> ShowS #

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

Associated Types

type Manifest RPS :: * Source #

type Vector 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 #

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

fromVector :: (Int, Int) -> Vector RPS (Pixel cs e) -> Image RPS cs e 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 #

type Manifest RPS Source # 
type Manifest RPS = VS
type Vector RPS Source # 
data Image RPS Source # 
data Image RPS = PSImage (Image (RP VS) cs e)
type SuperClass RPS cs e Source # 
type SuperClass RPS cs e = (ColorSpace cs e, Storable e, Storable (Pixel cs e), Elt e, Elt (Pixel cs e))