Graphics.Image.Interface

Documentation

class (Eq cs, Enum cs, Show cs, Typeable cs) => ColorSpace cs where

This class has all included color spaces installed into it and is also intended for implementing any other possible custom color spaces. Every instance of this class automatically installs an associated Pixel into Num, Fractional, Floating, Functor, Applicative and Foldable, which in turn make it possible to be used by the rest of the library.

Minimal complete definition

fromChannel, toElt, fromElt, getPxCh, chOp, pxOp, chApp, pxFoldMap, csColour

Associated Types

type PixelElt cs e

Representation of a pixel, such that it can be an element of any Array. Which is usally a tuple of channels or a channel itself for single channel color spaces.

data Pixel cs e

A concrete Pixel representation for a particular color space.

Methods

fromChannel :: e -> Pixel cs e

Construt a pixel by replicating a same value among all of the channels.

toElt :: Pixel cs e -> PixelElt cs e

Convert a Pixel to a representation suitable for storage as an unboxed element, usually a tuple of channels.

fromElt :: PixelElt cs e -> Pixel cs e

Convert from an elemnt representation back to a Pixel.

getPxCh :: Pixel cs e -> cs -> e

Retrieve Pixel's channel value

chOp :: (cs -> e' -> e) -> Pixel cs e' -> Pixel cs e

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

pxOp :: (e' -> e) -> Pixel cs e' -> Pixel cs e

Map a function over all Pixel's channels.

chApp :: Pixel cs (e' -> e) -> Pixel cs e' -> Pixel cs e

Function application to a Pixel.

pxFoldMap :: Monoid m => (e -> m) -> Pixel cs e -> m

A pixel eqiuvalent of foldMap.

csColour :: cs -> AlphaColour Double

Get a pure colour representation of a channel.

Instances

ColorSpace YCbCrA

Associated Types

type PixelElt YCbCrA e :: *

data Pixel YCbCrA e :: *

Methods

fromChannel :: e -> Pixel YCbCrA e

toElt :: Pixel YCbCrA e -> PixelElt YCbCrA e

fromElt :: PixelElt YCbCrA e -> Pixel YCbCrA e

getPxCh :: Pixel YCbCrA e -> YCbCrA -> e

chOp :: (YCbCrA -> e' -> e) -> Pixel YCbCrA e' -> Pixel YCbCrA e

pxOp :: (e' -> e) -> Pixel YCbCrA e' -> Pixel YCbCrA e

chApp :: Pixel YCbCrA (e' -> e) -> Pixel YCbCrA e' -> Pixel YCbCrA e

pxFoldMap :: Monoid m => (e -> m) -> Pixel YCbCrA e -> m

csColour :: YCbCrA -> AlphaColour Double

ColorSpace YCbCr

Associated Types

type PixelElt YCbCr e :: *

data Pixel YCbCr e :: *

Methods

fromChannel :: e -> Pixel YCbCr e

toElt :: Pixel YCbCr e -> PixelElt YCbCr e

fromElt :: PixelElt YCbCr e -> Pixel YCbCr e

getPxCh :: Pixel YCbCr e -> YCbCr -> e

chOp :: (YCbCr -> e' -> e) -> Pixel YCbCr e' -> Pixel YCbCr e

pxOp :: (e' -> e) -> Pixel YCbCr e' -> Pixel YCbCr e

chApp :: Pixel YCbCr (e' -> e) -> Pixel YCbCr e' -> Pixel YCbCr e

pxFoldMap :: Monoid m => (e -> m) -> Pixel YCbCr e -> m

csColour :: YCbCr -> AlphaColour Double

ColorSpace RGBA

Associated Types

type PixelElt RGBA e :: *

data Pixel RGBA e :: *

Methods

fromChannel :: e -> Pixel RGBA e

toElt :: Pixel RGBA e -> PixelElt RGBA e

fromElt :: PixelElt RGBA e -> Pixel RGBA e

getPxCh :: Pixel RGBA e -> RGBA -> e

chOp :: (RGBA -> e' -> e) -> Pixel RGBA e' -> Pixel RGBA e

pxOp :: (e' -> e) -> Pixel RGBA e' -> Pixel RGBA e

chApp :: Pixel RGBA (e' -> e) -> Pixel RGBA e' -> Pixel RGBA e

pxFoldMap :: Monoid m => (e -> m) -> Pixel RGBA e -> m

csColour :: RGBA -> AlphaColour Double

ColorSpace RGB

Associated Types

type PixelElt RGB e :: *

data Pixel RGB e :: *

Methods

fromChannel :: e -> Pixel RGB e

toElt :: Pixel RGB e -> PixelElt RGB e

fromElt :: PixelElt RGB e -> Pixel RGB e

getPxCh :: Pixel RGB e -> RGB -> e

chOp :: (RGB -> e' -> e) -> Pixel RGB e' -> Pixel RGB e

pxOp :: (e' -> e) -> Pixel RGB e' -> Pixel RGB e

chApp :: Pixel RGB (e' -> e) -> Pixel RGB e' -> Pixel RGB e

pxFoldMap :: Monoid m => (e -> m) -> Pixel RGB e -> m

csColour :: RGB -> AlphaColour Double

ColorSpace YA

Associated Types

type PixelElt YA e :: *

data Pixel YA e :: *

Methods

fromChannel :: e -> Pixel YA e

toElt :: Pixel YA e -> PixelElt YA e

fromElt :: PixelElt YA e -> Pixel YA e

getPxCh :: Pixel YA e -> YA -> e

chOp :: (YA -> e' -> e) -> Pixel YA e' -> Pixel YA e

pxOp :: (e' -> e) -> Pixel YA e' -> Pixel YA e

chApp :: Pixel YA (e' -> e) -> Pixel YA e' -> Pixel YA e

pxFoldMap :: Monoid m => (e -> m) -> Pixel YA e -> m

csColour :: YA -> AlphaColour Double

ColorSpace Y

Associated Types

type PixelElt Y e :: *

data Pixel Y e :: *

Methods

fromChannel :: e -> Pixel Y e

toElt :: Pixel Y e -> PixelElt Y e

fromElt :: PixelElt Y e -> Pixel Y e

getPxCh :: Pixel Y e -> Y -> e

chOp :: (Y -> e' -> e) -> Pixel Y e' -> Pixel Y e

pxOp :: (e' -> e) -> Pixel Y e' -> Pixel Y e

chApp :: Pixel Y (e' -> e) -> Pixel Y e' -> Pixel Y e

pxFoldMap :: Monoid m => (e -> m) -> Pixel Y e -> m

csColour :: Y -> AlphaColour Double

ColorSpace HSIA

Associated Types

type PixelElt HSIA e :: *

data Pixel HSIA e :: *

Methods

fromChannel :: e -> Pixel HSIA e

toElt :: Pixel HSIA e -> PixelElt HSIA e

fromElt :: PixelElt HSIA e -> Pixel HSIA e

getPxCh :: Pixel HSIA e -> HSIA -> e

chOp :: (HSIA -> e' -> e) -> Pixel HSIA e' -> Pixel HSIA e

pxOp :: (e' -> e) -> Pixel HSIA e' -> Pixel HSIA e

chApp :: Pixel HSIA (e' -> e) -> Pixel HSIA e' -> Pixel HSIA e

pxFoldMap :: Monoid m => (e -> m) -> Pixel HSIA e -> m

csColour :: HSIA -> AlphaColour Double

ColorSpace HSI

Associated Types

type PixelElt HSI e :: *

data Pixel HSI e :: *

Methods

fromChannel :: e -> Pixel HSI e

toElt :: Pixel HSI e -> PixelElt HSI e

fromElt :: PixelElt HSI e -> Pixel HSI e

getPxCh :: Pixel HSI e -> HSI -> e

chOp :: (HSI -> e' -> e) -> Pixel HSI e' -> Pixel HSI e

pxOp :: (e' -> e) -> Pixel HSI e' -> Pixel HSI e

chApp :: Pixel HSI (e' -> e) -> Pixel HSI e' -> Pixel HSI e

pxFoldMap :: Monoid m => (e -> m) -> Pixel HSI e -> m

csColour :: HSI -> AlphaColour Double

ColorSpace Gray

Associated Types

type PixelElt Gray e :: *

data Pixel Gray e :: *

Methods

fromChannel :: e -> Pixel Gray e

toElt :: Pixel Gray e -> PixelElt Gray e

fromElt :: PixelElt Gray e -> Pixel Gray e

getPxCh :: Pixel Gray e -> Gray -> e

chOp :: (Gray -> e' -> e) -> Pixel Gray e' -> Pixel Gray e

pxOp :: (e' -> e) -> Pixel Gray e' -> Pixel Gray e

chApp :: Pixel Gray (e' -> e) -> Pixel Gray e' -> Pixel Gray e

pxFoldMap :: Monoid m => (e -> m) -> Pixel Gray e -> m

csColour :: Gray -> AlphaColour Double

ColorSpace CMYKA

Associated Types

type PixelElt CMYKA e :: *

data Pixel CMYKA e :: *

Methods

fromChannel :: e -> Pixel CMYKA e

toElt :: Pixel CMYKA e -> PixelElt CMYKA e

fromElt :: PixelElt CMYKA e -> Pixel CMYKA e

getPxCh :: Pixel CMYKA e -> CMYKA -> e

chOp :: (CMYKA -> e' -> e) -> Pixel CMYKA e' -> Pixel CMYKA e

pxOp :: (e' -> e) -> Pixel CMYKA e' -> Pixel CMYKA e

chApp :: Pixel CMYKA (e' -> e) -> Pixel CMYKA e' -> Pixel CMYKA e

pxFoldMap :: Monoid m => (e -> m) -> Pixel CMYKA e -> m

csColour :: CMYKA -> AlphaColour Double

ColorSpace CMYK

Associated Types

type PixelElt CMYK e :: *

data Pixel CMYK e :: *

Methods

fromChannel :: e -> Pixel CMYK e

toElt :: Pixel CMYK e -> PixelElt CMYK e

fromElt :: PixelElt CMYK e -> Pixel CMYK e

getPxCh :: Pixel CMYK e -> CMYK -> e

chOp :: (CMYK -> e' -> e) -> Pixel CMYK e' -> Pixel CMYK e

pxOp :: (e' -> e) -> Pixel CMYK e' -> Pixel CMYK e

chApp :: Pixel CMYK (e' -> e) -> Pixel CMYK e' -> Pixel CMYK e

pxFoldMap :: Monoid m => (e -> m) -> Pixel CMYK e -> m

csColour :: CMYK -> AlphaColour Double

ColorSpace Binary

Associated Types

type PixelElt Binary e :: *

data Pixel Binary e :: *

Methods

fromChannel :: e -> Pixel Binary e

toElt :: Pixel Binary e -> PixelElt Binary e

fromElt :: PixelElt Binary e -> Pixel Binary e

getPxCh :: Pixel Binary e -> Binary -> e

chOp :: (Binary -> e' -> e) -> Pixel Binary e' -> Pixel Binary e

pxOp :: (e' -> e) -> Pixel Binary e' -> Pixel Binary e

chApp :: Pixel Binary (e' -> e) -> Pixel Binary e' -> Pixel Binary e

pxFoldMap :: Monoid m => (e -> m) -> Pixel Binary e -> m

csColour :: Binary -> AlphaColour Double

class (ColorSpace (Opaque cs), ColorSpace cs) => Alpha cs where

A color space that supports transparency.

Minimal complete definition

getAlpha, addAlpha, dropAlpha, opaque

Associated Types

type Opaque cs

An corresponding opaque version of this color space.

Methods

getAlpha :: Pixel cs e -> e

Get an alpha channel of a transparant pixel.

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

Add an alpha channel of an opaque pixel.

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

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

Convert a transparent pixel to an opaque one by dropping the alpha channel.

 dropAlpha (PixelRGBA 1 2 3 4) == PixelRGB 1 2 3

opaque :: cs -> Opaque cs

Get a corresponding opaque channel type.

Instances

Alpha YCbCrA

Associated Types

type Opaque YCbCrA :: *

Methods

getAlpha :: Pixel YCbCrA e -> e

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

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

opaque :: YCbCrA -> Opaque YCbCrA

Alpha RGBA

Associated Types

type Opaque RGBA :: *

Methods

getAlpha :: Pixel RGBA e -> e

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

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

opaque :: RGBA -> Opaque RGBA

Alpha YA

Associated Types

type Opaque YA :: *

Methods

getAlpha :: Pixel YA e -> e

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

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

opaque :: YA -> Opaque YA

Alpha HSIA

Associated Types

type Opaque HSIA :: *

Methods

getAlpha :: Pixel HSIA e -> e

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

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

opaque :: HSIA -> Opaque HSIA

Alpha CMYKA

Associated Types

type Opaque CMYKA :: *

Methods

getAlpha :: Pixel CMYKA e -> e

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

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

opaque :: CMYKA -> Opaque CMYKA

class Elevator e where

A class with a set of convenient functions that allow for changing precision of channels within pixels, while scaling the values to keep them in an appropriate range.

>>> let rgb = PixelRGB 0.0 0.5 1.0 :: Pixel RGB Double
>>> toWord8 rgb
<RGB:(0|128|255)>

Minimal complete definition

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

Methods

toWord8 :: ColorSpace cs => Pixel cs e -> Pixel cs Word8

toWord16 :: ColorSpace cs => Pixel cs e -> Pixel cs Word16

toWord32 :: ColorSpace cs => Pixel cs e -> Pixel cs Word32

toWord64 :: ColorSpace cs => Pixel cs e -> Pixel cs Word64

toFloat :: ColorSpace cs => Pixel cs e -> Pixel cs Float

toDouble :: ColorSpace cs => Pixel cs e -> Pixel cs Double

fromDouble :: ColorSpace cs => Pixel cs Double -> Pixel cs e

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 where

Base array like representation for an image.

Minimal complete definition

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

Associated Types

type Elt arr cs e :: Constraint

Required array specific constraints for an array element.

data Image arr cs e

Underlying image representation.

Methods

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

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

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

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

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

map :: 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' => ((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 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 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

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

Traverse an image

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

Traverse two images.

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

Transpose an image

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

Backwards permutation of an image.

fromLists :: [[Pixel cs e]] -> Image arr 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.

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 where

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

Methods

index :: 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

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

Make sure that an image is fully evaluated.

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

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

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

Undirected reduction of an image.

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

Pixelwise equality function of two images. Images are considered distinct if either images' dimensions or at least one pair of corresponding pixels are not the same. Used in defining an in instance for the Eq typeclass.

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 where

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_

Methods

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

Fold an image from the left in a row major order.

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

Fold an image from the right in a row major order.

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

Monading mapping over an image.

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

Monading mapping over an image. Result is discarded.

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

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

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 where

Array representation that supports mutation.

Minimal complete definition

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

Associated Types

data MImage st arr cs e

Methods

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

Get dimensions of a mutable image.

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

Yield a mutable copy of an image.

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

Yield an immutable copy of an image.

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

Create a mutable image with given dimensions. Pixels are likely uninitialized.

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

Yield the pixel at a given location.

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

Set a pixel at a given location.

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

Swap pixels at given locations.

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 where

Allows for changing an underlying image representation.

Minimal complete definition

exchange

Methods

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

Exchange the underlying array representation of an image.

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

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.

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.

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

handleBorderIndex

Arguments

:: Border (Pixel cs e)

Border handling strategy.

-> (Int, Int)

Image dimensions

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

Image's indexing function.

-> (Int, Int)

(i, j) location of a pixel lookup.

-> Pixel cs e

Border handling function. If (i, j) location is within bounds, then supplied lookup function will be used, otherwise it will be handled according to a supplied border strategy.