Graphics.Image

Haskell Image Processing (HIP) library is a wrapper around any array like data structure and is fully agnostic to the underlying representation. All of the functionality in this library relies upon a few type classes, which corresponding representation types are instances of:

• Array arr cs e - this is a base class for every Image arr cs e, where arr stands for an underlying array representation, cs is the ColorSpace of an image and e is the type denoting precision of an image.
• ManifestArray arr cs e - is a kind of array that is represented by an actual data in memory.
• SequentialArray arr cs e - contains functionality that can only be computed sequentially.
• MutableArray arr cs e - allows mutation on MImage st arr cs e, which is Image's mutable cousin.

Array representation type and the above classes it is installed in determine operations that can be done on the image with that representation.

Representations using Vector and Repa packages:

• VU - Unboxed Vector representation. (Default)
• RD - Delayed Repa array representation.
• RS - Unboxed Repa array representation (computation is done sequentially).
• RP - Unboxed Repa array representation (computation is done in parallel).

Images with RD type hold functions rather then actual data, so this representation should be used for fusing computation together, and later changed to RS or RP using exchange, which in turn performs the fused computation.

Just as it is mentioned above, Vector representation is a default one, so in order to create images with Repa representation Graphics.Image.Interface.Repa module should be used. It has to be imported as qualified, since it contains image generating functions with same names as here.

Many of the function names exported by this module will clash with the ones from Prelude, hence it can be more convenient to import it qualified and all relevenat types import using Graphics.Image.Types module:

import qualified Graphics.Image as I
import Graphics.Image.Types

Color Space

Here is a list of default Pixels with their respective constructors:

    * Pixel Y e      = PixelY y              - Luma, also commonly denoted as Y'.
    * Pixel YA e     = PixelYA y a           - Luma with alpha.
    * Pixel RGB e    = PixelRGB r g b        - Red, Green and Blue.
    * Pixel RGBA e   = PixelRGBA r g b a     - RGB with alpha
    * Pixel HSI e    = PixelHSI h s i        - Hue, Saturation and Intensity.
    * Pixel HSIA e   = PixelHSIA h s i a     - HSI with alpha
    * Pixel CMYK e   = PixelCMYK c m y k     - Cyan, Magenta, Yellow and Key (Black).
    * Pixel CMYKA e  = PixelCMYKA c m y k a  - CMYK with alpha.
    * Pixel YCbCr e  = PixelYCbCr y cb cr    - Luma, blue-difference and red-difference chromas.
    * Pixel YCbCrA e = PixelYCbCrA y cb cr a - YCbCr with alpha.
      ------------------------------------------------------------------------------------------
    * Pixel Binary Bit     = on | off - Bi-tonal.
    * Pixel cs (Complex e) = (Pixel cs e) +: (Pixel cs e) - Complex pixels with any color space.
    * Pixel Gray e         = PixelGray g - Used for separating channels from other color spaces.

Every Pixel is an instance of Functor, Applicative, Foldable and Num, as well as Floating and Fractional if e is also an instance.

All of the functionality related to every ColorSpace is re-exported by Graphics.Image.Types module.

Creation

makeImage

Arguments

:: Array VU 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 VU cs Double

Create an image with VU (Vector Unboxed) representation and pixels of Double precision. Note, that for Double precision pixels it is essential to keep values normalized in the [0, 1] range in order for an image to be written to file properly.

>>> let grad_gray = makeImage (200, 200) (\(i, j) -> PixelY (fromIntegral i)/200 * (fromIntegral j)/200)

Because all Pixels and Images are installed into Num, above is equivalent to:

>>> let grad_gray = makeImage (200, 200) (\(i, j) -> PixelY $ fromIntegral (i*j)) / (200*200)
>>> writeImage "images/grad_gray.png" grad_gray

Creating color images is just as easy.

>>> let grad_color = makeImage (200, 200) (\(i, j) -> PixelRGB (fromIntegral i) (fromIntegral j) (fromIntegral (i + j))) / 400
>>> writeImage "images/grad_color.png" grad_color

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

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

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

toLists :: ManifestArray arr cs e => Image arr cs e -> [[Pixel cs e]]

Generates a nested list of pixels from an image.

 img == fromLists (toLists img)

IO

Reading

Read any supported image file into an Image with VU (Vector Unboxed) representation and pixels with Double precision. In order to read an image with different representation, color space and precision readImage or readImageExact from Graphics.Image.IO can be used.

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

Read image as luma (brightness).

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

Read image as luma with Alpha channel.

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

Read image in RGB colorspace.

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

Read image in RGB colorspace with Alpha channel.

readImageExact

Arguments

