mapalgebra-0.1.1: Efficient, polymorphic Map Algebra.

Copyright(c) Colin Woodbury 2018
LicenseBSD3
MaintainerColin Woodbury <colin@fosskers.ca>
Safe HaskellNone
LanguageHaskell2010

Geography.MapAlgebra

Contents

Description

This library is an implementation of Map Algebra as described in the book GIS and Cartographic Modeling (GaCM) by Dana Tomlin. The fundamental primitive is the Raster, a rectangular grid of data that usually describes some area on the earth. A Raster need not contain numerical data, however, and need not just represent satellite imagery. It is essentially a matrix, which of course forms a Functor, and thus is available for all the operations we would expect to run on any Functor. GIS and Cartographic Modeling doesn't lean on this fact, and so describes many seemingly custom operations which to Haskell are just applications of fmap or zipWith with pure functions.

Here are the main classes of operations ascribed to Map Algebra and their corresponding approach in Haskell:

  • Single-Raster Local Operations -> fmap with pure functions
  • Multi-Raster Local Operations -> foldl with zipWith and pure functions
  • Focal Operations -> massiv-based smart Stencil operations
  • Zonal Operations -> Not yet implemented

Whether it is meaningful to perform operations between two given Rasters (i.e. whether the Rasters properly overlap on the earth) is not handled in this library and is left to the application.

The "colour ramp" generation functions (like greenRed) gratefully borrow colour sets from Gretchen N. Peterson's book Cartographer's Toolkit.

A Word on Massiv: Fused, Parallel Arrays

Thanks to the underlying Array library massiv, most operations over and between Rasters are fused, meaning that no extra memory is allocated in between each step of a composite operation.

Take the Enhanced Vegetation Index calculation:

evi :: Raster D p r c Double -> Raster D p r c Double -> Raster D p r c Double -> Raster D p r c Double
evi nir red blue = 2.5 * (numer / denom)
  where numer = nir - red
        denom = nir + (6 * red) - (7.5 * blue) + 1

8 binary operators are used here, but none allocate new memory. It's only when some lazy Raster is made strict that calculations occur and memory is allocated.

Provided your machine has more than 1 CPU, Rasters read by functions like fromRGBA will automatically be in Parallel mode. This means that forcing calculations with strict will cause evaluation to be done with every CPU your machine has. The effect of this is quite potent for Focal Operations, which yield special, cache-friendly windowed (DW) Rasters.

Familiarity with Massiv will help in using this library. A guide can be found here.

Compilation Options for Best Performance

When using this library, always compile your project with -threaded and -with-rtsopts=-N. These will ensure your executables will automatically use all the available CPU cores.