:: Readable img format

=> format

A file format that an image should be read as. See Supported Image Formats

-> FilePath

Location of an image.

-> IO (Either String img)

This function allows for reading any supported image in the exact colorspace and precision it is currently encoded in. For instance, frog image can be read into it's YCbCr colorspace with Word8 precision and into any supported array representation.

>>> readImageExact JPG "images/frog.jpg" :: IO (Either String (Image RP YCbCr Word8))
Right <Image RepaParallel YCbCr (Word8): 200x320>

The drawback here is that colorspace and precision has to match exactly, otherwise it will return an error:

>>> readImageExact JPG "images/frog.jpg" :: IO (Either String (Image RD RGB Word8))
Left "JuicyPixel decoding error: Input image is in YCbCr8 (Pixel YCbCr Word8), cannot convert it to RGB8 (Pixel RGB Word8) colorspace."

Attempt to read an image in a particular color space that is not supported by the format, will result in a compile error. Refer to Readable class for all images that can be decoded.

Writing

writeImage

Arguments

:: Writable (Image arr cs e) OutputFormat

=> FilePath

Location where an image should be written.

-> Image arr cs e

An image to write.

-> IO ()

Just like readImage, this function will guess an output file format from the extension and write to file any image that is in one of Y, YA, RGB or RGBA color spaces with Double precision. While doing necessary conversions the choice will be given to the most suited color space supported by the format. For instance, in case of a PNG format, an (Image arr RGBA Double) would be written as RGBA16, hence preserving transparency and using highest supported precision Word16. At the same time, writing that image in GIF format would save it in RGB8, since Word8 is the highest precision GIF supports and it currently cannot be saved with transparency.

writeImageExact

Arguments

:: Writable img format

=> format

A file format that an image should be saved in. See Supported Image Formats

-> [SaveOption format]

A list of format specific options.

-> FilePath

Location where an image should be written.

-> img

An image to write. Can be a list of images in case of formats supporting animation.

-> IO ()

Write an image in a specific format, while supplying any format specific options. Precision and color space that an image will be written is decided from image's type. Attempt to write image file in a format that does not support color space and precision combination will result in a compile error.

displayImage

Arguments

:: Writable (Image arr cs e) TIF

=> Image arr cs e

Image to be displayed

-> IO ()

Makes a call to an external viewer that is set as a default image viewer by the OS. This is a non-blocking function call, so it will take some time before an image will appear.

>>> frog <- readImageRGB "images/frog.jpg"
>>> displayImage frog

Accessors

Dimensions

rows :: Array arr cs e => Image arr cs e -> Int

Get the number of rows in an image.

>>> frog <- readImageRGB "images/frog.jpg"
>>> frog
<Image VectorUnboxed RGB (Double): 200x320>
>>> rows frog
200

cols :: Array arr cs e => Image arr cs e -> Int

Get the number of columns in an image.

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

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

Get dimensions of an image.

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

Indexing

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

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

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

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

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

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

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

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

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

Transformation

Pointwise

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

Map a function over a an image.

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

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

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

Zip two images with a function

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

Zip two images with an index aware function

Geometric

traverse :: (Array arr cs e, 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

Traverse an image

traverse2 :: (Array arr cs e, 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

Traverse two images.

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

Transpose an image

backpermute :: Array arr cs e => (Int, Int) -> ((Int, Int) -> (Int, Int)) -> Image arr cs e -> Image arr cs e

Backwards permutation of an image.

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

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

Reduction

fold :: ManifestArray arr cs e => (Pixel cs e -> Pixel cs e -> Pixel cs e) -> Pixel cs e -> Image arr cs e -> Pixel cs e

Undirected reduction of an image.

sum :: ManifestArray arr cs e => Image arr cs e -> Pixel cs e

Sum all pixels in the image.

product :: ManifestArray arr cs e => Image arr cs e -> Pixel cs e

Multiply all pixels in the image.

maximum :: (ManifestArray arr cs e, Ord (Pixel cs e)) => Image arr cs e -> Pixel cs e

Retrieve the biggest pixel from an image

minimum :: (ManifestArray arr cs e, Ord (Pixel cs e)) => Image arr cs e -> Pixel cs e

Retrieve the smallest pixel from an image

normalize :: (ManifestArray arr cs e, ManifestArray arr Gray e, Fractional e, Ord e) => Image arr cs e -> Image arr cs e

Scales all of the pixels to be in the range [0, 1].

Representations

exchange :: (Exchangable arr' arr, Array arr' cs e, Array arr cs e) => arr -> Image arr' cs e -> Image arr cs e

Exchange the underlying array representation of an image.

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