As always, -O2 is your friend. The {-# INLINE ... #-} pragma is also very likely to improve the performance of code that uses functions from this library. Make sure to benchmark proactively.

For particularly mathy operations like fmean, compiling with -fllvm grants about a 2x speedup.

Synopsis

Types

Rasters

newtype Raster u p (r :: Nat) (c :: Nat) a Source #

A rectangular grid of data representing some area on the earth.

  • u: What is the underlying representation of this Raster? (see massiv)
  • p: What Projection is this Raster in?
  • r: How many rows does this Raster have?
  • c: How many columns does this Raster have?
  • a: What data type is held in this Raster?

By having explicit p, r, and c, we make impossible any operation between two Rasters of differing size or projection. Conceptually, we consider Rasters of different size and projection to be entirely different types. Example:

-- | A lazy 256x256 Raster with the value 5 at every index. Uses DataKinds
-- and "type literals" to achieve the same-size guarantee.
myRaster :: Raster D WebMercator 256 256 Int
myRaster = constant D Par 5

>>> length myRaster
65536

Constructors

Raster 

Fields

Instances

Functor (Raster k DI p r c) Source # 

Methods

fmap :: (a -> b) -> Raster k DI p r c a -> Raster k DI p r c b #

(<$) :: a -> Raster k DI p r c b -> Raster k DI p r c a #

Functor (Raster k D p r c) Source # 

Methods

fmap :: (a -> b) -> Raster k D p r c a -> Raster k D p r c b #

(<$) :: a -> Raster k D p r c b -> Raster k D p r c a #

Functor (Raster k DW p r c) Source # 

Methods

fmap :: (a -> b) -> Raster k DW p r c a -> Raster k DW p r c b #

(<$) :: a -> Raster k DW p r c b -> Raster k DW p r c a #

(KnownNat r, KnownNat c) => Applicative (Raster k D p r c) Source # 

Methods

pure :: a -> Raster k D p r c a #

(<*>) :: Raster k D p r c (a -> b) -> Raster k D p r c a -> Raster k D p r c b #

liftA2 :: (a -> b -> c) -> Raster k D p r c a -> Raster k D p r c b -> Raster k D p r c c #

(*>) :: Raster k D p r c a -> Raster k D p r c b -> Raster k D p r c b #

(<*) :: Raster k D p r c a -> Raster k D p r c b -> Raster k D p r c a #

Foldable (Raster k D p r c) Source #

length has a specialized \(\mathcal{O}(1)\) implementation.

Methods

fold :: Monoid m => Raster k D p r c m -> m #

foldMap :: Monoid m => (a -> m) -> Raster k D p r c a -> m #

foldr :: (a -> b -> b) -> b -> Raster k D p r c a -> b #

foldr' :: (a -> b -> b) -> b -> Raster k D p r c a -> b #

foldl :: (b -> a -> b) -> b -> Raster k D p r c a -> b #

foldl' :: (b -> a -> b) -> b -> Raster k D p r c a -> b #

foldr1 :: (a -> a -> a) -> Raster k D p r c a -> a #

foldl1 :: (a -> a -> a) -> Raster k D p r c a -> a #

toList :: Raster k D p r c a -> [a] #

null :: Raster k D p r c a -> Bool #

length :: Raster k D p r c a -> Int #

elem :: Eq a => a -> Raster k D p r c a -> Bool #

maximum :: Ord a => Raster k D p r c a -> a #

minimum :: Ord a => Raster k D p r c a -> a #

sum :: Num a => Raster k D p r c a -> a #

product :: Num a => Raster k D p r c a -> a #

Eq a => Eq (Raster k D p r c a) Source # 

Methods

(==) :: Raster k D p r c a -> Raster k D p r c a -> Bool #

(/=) :: Raster k D p r c a -> Raster k D p r c a -> Bool #

Eq a => Eq (Raster k B p r c a) Source # 

Methods

(==) :: Raster k B p r c a -> Raster k B p r c a -> Bool #

(/=) :: Raster k B p r c a -> Raster k B p r c a -> Bool #

(Eq a, NFData a) => Eq (Raster k N p r c a) Source # 

Methods

(==) :: Raster k N p r c a -> Raster k N p r c a -> Bool #

(/=) :: Raster k N p r c a -> Raster k N p r c a -> Bool #

(Eq a, Prim a) => Eq (Raster k P p r c a) Source # 

Methods

(==) :: Raster k P p r c a -> Raster k P p r c a -> Bool #

(/=) :: Raster k P p r c a -> Raster k P p r c a -> Bool #

(Eq a, Storable a) => Eq (Raster k S p r c a) Source # 

Methods

(==) :: Raster k S p r c a -> Raster k S p r c a -> Bool #

(/=) :: Raster k S p r c a -> Raster k S p r c a -> Bool #

(Eq a, Unbox a) => Eq (Raster k U p r c a) Source # 

Methods

(==) :: Raster k U p r c a -> Raster k U p r c a -> Bool #

(/=) :: Raster k U p r c a -> Raster k U p r c a -> Bool #

(Fractional a, KnownNat r, KnownNat c) => Fractional (Raster k D p r c a) Source # 

Methods

(/) :: Raster k D p r c a -> Raster k D p r c a -> Raster k D p r c a #

recip :: Raster k D p r c a -> Raster k D p r c a #

fromRational :: Rational -> Raster k D p r c a #

(Num a, KnownNat r, KnownNat c) => Num (Raster k D p r c a) Source # 

Methods

(+) :: Raster k D p r c a -> Raster k D p r c a -> Raster k D p r c a #

(-) :: Raster k D p r c a -> Raster k D p r c a -> Raster k D p r c a #

(*) :: Raster k D p r c a -> Raster k D p r c a -> Raster k D p r c a #

negate :: Raster k D p r c a -> Raster k D p r c a #

abs :: Raster k D p r c a -> Raster k D p r c a #

signum :: Raster k D p r c a -> Raster k D p r c a #

fromInteger :: Integer -> Raster k D p r c a #

(Show a, Load (EltRepr u Ix2) Ix2 a, Size u Ix2 a) => Show (Raster k u p r c a) Source #

Warning: This will evaluate (at most) the 10x10 top-left corner of your Raster for display. This should only be used for debugging.

Methods

showsPrec :: Int -> Raster k u p r c a -> ShowS #

show :: Raster k u p r c a -> String #

showList :: [Raster k u p r c a] -> ShowS #

Semigroup a => Semigroup (Raster k D p r c a) Source # 

Methods

(<>) :: Raster k D p r c a -> Raster k D p r c a -> Raster k D p r c a #

sconcat :: NonEmpty (Raster k D p r c a) -> Raster k D p r c a #

stimes :: Integral b => b -> Raster k D p r c a -> Raster k D p r c a #

(Monoid a, KnownNat r, KnownNat c) => Monoid (Raster k D p r c a) Source # 

Methods

mempty :: Raster k D p r c a #

mappend :: Raster k D p r c a -> Raster k D p r c a -> Raster k D p r c a #

mconcat :: [Raster k D p r c a] -> Raster k D p r c a #

lazy :: Source u Ix2 a => Raster u p r c a -> Raster D p r c a Source #

\(\mathcal{O}(1)\). Force a Raster's representation to D, allowing it to undergo various operations. All operations between D Rasters are fused and allocate no extra memory.

strict :: (Load v Ix2 a, Mutable u Ix2 a) => u -> Raster v p r c a -> Raster u p r c a Source #

Evaluate some lazy (D, DW, or DI) Raster to some explicit Manifest type (i.e. to a real memory-backed Array). Will follow the Computation strategy of the underlying massiv Array.

Note: If using the Par computation strategy, make sure you're compiling with -with-rtsopts=-N to automatically use all available CPU cores at runtime. Otherwise your "parallel" operations will only execute on one core.

data RGBARaster p r c a Source #

An RGBA image whose colour bands are distinct.

Constructors

RGBARaster 

Fields

Creation

constant :: (KnownNat r, KnownNat c, Construct u Ix2 a) => u -> Comp -> a -> Raster u p r c a Source #

Create a Raster of any size which has the same value everywhere.

fromFunction :: forall u p r c a. (KnownNat r, KnownNat c, Construct u Ix2 a) => u -> Comp -> (Ix2 -> a) -> Raster u p r c a Source #

\(\mathcal{O}(1)\). Create a Raster from a function of its row and column number respectively.

fromVector :: forall v p r c a. (KnownNat r, KnownNat c, Vector v a, Mutable (ARepr v) Ix2 a, Typeable v) => Comp -> v a -> Either String (Raster (ARepr v) p r c a) Source #

\(\mathcal{O}(1)\). Create a Raster from the values of any Vector type. Will fail if the size of the Vector does not match the declared size of the Raster.

fromRGBA :: forall p r c a. (Elevator a, KnownNat r, KnownNat c) => FilePath -> IO (Either String (RGBARaster p r c a)) Source #

Read any image type into a Raster of distinct colour bands with the cell type you declare. If the source image stores its values as Int but you declare Double, the conversion will happen automatically.

Will fail if the declared size of the Raster does not match the actual size of the input image.

fromGray :: forall p r c a. (Elevator a, KnownNat r, KnownNat c) => FilePath -> IO (Either String (Raster S p r c a)) Source #

Read a grayscale image. If the source file has more than one colour band, they'll be combined automatically.

Colouring

To colour a Raster:

  1. Fully evaluate it with strict S.
  2. Use histogram to analyse the spread of its values. Currently only Word8 is supported.
  3. Use breaks on the Histogram to generate a list of "break points".
  4. Pass the break points to a function like greenRed to generate a "colour ramp" (a Map).
  5. Use this ramp with classify to colour your Raster in \(\mathcal{O}(n\log(n))\). invisible can be used as the default colour for values that fall outside the range of the Map.
colourIt :: Raster D p r c Word8 -> Raster S p r c (Pixel RGBA Word8)
colourIt (strict S -> r) = strict S . classify invisible cm $ lazy r
  where cm = blueGreen . breaks $ histogram r

If you aren't interested in colour but still want to render your Raster, consider grayscale. Coloured Rasters can be unwrapped with _array and then output with functions like writeImage.

grayscale :: Functor (Raster u p r c) => Raster u p r c a -> Raster u p r c (Pixel Y a) Source #

Convert a Raster into grayscale pixels, suitable for easy output with functions like writeImage.

newtype Histogram Source #

A count of Word8 values across some Raster.

Constructors

Histogram 

histogram :: Source u Ix2 Word8 => Raster u p r c Word8 -> Histogram Source #

Given a Raster of byte data, efficiently produce a Histogram that describes value counts across the image. To be passed to breaks.

breaks :: Histogram -> [Word8] Source #

Given a Histogram, produce a list of "colour breaks" as needed by functions like greenRed.

invisible :: Pixel RGBA Word8 Source #

An invisible pixel (alpha channel set to 0).

greenRed :: Ord k => [k] -> Map k (Pixel RGBA Word8) Source #

From page 32 of Cartographer's Toolkit.

spectrum :: Ord k => [k] -> Map k (Pixel RGBA Word8) Source #

From page 33 of Cartographer's Toolkit.

blueGreen :: Ord k => [k] -> Map k (Pixel RGBA Word8) Source #

From page 34 of Cartographer's Toolkit.

purpleYellow :: Ord k => [k] -> Map k (Pixel RGBA Word8) Source #

From page 35 of Cartographer's Toolkit.

brownBlue :: Ord k => [k] -> Map k (Pixel RGBA Word8) Source #

From page 36 of Cartographer's Toolkit.

grayBrown :: Ord k => [k] -> Map k (Pixel RGBA Word8) Source #

From page 37 of Cartographer's Toolkit.

greenPurple :: Ord k => [k] -> Map k (Pixel RGBA Word8) Source #

From page 38 of Cartographer's Toolkit.

brownYellow :: Ord k => [k] -> Map k (Pixel RGBA Word8) Source #

From page 39 of Cartographer's Toolkit.

purpleGreen :: Ord k => [k] -> Map k (Pixel RGBA Word8) Source #

From page 40 of Cartographer's Toolkit.

purpleRed :: Ord k => [k] -> Map k (Pixel RGBA Word8) Source #

From page 41 of Cartographer's Toolkit.

Output and Display

For coloured output, first use classify over your Raster to produce a Raster u p r c (Pixel RGBA Word8). Then unwrap it with _array and output with something like writeImage.

For quick debugging, you can visualize a Raster with displayImage:

raster :: Raster D p 512 512 Word8

>>> displayImage . _array . strict S . grayscale

writeImage :: (Source r Ix2 (Pixel cs e), ColorSpace cs e) => FilePath -> Image r cs e -> IO () #

This function will guess an output file format from the file extension and will write to file any image with the colorspace that is supported by that format. Precision of the image might be adjusted using Elevator if precision of the source array is not supported by the image file format. For instance an (Image r RGBA Double) being saved as PNG file would be written as (Image r RGBA Word16), thus using highest supported precision Word16 for that format. If automatic colors space is also desired, writeImageAuto can be used instead.

Can throw ConvertError, EncodeError and other usual IO errors.

writeImageAuto :: (Source r Ix2 (Pixel cs e), ColorSpace cs e, ToYA cs e, ToRGBA cs e, ToYCbCr cs e, ToCMYK cs e) => FilePath -> Image r cs e -> IO () #

Write an image to file while performing all necessary precisiona and color space conversions.

displayImage :: Writable (Auto TIF) (Image r cs e) => Image r cs e -> 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 might take some time before an image will appear.

png :: (Source u Ix2 (Pixel cs a), ColorSpace cs a) => Raster u p r c (Pixel cs a) -> ByteString Source #

Render a PNG-encoded ByteString from a coloured Raster. Useful for returning a Raster from a webserver endpoint.

Projections

class Projection p where Source #

The Earth is not a sphere. Various schemes have been invented throughout history that provide Point coordinates for locations on the earth, although all are approximations and come with trade-offs. We call these Projections, since they are a mapping of Sphere coordinates to some other approximation. The Projection used most commonly for mapping on the internet is called WebMercator.

A Projection is also known as a Coordinate Reference System (CRS).

Use reproject to convert Points between various Projections.

Note: Full support for Projections is still pending.

Minimal complete definition

toSphere, fromSphere

Methods

toSphere :: Point p -> Point Sphere Source #

Convert a Point in this Projection to one of radians on a perfect Sphere.

fromSphere :: Point Sphere -> Point p Source #

Convert a Point of radians on a perfect sphere to that of a specific Projection.

reproject :: (Projection p, Projection r) => Point p -> Point r Source #

Reproject a Point from one Projection to another.

data Sphere Source #

A perfect geometric sphere. The earth isn't actually shaped this way, but it's a convenient middle-ground for converting between various Projections.

data LatLng Source #

Latitude (north-south position) and Longitude (east-west position).

data WebMercator Source #

The most commonly used Projection for mapping in internet applications.

data Point p Source #

A location on the Earth in some Projection.

Constructors

Point 

Fields

Instances

Eq (Point k p) Source # 

Methods

(==) :: Point k p -> Point k p -> Bool #

(/=) :: Point k p -> Point k p -> Bool #

Show (Point k p) Source # 

Methods

showsPrec :: Int -> Point k p -> ShowS #

show :: Point k p -> String #

showList :: [Point k p] -> ShowS #

Map Algebra

Local Operations

Operations between Rasters. All operations are element-wise:

1 1 + 2 2  ==  3 3
1 1   2 2      3 3

2 2 * 3 3  ==  6 6
2 2   3 3      6 6

If an operation you need isn't available here, use our zipWith:

zipWith :: (a -> b -> d) -> Raster u p r c a -> Raster u p r c b -> Raster D p r c d

-- Your operation.
foo :: Int -> Int -> Int

bar :: Raster u p r c Int -> Raster u p r c Int -> Raster D p r c Int
bar a b = zipWith foo a b

zipWith :: (Source u Ix2 a, Source u Ix2 b) => (a -> b -> d) -> Raster u p r c a -> Raster u p r c b -> Raster D p r c d Source #

Combine two Rasters, element-wise, with a binary operator.

Unary

If you want to do simple unary Raster -> Raster operations (called LocalCalculation in GaCM), Raster is a Functor so you can use fmap as normal:

myRaster :: Raster D p r c Int

-- Add 17 to every value in the Raster.
fmap (+ 17) myRaster

classify :: (Ord a, Functor f) => b -> Map a b -> f a -> f b Source #

Called LocalClassification in GaCM. The first argument is the value to give to any index whose value is less than the lowest break in the Map.

This is a glorified fmap operation, but we expose it for convenience.

Binary

You can safely use these with the foldl family on any Foldable of Rasters. You would likely want foldl1' which is provided by both List and Vector.

Keep in mind that Raster D has a Num instance, so you can use all the normal math operators with them as well.

lmax :: (Ord a, Source u Ix2 a) => Raster u p r c a -> Raster u p r c a -> Raster D p r c a Source #

Finds the maximum value at each index between two Rasters.

lmin :: (Ord a, Source u Ix2 a) => Raster u p r c a -> Raster u p r c a -> Raster D p r c a Source #

Finds the minimum value at each index between two Rasters.

Other

There is no binary form of these functions that exists without producing numerical error, so you can't use the foldl family with these. Consider the average operation, where the following is not true: \[ \forall abc \in \mathbb{R}. \frac{\frac{a + b}{2} + c}{2} = \frac{a + b + c}{3} \]

lmean :: (Real a, Fractional b, KnownNat r, KnownNat c) => NonEmpty (Raster D p r c a) -> Raster D p r c b Source #

Averages the values per-index of all Rasters in a collection.

lvariety :: (KnownNat r, KnownNat c, Eq a) => NonEmpty (Raster D p r c a) -> Raster D p r c Word Source #

The count of unique values at each shared index.

lmajority :: (KnownNat r, KnownNat c, Ord a) => NonEmpty (Raster D p r c a) -> Raster D p r c a Source #

The most frequently appearing value at each shared index.

lminority :: (KnownNat r, KnownNat c, Ord a) => NonEmpty (Raster D p r c a) -> Raster D p r c a Source #

The least frequently appearing value at each shared index.

lvariance :: (Real a, KnownNat r, KnownNat c) => NonEmpty (Raster D p r c a) -> Maybe (Raster D p r c Double) Source #

A measure of how spread out a dataset is. This calculation will fail with Nothing if a length 1 list is given.

Focal Operations

Operations on one Raster, given some polygonal neighbourhood. Your Raster must be of a Manifest type (i.e. backed by real memory) before you attempt any focal operations. Without this constraint, wayward users run the risk of setting up operations that would perform terribly. Use strict to easily convert a lazy Raster to a memory-backed one.

myRaster :: Raster D p r c Float

averaged :: Raster DW p r c Float
averaged = fmean $ strict P myRaster

fsum :: (Num a, Default a, Manifest u Ix2 a) => Raster u p r c a -> Raster DW p r c a Source #

Focal Addition.

fproduct :: (Num a, Default a, Manifest u Ix2 a) => Raster u p r c a -> Raster DW p r c a Source #

Focal Product.

fmonoid :: (Monoid a, Default a, Manifest u Ix2 a) => Raster u p r c a -> Raster DW p r c a Source #

Focal Monoid - combine all elements of a neighbourhood via their Monoid instance. In terms of precedence, the neighbourhood focus is the "left-most", and all other elements are "added" to it.

This is not mentioned in GaCM, but seems useful nonetheless.

fmean :: (Real a, Fractional b, Default a, Manifest u Ix2 a) => Raster u p r c a -> Raster DW p r c b Source #

Focal Mean.

fmax :: (Ord a, Default a, Manifest u Ix2 a) => Raster u p r c a -> Raster DW p r c a Source #

Focal Maximum.

fmin :: (Ord a, Default a, Manifest u Ix2 a) => Raster u p r c a -> Raster DW p r c a Source #

Focal Minimum.

fmajority :: (Ord a, Default a, Manifest u Ix2 a) => Raster u p r c a -> Raster DW p r c a Source #

Focal Majority - the most frequently appearing value in each neighbourhood.

fminority :: (Ord a, Default a, Manifest u Ix2 a) => Raster u p r c a -> Raster DW p r c a Source #

Focal Minority - the least frequently appearing value in each neighbourhood.

fvariety :: (Ord a, Default a, Manifest u Ix2 a) => Raster u p r c a -> Raster DW p r c Word Source #

Focal Variety - the number of unique values in each neighbourhood.

fpercentage :: (Eq a, Default a, Manifest u Ix2 a) => Raster u p r c a -> Raster DW p r c Double Source #

Focal Percentage - the percentage of neighbourhood values that are equal to the neighbourhood focus. Not to be confused with fpercentile.

fpercentile :: (Ord a, Default a, Manifest u Ix2 a) => Raster u p r c a -> Raster DW p r c Double Source #

Focal Percentile - the percentage of neighbourhood values that are less than the neighbourhood focus. Not to be confused with fpercentage.

Lineal

Focal operations that assume that groups of data points represent line-like objects in a Raster. GaCM calls these lineal characteristics and describes them fully on page 18 and 19.

newtype Line Source #

A description of lineal directions with the same encoding as Drain. See flinkage and flength.

Constructors

Line 

Fields

Instances

Eq Line Source # 

Methods

(==) :: Line -> Line -> Bool #

(/=) :: Line -> Line -> Bool #

Ord Line Source # 

Methods

compare :: Line -> Line -> Ordering #

(<) :: Line -> Line -> Bool #

(<=) :: Line -> Line -> Bool #

(>) :: Line -> Line -> Bool #

(>=) :: Line -> Line -> Bool #

max :: Line -> Line -> Line #

min :: Line -> Line -> Line #

Show Line Source # 

Methods

showsPrec :: Int -> Line -> ShowS #

show :: Line -> String #

showList :: [Line] -> ShowS #

Storable Line Source # 

Methods

sizeOf :: Line -> Int #

alignment :: Line -> Int #

peekElemOff :: Ptr Line -> Int -> IO Line #

pokeElemOff :: Ptr Line -> Int -> Line -> IO () #

peekByteOff :: Ptr b -> Int -> IO Line #

pokeByteOff :: Ptr b -> Int -> Line -> IO () #

peek :: Ptr Line -> IO Line #

poke :: Ptr Line -> Line -> IO () #

Default Line Source # 

Methods

def :: Line #

NFData Line Source # 

Methods

rnf :: Line -> () #

Prim Line Source # 

flinkage :: (Default a, Eq a, Manifest u Ix2 a) => Raster u p r c a -> Raster DW p r c Line Source #

Focal Linkage - a description of how each neighbourhood focus is connected to its neighbours. Foci of equal value to none of their neighbours will have a value of 0.

flength :: Functor (Raster u p r c) => Raster u p r c Line -> Raster u p r c Double Source #

Focal Length - the length of the lineal structure at every location. The result is in "pixel units", where 1 is the height/width of one pixel.

Areal

Focal operations that assume that groups of data points represent 2D areas in a Raster. GaCM calls these areal characteristics and describes them fully on page 20 and 21.

data Corners Source #

A layout of the areal conditions of a single Raster pixel. It describes whether each pixel corner is occupied by the same "areal zone" as the pixel centre.

Instances

data Surround Source #

A state of surroundedness of a pixel corner. For the examples below, the bottom-left pixel is considered the focus and we're wondering about the surroundedness of its top-right corner.

Constructors

Complete

A corner has three of the same opponent against it.

The corner is considered "occupied" by the opponent value, thus forming a diagonal areal edge.

[ 1 1 ]
[ 0 1 ]
OneSide

One edge of a corner is touching an opponent, but the other edge touches a friend.

[ 1 1 ]  or  [ 0 1 ]
[ 0 0 ]      [ 0 1 ]
Open

A corner is surrounded by friends.

[ 0 0 ]  or  [ 0 0 ]  or  [ 1 0 ]
[ 0 0 ]      [ 0 1 ]      [ 0 0 ]
RightAngle

Similar to Complete, except that the diagonal opponent doesn't match the other two. The corner is considered surrounded, but not "occupied".

[ 1 2 ]
[ 0 1 ]
OutFlow

Similar to Complete, except that the area of the focus surrounds the diagonal neighbour.

[ 0 1 ]
[ 0 0 ]

fpartition :: (Default a, Eq a, Manifest u Ix2 a) => Raster u p r c a -> Raster DW p r c Corners Source #

Focal Partition - the areal form of each location, only considering the top-right edge.

fshape :: (Default a, Eq a, Manifest u Ix2 a) => Raster u p r c a -> Raster DW p r c Corners Source #

Like fpartition, but considers the Surround of all corners. Is alluded to in GaCM but isn't given its own operation name.

If preparing for ffrontage or farea, you almost certainly want this function and not fpartition.

ffrontage :: Functor (Raster u p r c) => Raster u p r c Corners -> Raster u p r c Double Source #

Focal Frontage - the length of areal edges between each pixel and its neighbourhood.

Usually, the output of fshape is the appropriate input for this function.

farea :: Functor (Raster u p r c) => Raster u p r c Corners -> Raster u p r c Double Source #

Focal Area - the area of the shape made up by a neighbourhood focus and its surrounding pixels. Each pixel is assumed to have length and width of 1.

Usually, the output of fshape is the appropriate input for this function.

Surficial

Focal operations that work over elevation Rasters. GaCM calls elevation features surficial characteristics and describes them fully on page 21 and 22.

Some of these operations require finding a "best-fit plane" that approximates the surficial shape of each pixel. Each pixel has 9 "facet points" calculated for it based on its surrounding pixels. We then use these facets to determine a plane which adheres to this equation:

\[ ax + by + c = z \] This is a linear equation that we can solve for in the form \(Ax = B\). For facet points \((x_i, y_i, z_i)\), we have:

\[ \begin{bmatrix} x_0 & y_0 & 1 \\ x_1 & y_1 & 1 \\ \vdots & \vdots & \vdots \\ x_n & y_n & 1 \end{bmatrix} \begin{bmatrix} a\\ b\\ c \end{bmatrix} = \begin{bmatrix} z_0\\ z_1\\ \vdots\\ z_n \end{bmatrix} \]

Since this system of equations is "over determined", we rework the above to find the coefficients of the best-fitting plane via: \[ \begin{bmatrix} a\\ b\\ c \end{bmatrix} = \boxed{(A^{T}A)^{-1}A^{T}}B \] The boxed section is called the "left pseudo inverse" and is available as leftPseudo. The actual values of \(A\) don't matter for our purposes, hence \(A\) can be fixed to avoid redundant calculations.

newtype Drain Source #

The main type for fdownstream and fupstream, used to calculate Focal Drainage. This scheme for encoding drainage patterns is described on page 81 of GaCM.

Full Explanation

Fluid can flow in or out of a square pixel in one of 256 ways. Imagine a pit, whose neighbours are all higher in elevation: liquid would flow in from all eight compass directions, but no liquid would flow out. Consider then a neighbourhood of random heights - fluid might flow in or out of the focus in any permutation of the eight directions.

The scheme for encoding these permutations in a single Word8 as described in GaCM is this:

Flow in a particular direction is represented by a power of 2:

[  1   2   4  ]
[  8       16 ]
[ 32  64  128 ]

Direction values are summed to make the encoding. If there were drainage to the North, East, and SouthEast, we'd see a sum of \(2 + 16 + 128 = 146\) to uniquely represent this.

Analysing a drainage pattern from a Drain is just as easy: check if the bit corresponding to the desired direction is flipped. The direction function handles this.

Constructors

Drain 

Fields

Instances

Eq Drain Source # 

Methods

(==) :: Drain -> Drain -> Bool #

(/=) :: Drain -> Drain -> Bool #

Ord Drain Source # 

Methods

compare :: Drain -> Drain -> Ordering #

(<) :: Drain -> Drain -> Bool #

(<=) :: Drain -> Drain -> Bool #

(>) :: Drain -> Drain -> Bool #

(>=) :: Drain -> Drain -> Bool #

max :: Drain -> Drain -> Drain #

min :: Drain -> Drain -> Drain #

Show Drain Source # 

Methods

showsPrec :: Int -> Drain -> ShowS #

show :: Drain -> String #

showList :: [Drain] -> ShowS #

Storable Drain Source # 

Methods

sizeOf :: Drain -> Int #

alignment :: Drain -> Int #

peekElemOff :: Ptr Drain -> Int -> IO Drain #

pokeElemOff :: Ptr Drain -> Int -> Drain -> IO () #

peekByteOff :: Ptr b -> Int -> IO Drain #

pokeByteOff :: Ptr b -> Int -> Drain -> IO () #

peek :: Ptr Drain -> IO Drain #

poke :: Ptr Drain -> Drain -> IO () #

Default Drain Source # 

Methods

def :: Drain #

NFData Drain Source # 

Methods

rnf :: Drain -> () #

Prim Drain Source # 

direction :: Direction -> Drain -> Bool Source #

Does a given Drain indicate flow in a certain Direction?

directions :: Drain -> Set Direction Source #

All Directions that a Drain indicates flow toward.

drainage :: Set Direction -> Drain Source #

The opposite of directions.

fvolume :: (Fractional a, Default a, Manifest u Ix2 a) => Raster u p r c a -> Raster DW p r c a Source #

Focal Volume - the surficial volume under each pixel, assuming the Raster represents elevation in some way.

fgradient :: Manifest u Ix2 Double => Raster u p r c Double -> Raster DW p r c Double Source #

Focal Gradient - a measurement of surficial slope for each pixel relative to the horizonal cartographic plane. Results are in radians, with a flat plane having a slope angle of 0 and a near-vertical plane approaching \(\tau / 4\).

faspect :: Manifest u Ix2 Double => Raster u p r c Double -> Raster DW p r c (Maybe Double) Source #

Focal Aspect - the compass direction toward which the surface descends most rapidly. Results are in radians, with 0 or \(\tau\) being North, \(\tau / 4\) being East, and so on. For areas that are essentially flat, their aspect will be Nothing.

faspect' :: Manifest u Ix2 Double => Raster u p r c Double -> Raster DW p r c Double Source #

Like faspect, but slightly faster. Beware of nonsense results when the plane is flat.

fdownstream :: Manifest u Ix2 Double => Raster u p r c Double -> Raster DW p r c Drain Source #

Focal Drainage - downstream portion. This indicates the one or more compass directions of steepest descent from each location. Appropriate as the input to fupstream.

Note: Peak-like surfaces will not flow equally in all 8 directions. Consider this neighbourhood:

[ 1 1 1 ]
[ 1 3 1 ]
[ 1 1 1 ]

According to the rules in GaCM for calculating the intermediate surficial "facet" points for the focus, 3, we arrive at the following facet height matrix:

[ 1.5 2 1.5 ]
[  2  3  2  ]
[ 1.5 2 1.5 ]

With these numbers it's clear that the corners would yield a steeper angle, so our resulting Drain would only contain the directions of the diagonals.

fupstream :: Manifest u Ix2 Drain => Raster u p r c Drain -> Raster DW p r c Drain Source #

Focal Drainage - upstream portion. This indicates the one of more compass directions from which liquid would flow into each surface location. See also fdownstream.

Utilities

leftPseudo :: Matrix Double Source #

The first part to the "left pseudo inverse" needed to calculate a best-fitting plane of 9 points.

tau :: Double Source #

\(\tau\). One full rotation of the unit circle.

Massiv Re-exports

For your convenience.

data D :: * #

Delayed representation.

Constructors

D 

Instances

Show D 

Methods

showsPrec :: Int -> D -> ShowS #

show :: D -> String #

showList :: [D] -> ShowS #

Index ix => Construct D ix e 

Methods

getComp :: Array D ix e -> Comp #

setComp :: Comp -> Array D ix e -> Array D ix e #

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array D ix e #

Index ix => Size D ix e 

Methods

size :: Array D ix e -> ix #

unsafeResize :: Index ix' => ix' -> Array D ix e -> Array D ix' e #

unsafeExtract :: ix -> ix -> Array D ix e -> Array (EltRepr D ix) ix e #

Index ix => Source D ix e 

Methods

unsafeIndex :: Array D ix e -> ix -> e #

unsafeLinearIndex :: Array D ix e -> Int -> e #

Index ix => Load D ix e 

Methods

loadS :: Monad m => Array D ix e -> (Int -> m e) -> (Int -> e -> m ()) -> m () #

loadP :: [Int] -> Array D ix e -> (Int -> IO e) -> (Int -> e -> IO ()) -> IO () #

((~) * (Elt D ix e) (Array D (Lower ix) e), Index ix) => OuterSlice D ix e 

Methods

unsafeOuterSlice :: Array D ix e -> Int -> Elt D ix e #

outerLength :: Array D ix e -> Int #

((~) * (Elt D ix e) (Array D (Lower ix) e), Index ix) => InnerSlice D ix e 

Methods

unsafeInnerSlice :: Array D ix e -> (Lower ix, Int) -> Int -> Elt D ix e #

(Index ix, Index (Lower ix), (~) * (Elt D ix e) (Array D (Lower ix) e)) => Slice D ix e 

Methods

unsafeSlice :: Array D ix e -> ix -> ix -> Dim -> Maybe (Elt D ix e) #

Functor (Array D ix) 

Methods

fmap :: (a -> b) -> Array D ix a -> Array D ix b #

(<$) :: a -> Array D ix b -> Array D ix a #

Index ix => Applicative (Array D ix) 

Methods

pure :: a -> Array D ix a #

(<*>) :: Array D ix (a -> b) -> Array D ix a -> Array D ix b #

liftA2 :: (a -> b -> c) -> Array D ix a -> Array D ix b -> Array D ix c #

(*>) :: Array D ix a -> Array D ix b -> Array D ix b #

(<*) :: Array D ix a -> Array D ix b -> Array D ix a #

Index ix => Foldable (Array D ix)

Row-major sequential folding over a Delayed array.

Methods

fold :: Monoid m => Array D ix m -> m #

foldMap :: Monoid m => (a -> m) -> Array D ix a -> m #

foldr :: (a -> b -> b) -> b -> Array D ix a -> b #

foldr' :: (a -> b -> b) -> b -> Array D ix a -> b #

foldl :: (b -> a -> b) -> b -> Array D ix a -> b #

foldl' :: (b -> a -> b) -> b -> Array D ix a -> b #

foldr1 :: (a -> a -> a) -> Array D ix a -> a #

foldl1 :: (a -> a -> a) -> Array D ix a -> a #

toList :: Array D ix a -> [a] #

null :: Array D ix a -> Bool #

length :: Array D ix a -> Int #

elem :: Eq a => a -> Array D ix a -> Bool #

maximum :: Ord a => Array D ix a -> a #

minimum :: Ord a => Array D ix a -> a #

sum :: Num a => Array D ix a -> a #

product :: Num a => Array D ix a -> a #

(Eq e, Index ix) => Eq (Array D ix e) 

Methods

(==) :: Array D ix e -> Array D ix e -> Bool #

(/=) :: Array D ix e -> Array D ix e -> Bool #

(Index ix, Floating e) => Floating (Array D ix e) 

Methods

pi :: Array D ix e #

exp :: Array D ix e -> Array D ix e #

log :: Array D ix e -> Array D ix e #

sqrt :: Array D ix e -> Array D ix e #

(**) :: Array D ix e -> Array D ix e -> Array D ix e #

logBase :: Array D ix e -> Array D ix e -> Array D ix e #

sin :: Array D ix e -> Array D ix e #

cos :: Array D ix e -> Array D ix e #

tan :: Array D ix e -> Array D ix e #

asin :: Array D ix e -> Array D ix e #

acos :: Array D ix e -> Array D ix e #

atan :: Array D ix e -> Array D ix e #

sinh :: Array D ix e -> Array D ix e #

cosh :: Array D ix e -> Array D ix e #

tanh :: Array D ix e -> Array D ix e #

asinh :: Array D ix e -> Array D ix e #

acosh :: Array D ix e -> Array D ix e #

atanh :: Array D ix e -> Array D ix e #

log1p :: Array D ix e -> Array D ix e #

expm1 :: Array D ix e -> Array D ix e #

log1pexp :: Array D ix e -> Array D ix e #

log1mexp :: Array D ix e -> Array D ix e #

(Index ix, Fractional e) => Fractional (Array D ix e) 

Methods

(/) :: Array D ix e -> Array D ix e -> Array D ix e #

recip :: Array D ix e -> Array D ix e #

fromRational :: Rational -> Array D ix e #

(Index ix, Num e) => Num (Array D ix e) 

Methods

(+) :: Array D ix e -> Array D ix e -> Array D ix e #

(-) :: Array D ix e -> Array D ix e -> Array D ix e #

(*) :: Array D ix e -> Array D ix e -> Array D ix e #

negate :: Array D ix e -> Array D ix e #

abs :: Array D ix e -> Array D ix e #

signum :: Array D ix e -> Array D ix e #

fromInteger :: Integer -> Array D ix e #

(Ord e, Index ix) => Ord (Array D ix e) 

Methods

compare :: Array D ix e -> Array D ix e -> Ordering #

(<) :: Array D ix e -> Array D ix e -> Bool #

(<=) :: Array D ix e -> Array D ix e -> Bool #

(>) :: Array D ix e -> Array D ix e -> Bool #

(>=) :: Array D ix e -> Array D ix e -> Bool #

max :: Array D ix e -> Array D ix e -> Array D ix e #

min :: Array D ix e -> Array D ix e -> Array D ix e #

Functor (Raster k D p r c) # 

Methods

fmap :: (a -> b) -> Raster k D p r c a -> Raster k D p r c b #

(<$) :: a -> Raster k D p r c b -> Raster k D p r c a #

(KnownNat r, KnownNat c) => Applicative (Raster k D p r c) # 

Methods

pure :: a -> Raster k D p r c a #

(<*>) :: Raster k D p r c (a -> b) -> Raster k D p r c a -> Raster k D p r c b #

liftA2 :: (a -> b -> c) -> Raster k D p r c a -> Raster k D p r c b -> Raster k D p r c c #

(*>) :: Raster k D p r c a -> Raster k D p r c b -> Raster k D p r c b #

(<*) :: Raster k D p r c a -> Raster k D p r c b -> Raster k D p r c a #

Foldable (Raster k D p r c) #

length has a specialized \(\mathcal{O}(1)\) implementation.

Methods

fold :: Monoid m => Raster k D p r c m -> m #

foldMap :: Monoid m => (a -> m) -> Raster k D p r c a -> m #

foldr :: (a -> b -> b) -> b -> Raster k D p r c a -> b #

foldr' :: (a -> b -> b) -> b -> Raster k D p r c a -> b #

foldl :: (b -> a -> b) -> b -> Raster k D p r c a -> b #

foldl' :: (b -> a -> b) -> b -> Raster k D p r c a -> b #

foldr1 :: (a -> a -> a) -> Raster k D p r c a -> a #

foldl1 :: (a -> a -> a) -> Raster k D p r c a -> a #

toList :: Raster k D p r c a -> [a] #

null :: Raster k D p r c a -> Bool #

length :: Raster k D p r c a -> Int #

elem :: Eq a => a -> Raster k D p r c a -> Bool #

maximum :: Ord a => Raster k D p r c a -> a #

minimum :: Ord a => Raster k D p r c a -> a #

sum :: Num a => Raster k D p r c a -> a #

product :: Num a => Raster k D p r c a -> a #

Eq a => Eq (Raster k D p r c a) # 

Methods

(==) :: Raster k D p r c a -> Raster k D p r c a -> Bool #

(/=) :: Raster k D p r c a -> Raster k D p r c a -> Bool #

(Fractional a, KnownNat r, KnownNat c) => Fractional (Raster k D p r c a) # 

Methods

(/) :: Raster k D p r c a -> Raster k D p r c a -> Raster k D p r c a #

recip :: Raster k D p r c a -> Raster k D p r c a #

fromRational :: Rational -> Raster k D p r c a #

(Num a, KnownNat r, KnownNat c) => Num (Raster k D p r c a) # 

Methods

(+) :: Raster k D p r c a -> Raster k D p r c a -> Raster k D p r c a #

(-) :: Raster k D p r c a -> Raster k D p r c a -> Raster k D p r c a #

(*) :: Raster k D p r c a -> Raster k D p r c a -> Raster k D p r c a #

negate :: Raster k D p r c a -> Raster k D p r c a #

abs :: Raster k D p r c a -> Raster k D p r c a #

signum :: Raster k D p r c a -> Raster k D p r c a #

fromInteger :: Integer -> Raster k D p r c a #

Semigroup a => Semigroup (Raster k D p r c a) # 

Methods

(<>) :: Raster k D p r c a -> Raster k D p r c a -> Raster k D p r c a #

sconcat :: NonEmpty (Raster k D p r c a) -> Raster k D p r c a #

stimes :: Integral b => b -> Raster k D p r c a -> Raster k D p r c a #

(Monoid a, KnownNat r, KnownNat c) => Monoid (Raster k D p r c a) # 

Methods

mempty :: Raster k D p r c a #

mappend :: Raster k D p r c a -> Raster k D p r c a -> Raster k D p r c a #

mconcat :: [Raster k D p r c a] -> Raster k D p r c a #

data Array D 
data Array D = DArray {}
type EltRepr D ix 
type EltRepr D ix = D

data DW :: * #

Delayed Windowed Array representation.

Instances

Index ix => Construct DW ix e 

Methods

getComp :: Array DW ix e -> Comp #

setComp :: Comp -> Array DW ix e -> Array DW ix e #

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array DW ix e #

Index ix => Size DW ix e

Any resize or extract on Windowed Array will hurt the performance.

Methods

size :: Array DW ix e -> ix #

unsafeResize :: Index ix' => ix' -> Array DW ix e -> Array DW ix' e #

unsafeExtract :: ix -> ix -> Array DW ix e -> Array (EltRepr DW ix) ix e #

(Index ix, Load DW (Lower ix) e) => Load DW ix e 

Methods

loadS :: Monad m => Array DW ix e -> (Int -> m e) -> (Int -> e -> m ()) -> m () #

loadP :: [Int] -> Array DW ix e -> (Int -> IO e) -> (Int -> e -> IO ()) -> IO () #

Load DW Ix1 e 

Methods

loadS :: Monad m => Array DW Ix1 e -> (Int -> m e) -> (Int -> e -> m ()) -> m () #

loadP :: [Int] -> Array DW Ix1 e -> (Int -> IO e) -> (Int -> e -> IO ()) -> IO () #

Load DW Ix2 e 

Methods

loadS :: Monad m => Array DW Ix2 e -> (Int -> m e) -> (Int -> e -> m ()) -> m () #

loadP :: [Int] -> Array DW Ix2 e -> (Int -> IO e) -> (Int -> e -> IO ()) -> IO () #

Load DW Ix2T e 

Methods

loadS :: Monad m => Array DW Ix2T e -> (Int -> m e) -> (Int -> e -> m ()) -> m () #

loadP :: [Int] -> Array DW Ix2T e -> (Int -> IO e) -> (Int -> e -> IO ()) -> IO () #

Functor (Array DW ix) 

Methods

fmap :: (a -> b) -> Array DW ix a -> Array DW ix b #

(<$) :: a -> Array DW ix b -> Array DW ix a #

Functor (Raster k DW p r c) # 

Methods

fmap :: (a -> b) -> Raster k DW p r c a -> Raster k DW p r c b #

(<$) :: a -> Raster k DW p r c b -> Raster k DW p r c a #

data Array DW 
type EltRepr DW ix 
type EltRepr DW ix = D

data S :: * #

Representation for Storable elements

Constructors

S 

Instances

Show S 

Methods

showsPrec :: Int -> S -> ShowS #

show :: S -> String #

showList :: [S] -> ShowS #

(Storable e, Index ix) => Construct S ix e 

Methods

getComp :: Array S ix e -> Comp #

setComp :: Comp -> Array S ix e -> Array S ix e #

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array S ix e #

(Storable e, Index ix) => Size S ix e 

Methods

size :: Array S ix e -> ix #

unsafeResize :: Index ix' => ix' -> Array S ix e -> Array S ix' e #

unsafeExtract :: ix -> ix -> Array S ix e -> Array (EltRepr S ix) ix e #

(Storable e, Index ix) => Source S ix e 

Methods

unsafeIndex :: Array S ix e -> ix -> e #

unsafeLinearIndex :: Array S ix e -> Int -> e #

(Storable e, Index ix, Index (Lower ix), (~) * (Elt M ix e) (Array M (Lower ix) e), (~) * (Elt S ix e) (Array M (Lower ix) e)) => OuterSlice S ix e 

Methods

unsafeOuterSlice :: Array S ix e -> Int -> Elt S ix e #

outerLength :: Array S ix e -> Int #

(Storable e, Index ix, Index (Lower ix), (~) * (Elt M ix e) (Array M (Lower ix) e), (~) * (Elt S ix e) (Array M (Lower ix) e)) => InnerSlice S ix e 

Methods

unsafeInnerSlice :: Array S ix e -> (Lower ix, Int) -> Int -> Elt S ix e #

(Index ix, Storable e) => Manifest S ix e 

Methods

unsafeLinearIndexM :: Array S ix e -> Int -> e #

(Index ix, Storable e) => Mutable S ix e 

Associated Types

data MArray s S ix e :: * #

Methods

msize :: MArray s S ix e -> ix #

unsafeThaw :: PrimMonad m => Array S ix e -> m (MArray (PrimState m) S ix e) #

unsafeFreeze :: PrimMonad m => Comp -> MArray (PrimState m) S ix e -> m (Array S ix e) #

unsafeNew :: PrimMonad m => ix -> m (MArray (PrimState m) S ix e) #

unsafeNewZero :: PrimMonad m => ix -> m (MArray (PrimState m) S ix e) #

unsafeLinearRead :: PrimMonad m => MArray (PrimState m) S ix e -> Int -> m e #

unsafeLinearWrite :: PrimMonad m => MArray (PrimState m) S ix e -> Int -> e -> m () #

unsafeNewA :: Applicative f => ix -> WorldState -> f (WorldState, MArray RealWorld S ix e)

unsafeThawA :: Applicative m => Array S ix e -> WorldState -> m (WorldState, MArray RealWorld S ix e)

unsafeFreezeA :: Applicative m => Comp -> MArray RealWorld S ix e -> WorldState -> m (WorldState, Array S ix e)

unsafeLinearWriteA :: Applicative m => MArray RealWorld S ix e -> Int -> e -> WorldState -> m WorldState

ColorSpace cs e => Readable PBM (Image S cs e) 

Methods

decode :: PBM -> ReadOptions PBM -> ByteString -> Image S cs e #

ColorSpace cs e => Readable PGM (Image S cs e) 

Methods

decode :: PGM -> ReadOptions PGM -> ByteString -> Image S cs e #

ColorSpace cs e => Readable PPM (Image S cs e) 

Methods

decode :: PPM -> ReadOptions PPM -> ByteString -> Image S cs e #

ColorSpace cs e => Readable BMP (Image S cs e) 

Methods

decode :: BMP -> ReadOptions BMP -> ByteString -> Image S cs e #

ColorSpace cs e => Readable PNG (Image S cs e) 

Methods

decode :: PNG -> ReadOptions PNG -> ByteString -> Image S cs e #

ColorSpace cs e => Readable GIF (Image S cs e) 

Methods

decode :: GIF -> ReadOptions GIF -> ByteString -> Image S cs e #

ColorSpace cs e => Readable HDR (Image S cs e) 

Methods

decode :: HDR -> ReadOptions HDR -> ByteString -> Image S cs e #

ColorSpace cs e => Readable JPG (Image S cs e) 

Methods

decode :: JPG -> ReadOptions JPG -> ByteString -> Image S cs e #

ColorSpace cs e => Readable TGA (Image S cs e) 

Methods

decode :: TGA -> ReadOptions TGA -> ByteString -> Image S cs e #

ColorSpace cs e => Readable TIF (Image S cs e) 

Methods

decode :: TIF -> ReadOptions TIF -> ByteString -> Image S cs e #

ColorSpace cs e => Readable (Sequence PBM) (Array B Ix1 (Image S cs e)) 
ColorSpace cs e => Readable (Sequence PGM) (Array B Ix1 (Image S cs e)) 
ColorSpace cs e => Readable (Sequence PPM) (Array B Ix1 (Image S cs e)) 
ColorSpace cs e => Readable (Sequence GIF) (Array B Ix1 (GifDelay, Image S cs e)) 
ColorSpace cs e => Readable (Sequence GIF) (Array B Ix1 (Image S cs e)) 
(Storable e, IsList (Array L ix e), Nested LN ix e, Nested L ix e, Ragged L ix e) => IsList (Array S ix e) 

Associated Types

type Item (Array S ix e) :: * #

Methods

fromList :: [Item (Array S ix e)] -> Array S ix e #

fromListN :: Int -> [Item (Array S ix e)] -> Array S ix e #

toList :: Array S ix e -> [Item (Array S ix e)] #

(Storable e, Eq e, Index ix) => Eq (Array S ix e) 

Methods

(==) :: Array S ix e -> Array S ix e -> Bool #

(/=) :: Array S ix e -> Array S ix e -> Bool #

(Storable e, Ord e, Index ix) => Ord (Array S ix e) 

Methods

compare :: Array S ix e -> Array S ix e -> Ordering #

(<) :: Array S ix e -> Array S ix e -> Bool #

(<=) :: Array S ix e -> Array S ix e -> Bool #

(>) :: Array S ix e -> Array S ix e -> Bool #

(>=) :: Array S ix e -> Array S ix e -> Bool #

max :: Array S ix e -> Array S ix e -> Array S ix e #

min :: Array S ix e -> Array S ix e -> Array S ix e #

(Index ix, NFData e) => NFData (Array S ix e) 

Methods

rnf :: Array S ix e -> () #

(Eq a, Storable a) => Eq (Raster k S p r c a) # 

Methods

(==) :: Raster k S p r c a -> Raster k S p r c a -> Bool #

(/=) :: Raster k S p r c a -> Raster k S p r c a -> Bool #

type VRepr S 
type VRepr S = Vector
data Array S 
data Array S = SArray {}
type EltRepr S ix 
type EltRepr S ix = M
data MArray s S 
data MArray s S = MSArray !ix !(MVector s e)
type Item (Array S ix e) 
type Item (Array S ix e) = Item (Array L ix e)

data P :: * #

Representation for Primitive elements

Constructors

P 

Instances

Show P 

Methods

showsPrec :: Int -> P -> ShowS #

show :: P -> String #

showList :: [P] -> ShowS #

(Prim e, Index ix) => Construct P ix e 

Methods

getComp :: Array P ix e -> Comp #

setComp :: Comp -> Array P ix e -> Array P ix e #

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array P ix e #

(Prim e, Index ix) => Size P ix e 

Methods

size :: Array P ix e -> ix #

unsafeResize :: Index ix' => ix' -> Array P ix e -> Array P ix' e #

unsafeExtract :: ix -> ix -> Array P ix e -> Array (EltRepr P ix) ix e #

(Prim e, Index ix) => Source P ix e 

Methods

unsafeIndex :: Array P ix e -> ix -> e #

unsafeLinearIndex :: Array P ix e -> Int -> e #

(Prim e, Index ix, Index (Lower ix), (~) * (Elt M ix e) (Array M (Lower ix) e), (~) * (Elt P ix e) (Array M (Lower ix) e)) => OuterSlice P ix e 

Methods

unsafeOuterSlice :: Array P ix e -> Int -> Elt P ix e #

outerLength :: Array P ix e -> Int #

Prim e => OuterSlice P Ix1 e 

Methods

unsafeOuterSlice :: Array P Ix1 e -> Int -> Elt P Ix1 e #

outerLength :: Array P Ix1 e -> Int #

(Prim e, Index ix, Index (Lower ix), (~) * (Elt M ix e) (Array M (Lower ix) e), (~) * (Elt P ix e) (Array M (Lower ix) e)) => InnerSlice P ix e 

Methods

unsafeInnerSlice :: Array P ix e -> (Lower ix, Int) -> Int -> Elt P ix e #

Prim e => InnerSlice P Ix1 e 

Methods

unsafeInnerSlice :: Array P Ix1 e -> (Lower Ix1, Int) -> Int -> Elt P Ix1 e #

(Prim e, Index ix, Index (Lower ix), (~) * (Elt P ix e) (Elt M ix e), (~) * (Elt M ix e) (Array M (Lower ix) e)) => Slice P ix e 

Methods

unsafeSlice :: Array P ix e -> ix -> ix -> Dim -> Maybe (Elt P ix e) #

Prim e => Slice P Ix1 e 

Methods

unsafeSlice :: Array P Ix1 e -> Ix1 -> Ix1 -> Dim -> Maybe (Elt P Ix1 e) #

(Index ix, Prim e) => Manifest P ix e 

Methods

unsafeLinearIndexM :: Array P ix e -> Int -> e #

(Index ix, Prim e) => Mutable P ix e 

Associated Types

data MArray s P ix e :: * #

Methods

msize :: MArray s P ix e -> ix #

unsafeThaw :: PrimMonad m => Array P ix e -> m (MArray (PrimState m) P ix e) #

unsafeFreeze :: PrimMonad m => Comp -> MArray (PrimState m) P ix e -> m (Array P ix e) #

unsafeNew :: PrimMonad m => ix -> m (MArray (PrimState m) P ix e) #

unsafeNewZero :: PrimMonad m => ix -> m (MArray (PrimState m) P ix e) #

unsafeLinearRead :: PrimMonad m => MArray (PrimState m) P ix e -> Int -> m e #

unsafeLinearWrite :: PrimMonad m => MArray (PrimState m) P ix e -> Int -> e -> m () #

unsafeNewA :: Applicative f => ix -> WorldState -> f (WorldState, MArray RealWorld P ix e)

unsafeThawA :: Applicative m => Array P ix e -> WorldState -> m (WorldState, MArray RealWorld P ix e)

unsafeFreezeA :: Applicative m => Comp -> MArray RealWorld P ix e -> WorldState -> m (WorldState, Array P ix e)

unsafeLinearWriteA :: Applicative m => MArray RealWorld P ix e -> Int -> e -> WorldState -> m WorldState

(Prim e, IsList (Array L ix e), Nested LN ix e, Nested L ix e, Ragged L ix e) => IsList (Array P ix e) 

Associated Types

type Item (Array P ix e) :: * #

Methods

fromList :: [Item (Array P ix e)] -> Array P ix e #

fromListN :: Int -> [Item (Array P ix e)] -> Array P ix e #

toList :: Array P ix e -> [Item (Array P ix e)] #

(Prim e, Eq e, Index ix) => Eq (Array P ix e) 

Methods

(==) :: Array P ix e -> Array P ix e -> Bool #

(/=) :: Array P ix e -> Array P ix e -> Bool #

(Prim e, Ord e, Index ix) => Ord (Array P ix e) 

Methods

compare :: Array P ix e -> Array P ix e -> Ordering #

(<) :: Array P ix e -> Array P ix e -> Bool #

(<=) :: Array P ix e -> Array P ix e -> Bool #

(>) :: Array P ix e -> Array P ix e -> Bool #

(>=) :: Array P ix e -> Array P ix e -> Bool #

max :: Array P ix e -> Array P ix e -> Array P ix e #

min :: Array P ix e -> Array P ix e -> Array P ix e #

(Index ix, NFData e) => NFData (Array P ix e) 

Methods

rnf :: Array P ix e -> () #

(Eq a, Prim a) => Eq (Raster k P p r c a) # 

Methods

(==) :: Raster k P p r c a -> Raster k P p r c a -> Bool #

(/=) :: Raster k P p r c a -> Raster k P p r c a -> Bool #

type VRepr P 
type VRepr P = Vector
data Array P 
data Array P = PArray {}
type EltRepr P ix 
type EltRepr P ix = M
data MArray s P 
data MArray s P = MPArray !ix !(MutableByteArray s)
type Item (Array P ix e) 
type Item (Array P ix e) = Item (Array L ix e)

data U :: * #

Representation for Unboxed elements

Constructors

U 

Instances

Show U 

Methods

showsPrec :: Int -> U -> ShowS #

show :: U -> String #

showList :: [U] -> ShowS #

(Unbox e, Index ix) => Construct U ix e 

Methods

getComp :: Array U ix e -> Comp #

setComp :: Comp -> Array U ix e -> Array U ix e #

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array U ix e #

(Unbox e, Index ix) => Size U ix e 

Methods

size :: Array U ix e -> ix #

unsafeResize :: Index ix' => ix' -> Array U ix e -> Array U ix' e #

unsafeExtract :: ix -> ix -> Array U ix e -> Array (EltRepr U ix) ix e #

(Unbox e, Index ix) => Source U ix e 

Methods

unsafeIndex :: Array U ix e -> ix -> e #

unsafeLinearIndex :: Array U ix e -> Int -> e #

(Unbox e, Index ix, Index (Lower ix), (~) * (Elt U ix e) (Elt M ix e), (~) * (Elt M ix e) (Array M (Lower ix) e)) => OuterSlice U ix e 

Methods

unsafeOuterSlice :: Array U ix e -> Int -> Elt U ix e #

outerLength :: Array U ix e -> Int #

Unbox e => OuterSlice U Ix1 e 

Methods

unsafeOuterSlice :: Array U Ix1 e -> Int -> Elt U Ix1 e #

outerLength :: Array U Ix1 e -> Int #

(Unbox e, Index ix, Index (Lower ix), (~) * (Elt U ix e) (Elt M ix e), (~) * (Elt M ix e) (Array M (Lower ix) e)) => InnerSlice U ix e 

Methods

unsafeInnerSlice :: Array U ix e -> (Lower ix, Int) -> Int -> Elt U ix e #

Unbox e => InnerSlice U Ix1 e 

Methods

unsafeInnerSlice :: Array U Ix1 e -> (Lower Ix1, Int) -> Int -> Elt U Ix1 e #

(Unbox e, Index ix, Index (Lower ix), (~) * (Elt U ix e) (Elt M ix e), (~) * (Elt M ix e) (Array M (Lower ix) e)) => Slice U ix e 

Methods

unsafeSlice :: Array U ix e -> ix -> ix -> Dim -> Maybe (Elt U ix e) #

Unbox e => Slice U Ix1 e 

Methods

unsafeSlice :: Array U Ix1 e -> Ix1 -> Ix1 -> Dim -> Maybe (Elt U Ix1 e) #

(Unbox e, Index ix) => Manifest U ix e 

Methods

unsafeLinearIndexM :: Array U ix e -> Int -> e #

(Unbox e, Index ix) => Mutable U ix e 

Associated Types

data MArray s U ix e :: * #

Methods

msize :: MArray s U ix e -> ix #

unsafeThaw :: PrimMonad m => Array U ix e -> m (MArray (PrimState m) U ix e) #

unsafeFreeze :: PrimMonad m => Comp -> MArray (PrimState m) U ix e -> m (Array U ix e) #

unsafeNew :: PrimMonad m => ix -> m (MArray (PrimState m) U ix e) #

unsafeNewZero :: PrimMonad m => ix -> m (MArray (PrimState m) U ix e) #

unsafeLinearRead :: PrimMonad m => MArray (PrimState m) U ix e -> Int -> m e #

unsafeLinearWrite :: PrimMonad m => MArray (PrimState m) U ix e -> Int -> e -> m () #

unsafeNewA :: Applicative f => ix -> WorldState -> f (WorldState, MArray RealWorld U ix e)

unsafeThawA :: Applicative m => Array U ix e -> WorldState -> m (WorldState, MArray RealWorld U ix e)

unsafeFreezeA :: Applicative m => Comp -> MArray RealWorld U ix e -> WorldState -> m (WorldState, Array U ix e)

unsafeLinearWriteA :: Applicative m => MArray RealWorld U ix e -> Int -> e -> WorldState -> m WorldState

(Unbox e, IsList (Array L ix e), Nested LN ix e, Nested L ix e, Ragged L ix e) => IsList (Array U ix e) 

Associated Types

type Item (Array U ix e) :: * #

Methods

fromList :: [Item (Array U ix e)] -> Array U ix e #

fromListN :: Int -> [Item (Array U ix e)] -> Array U ix e #

toList :: Array U ix e -> [Item (Array U ix e)] #

(Unbox e, Eq e, Index ix) => Eq (Array U ix e) 

Methods

(==) :: Array U ix e -> Array U ix e -> Bool #

(/=) :: Array U ix e -> Array U ix e -> Bool #

(Unbox e, Ord e, Index ix) => Ord (Array U ix e) 

Methods

compare :: Array U ix e -> Array U ix e -> Ordering #

(<) :: Array U ix e -> Array U ix e -> Bool #

(<=) :: Array U ix e -> Array U ix e -> Bool #

(>) :: Array U ix e -> Array U ix e -> Bool #

(>=) :: Array U ix e -> Array U ix e -> Bool #

max :: Array U ix e -> Array U ix e -> Array U ix e #

min :: Array U ix e -> Array U ix e -> Array U ix e #

(Index ix, NFData e) => NFData (Array U ix e) 

Methods

rnf :: Array U ix e -> () #

(Eq a, Unbox a) => Eq (Raster k U p r c a) # 

Methods

(==) :: Raster k U p r c a -> Raster k U p r c a -> Bool #

(/=) :: Raster k U p r c a -> Raster k U p r c a -> Bool #

type VRepr U 
type VRepr U = Vector
data Array U 
data Array U = UArray {}
type EltRepr U ix 
type EltRepr U ix = M
data MArray s U 
data MArray s U = MUArray ix (MVector s e)
type Item (Array U ix e) 
type Item (Array U ix e) = Item (Array L ix e)

data B :: * #

Array representation for Boxed elements. This structure is element and spine strict, but elements are strict to Weak Head Normal Form (WHNF) only.

Constructors

B 

Instances

Show B 

Methods

showsPrec :: Int -> B -> ShowS #

show :: B -> String #

showList :: [B] -> ShowS #

Index ix => Construct B ix e 

Methods

getComp :: Array B ix e -> Comp #

setComp :: Comp -> Array B ix e -> Array B ix e #

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array B ix e #

Index ix => Size B ix e 

Methods

size :: Array B ix e -> ix #

unsafeResize :: Index ix' => ix' -> Array B ix e -> Array B ix' e #

unsafeExtract :: ix -> ix -> Array B ix e -> Array (EltRepr B ix) ix e #

Index ix => Source B ix e 

Methods

unsafeIndex :: Array B ix e -> ix -> e #

unsafeLinearIndex :: Array B ix e -> Int -> e #

(NFData e, Index ix, Index (Lower ix), (~) * (Elt M ix e) (Array M (Lower ix) e), (~) * (Elt B ix e) (Array M (Lower ix) e)) => OuterSlice B ix e 

Methods

unsafeOuterSlice :: Array B ix e -> Int -> Elt B ix e #

outerLength :: Array B ix e -> Int #

(NFData e, Index ix, Index (Lower ix), (~) * (Elt M ix e) (Array M (Lower ix) e), (~) * (Elt B ix e) (Array M (Lower ix) e)) => InnerSlice B ix e 

Methods

unsafeInnerSlice :: Array B ix e -> (Lower ix, Int) -> Int -> Elt B ix e #

Index ix => Manifest B ix e 

Methods

unsafeLinearIndexM :: Array B ix e -> Int -> e #

Index ix => Mutable B ix e 

Associated Types

data MArray s B ix e :: * #

Methods

msize :: MArray s B ix e -> ix #

unsafeThaw :: PrimMonad m => Array B ix e -> m (MArray (PrimState m) B ix e) #

unsafeFreeze :: PrimMonad m => Comp -> MArray (PrimState m) B ix e -> m (Array B ix e) #

unsafeNew :: PrimMonad m => ix -> m (MArray (PrimState m) B ix e) #

unsafeNewZero :: PrimMonad m => ix -> m (MArray (PrimState m) B ix e) #

unsafeLinearRead :: PrimMonad m => MArray (PrimState m) B ix e -> Int -> m e #

unsafeLinearWrite :: PrimMonad m => MArray (PrimState m) B ix e -> Int -> e -> m () #

unsafeNewA :: Applicative f => ix -> WorldState -> f (WorldState, MArray RealWorld B ix e)

unsafeThawA :: Applicative m => Array B ix e -> WorldState -> m (WorldState, MArray RealWorld B ix e)

unsafeFreezeA :: Applicative m => Comp -> MArray RealWorld B ix e -> WorldState -> m (WorldState, Array B ix e)

unsafeLinearWriteA :: Applicative m => MArray RealWorld B ix e -> Int -> e -> WorldState -> m WorldState

ColorSpace cs e => Readable (Sequence PBM) (Array B Ix1 (Image S cs e)) 
ColorSpace cs e => Readable (Sequence PGM) (Array B Ix1 (Image S cs e)) 
ColorSpace cs e => Readable (Sequence PPM) (Array B Ix1 (Image S cs e)) 
ColorSpace cs e => Readable (Sequence GIF) (Array B Ix1 (GifDelay, Image S cs e)) 
ColorSpace cs e => Readable (Sequence GIF) (Array B Ix1 (Image S cs e)) 
(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Sequence (Auto PBM)) (Array B Ix1 (Image r cs e)) 
(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Sequence (Auto PGM)) (Array B Ix1 (Image r cs e)) 
(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Sequence (Auto PPM)) (Array B Ix1 (Image r cs e)) 
(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Sequence (Auto GIF)) (Array B Ix1 (Image r cs e)) 
(ColorSpace cs e, Source r Ix2 (Pixel cs e)) => Writable (Sequence GIF) (Array B Ix1 (GifDelay, Image r cs e)) 
Index ix => Foldable (Array B ix)

Row-major sequential folding over a Boxed array.

Methods

fold :: Monoid m => Array B ix m -> m #

foldMap :: Monoid m => (a -> m) -> Array B ix a -> m #

foldr :: (a -> b -> b) -> b -> Array B ix a -> b #

foldr' :: (a -> b -> b) -> b -> Array B ix a -> b #

foldl :: (b -> a -> b) -> b -> Array B ix a -> b #

foldl' :: (b -> a -> b) -> b -> Array B ix a -> b #

foldr1 :: (a -> a -> a) -> Array B ix a -> a #

foldl1 :: (a -> a -> a) -> Array B ix a -> a #

toList :: Array B ix a -> [a] #

null :: Array B ix a -> Bool #

length :: Array B ix a -> Int #

elem :: Eq a => a -> Array B ix a -> Bool #

maximum :: Ord a => Array B ix a -> a #

minimum :: Ord a => Array B ix a -> a #

sum :: Num a => Array B ix a -> a #

product :: Num a => Array B ix a -> a #

(IsList (Array L ix e), Nested LN ix e, Nested L ix e, Ragged L ix e) => IsList (Array B ix e) 

Associated Types

type Item (Array B ix e) :: * #

Methods

fromList :: [Item (Array B ix e)] -> Array B ix e #

fromListN :: Int -> [Item (Array B ix e)] -> Array B ix e #

toList :: Array B ix e -> [Item (Array B ix e)] #

(Index ix, Eq e) => Eq (Array B ix e) 

Methods

(==) :: Array B ix e -> Array B ix e -> Bool #

(/=) :: Array B ix e -> Array B ix e -> Bool #

(Index ix, Ord e) => Ord (Array B ix e) 

Methods

compare :: Array B ix e -> Array B ix e -> Ordering #

(<) :: Array B ix e -> Array B ix e -> Bool #

(<=) :: Array B ix e -> Array B ix e -> Bool #

(>) :: Array B ix e -> Array B ix e -> Bool #

(>=) :: Array B ix e -> Array B ix e -> Bool #

max :: Array B ix e -> Array B ix e -> Array B ix e #

min :: Array B ix e -> Array B ix e -> Array B ix e #

(Index ix, NFData e) => NFData (Array B ix e) 

Methods

rnf :: Array B ix e -> () #

Eq a => Eq (Raster k B p r c a) # 

Methods

(==) :: Raster k B p r c a -> Raster k B p r c a -> Bool #

(/=) :: Raster k B p r c a -> Raster k B p r c a -> Bool #

type VRepr B 
type VRepr B = Vector
data Array B 
data Array B = BArray {}
type EltRepr B ix 
type EltRepr B ix = M
data MArray s B 
data MArray s B = MBArray !ix !(MutableArray s e)
type Item (Array B ix e) 
type Item (Array B ix e) = Item (Array L ix e)

data N :: * #

Array representation for Boxed elements. This structure is element and spine strict, and elements are always in Normal Form (NF), therefore NFData instance is required.

Constructors

N 

Instances

Show N 

Methods

showsPrec :: Int -> N -> ShowS #

show :: N -> String #

showList :: [N] -> ShowS #

(Index ix, NFData e) => Construct N ix e 

Methods

getComp :: Array N ix e -> Comp #

setComp :: Comp -> Array N ix e -> Array N ix e #

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array N ix e #

(Index ix, NFData e) => Size N ix e 

Methods

size :: Array N ix e -> ix #

unsafeResize :: Index ix' => ix' -> Array N ix e -> Array N ix' e #

unsafeExtract :: ix -> ix -> Array N ix e -> Array (EltRepr N ix) ix e #

(Index ix, NFData e) => Source N ix e 

Methods

unsafeIndex :: Array N ix e -> ix -> e #

unsafeLinearIndex :: Array N ix e -> Int -> e #

(NFData e, Index ix, Index (Lower ix), (~) * (Elt M ix e) (Array M (Lower ix) e), (~) * (Elt N ix e) (Array M (Lower ix) e)) => OuterSlice N ix e 

Methods

unsafeOuterSlice :: Array N ix e -> Int -> Elt N ix e #

outerLength :: Array N ix e -> Int #

(NFData e, Index ix, Index (Lower ix), (~) * (Elt M ix e) (Array M (Lower ix) e), (~) * (Elt N ix e) (Array M (Lower ix) e)) => InnerSlice N ix e 

Methods

unsafeInnerSlice :: Array N ix e -> (Lower ix, Int) -> Int -> Elt N ix e #

(Index ix, NFData e) => Manifest N ix e 

Methods

unsafeLinearIndexM :: Array N ix e -> Int -> e #

(Index ix, NFData e) => Mutable N ix e 

Associated Types

data MArray s N ix e :: * #

Methods

msize :: MArray s N ix e -> ix #

unsafeThaw :: PrimMonad m => Array N ix e -> m (MArray (PrimState m) N ix e) #

unsafeFreeze :: PrimMonad m => Comp -> MArray (PrimState m) N ix e -> m (Array N ix e) #

unsafeNew :: PrimMonad m => ix -> m (MArray (PrimState m) N ix e) #

unsafeNewZero :: PrimMonad m => ix -> m (MArray (PrimState m) N ix e) #

unsafeLinearRead :: PrimMonad m => MArray (PrimState m) N ix e -> Int -> m e #

unsafeLinearWrite :: PrimMonad m => MArray (PrimState m) N ix e -> Int -> e -> m () #

unsafeNewA :: Applicative f => ix -> WorldState -> f (WorldState, MArray RealWorld N ix e)

unsafeThawA :: Applicative m => Array N ix e -> WorldState -> m (WorldState, MArray RealWorld N ix e)

unsafeFreezeA :: Applicative m => Comp -> MArray RealWorld N ix e -> WorldState -> m (WorldState, Array N ix e)

unsafeLinearWriteA :: Applicative m => MArray RealWorld N ix e -> Int -> e -> WorldState -> m WorldState

(NFData e, IsList (Array L ix e), Nested LN ix e, Nested L ix e, Ragged L ix e) => IsList (Array N ix e) 

Associated Types

type Item (Array N ix e) :: * #

Methods

fromList :: [Item (Array N ix e)] -> Array N ix e #

fromListN :: Int -> [Item (Array N ix e)] -> Array N ix e #

toList :: Array N ix e -> [Item (Array N ix e)] #

(Index ix, NFData e, Eq e) => Eq (Array N ix e) 

Methods

(==) :: Array N ix e -> Array N ix e -> Bool #

(/=) :: Array N ix e -> Array N ix e -> Bool #

(Index ix, NFData e, Ord e) => Ord (Array N ix e) 

Methods

compare :: Array N ix e -> Array N ix e -> Ordering #

(<) :: Array N ix e -> Array N ix e -> Bool #

(<=) :: Array N ix e -> Array N ix e -> Bool #

(>) :: Array N ix e -> Array N ix e -> Bool #

(>=) :: Array N ix e -> Array N ix e -> Bool #

max :: Array N ix e -> Array N ix e -> Array N ix e #

min :: Array N ix e -> Array N ix e -> Array N ix e #

(Index ix, NFData e) => NFData (Array N ix e) 

Methods

rnf :: Array N ix e -> () #

(Eq a, NFData a) => Eq (Raster k N p r c a) # 

Methods

(==) :: Raster k N p r c a -> Raster k N p r c a -> Bool #

(/=) :: Raster k N p r c a -> Raster k N p r c a -> Bool #

type VRepr N 
type VRepr N = Vector
data Array N 
data Array N = NArray {}
type EltRepr N ix 
type EltRepr N ix = M
data MArray s N 
data MArray s N = MNArray !ix !(MutableArray s e)
type Item (Array N ix e) 
type Item (Array N ix e) = Item (Array L ix e)

data Ix2 :: * #

2-dimensional index. This also a base index for higher dimensions.

Constructors

(:.) !Int !Int infixr 5 

Instances

Bounded Ix2 

Methods

minBound :: Ix2 #

maxBound :: Ix2 #

Eq Ix2 

Methods

(==) :: Ix2 -> Ix2 -> Bool #

(/=) :: Ix2 -> Ix2 -> Bool #

Num Ix2 

Methods

(+) :: Ix2 -> Ix2 -> Ix2 #

(-) :: Ix2 -> Ix2 -> Ix2 #

(*) :: Ix2 -> Ix2 -> Ix2 #

negate :: Ix2 -> Ix2 #

abs :: Ix2 -> Ix2 #

signum :: Ix2 -> Ix2 #

fromInteger :: Integer -> Ix2 #

Ord Ix2 

Methods

compare :: Ix2 -> Ix2 -> Ordering #

(<) :: Ix2 -> Ix2 -> Bool #

(<=) :: Ix2 -> Ix2 -> Bool #

(>) :: Ix2 -> Ix2 -> Bool #

(>=) :: Ix2 -> Ix2 -> Bool #

max :: Ix2 -> Ix2 -> Ix2 #

min :: Ix2 -> Ix2 -> Ix2 #

Show Ix2 

Methods

showsPrec :: Int -> Ix2 -> ShowS #

show :: Ix2 -> String #

showList :: [Ix2] -> ShowS #

NFData Ix2 

Methods

rnf :: Ix2 -> () #

Index Ix2 

Associated Types

type Rank Ix2 :: Nat #

Methods

rank :: Ix2 -> Dim #

totalElem :: Ix2 -> Int #

consDim :: Int -> Lower Ix2 -> Ix2 #

unconsDim :: Ix2 -> (Int, Lower Ix2) #

snocDim :: Lower Ix2 -> Int -> Ix2 #

unsnocDim :: Ix2 -> (Lower Ix2, Int) #

dropDim :: Ix2 -> Dim -> Maybe (Lower Ix2) #

getIndex :: Ix2 -> Dim -> Maybe Int #

setIndex :: Ix2 -> Dim -> Int -> Maybe Ix2 #

pureIndex :: Int -> Ix2 #

liftIndex2 :: (Int -> Int -> Int) -> Ix2 -> Ix2 -> Ix2 #

zeroIndex :: Ix2 #

liftIndex :: (Int -> Int) -> Ix2 -> Ix2 #

isSafeIndex :: Ix2 -> Ix2 -> Bool #

toLinearIndex :: Ix2 -> Ix2 -> Int #

toLinearIndexAcc :: Int -> Ix2 -> Ix2 -> Int #

fromLinearIndex :: Ix2 -> Int -> Ix2 #

fromLinearIndexAcc :: Ix2 -> Int -> (Int, Ix2) #

repairIndex :: Ix2 -> Ix2 -> (Int -> Int -> Int) -> (Int -> Int -> Int) -> Ix2 #

iter :: Ix2 -> Ix2 -> Int -> (Int -> Int -> Bool) -> a -> (Ix2 -> a -> a) -> a #

iterM :: Monad m => Ix2 -> Ix2 -> Int -> (Int -> Int -> Bool) -> a -> (Ix2 -> a -> m a) -> m a #

iterM_ :: Monad m => Ix2 -> Ix2 -> Int -> (Int -> Int -> Bool) -> (Ix2 -> m a) -> m () #

Unbox Ix2

Unboxing of a Ix2.

Vector Vector Ix2 
MVector MVector Ix2 
Load DW Ix2 e 

Methods

loadS :: Monad m => Array DW Ix2 e -> (Int -> m e) -> (Int -> e -> m ()) -> m () #

loadP :: [Int] -> Array DW Ix2 e -> (Int -> IO e) -> (Int -> e -> IO ()) -> IO () #

ColorSpace cs e => Readable PBM (Image S cs e) 

Methods

decode :: PBM -> ReadOptions PBM -> ByteString -> Image S cs e #

ColorSpace cs e => Readable PGM (Image S cs e) 

Methods

decode :: PGM -> ReadOptions PGM -> ByteString -> Image S cs e #

ColorSpace cs e => Readable PPM (Image S cs e) 

Methods

decode :: PPM -> ReadOptions PPM -> ByteString -> Image S cs e #

ColorSpace cs e => Readable BMP (Image S cs e) 

Methods

decode :: BMP -> ReadOptions BMP -> ByteString -> Image S cs e #

ColorSpace cs e => Readable PNG (Image S cs e) 

Methods

decode :: PNG -> ReadOptions PNG -> ByteString -> Image S cs e #

ColorSpace cs e => Readable GIF (Image S cs e) 

Methods

decode :: GIF -> ReadOptions GIF -> ByteString -> Image S cs e #

ColorSpace cs e => Readable HDR (Image S cs e) 

Methods

decode :: HDR -> ReadOptions HDR -> ByteString -> Image S cs e #

ColorSpace cs e => Readable JPG (Image S cs e) 

Methods

decode :: JPG -> ReadOptions JPG -> ByteString -> Image S cs e #

ColorSpace cs e => Readable TGA (Image S cs e) 

Methods

decode :: TGA -> ReadOptions TGA -> ByteString -> Image S cs e #

ColorSpace cs e => Readable TIF (Image S cs e) 

Methods

decode :: TIF -> ReadOptions TIF -> ByteString -> Image S cs e #

(ColorSpace cs e, Source r Ix2 (Pixel cs e)) => Writable BMP (Image r cs e) 

Methods

encode :: BMP -> WriteOptions BMP -> Image r cs e -> ByteString #

(ColorSpace cs e, Source r Ix2 (Pixel cs e)) => Writable PNG (Image r cs e) 

Methods

encode :: PNG -> WriteOptions PNG -> Image r cs e -> ByteString #

(ColorSpace cs e, Source r Ix2 (Pixel cs e)) => Writable GIF (Image r cs e) 

Methods

encode :: GIF -> WriteOptions GIF -> Image r cs e -> ByteString #

(ColorSpace cs e, Source r Ix2 (Pixel cs e)) => Writable HDR (Image r cs e) 

Methods

encode :: HDR -> WriteOptions HDR -> Image r cs e -> ByteString #

(ColorSpace cs e, Source r Ix2 (Pixel cs e)) => Writable JPG (Image r cs e) 

Methods

encode :: JPG -> WriteOptions JPG -> Image r cs e -> ByteString #

(ColorSpace cs e, Source r Ix2 (Pixel cs e)) => Writable TGA (Image r cs e) 

Methods

encode :: TGA -> WriteOptions TGA -> Image r cs e -> ByteString #

(ColorSpace cs e, Source r Ix2 (Pixel cs e)) => Writable TIF (Image r cs e) 

Methods

encode :: TIF -> WriteOptions TIF -> Image r cs e -> ByteString #

FileFormat (Encode (Image r cs e)) 

Associated Types

type ReadOptions (Encode (Image r cs e)) :: * #

type WriteOptions (Encode (Image r cs e)) :: * #

Methods

ext :: Encode (Image r cs e) -> String #

exts :: Encode (Image r cs e) -> [String] #

isFormat :: String -> Encode (Image r cs e) -> Bool #

FileFormat (Decode (Image r cs e)) 

Associated Types

type ReadOptions (Decode (Image r cs e)) :: * #

type WriteOptions (Decode (Image r cs e)) :: * #

Methods

ext :: Decode (Image r cs e) -> String #

exts :: Decode (Image r cs e) -> [String] #

isFormat :: String -> Decode (Image r cs e) -> Bool #

Readable (Decode (Image r cs e)) (Image r cs e) 

Methods

decode :: Decode (Image r cs e) -> ReadOptions (Decode (Image r cs e)) -> ByteString -> Image r cs e #

ColorSpace cs e => Readable (Sequence PBM) (Array B Ix1 (Image S cs e)) 
ColorSpace cs e => Readable (Sequence PGM) (Array B Ix1 (Image S cs e)) 
ColorSpace cs e => Readable (Sequence PPM) (Array B Ix1 (Image S cs e)) 
ColorSpace cs e => Readable (Sequence GIF) (Array B Ix1 (GifDelay, Image S cs e)) 
ColorSpace cs e => Readable (Sequence GIF) (Array B Ix1 (Image S cs e)) 
(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Sequence (Auto PBM)) (Array B Ix1 (Image r cs e)) 
(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Sequence (Auto PGM)) (Array B Ix1 (Image r cs e)) 
(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Sequence (Auto PPM)) (Array B Ix1 (Image r cs e)) 
(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Sequence (Auto GIF)) (Array B Ix1 (Image r cs e)) 
(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Auto PBM) (Image r cs e) 

Methods

decode :: Auto PBM -> ReadOptions (Auto PBM) -> ByteString -> Image r cs e #

(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Auto PGM) (Image r cs e) 

Methods

decode :: Auto PGM -> ReadOptions (Auto PGM) -> ByteString -> Image r cs e #

(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Auto PPM) (Image r cs e) 

Methods

decode :: Auto PPM -> ReadOptions (Auto PPM) -> ByteString -> Image r cs e #

(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Auto BMP) (Image r cs e) 

Methods

decode :: Auto BMP -> ReadOptions (Auto BMP) -> ByteString -> Image r cs e #

(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Auto PNG) (Image r cs e) 

Methods

decode :: Auto PNG -> ReadOptions (Auto PNG) -> ByteString -> Image r cs e #

(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Auto GIF) (Image r cs e) 

Methods

decode :: Auto GIF -> ReadOptions (Auto GIF) -> ByteString -> Image r cs e #

(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Auto HDR) (Image r cs e) 

Methods

decode :: Auto HDR -> ReadOptions (Auto HDR) -> ByteString -> Image r cs e #

(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Auto JPG) (Image r cs e) 

Methods

decode :: Auto JPG -> ReadOptions (Auto JPG) -> ByteString -> Image r cs e #

(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Auto TGA) (Image r cs e) 

Methods

decode :: Auto TGA -> ReadOptions (Auto TGA) -> ByteString -> Image r cs e #

(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Auto TIF) (Image r cs e) 

Methods

decode :: Auto TIF -> ReadOptions (Auto TIF) -> ByteString -> Image r cs e #

Writable (Encode (Image r cs e)) (Image r cs e) 

Methods

encode :: Encode (Image r cs e) -> WriteOptions (Encode (Image r cs e)) -> Image r cs e -> ByteString #

(ColorSpace cs e, Source r Ix2 (Pixel cs e)) => Writable (Sequence GIF) (Array B Ix1 (GifDelay, Image r cs e)) 
(ColorSpace cs e, ToRGBA cs e, Source r Ix2 (Pixel cs e)) => Writable (Auto BMP) (Image r cs e) 

Methods

encode :: Auto BMP -> WriteOptions (Auto BMP) -> Image r cs e -> ByteString #

(ColorSpace cs e, ToYA cs e, ToRGBA cs e, Source r Ix2 (Pixel cs e)) => Writable (Auto PNG) (Image r cs e) 

Methods

encode :: Auto PNG -> WriteOptions (Auto PNG) -> Image r cs e -> ByteString #

(ColorSpace cs e, ToY cs e, ToRGB cs e, Source r Ix2 (Pixel cs e)) => Writable (Auto GIF) (Image r cs e) 

Methods

encode :: Auto GIF -> WriteOptions (Auto GIF) -> Image r cs e -> ByteString #

(ColorSpace cs e, ToRGB cs e, Source r Ix2 (Pixel cs e)) => Writable (Auto HDR) (Image r cs e) 

Methods

encode :: Auto HDR -> WriteOptions (Auto HDR) -> Image r cs e -> ByteString #

(ColorSpace cs e, ToYCbCr cs e, Source r Ix2 (Pixel cs e)) => Writable (Auto JPG) (Image r cs e) 

Methods

encode :: Auto JPG -> WriteOptions (Auto JPG) -> Image r cs e -> ByteString #

(ColorSpace cs e, ToRGBA cs e, Source r Ix2 (Pixel cs e)) => Writable (Auto TGA) (Image r cs e) 

Methods

encode :: Auto TGA -> WriteOptions (Auto TGA) -> Image r cs e -> ByteString #

(ColorSpace cs e, ToRGBA cs e, Source r Ix2 (Pixel cs e)) => Writable (Auto TIF) (Image r cs e) 

Methods

encode :: Auto TIF -> WriteOptions (Auto TIF) -> Image r cs e -> ByteString #

data Vector Ix2 
type Lower Ix2 
type Lower Ix2 = Ix1
type Rank Ix2 
type Rank Ix2 = 2
data MVector s Ix2 
type WriteOptions (Encode (Image r cs e)) 
type WriteOptions (Encode (Image r cs e)) = ()
type WriteOptions (Decode (Image r cs e)) 
type WriteOptions (Decode (Image r cs e)) = ()
type ReadOptions (Encode (Image r cs e)) 
type ReadOptions (Encode (Image r cs e)) = ()
type ReadOptions (Decode (Image r cs e)) 
type ReadOptions (Decode (Image r cs e)) = ()

data Comp :: * #

Computation type to use.

Constructors

Seq

Sequential computation

ParOn [Int]

Use Par instead to use your CPU to the fullest. Also don't forget to compile the program with -threaded flag.

Parallel computation with a list of capabilities to run computation on. Specifying an empty list (ParOn []) or using Par will result in utilization of all available capabilities, which are set at runtime by +RTS -Nx or at compile time by GHC flag -with-rtsopts=-Nx, where x is the number of capabilities. Ommiting x in above flags defaults to number available cores.

Instances

Eq Comp 

Methods

(==) :: Comp -> Comp -> Bool #

(/=) :: Comp -> Comp -> Bool #

Show Comp 

Methods

showsPrec :: Int -> Comp -> ShowS #

show :: Comp -> String #

showList :: [Comp] -> ShowS #

Semigroup Comp 

Methods

(<>) :: Comp -> Comp -> Comp #

sconcat :: NonEmpty Comp -> Comp #

stimes :: Integral b => b -> Comp -> Comp #

Monoid Comp 

Methods

mempty :: Comp #

mappend :: Comp -> Comp -> Comp #

mconcat :: [Comp] -> Comp #

NFData Comp 

Methods

rnf :: Comp -> () #

data family Pixel cs e :: * #

A Pixel family with a color space and a precision of elements.

Instances

ColorSpace cs e => Vector Vector (Pixel cs e) 

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Pixel cs e) -> m (Vector (Pixel cs e)) #

basicUnsafeThaw :: PrimMonad m => Vector (Pixel cs e) -> m (Mutable Vector (PrimState m) (Pixel cs e)) #

basicLength :: Vector (Pixel cs e) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (Pixel cs e) -> Vector (Pixel cs e) #

basicUnsafeIndexM :: Monad m => Vector (Pixel cs e) -> Int -> m (Pixel cs e) #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Pixel cs e) -> Vector (Pixel cs e) -> m () #

elemseq :: Vector (Pixel cs e) -> Pixel cs e -> b -> b #

ColorSpace cs e => MVector MVector (Pixel cs e) 

Methods

basicLength :: MVector s (Pixel cs e) -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s (Pixel cs e) -> MVector s (Pixel cs e) #

basicOverlaps :: MVector s (Pixel cs e) -> MVector s (Pixel cs e) -> Bool #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Pixel cs e)) #

basicInitialize :: PrimMonad m => MVector (PrimState m) (Pixel cs e) -> m () #

basicUnsafeReplicate :: PrimMonad m => Int -> Pixel cs e -> m (MVector (PrimState m) (Pixel cs e)) #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Pixel cs e) -> Int -> m (Pixel cs e) #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Pixel cs e) -> Int -> Pixel cs e -> m () #

basicClear :: PrimMonad m => MVector (PrimState m) (Pixel cs e) -> m () #

basicSet :: PrimMonad m => MVector (PrimState m) (Pixel cs e) -> Pixel cs e -> m () #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Pixel cs e) -> MVector (PrimState m) (Pixel cs e) -> m () #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Pixel cs e) -> MVector (PrimState m) (Pixel cs e) -> m () #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Pixel cs e) -> Int -> m (MVector (PrimState m) (Pixel cs e)) #

ColorSpace cs e => Readable PBM (Image S cs e) 

Methods

decode :: PBM -> ReadOptions PBM -> ByteString -> Image S cs e #

ColorSpace cs e => Readable PGM (Image S cs e) 

Methods

decode :: PGM -> ReadOptions PGM -> ByteString -> Image S cs e #

ColorSpace cs e => Readable PPM (Image S cs e) 

Methods

decode :: PPM -> ReadOptions PPM -> ByteString -> Image S cs e #

ColorSpace cs e => Readable BMP (Image S cs e) 

Methods

decode :: BMP -> ReadOptions BMP -> ByteString -> Image S cs e #

ColorSpace cs e => Readable PNG (Image S cs e) 

Methods

decode :: PNG -> ReadOptions PNG -> ByteString -> Image S cs e #

ColorSpace cs e => Readable GIF (Image S cs e) 

Methods

decode :: GIF -> ReadOptions GIF -> ByteString -> Image S cs e #

ColorSpace cs e => Readable HDR (Image S cs e) 

Methods

decode :: HDR -> ReadOptions HDR -> ByteString -> Image S cs e #

ColorSpace cs e => Readable JPG (Image S cs e) 

Methods

decode :: JPG -> ReadOptions JPG -> ByteString -> Image S cs e #

ColorSpace cs e => Readable TGA (Image S cs e) 

Methods

decode :: TGA -> ReadOptions TGA -> ByteString -> Image S cs e #

ColorSpace cs e => Readable TIF (Image S cs e) 

Methods

decode :: TIF -> ReadOptions TIF -> ByteString -> Image S cs e #

(ColorSpace cs e, Source r Ix2 (Pixel cs e)) => Writable BMP (Image r cs e) 

Methods

encode :: BMP -> WriteOptions BMP -> Image r cs e -> ByteString #

(ColorSpace cs e, Source r Ix2 (Pixel cs e)) => Writable PNG (Image r cs e) 

Methods

encode :: PNG -> WriteOptions PNG -> Image r cs e -> ByteString #

(ColorSpace cs e, Source r Ix2 (Pixel cs e)) => Writable GIF (Image r cs e) 

Methods

encode :: GIF -> WriteOptions GIF -> Image r cs e -> ByteString #

(ColorSpace cs e, Source r Ix2 (Pixel cs e)) => Writable HDR (Image r cs e) 

Methods

encode :: HDR -> WriteOptions HDR -> Image r cs e -> ByteString #

(ColorSpace cs e, Source r Ix2 (Pixel cs e)) => Writable JPG (Image r cs e) 

Methods

encode :: JPG -> WriteOptions JPG -> Image r cs e -> ByteString #

(ColorSpace cs e, Source r Ix2 (Pixel cs e)) => Writable TGA (Image r cs e) 

Methods

encode :: TGA -> WriteOptions TGA -> Image r cs e -> ByteString #

(ColorSpace cs e, Source r Ix2 (Pixel cs e)) => Writable TIF (Image r cs e) 

Methods

encode :: TIF -> WriteOptions TIF -> Image r cs e -> ByteString #

Monad (Pixel Y) 

Methods

(>>=) :: Pixel Y a -> (a -> Pixel Y b) -> Pixel Y b #

(>>) :: Pixel Y a -> Pixel Y b -> Pixel Y b #

return :: a -> Pixel Y a #

fail :: String -> Pixel Y a #

Monad (Pixel X) 

Methods

(>>=) :: Pixel X a -> (a -> Pixel X b) -> Pixel X b #

(>>) :: Pixel X a -> Pixel X b -> Pixel X b #

return :: a -> Pixel X a #

fail :: String -> Pixel X a #

Functor (Pixel YCbCr) 

Methods

fmap :: (a -> b) -> Pixel YCbCr a -> Pixel YCbCr b #

(<$) :: a -> Pixel YCbCr b -> Pixel YCbCr a #

Functor (Pixel YCbCrA) 

Methods

fmap :: (a -> b) -> Pixel YCbCrA a -> Pixel YCbCrA b #

(<$) :: a -> Pixel YCbCrA b -> Pixel YCbCrA a #

Functor (Pixel Y) 

Methods

fmap :: (a -> b) -> Pixel Y a -> Pixel Y b #

(<$) :: a -> Pixel Y b -> Pixel Y a #

Functor (Pixel YA) 

Methods

fmap :: (a -> b) -> Pixel YA a -> Pixel YA b #

(<$) :: a -> Pixel YA b -> Pixel YA a #

Functor (Pixel X) 

Methods

fmap :: (a -> b) -> Pixel X a -> Pixel X b #

(<$) :: a -> Pixel X b -> Pixel X a #

Functor (Pixel RGB) 

Methods

fmap :: (a -> b) -> Pixel RGB a -> Pixel RGB b #

(<$) :: a -> Pixel RGB b -> Pixel RGB a #

Functor (Pixel RGBA) 

Methods

fmap :: (a -> b) -> Pixel RGBA a -> Pixel RGBA b #

(<$) :: a -> Pixel RGBA b -> Pixel RGBA a #

Functor (Pixel CMYK) 

Methods

fmap :: (a -> b) -> Pixel CMYK a -> Pixel CMYK b #

(<$) :: a -> Pixel CMYK b -> Pixel CMYK a #

Functor (Pixel CMYKA) 

Methods

fmap :: (a -> b) -> Pixel CMYKA a -> Pixel CMYKA b #

(<$) :: a -> Pixel CMYKA b -> Pixel CMYKA a #

Functor (Pixel HSI) 

Methods

fmap :: (a -> b) -> Pixel HSI a -> Pixel HSI b #

(<$) :: a -> Pixel HSI b -> Pixel HSI a #

Functor (Pixel HSIA) 

Methods

fmap :: (a -> b) -> Pixel HSIA a -> Pixel HSIA b #

(<$) :: a -> Pixel HSIA b -> Pixel HSIA a #

Applicative (Pixel YCbCr) 

Methods

pure :: a -> Pixel YCbCr a #

(<*>) :: Pixel YCbCr (a -> b) -> Pixel YCbCr a -> Pixel YCbCr b #

liftA2 :: (a -> b -> c) -> Pixel YCbCr a -> Pixel YCbCr b -> Pixel YCbCr c #

(*>) :: Pixel YCbCr a -> Pixel YCbCr b -> Pixel YCbCr b #

(<*) :: Pixel YCbCr a -> Pixel YCbCr b -> Pixel YCbCr a #

Applicative (Pixel YCbCrA) 

Methods

pure :: a -> Pixel YCbCrA a #

(<*>) :: Pixel YCbCrA (a -> b) -> Pixel YCbCrA a -> Pixel YCbCrA b #

liftA2 :: (a -> b -> c) -> Pixel YCbCrA a -> Pixel YCbCrA b -> Pixel YCbCrA c #

(*>) :: Pixel YCbCrA a -> Pixel YCbCrA b -> Pixel YCbCrA b #

(<*) :: Pixel YCbCrA a -> Pixel YCbCrA b -> Pixel YCbCrA a #

Applicative (Pixel Y) 

Methods

pure :: a -> Pixel Y a #

(<*>) :: Pixel Y (a -> b) -> Pixel Y a -> Pixel Y b #

liftA2 :: (a -> b -> c) -> Pixel Y a -> Pixel Y b -> Pixel Y c #

(*>) :: Pixel Y a -> Pixel Y b -> Pixel Y b #

(<*) :: Pixel Y a -> Pixel Y b -> Pixel Y a #

Applicative (Pixel YA) 

Methods

pure :: a -> Pixel YA a #

(<*>) :: Pixel YA (a -> b) -> Pixel YA a -> Pixel YA b #

liftA2 :: (a -> b -> c) -> Pixel YA a -> Pixel YA b -> Pixel YA c #

(*>) :: Pixel YA a -> Pixel YA b -> Pixel YA b #

(<*) :: Pixel YA a -> Pixel YA b -> Pixel YA a #

Applicative (Pixel X) 

Methods

pure :: a -> Pixel X a #

(<*>) :: Pixel X (a -> b) -> Pixel X a -> Pixel X b #

liftA2 :: (a -> b -> c) -> Pixel X a -> Pixel X b -> Pixel X c #

(*>) :: Pixel X a -> Pixel X b -> Pixel X b #

(<*) :: Pixel X a -> Pixel X b -> Pixel X a #

Applicative (Pixel RGB) 

Methods

pure :: a -> Pixel RGB a #

(<*>) :: Pixel RGB (a -> b) -> Pixel RGB a -> Pixel RGB b #

liftA2 :: (a -> b -> c) -> Pixel RGB a -> Pixel RGB b -> Pixel RGB c #

(*>) :: Pixel RGB a -> Pixel RGB b -> Pixel RGB b #

(<*) :: Pixel RGB a -> Pixel RGB b -> Pixel RGB a #

Applicative (Pixel RGBA) 

Methods

pure :: a -> Pixel RGBA a #

(<*>) :: Pixel RGBA (a -> b) -> Pixel RGBA a -> Pixel RGBA b #

liftA2 :: (a -> b -> c) -> Pixel RGBA a -> Pixel RGBA b -> Pixel RGBA c #

(*>) :: Pixel RGBA a -> Pixel RGBA b -> Pixel RGBA b #

(<*) :: Pixel RGBA a -> Pixel RGBA b -> Pixel RGBA a #

Applicative (Pixel CMYK) 

Methods

pure :: a -> Pixel CMYK a #

(<*>) :: Pixel CMYK (a -> b) -> Pixel CMYK a -> Pixel CMYK b #

liftA2 :: (a -> b -> c) -> Pixel CMYK a -> Pixel CMYK b -> Pixel CMYK c #

(*>) :: Pixel CMYK a -> Pixel CMYK b -> Pixel CMYK b #

(<*) :: Pixel CMYK a -> Pixel CMYK b -> Pixel CMYK a #

Applicative (Pixel CMYKA) 

Methods

pure :: a -> Pixel CMYKA a #

(<*>) :: Pixel CMYKA (a -> b) -> Pixel CMYKA a -> Pixel CMYKA b #

liftA2 :: (a -> b -> c) -> Pixel CMYKA a -> Pixel CMYKA b -> Pixel CMYKA c #

(*>) :: Pixel CMYKA a -> Pixel CMYKA b -> Pixel CMYKA b #

(<*) :: Pixel CMYKA a -> Pixel CMYKA b -> Pixel CMYKA a #

Applicative (Pixel HSI) 

Methods

pure :: a -> Pixel HSI a #

(<*>) :: Pixel HSI (a -> b) -> Pixel HSI a -> Pixel HSI b #

liftA2 :: (a -> b -> c) -> Pixel HSI a -> Pixel HSI b -> Pixel HSI c #

(*>) :: Pixel HSI a -> Pixel HSI b -> Pixel HSI b #

(<*) :: Pixel HSI a -> Pixel HSI b -> Pixel HSI a #

Applicative (Pixel HSIA) 

Methods

pure :: a -> Pixel HSIA a #

(<*>) :: Pixel HSIA (a -> b) -> Pixel HSIA a -> Pixel HSIA b #

liftA2 :: (a -> b -> c) -> Pixel HSIA a -> Pixel HSIA b -> Pixel HSIA c #

(*>) :: Pixel HSIA a -> Pixel HSIA b -> Pixel HSIA b #

(<*) :: Pixel HSIA a -> Pixel HSIA b -> Pixel HSIA a #

Foldable (Pixel YCbCr) 

Methods

fold :: Monoid m => Pixel YCbCr m -> m #

foldMap :: Monoid m => (a -> m) -> Pixel YCbCr a -> m #

foldr :: (a -> b -> b) -> b -> Pixel YCbCr a -> b #

foldr' :: (a -> b -> b) -> b -> Pixel YCbCr a -> b #

foldl :: (b -> a -> b) -> b -> Pixel YCbCr a -> b #

foldl' :: (b -> a -> b) -> b -> Pixel YCbCr a -> b #

foldr1 :: (a -> a -> a) -> Pixel YCbCr a -> a #

foldl1 :: (a -> a -> a) -> Pixel YCbCr a -> a #

toList :: Pixel YCbCr a -> [a] #

null :: Pixel YCbCr a -> Bool #

length :: Pixel YCbCr a -> Int #

elem :: Eq a => a -> Pixel YCbCr a -> Bool #

maximum :: Ord a => Pixel YCbCr a -> a #

minimum :: Ord a => Pixel YCbCr a -> a #

sum :: Num a => Pixel YCbCr a -> a #

product :: Num a => Pixel YCbCr a -> a #

Foldable (Pixel YCbCrA) 

Methods

fold :: Monoid m => Pixel YCbCrA m -> m #

foldMap :: Monoid m => (a -> m) -> Pixel YCbCrA a -> m #

foldr :: (a -> b -> b) -> b -> Pixel YCbCrA a -> b #

foldr' :: (a -> b -> b) -> b -> Pixel YCbCrA a -> b #

foldl :: (b -> a -> b) -> b -> Pixel YCbCrA a -> b #

foldl' :: (b -> a -> b) -> b -> Pixel YCbCrA a -> b #

foldr1 :: (a -> a -> a) -> Pixel YCbCrA a -> a #

foldl1 :: (a -> a -> a) -> Pixel YCbCrA a -> a #

toList :: Pixel YCbCrA a -> [a] #

null :: Pixel YCbCrA a -> Bool #

length :: Pixel YCbCrA a -> Int #

elem :: Eq a => a -> Pixel YCbCrA a -> Bool #

maximum :: Ord a => Pixel YCbCrA a -> a #

minimum :: Ord a => Pixel YCbCrA a -> a #

sum :: Num a => Pixel YCbCrA a -> a #

product :: Num a => Pixel YCbCrA a -> a #

Foldable (Pixel Y) 

Methods

fold :: Monoid m => Pixel Y m -> m #

foldMap :: Monoid m => (a -> m) -> Pixel Y a -> m #

foldr :: (a -> b -> b) -> b -> Pixel Y a -> b #

foldr' :: (a -> b -> b) -> b -> Pixel Y a -> b #

foldl :: (b -> a -> b) -> b -> Pixel Y a -> b #

foldl' :: (b -> a -> b) -> b -> Pixel Y a -> b #

foldr1 :: (a -> a -> a) -> Pixel Y a -> a #

foldl1 :: (a -> a -> a) -> Pixel Y a -> a #

toList :: Pixel Y a -> [a] #

null :: Pixel Y a -> Bool #

length :: Pixel Y a -> Int #

elem :: Eq a => a -> Pixel Y a -> Bool #

maximum :: Ord a => Pixel Y a -> a #

minimum :: Ord a => Pixel Y a -> a #

sum :: Num a => Pixel Y a -> a #

product :: Num a => Pixel Y a -> a #

Foldable (Pixel YA) 

Methods

fold :: Monoid m => Pixel YA m -> m #

foldMap :: Monoid m => (a -> m) -> Pixel YA a -> m #

foldr :: (a -> b -> b) -> b -> Pixel YA a -> b #

foldr' :: (a -> b -> b) -> b -> Pixel YA a -> b #

foldl :: (b -> a -> b) -> b -> Pixel YA a -> b #

foldl' :: (b -> a -> b) -> b -> Pixel YA a -> b #

foldr1 :: (a -> a -> a) -> Pixel YA a -> a #

foldl1 :: (a -> a -> a) -> Pixel YA a -> a #

toList :: Pixel YA a -> [a] #

null :: Pixel YA a -> Bool #

length :: Pixel YA a -> Int #

elem :: Eq a => a -> Pixel YA a -> Bool #

maximum :: Ord a => Pixel YA a -> a #

minimum :: Ord a => Pixel YA a -> a #

sum :: Num a => Pixel YA a -> a #

product :: Num a => Pixel YA a -> a #

Foldable (Pixel X) 

Methods

fold :: Monoid m => Pixel X m -> m #

foldMap :: Monoid m => (a -> m) -> Pixel X a -> m #

foldr :: (a -> b -> b) -> b -> Pixel X a -> b #

foldr' :: (a -> b -> b) -> b -> Pixel X a -> b #

foldl :: (b -> a -> b) -> b -> Pixel X a -> b #

foldl' :: (b -> a -> b) -> b -> Pixel X a -> b #

foldr1 :: (a -> a -> a) -> Pixel X a -> a #

foldl1 :: (a -> a -> a) -> Pixel X a -> a #

toList :: Pixel X a -> [a] #

null :: Pixel X a -> Bool #

length :: Pixel X a -> Int #

elem :: Eq a => a -> Pixel X a -> Bool #

maximum :: Ord a => Pixel X a -> a #

minimum :: Ord a => Pixel X a -> a #

sum :: Num a => Pixel X a -> a #

product :: Num a => Pixel X a -> a #

Foldable (Pixel RGB) 

Methods

fold :: Monoid m => Pixel RGB m -> m #

foldMap :: Monoid m => (a -> m) -> Pixel RGB a -> m #

foldr :: (a -> b -> b) -> b -> Pixel RGB a -> b #

foldr' :: (a -> b -> b) -> b -> Pixel RGB a -> b #

foldl :: (b -> a -> b) -> b -> Pixel RGB a -> b #

foldl' :: (b -> a -> b) -> b -> Pixel RGB a -> b #

foldr1 :: (a -> a -> a) -> Pixel RGB a -> a #

foldl1 :: (a -> a -> a) -> Pixel RGB a -> a #

toList :: Pixel RGB a -> [a] #

null :: Pixel RGB a -> Bool #

length :: Pixel RGB a -> Int #

elem :: Eq a => a -> Pixel RGB a -> Bool #

maximum :: Ord a => Pixel RGB a -> a #

minimum :: Ord a => Pixel RGB a -> a #

sum :: Num a => Pixel RGB a -> a #

product :: Num a => Pixel RGB a -> a #

Foldable (Pixel RGBA) 

Methods

fold :: Monoid m => Pixel RGBA m -> m #

foldMap :: Monoid m => (a -> m) -> Pixel RGBA a -> m #

foldr :: (a -> b -> b) -> b -> Pixel RGBA a -> b #

foldr' :: (a -> b -> b) -> b -> Pixel RGBA a -> b #

foldl :: (b -> a -> b) -> b -> Pixel RGBA a -> b #

foldl' :: (b -> a -> b) -> b -> Pixel RGBA a -> b #

foldr1 :: (a -> a -> a) -> Pixel RGBA a -> a #

foldl1 :: (a -> a -> a) -> Pixel RGBA a -> a #

toList :: Pixel RGBA a -> [a] #

null :: Pixel RGBA a -> Bool #

length :: Pixel RGBA a -> Int #

elem :: Eq a => a -> Pixel RGBA a -> Bool #

maximum :: Ord a => Pixel RGBA a -> a #

minimum :: Ord a => Pixel RGBA a -> a #

sum :: Num a => Pixel RGBA a -> a #

product :: Num a => Pixel RGBA a -> a #

Foldable (Pixel CMYK) 

Methods

fold :: Monoid m => Pixel CMYK m -> m #

foldMap :: Monoid m => (a -> m) -> Pixel CMYK a -> m #

foldr :: (a -> b -> b) -> b -> Pixel CMYK a -> b #

foldr' :: (a -> b -> b) -> b -> Pixel CMYK a -> b #

foldl :: (b -> a -> b) -> b -> Pixel CMYK a -> b #

foldl' :: (b -> a -> b) -> b -> Pixel CMYK a -> b #

foldr1 :: (a -> a -> a) -> Pixel CMYK a -> a #

foldl1 :: (a -> a -> a) -> Pixel CMYK a -> a #

toList :: Pixel CMYK a -> [a] #

null :: Pixel CMYK a -> Bool #

length :: Pixel CMYK a -> Int #

elem :: Eq a => a -> Pixel CMYK a -> Bool #

maximum :: Ord a => Pixel CMYK a -> a #

minimum :: Ord a => Pixel CMYK a -> a #

sum :: Num a => Pixel CMYK a -> a #

product :: Num a => Pixel CMYK a -> a #

Foldable (Pixel CMYKA) 

Methods

fold :: Monoid m => Pixel CMYKA m -> m #

foldMap :: Monoid m => (a -> m) -> Pixel CMYKA a -> m #

foldr :: (a -> b -> b) -> b -> Pixel CMYKA a -> b #

foldr' :: (a -> b -> b) -> b -> Pixel CMYKA a -> b #

foldl :: (b -> a -> b) -> b -> Pixel CMYKA a -> b #

foldl' :: (b -> a -> b) -> b -> Pixel CMYKA a -> b #

foldr1 :: (a -> a -> a) -> Pixel CMYKA a -> a #

foldl1 :: (a -> a -> a) -> Pixel CMYKA a -> a #

toList :: Pixel CMYKA a -> [a] #

null :: Pixel CMYKA a -> Bool #

length :: Pixel CMYKA a -> Int #

elem :: Eq a => a -> Pixel CMYKA a -> Bool #

maximum :: Ord a => Pixel CMYKA a -> a #

minimum :: Ord a => Pixel CMYKA a -> a #

sum :: Num a => Pixel CMYKA a -> a #

product :: Num a => Pixel CMYKA a -> a #

Foldable (Pixel HSI) 

Methods

fold :: Monoid m => Pixel HSI m -> m #

foldMap :: Monoid m => (a -> m) -> Pixel HSI a -> m #

foldr :: (a -> b -> b) -> b -> Pixel HSI a -> b #

foldr' :: (a -> b -> b) -> b -> Pixel HSI a -> b #

foldl :: (b -> a -> b) -> b -> Pixel HSI a -> b #

foldl' :: (b -> a -> b) -> b -> Pixel HSI a -> b #

foldr1 :: (a -> a -> a) -> Pixel HSI a -> a #

foldl1 :: (a -> a -> a) -> Pixel HSI a -> a #

toList :: Pixel HSI a -> [a] #

null :: Pixel HSI a -> Bool #

length :: Pixel HSI a -> Int #

elem :: Eq a => a -> Pixel HSI a -> Bool #

maximum :: Ord a => Pixel HSI a -> a #

minimum :: Ord a => Pixel HSI a -> a #

sum :: Num a => Pixel HSI a -> a #

product :: Num a => Pixel HSI a -> a #

Foldable (Pixel HSIA) 

Methods

fold :: Monoid m => Pixel HSIA m -> m #

foldMap :: Monoid m => (a -> m) -> Pixel HSIA a -> m #

foldr :: (a -> b -> b) -> b -> Pixel HSIA a -> b #

foldr' :: (a -> b -> b) -> b -> Pixel HSIA a -> b #

foldl :: (b -> a -> b) -> b -> Pixel HSIA a -> b #

foldl' :: (b -> a -> b) -> b -> Pixel HSIA a -> b #

foldr1 :: (a -> a -> a) -> Pixel HSIA a -> a #

foldl1 :: (a -> a -> a) -> Pixel HSIA a -> a #

toList :: Pixel HSIA a -> [a] #

null :: Pixel HSIA a -> Bool #

length :: Pixel HSIA a -> Int #

elem :: Eq a => a -> Pixel HSIA a -> Bool #

maximum :: Ord a => Pixel HSIA a -> a #

minimum :: Ord a => Pixel HSIA a -> a #

sum :: Num a => Pixel HSIA a -> a #

product :: Num a => Pixel HSIA a -> a #

FileFormat (Encode (Image r cs e)) 

Associated Types

type ReadOptions (Encode (Image r cs e)) :: * #

type WriteOptions (Encode (Image r cs e)) :: * #

Methods

ext :: Encode (Image r cs e) -> String #

exts :: Encode (Image r cs e) -> [String] #

isFormat :: String -> Encode (Image r cs e) -> Bool #

FileFormat (Decode (Image r cs e)) 

Associated Types

type ReadOptions (Decode (Image r cs e)) :: * #

type WriteOptions (Decode (Image r cs e)) :: * #

Methods

ext :: Decode (Image r cs e) -> String #

exts :: Decode (Image r cs e) -> [String] #

isFormat :: String -> Decode (Image r cs e) -> Bool #

Readable (Decode (Image r cs e)) (Image r cs e) 

Methods

decode :: Decode (Image r cs e) -> ReadOptions (Decode (Image r cs e)) -> ByteString -> Image r cs e #

ColorSpace cs e => Readable (Sequence PBM) (Array B Ix1 (Image S cs e)) 
ColorSpace cs e => Readable (Sequence PGM) (Array B Ix1 (Image S cs e)) 
ColorSpace cs e => Readable (Sequence PPM) (Array B Ix1 (Image S cs e)) 
ColorSpace cs e => Readable (Sequence GIF) (Array B Ix1 (GifDelay, Image S cs e)) 
ColorSpace cs e => Readable (Sequence GIF) (Array B Ix1 (Image S cs e)) 
(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Sequence (Auto PBM)) (Array B Ix1 (Image r cs e)) 
(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Sequence (Auto PGM)) (Array B Ix1 (Image r cs e)) 
(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Sequence (Auto PPM)) (Array B Ix1 (Image r cs e)) 
(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Sequence (Auto GIF)) (Array B Ix1 (Image r cs e)) 
(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Auto PBM) (Image r cs e) 

Methods

decode :: Auto PBM -> ReadOptions (Auto PBM) -> ByteString -> Image r cs e #

(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Auto PGM) (Image r cs e) 

Methods

decode :: Auto PGM -> ReadOptions (Auto PGM) -> ByteString -> Image r cs e #

(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Auto PPM) (Image r cs e) 

Methods

decode :: Auto PPM -> ReadOptions (Auto PPM) -> ByteString -> Image r cs e #

(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Auto BMP) (Image r cs e) 

Methods

decode :: Auto BMP -> ReadOptions (Auto BMP) -> ByteString -> Image r cs e #

(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Auto PNG) (Image r cs e) 

Methods

decode :: Auto PNG -> ReadOptions (Auto PNG) -> ByteString -> Image r cs e #

(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Auto GIF) (Image r cs e) 

Methods

decode :: Auto GIF -> ReadOptions (Auto GIF) -> ByteString -> Image r cs e #

(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Auto HDR) (Image r cs e) 

Methods

decode :: Auto HDR -> ReadOptions (Auto HDR) -> ByteString -> Image r cs e #

(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Auto JPG) (Image r cs e) 

Methods

decode :: Auto JPG -> ReadOptions (Auto JPG) -> ByteString -> Image r cs e #

(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Auto TGA) (Image r cs e) 

Methods

decode :: Auto TGA -> ReadOptions (Auto TGA) -> ByteString -> Image r cs e #

(Mutable r Ix2 (Pixel cs e), ColorSpace cs e) => Readable (Auto TIF) (Image r cs e) 

Methods

decode :: Auto TIF -> ReadOptions (Auto TIF) -> ByteString -> Image r cs e #

Writable (Encode (Image r cs e)) (Image r cs e) 

Methods

encode :: Encode (Image r cs e) -> WriteOptions (Encode (Image r cs e)) -> Image r cs e -> ByteString #

(ColorSpace cs e, Source r Ix2 (Pixel cs e)) => Writable (Sequence GIF) (Array B Ix1 (GifDelay, Image r cs e)) 
(ColorSpace cs e, ToRGBA cs e, Source r Ix2 (Pixel cs e)) => Writable (Auto BMP) (Image r cs e) 

Methods

encode :: Auto BMP -> WriteOptions (Auto BMP) -> Image r cs e -> ByteString #

(ColorSpace cs e, ToYA cs e, ToRGBA cs e, Source r Ix2 (Pixel cs e)) => Writable (Auto PNG) (Image r cs e) 

Methods

encode :: Auto PNG -> WriteOptions (Auto PNG) -> Image r cs e -> ByteString #

(ColorSpace cs e, ToY cs e, ToRGB cs e, Source r Ix2 (Pixel cs e)) => Writable (Auto GIF) (Image r cs e) 

Methods

encode :: Auto GIF -> WriteOptions (Auto GIF) -> Image r cs e -> ByteString #

(ColorSpace cs e, ToRGB cs e, Source r Ix2 (Pixel cs e)) => Writable (Auto HDR) (Image r cs e) 

Methods

encode :: Auto HDR -> WriteOptions (Auto HDR) -> Image r cs e -> ByteString #

(ColorSpace cs e, ToYCbCr cs e, Source r Ix2 (Pixel cs e)) => Writable (Auto JPG) (Image r cs e) 

Methods

encode :: Auto JPG -> WriteOptions (Auto JPG) -> Image r cs e -> ByteString #

(ColorSpace cs e, ToRGBA cs e, Source r Ix2 (Pixel cs e)) => Writable (Auto TGA) (Image r cs e) 

Methods

encode :: Auto TGA -> WriteOptions (Auto TGA) -> Image r cs e -> ByteString #

(ColorSpace cs e, ToRGBA cs e, Source r Ix2 (Pixel cs e)) => Writable (Auto TIF) (Image r cs e) 

Methods

encode :: Auto TIF -> WriteOptions (Auto TIF) -> Image r cs e -> ByteString #

(ColorSpace cs e, Bounded e) => Bounded (Pixel cs e) 

Methods

minBound :: Pixel cs e #

maxBound :: Pixel cs e #

Eq e => Eq (Pixel YCbCr e) 

Methods

(==) :: Pixel YCbCr e -> Pixel YCbCr e -> Bool #

(/=) :: Pixel YCbCr e -> Pixel YCbCr e -> Bool #

Eq e => Eq (Pixel YCbCrA e) 

Methods

(==) :: Pixel YCbCrA e -> Pixel YCbCrA e -> Bool #

(/=) :: Pixel YCbCrA e -> Pixel YCbCrA e -> Bool #

Eq e => Eq (Pixel Y e) 

Methods

(==) :: Pixel Y e -> Pixel Y e -> Bool #

(/=) :: Pixel Y e -> Pixel Y e -> Bool #

Eq e => Eq (Pixel YA e) 

Methods

(==) :: Pixel YA e -> Pixel YA e -> Bool #

(/=) :: Pixel YA e -> Pixel YA e -> Bool #

Eq e => Eq (Pixel X e) 

Methods

(==) :: Pixel X e -> Pixel X e -> Bool #

(/=) :: Pixel X e -> Pixel X e -> Bool #

Eq e => Eq (Pixel RGB e) 

Methods

(==) :: Pixel RGB e -> Pixel RGB e -> Bool #

(/=) :: Pixel RGB e -> Pixel RGB e -> Bool #

Eq e => Eq (Pixel RGBA e) 

Methods

(==) :: Pixel RGBA e -> Pixel RGBA e -> Bool #

(/=) :: Pixel RGBA e -> Pixel RGBA e -> Bool #

Eq e => Eq (Pixel CMYK e) 

Methods

(==) :: Pixel CMYK e -> Pixel CMYK e -> Bool #

(/=) :: Pixel CMYK e -> Pixel CMYK e -> Bool #

Eq e => Eq (Pixel CMYKA e) 

Methods

(==) :: Pixel CMYKA e -> Pixel CMYKA e -> Bool #

(/=) :: Pixel CMYKA e -> Pixel CMYKA e -> Bool #

Eq e => Eq (Pixel HSI e) 

Methods

(==) :: Pixel HSI e -> Pixel HSI e -> Bool #

(/=) :: Pixel HSI e -> Pixel HSI e -> Bool #

Eq e => Eq (Pixel HSIA e) 

Methods

(==) :: Pixel HSIA e -> Pixel HSIA e -> Bool #

(/=) :: Pixel HSIA e -> Pixel HSIA e -> Bool #

(ColorSpace cs e, Floating e) => Floating (Pixel cs e) 

Methods

pi :: Pixel cs e #

exp :: Pixel cs e -> Pixel cs e #

log :: Pixel cs e -> Pixel cs e #

sqrt :: Pixel cs e -> Pixel cs e #

(**) :: Pixel cs e -> Pixel cs e -> Pixel cs e #

logBase :: Pixel cs e -> Pixel cs e -> Pixel cs e #

sin :: Pixel cs e -> Pixel cs e #

cos :: Pixel cs e -> Pixel cs e #

tan :: Pixel cs e -> Pixel cs e #

asin :: Pixel cs e -> Pixel cs e #

acos :: Pixel cs e -> Pixel cs e #

atan :: Pixel cs e -> Pixel cs e #

sinh :: Pixel cs e -> Pixel cs e #

cosh :: Pixel cs e -> Pixel cs e #

tanh :: Pixel cs e -> Pixel cs e #

asinh :: Pixel cs e -> Pixel cs e #

acosh :: Pixel cs e -> Pixel cs e #

atanh :: Pixel cs e -> Pixel cs e #

log1p :: Pixel cs e -> Pixel cs e #

expm1 :: Pixel cs e -> Pixel cs e #

log1pexp :: Pixel cs e -> Pixel cs e #

log1mexp :: Pixel cs e -> Pixel cs e #

(ColorSpace cs e, Fractional e) => Fractional (Pixel cs e) 

Methods

(/) :: Pixel cs e -> Pixel cs e -> Pixel cs e #

recip :: Pixel cs e -> Pixel cs e #

fromRational :: Rational -> Pixel cs e #

ColorSpace cs e => Num (Pixel cs e) 

Methods

(+) :: Pixel cs e -> Pixel cs e -> Pixel cs e #

(-) :: Pixel cs e -> Pixel cs e -> Pixel cs e #

(*) :: Pixel cs e -> Pixel cs e -> Pixel cs e #

negate :: Pixel cs e -> Pixel cs e #

abs :: Pixel cs e -> Pixel cs e #

signum :: Pixel cs e -> Pixel cs e #

fromInteger :: Integer -> Pixel cs e #

Ord e => Ord (Pixel YCbCr e) 

Methods

compare :: Pixel YCbCr e -> Pixel YCbCr e -> Ordering #

(<) :: Pixel YCbCr e -> Pixel YCbCr e -> Bool #

(<=) :: Pixel YCbCr e -> Pixel YCbCr e -> Bool #

(>) :: Pixel YCbCr e -> Pixel YCbCr e -> Bool #

(>=) :: Pixel YCbCr e -> Pixel YCbCr e -> Bool #

max :: Pixel YCbCr e -> Pixel YCbCr e -> Pixel YCbCr e #

min :: Pixel YCbCr e -> Pixel YCbCr e -> Pixel YCbCr e #

Ord e => Ord (Pixel YCbCrA e) 
Ord e => Ord (Pixel Y e) 

Methods

compare :: Pixel Y e -> Pixel Y e -> Ordering #

(<) :: Pixel Y e -> Pixel Y e -> Bool #

(<=) :: Pixel Y e -> Pixel Y e -> Bool #

(>) :: Pixel Y e -> Pixel Y e -> Bool #

(>=) :: Pixel Y e -> Pixel Y e -> Bool #

max :: Pixel Y e -> Pixel Y e -> Pixel Y e #

min :: Pixel Y e -> Pixel Y e -> Pixel Y e #

Ord e => Ord (Pixel YA e) 

Methods

compare :: Pixel YA e -> Pixel YA e -> Ordering #

(<) :: Pixel YA e -> Pixel YA e -> Bool #

(<=) :: Pixel YA e -> Pixel YA e -> Bool #

(>) :: Pixel YA e -> Pixel YA e -> Bool #

(>=) :: Pixel YA e -> Pixel YA e -> Bool #

max :: Pixel YA e -> Pixel YA e -> Pixel YA e #

min :: Pixel YA e -> Pixel YA e -> Pixel YA e #

Ord e => Ord (Pixel X e) 

Methods

compare :: Pixel X e -> Pixel X e -> Ordering #

(<) :: Pixel X e -> Pixel X e -> Bool #

(<=) :: Pixel X e -> Pixel X e -> Bool #

(>) :: Pixel X e -> Pixel X e -> Bool #

(>=) :: Pixel X e -> Pixel X e -> Bool #

max :: Pixel X e -> Pixel X e -> Pixel X e #

min :: Pixel X e -> Pixel X e -> Pixel X e #

Ord e => Ord (Pixel RGB e) 

Methods

compare :: Pixel RGB e -> Pixel RGB e -> Ordering #

(<) :: Pixel RGB e -> Pixel RGB e -> Bool #

(<=) :: Pixel RGB e -> Pixel RGB e -> Bool #

(>) :: Pixel RGB e -> Pixel RGB e -> Bool #

(>=) :: Pixel RGB e -> Pixel RGB e -> Bool #

max :: Pixel RGB e -> Pixel RGB e -> Pixel RGB e #

min :: Pixel RGB e -> Pixel RGB e -> Pixel RGB e #

Ord e => Ord (Pixel RGBA e) 

Methods

compare :: Pixel RGBA e -> Pixel RGBA e -> Ordering #

(<) :: Pixel RGBA e -> Pixel RGBA e -> Bool #

(<=) :: Pixel RGBA e -> Pixel RGBA e -> Bool #

(>) :: Pixel RGBA e -> Pixel RGBA e -> Bool #

(>=) :: Pixel RGBA e -> Pixel RGBA e -> Bool #

max :: Pixel RGBA e -> Pixel RGBA e -> Pixel RGBA e #

min :: Pixel RGBA e -> Pixel RGBA e -> Pixel RGBA e #

Ord e => Ord (Pixel CMYK e) 

Methods

compare :: Pixel CMYK e -> Pixel CMYK e -> Ordering #

(<) :: Pixel CMYK e -> Pixel CMYK e -> Bool #

(<=) :: Pixel CMYK e -> Pixel CMYK e -> Bool #

(>) :: Pixel CMYK e -> Pixel CMYK e -> Bool #

(>=) :: Pixel CMYK e -> Pixel CMYK e -> Bool #

max :: Pixel CMYK e -> Pixel CMYK e -> Pixel CMYK e #

min :: Pixel CMYK e -> Pixel CMYK e -> Pixel CMYK e #

Ord e => Ord (Pixel CMYKA e) 

Methods

compare :: Pixel CMYKA e -> Pixel CMYKA e -> Ordering #

(<) :: Pixel CMYKA e -> Pixel CMYKA e -> Bool #

(<=) :: Pixel CMYKA e -> Pixel CMYKA e -> Bool #

(>) :: Pixel CMYKA e -> Pixel CMYKA e -> Bool #

(>=) :: Pixel CMYKA e -> Pixel CMYKA e -> Bool #

max :: Pixel CMYKA e -> Pixel CMYKA e -> Pixel CMYKA e #

min :: Pixel CMYKA e -> Pixel CMYKA e -> Pixel CMYKA e #

Ord e => Ord (Pixel HSI e) 

Methods

compare :: Pixel HSI e -> Pixel HSI e -> Ordering #

(<) :: Pixel HSI e -> Pixel HSI e -> Bool #

(<=) :: Pixel HSI e -> Pixel HSI e -> Bool #

(>) :: Pixel HSI e -> Pixel HSI e -> Bool #

(>=) :: Pixel HSI e -> Pixel HSI e -> Bool #

max :: Pixel HSI e -> Pixel HSI e -> Pixel HSI e #

min :: Pixel HSI e -> Pixel HSI e -> Pixel HSI e #

Ord e => Ord (Pixel HSIA e) 

Methods

compare :: Pixel HSIA e -> Pixel HSIA e -> Ordering #

(<) :: Pixel HSIA e -> Pixel HSIA e -> Bool #

(<=) :: Pixel HSIA e -> Pixel HSIA e -> Bool #

(>) :: Pixel HSIA e -> Pixel HSIA e -> Bool #

(>=) :: Pixel HSIA e -> Pixel HSIA e -> Bool #

max :: Pixel HSIA e -> Pixel HSIA e -> Pixel HSIA e #

min :: Pixel HSIA e -> Pixel HSIA e -> Pixel HSIA e #

Show e => Show (Pixel YCbCr e) 

Methods

showsPrec :: Int -> Pixel YCbCr e -> ShowS #

show :: Pixel YCbCr e -> String #

showList :: [Pixel YCbCr e] -> ShowS #

Show e => Show (Pixel YCbCrA e) 
Show e => Show (Pixel Y e) 

Methods

showsPrec :: Int -> Pixel Y e -> ShowS #

show :: Pixel Y e -> String #

showList :: [Pixel Y e] -> ShowS #

Show e => Show (Pixel YA e) 

Methods

showsPrec :: Int -> Pixel YA e -> ShowS #

show :: Pixel YA e -> String #

showList :: [Pixel YA e] -> ShowS #

Show e => Show (Pixel X e) 

Methods

showsPrec :: Int -> Pixel X e -> ShowS #

show :: Pixel X e -> String #

showList :: [Pixel X e] -> ShowS #

Show e => Show (Pixel RGB e) 

Methods

showsPrec :: Int -> Pixel RGB e -> ShowS #

show :: Pixel RGB e -> String #

showList :: [Pixel RGB e] -> ShowS #

Show e => Show (Pixel RGBA e) 

Methods

showsPrec :: Int -> Pixel RGBA e -> ShowS #

show :: Pixel RGBA e -> String #

showList :: [Pixel RGBA e] -> ShowS #

Show e => Show (Pixel CMYK e) 

Methods

showsPrec :: Int -> Pixel CMYK e -> ShowS #

show :: Pixel CMYK e -> String #

showList :: [Pixel CMYK e] -> ShowS #

Show e => Show (Pixel CMYKA e) 

Methods

showsPrec :: Int -> Pixel CMYKA e -> ShowS #

show :: Pixel CMYKA e -> String #

showList :: [Pixel CMYKA e] -> ShowS #

Show e => Show (Pixel HSI e) 

Methods

showsPrec :: Int -> Pixel HSI e -> ShowS #

show :: Pixel HSI e -> String #

showList :: [Pixel HSI e] -> ShowS #

Show e => Show (Pixel HSIA e) 

Methods

showsPrec :: Int -> Pixel HSIA e -> ShowS #

show :: Pixel HSIA e -> String #

showList :: [Pixel HSIA e] -> ShowS #

Storable e => Storable (Pixel YCbCr e) 

Methods

sizeOf :: Pixel YCbCr e -> Int #

alignment :: Pixel YCbCr e -> Int #

peekElemOff :: Ptr (Pixel YCbCr e) -> Int -> IO (Pixel YCbCr e) #

pokeElemOff :: Ptr (Pixel YCbCr e) -> Int -> Pixel YCbCr e -> IO () #

peekByteOff :: Ptr b -> Int -> IO (Pixel YCbCr e) #

pokeByteOff :: Ptr b -> Int -> Pixel YCbCr e -> IO () #

peek :: Ptr (Pixel YCbCr e) -> IO (Pixel YCbCr e) #

poke :: Ptr (Pixel YCbCr e) -> Pixel YCbCr e -> IO () #

Storable e => Storable (Pixel YCbCrA e) 

Methods

sizeOf :: Pixel YCbCrA e -> Int #

alignment :: Pixel YCbCrA e -> Int #

peekElemOff :: Ptr (Pixel YCbCrA e) -> Int -> IO (Pixel YCbCrA e) #

pokeElemOff :: Ptr (Pixel YCbCrA e) -> Int -> Pixel YCbCrA e -> IO () #

peekByteOff :: Ptr b -> Int -> IO (Pixel YCbCrA e) #

pokeByteOff :: Ptr b -> Int -> Pixel YCbCrA e -> IO () #

peek :: Ptr (Pixel YCbCrA e) -> IO (Pixel YCbCrA e) #

poke :: Ptr (Pixel YCbCrA e) -> Pixel YCbCrA e -> IO () #

Storable e => Storable (Pixel Y e) 

Methods

sizeOf :: Pixel Y e -> Int #

alignment :: Pixel Y e -> Int #

peekElemOff :: Ptr (Pixel Y e) -> Int -> IO (Pixel Y e) #

pokeElemOff :: Ptr (Pixel Y e) -> Int -> Pixel Y e -> IO () #

peekByteOff :: Ptr b -> Int -> IO (Pixel Y e) #

pokeByteOff :: Ptr b -> Int -> Pixel Y e -> IO () #

peek :: Ptr (Pixel Y e) -> IO (Pixel Y e) #

poke :: Ptr (Pixel Y e) -> Pixel Y e -> IO () #

Storable e => Storable (Pixel YA e) 

Methods

sizeOf :: Pixel YA e -> Int #

alignment :: Pixel YA e -> Int #

peekElemOff :: Ptr (Pixel YA e) -> Int -> IO (Pixel YA e) #

pokeElemOff :: Ptr (Pixel YA e) -> Int -> Pixel YA e -> IO () #

peekByteOff :: Ptr b -> Int -> IO (Pixel YA e) #

pokeByteOff :: Ptr b -> Int -> Pixel YA e -> IO () #

peek :: Ptr (Pixel YA e) -> IO (Pixel YA e) #

poke :: Ptr (Pixel YA e) -> Pixel YA e -> IO () #

Storable e => Storable (Pixel X e) 

Methods

sizeOf :: Pixel X e -> Int #

alignment :: Pixel X e -> Int #

peekElemOff :: Ptr (Pixel X e) -> Int -> IO (Pixel X e) #

pokeElemOff :: Ptr (Pixel X e) -> Int -> Pixel X e -> IO () #

peekByteOff :: Ptr b -> Int -> IO (Pixel X e) #

pokeByteOff :: Ptr b -> Int -> Pixel X e -> IO () #

peek :: Ptr (Pixel X e) -> IO (Pixel X e) #

poke :: Ptr (Pixel X e) -> Pixel X e -> IO () #

Storable e => Storable (Pixel RGB e) 

Methods

sizeOf :: Pixel RGB e -> Int #

alignment :: Pixel RGB e -> Int #

peekElemOff :: Ptr (Pixel RGB e) -> Int -> IO (Pixel RGB e) #

pokeElemOff :: Ptr (Pixel RGB e) -> Int -> Pixel RGB e -> IO () #

peekByteOff :: Ptr b -> Int -> IO (Pixel RGB e) #

pokeByteOff :: Ptr b -> Int -> Pixel RGB e -> IO () #

peek :: Ptr (Pixel RGB e) -> IO (Pixel RGB e) #

poke :: Ptr (Pixel RGB e) -> Pixel RGB e -> IO () #

Storable e => Storable (Pixel RGBA e) 

Methods

sizeOf :: Pixel RGBA e -> Int #

alignment :: Pixel RGBA e -> Int #

peekElemOff :: Ptr (Pixel RGBA e) -> Int -> IO (Pixel RGBA e) #

pokeElemOff :: Ptr (Pixel RGBA e) -> Int -> Pixel RGBA e -> IO () #

peekByteOff :: Ptr b -> Int -> IO (Pixel RGBA e) #

pokeByteOff :: Ptr b -> Int -> Pixel RGBA e -> IO () #

peek :: Ptr (Pixel RGBA e) -> IO (Pixel RGBA e) #

poke :: Ptr (Pixel RGBA e) -> Pixel RGBA e -> IO () #

Storable e => Storable (Pixel CMYK e) 

Methods

sizeOf :: Pixel CMYK e -> Int #

alignment :: Pixel CMYK e -> Int #

peekElemOff :: Ptr (Pixel CMYK e) -> Int -> IO (Pixel CMYK e) #

pokeElemOff :: Ptr (Pixel CMYK e) -> Int -> Pixel CMYK e -> IO () #

peekByteOff :: Ptr b -> Int -> IO (Pixel CMYK e) #

pokeByteOff :: Ptr b -> Int -> Pixel CMYK e -> IO () #

peek :: Ptr (Pixel CMYK e) -> IO (Pixel CMYK e) #

poke :: Ptr (Pixel CMYK e) -> Pixel CMYK e -> IO () #

Storable e => Storable (Pixel CMYKA e) 

Methods

sizeOf :: Pixel CMYKA e -> Int #

alignment :: Pixel CMYKA e -> Int #

peekElemOff :: Ptr (Pixel CMYKA e) -> Int -> IO (Pixel CMYKA e) #

pokeElemOff :: Ptr (Pixel CMYKA e) -> Int -> Pixel CMYKA e -> IO () #

peekByteOff :: Ptr b -> Int -> IO (Pixel CMYKA e) #

pokeByteOff :: Ptr b -> Int -> Pixel CMYKA e -> IO () #

peek :: Ptr (Pixel CMYKA e) -> IO (Pixel CMYKA e) #

poke :: Ptr (Pixel CMYKA e) -> Pixel CMYKA e -> IO () #

Storable e => Storable (Pixel HSI e) 

Methods

sizeOf :: Pixel HSI e -> Int #

alignment :: Pixel HSI e -> Int #

peekElemOff :: Ptr (Pixel HSI e) -> Int -> IO (Pixel HSI e) #

pokeElemOff :: Ptr (Pixel HSI e) -> Int -> Pixel HSI e -> IO () #

peekByteOff :: Ptr b -> Int -> IO (Pixel HSI e) #

pokeByteOff :: Ptr b -> Int -> Pixel HSI e -> IO () #

peek :: Ptr (Pixel HSI e) -> IO (Pixel HSI e) #

poke :: Ptr (Pixel HSI e) -> Pixel HSI e -> IO () #

Storable e => Storable (Pixel HSIA e) 

Methods

sizeOf :: Pixel HSIA e -> Int #

alignment :: Pixel HSIA e -> Int #

peekElemOff :: Ptr (Pixel HSIA e) -> Int -> IO (Pixel HSIA e) #

pokeElemOff :: Ptr (Pixel HSIA e) -> Int -> Pixel HSIA e -> IO () #

peekByteOff :: Ptr b -> Int -> IO (Pixel HSIA e) #

pokeByteOff :: Ptr b -> Int -> Pixel HSIA e -> IO () #

peek :: Ptr (Pixel HSIA e) -> IO (Pixel HSIA e) #

poke :: Ptr (Pixel HSIA e) -> Pixel HSIA e -> IO () #

Bits (Pixel X Bit) 
ColorSpace cs e => Default (Pixel cs e) 

Methods

def :: Pixel cs e #

(ColorSpace cs e, NFData e) => NFData (Pixel cs e) 

Methods

rnf :: Pixel cs e -> () #

ColorSpace cs e => Unbox (Pixel cs e)

Unboxing of a Pixel.

data Pixel YCbCr 
data Pixel YCbCr = PixelYCbCr !e !e !e
data Pixel YCbCrA 
data Pixel YCbCrA = PixelYCbCrA !e !e !e !e
data Pixel Y 
data Pixel Y = PixelY e
data Pixel YA 
data Pixel YA = PixelYA !e !e
data Pixel X 
data Pixel X = PixelX {}
data Pixel RGB 
data Pixel RGB = PixelRGB !e !e !e
data Pixel RGBA 
data Pixel RGBA = PixelRGBA !e !e !e !e
data Pixel CMYK 
data Pixel CMYK = PixelCMYK !e !e !e !e
data Pixel CMYKA 
data Pixel CMYKA = PixelCMYKA !e !e !e !e !e
data Pixel HSI 
data Pixel HSI = PixelHSI !e !e !e
data Pixel HSIA 
data Pixel HSIA = PixelHSIA !e !e !e !e
data MVector s (Pixel cs e) 
data MVector s (Pixel cs e) = MV_Pixel (MVector s (Components cs e))
type WriteOptions (Encode (Image r cs e)) 
type WriteOptions (Encode (Image r cs e)) = ()
type WriteOptions (Decode (Image r cs e)) 
type WriteOptions (Decode (Image r cs e)) = ()
type ReadOptions (Encode (Image r cs e)) 
type ReadOptions (Encode (Image r cs e)) = ()
type ReadOptions (Decode (Image r cs e)) 
type ReadOptions (Decode (Image r cs e)) = ()
data Vector (Pixel cs e) 
data Vector (Pixel cs e) = V_Pixel (Vector (Components cs e))

data RGBA :: * #

Red, Green and Blue color space with Alpha channel.

Instances

Bounded RGBA 
Enum RGBA 

Methods

succ :: RGBA -> RGBA #

pred :: RGBA -> RGBA #

toEnum :: Int -> RGBA #

fromEnum :: RGBA -> Int #

enumFrom :: RGBA -> [RGBA] #

enumFromThen :: RGBA -> RGBA -> [RGBA] #

enumFromTo :: RGBA -> RGBA -> [RGBA] #

enumFromThenTo :: RGBA -> RGBA -> RGBA -> [RGBA] #

Eq RGBA 

Methods

(==) :: RGBA -> RGBA -> Bool #

(/=) :: RGBA -> RGBA -> Bool #

Show RGBA 

Methods

showsPrec :: Int -> RGBA -> ShowS #

show :: RGBA -> String #

showList :: [RGBA] -> ShowS #

Elevator e => ToY RGBA e 

Methods

toPixelY :: Pixel RGBA e -> Pixel Y Double #

Elevator e => ToYA RGBA e 
Elevator e => ToRGB RGBA e 
Elevator e => ToRGBA RGBA e 
Elevator e => ToHSI RGBA e 
Elevator e => ToHSIA RGBA e 
Elevator e => ToCMYK RGBA e 
Elevator e => ToCMYKA RGBA e 
Elevator e => ToYCbCr RGBA e 
Elevator e => ToYCbCrA RGBA e 
Elevator e => ColorSpace RGBA e 

Associated Types

type Components RGBA e :: * #

Methods

toComponents :: Pixel RGBA e -> Components RGBA e #

fromComponents :: Components RGBA e -> Pixel RGBA e #

promote :: e -> Pixel RGBA e #

getPxC :: Pixel RGBA e -> RGBA -> e #

setPxC :: Pixel RGBA e -> RGBA -> e -> Pixel RGBA e #

mapPxC :: (RGBA -> e -> e) -> Pixel RGBA e -> Pixel RGBA e #

foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel RGBA e -> Pixel RGBA e -> b #

liftPx :: (e -> e) -> Pixel RGBA e -> Pixel RGBA e #

liftPx2 :: (e -> e -> e) -> Pixel RGBA e -> Pixel RGBA e -> Pixel RGBA e #

foldrPx :: (e -> b -> b) -> b -> Pixel RGBA e -> b #

foldlPx :: (b -> e -> b) -> b -> Pixel RGBA e -> b #

foldl1Px :: (e -> e -> e) -> Pixel RGBA e -> e #

Elevator e => AlphaSpace RGBA e 

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 #

Functor (Pixel RGBA) 

Methods

fmap :: (a -> b) -> Pixel RGBA a -> Pixel RGBA b #

(<$) :: a -> Pixel RGBA b -> Pixel RGBA a #

Applicative (Pixel RGBA) 

Methods

pure :: a -> Pixel RGBA a #

(<*>) :: Pixel RGBA (a -> b) -> Pixel RGBA a -> Pixel RGBA b #

liftA2 :: (a -> b -> c) -> Pixel RGBA a -> Pixel RGBA b -> Pixel RGBA c #

(*>) :: Pixel RGBA a -> Pixel RGBA b -> Pixel RGBA b #

(<*) :: Pixel RGBA a -> Pixel RGBA b -> Pixel RGBA a #

Foldable (Pixel RGBA) 

Methods

fold :: Monoid m => Pixel RGBA m -> m #

foldMap :: Monoid m => (a -> m) -> Pixel RGBA a -> m #

foldr :: (a -> b -> b) -> b -> Pixel RGBA a -> b #

foldr' :: (a -> b -> b) -> b -> Pixel RGBA a -> b #

foldl :: (b -> a -> b) -> b -> Pixel RGBA a -> b #

foldl' :: (b -> a -> b) -> b -> Pixel RGBA a -> b #

foldr1 :: (a -> a -> a) -> Pixel RGBA a -> a #

foldl1 :: (a -> a -> a) -> Pixel RGBA a -> a #

toList :: Pixel RGBA a -> [a] #

null :: Pixel RGBA a -> Bool #

length :: Pixel RGBA a -> Int #

elem :: Eq a => a -> Pixel RGBA a -> Bool #

maximum :: Ord a => Pixel RGBA a -> a #

minimum :: Ord a => Pixel RGBA a -> a #

sum :: Num a => Pixel RGBA a -> a #

product :: Num a => Pixel RGBA a -> a #

Eq e => Eq (Pixel RGBA e) 

Methods

(==) :: Pixel RGBA e -> Pixel RGBA e -> Bool #

(/=) :: Pixel RGBA e -> Pixel RGBA e -> Bool #

Ord e => Ord (Pixel RGBA e) 

Methods

compare :: Pixel RGBA e -> Pixel RGBA e -> Ordering #

(<) :: Pixel RGBA e -> Pixel RGBA e -> Bool #

(<=) :: Pixel RGBA e -> Pixel RGBA e -> Bool #

(>) :: Pixel RGBA e -> Pixel RGBA e -> Bool #

(>=) :: Pixel RGBA e -> Pixel RGBA e -> Bool #

max :: Pixel RGBA e -> Pixel RGBA e -> Pixel RGBA e #

min :: Pixel RGBA e -> Pixel RGBA e -> Pixel RGBA e #

Show e => Show (Pixel RGBA e) 

Methods

showsPrec :: Int -> Pixel RGBA e -> ShowS #

show :: Pixel RGBA e -> String #

showList :: [Pixel RGBA e] -> ShowS #

Storable e => Storable (Pixel RGBA e) 

Methods

sizeOf :: Pixel RGBA e -> Int #

alignment :: Pixel RGBA e -> Int #

peekElemOff :: Ptr (Pixel RGBA e) -> Int -> IO (Pixel RGBA e) #

pokeElemOff :: Ptr (Pixel RGBA e) -> Int -> Pixel RGBA e -> IO () #

peekByteOff :: Ptr b -> Int -> IO (Pixel RGBA e) #

pokeByteOff :: Ptr b -> Int -> Pixel RGBA e -> IO () #

peek :: Ptr (Pixel RGBA e) -> IO (Pixel RGBA e) #

poke :: Ptr (Pixel RGBA e) -> Pixel RGBA e -> IO () #

data Pixel RGBA 
data Pixel RGBA = PixelRGBA !e !e !e !e
type Opaque RGBA 
type Opaque RGBA = RGB
type Components RGBA e 
type Components RGBA e = (e, e, e, e)

data Y :: * #

Luma or brightness, which is usually denoted as Y'.

Instances

Bounded Y 

Methods

minBound :: Y #

maxBound :: Y #

Enum Y 

Methods

succ :: Y -> Y #

pred :: Y -> Y #

toEnum :: Int -> Y #

fromEnum :: Y -> Int #

enumFrom :: Y -> [Y] #

enumFromThen :: Y -> Y -> [Y] #

enumFromTo :: Y -> Y -> [Y] #

enumFromThenTo :: Y -> Y -> Y -> [Y] #

Eq Y 

Methods

(==) :: Y -> Y -> Bool #

(/=) :: Y -> Y -> Bool #

Show Y 

Methods

showsPrec :: Int -> Y -> ShowS #

show :: Y -> String #

showList :: [Y] -> ShowS #

Elevator e => ToY Y e 

Methods

toPixelY :: Pixel Y e -> Pixel Y Double #

ToY Y e => ToYA Y e 

Methods

toPixelYA :: Pixel Y e -> Pixel YA Double #

Elevator e => ToRGB Y e 

Methods

toPixelRGB :: Pixel Y e -> Pixel RGB Double #

ToRGB Y e => ToRGBA Y e 
Elevator e => ToHSI Y e 

Methods

toPixelHSI :: Pixel Y e -> Pixel HSI Double #

ToHSI Y e => ToHSIA Y e 
Elevator e => ToCMYK Y e 
ToCMYK Y e => ToCMYKA Y e 
Elevator e => ToYCbCr Y e 
ToYCbCr Y e => ToYCbCrA Y e 
Elevator e => ColorSpace Y e 

Associated Types

type Components Y e :: * #

Methods

toComponents :: Pixel Y e -> Components Y e #

fromComponents :: Components Y e -> Pixel Y e #

promote :: e -> Pixel Y e #

getPxC :: Pixel Y e -> Y -> e #

setPxC :: Pixel Y e -> Y -> e -> Pixel Y e #

mapPxC :: (Y -> e -> e) -> Pixel Y e -> Pixel Y e #

foldlPx2 :: (b -> e -> e -> b) -> b -> Pixel Y e -> Pixel Y e -> b #

liftPx :: (e -> e) -> Pixel Y e -> Pixel Y e #

liftPx2 :: (e -> e -> e) -> Pixel Y e -> Pixel Y e -> Pixel Y e #

foldrPx :: (e -> b -> b) -> b -> Pixel Y e -> b #

foldlPx :: (b -> e -> b) -> b -> Pixel Y e -> b #

foldl1Px :: (e -> e -> e) -> Pixel Y e -> e #

Monad (Pixel Y) 

Methods

(>>=) :: Pixel Y a -> (a -> Pixel Y b) -> Pixel Y b #

(>>) :: Pixel Y a -> Pixel Y b -> Pixel Y b #

return :: a -> Pixel Y a #

fail :: String -> Pixel Y a #

Functor (Pixel Y) 

Methods

fmap :: (a -> b) -> Pixel Y a -> Pixel Y b #

(<$) :: a -> Pixel Y b -> Pixel Y a #

Applicative (Pixel Y) 

Methods

pure :: a -> Pixel Y a #

(<*>) :: Pixel Y (a -> b) -> Pixel Y a -> Pixel Y b #

liftA2 :: (a -> b -> c) -> Pixel Y a -> Pixel Y b -> Pixel Y c #

(*>) :: Pixel Y a -> Pixel Y b -> Pixel Y b #

(<*) :: Pixel Y a -> Pixel Y b -> Pixel Y a #

Foldable (Pixel Y) 

Methods

fold :: Monoid m => Pixel Y m -> m #

foldMap :: Monoid m => (a -> m) -> Pixel Y a -> m #

foldr :: (a -> b -> b) -> b -> Pixel Y a -> b #

foldr' :: (a -> b -> b) -> b -> Pixel Y a -> b #

foldl :: (b -> a -> b) -> b -> Pixel Y a -> b #

foldl' :: (b -> a -> b) -> b -> Pixel Y a -> b #

foldr1 :: (a -> a -> a) -> Pixel Y a -> a #

foldl1 :: (a -> a -> a) -> Pixel Y a -> a #

toList :: Pixel Y a -> [a] #

null :: Pixel Y a -> Bool #

length :: Pixel Y a -> Int #

elem :: Eq a => a -> Pixel Y a -> Bool #

maximum :: Ord a => Pixel Y a -> a #

minimum :: Ord a => Pixel Y a -> a #

sum :: Num a => Pixel Y a -> a #

product :: Num a => Pixel Y a -> a #

Eq e => Eq (Pixel Y e) 

Methods

(==) :: Pixel Y e -> Pixel Y e -> Bool #

(/=) :: Pixel Y e -> Pixel Y e -> Bool #

Ord e => Ord (Pixel Y e) 

Methods

compare :: Pixel Y e -> Pixel Y e -> Ordering #

(<) :: Pixel Y e -> Pixel Y e -> Bool #

(<=) :: Pixel Y e -> Pixel Y e -> Bool #

(>) :: Pixel Y e -> Pixel Y e -> Bool #

(>=) :: Pixel Y e -> Pixel Y e -> Bool #

max :: Pixel Y e -> Pixel Y e -> Pixel Y e #

min :: Pixel Y e -> Pixel Y e -> Pixel Y e #

Show e => Show (Pixel Y e) 

Methods

showsPrec :: Int -> Pixel Y e -> ShowS #

show :: Pixel Y e -> String #

showList :: [Pixel Y e] -> ShowS #

Storable e => Storable (Pixel Y e) 

Methods

sizeOf :: Pixel Y e -> Int #

alignment :: Pixel Y e -> Int #

peekElemOff :: Ptr (Pixel Y e) -> Int -> IO (Pixel Y e) #

pokeElemOff :: Ptr (Pixel Y e) -> Int -> Pixel Y e -> IO () #

peekByteOff :: Ptr b -> Int -> IO (Pixel Y e) #

pokeByteOff :: Ptr b -> Int -> Pixel Y e -> IO () #

peek :: Ptr (Pixel Y e) -> IO (Pixel Y e) #

poke :: Ptr (Pixel Y e) -> Pixel Y e -> IO () #

data Pixel Y 
data Pixel Y = PixelY e
type Components Y e 
type Components Y e = e