Graphics.Image.Processing.Binary

Construction

toImageBinaryUsing

Arguments

:: (Array arr cs e, Array arr X Bit)

=> (Pixel cs e -> Bool)

Predicate

-> Image arr cs e

Source image.

-> Image arr X Bit

Construct a binary image using a predicate from a source image.

toImageBinaryUsing2

Arguments

:: (Array arr cs e, Array arr X Bit)

=> (Pixel cs e -> Pixel cs e -> Bool)

Predicate

-> Image arr cs e

First source image.

-> Image arr cs e

Second source image.

-> Image arr X Bit

Construct a binary image using a predicate from two source images.

threshold :: (Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Pixel cs (e -> Bool) -> Image arr cs e -> Image arr cs Bit

threshold2 :: (Applicative (Pixel cs), Array arr cs e', Array arr cs e, Array arr cs Bit) => Pixel cs (e' -> e -> Bool) -> Image arr cs e' -> Image arr cs e -> Image arr cs Bit

thresholdWith

Arguments

:: (Applicative (Pixel cs), Foldable (Pixel cs), Array arr cs e, Array arr X Bit)

=> Pixel cs (e -> Bool)

Pixel containing a thresholding function per channel.

-> Image arr cs e

Source image.

-> Image arr X Bit

Threshold a source image with an applicative pixel.

>>> yield <- readImageRGB VU "images/yield.jpg"
>>> writeImageExact PNG [] "images/yield_bin.png" $ thresholdWith (PixelRGB (>0.55) (<0.6) (<0.5)) yield

thresholdWith2

Arguments

:: (Applicative (Pixel cs), Foldable (Pixel cs), Array arr cs e1, Array arr cs e2, Array arr X Bit)

=> Pixel cs (e1 -> e2 -> Bool)

Pixel containing a comparing function per channel.

-> Image arr cs e1

First image.

-> Image arr cs e2

second image.

-> Image arr X Bit

Compare two images with an applicative pixel. Works just like thresholdWith, but on two images.

compareWith

Arguments

:: (Applicative (Pixel cs), Foldable (Pixel cs), Array arr cs e1, Array arr cs e2, Array arr X Bit)

=> Pixel cs (e1 -> e2 -> Bool)

Pixel containing a comparing function per channel.

-> Image arr cs e1

First image.

-> Image arr cs e2

second image.

-> Image arr X Bit

Deprecated: Use thresholdWith2 instead.

Compare two images with an applicative pixel. Works just like thresholdWith, but on two images.

Thresholding

class Thresholding a b arr | a b -> arr where

Thresholding contains a convenient set of functions for binary image construction, which is done by comparing either a single pixel with every pixel in an image or two same size images pointwise. For example:

>>> frog <- readImageY VU "images/frog.jpg"
>>> frog .==. PixelY 0    -- (or: PixelY 0 .==. frog)
>>> frog .<. flipH frog   -- (or: flipH frog .>. frog)

Methods

(!==!) :: (Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => a cs e -> b cs e -> Image arr cs Bit infix 4

(!/=!) :: (Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => a cs e -> b cs e -> Image arr cs Bit infix 4

(!<!) :: (Ord e, Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => a cs e -> b cs e -> Image arr cs Bit infix 4

(!<=!) :: (Ord e, Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => a cs e -> b cs e -> Image arr cs Bit infix 4

(!>!) :: (Ord e, Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => a cs e -> b cs e -> Image arr cs Bit infix 4

(!>=!) :: (Ord e, Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => a cs e -> b cs e -> Image arr cs Bit infix 4

(.==.) :: (Array arr cs e, Array arr X Bit) => a cs e -> b cs e -> Image arr X Bit infix 4

(./=.) :: (Array arr cs e, Array arr X Bit) => a cs e -> b cs e -> Image arr X Bit infix 4

(.<.) :: (Ord (Pixel cs e), Array arr cs e, Array arr X Bit) => a cs e -> b cs e -> Image arr X Bit infix 4

(.<=.) :: (Ord (Pixel cs e), Array arr cs e, Array arr X Bit) => a cs e -> b cs e -> Image arr X Bit infix 4

(.>.) :: (Ord (Pixel cs e), Array arr cs e, Array arr X Bit) => a cs e -> b cs e -> Image arr X Bit infix 4

(.>=.) :: (Ord (Pixel cs e), Array arr cs e, Array arr X Bit) => a cs e -> b cs e -> Image arr X Bit infix 4

Instances

Array arr X Bit => Thresholding Pixel (Image arr) arr

Defined in Graphics.Image.Processing.Binary

Methods

(!==!) :: (Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Pixel cs e -> Image arr cs e -> Image arr cs Bit

(!/=!) :: (Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Pixel cs e -> Image arr cs e -> Image arr cs Bit

(!<!) :: (Ord e, Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Pixel cs e -> Image arr cs e -> Image arr cs Bit

(!<=!) :: (Ord e, Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Pixel cs e -> Image arr cs e -> Image arr cs Bit

(!>!) :: (Ord e, Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Pixel cs e -> Image arr cs e -> Image arr cs Bit

(!>=!) :: (Ord e, Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Pixel cs e -> Image arr cs e -> Image arr cs Bit

(.==.) :: (Array arr cs e, Array arr X Bit) => Pixel cs e -> Image arr cs e -> Image arr X Bit

(./=.) :: (Array arr cs e, Array arr X Bit) => Pixel cs e -> Image arr cs e -> Image arr X Bit

(.<.) :: (Ord (Pixel cs e), Array arr cs e, Array arr X Bit) => Pixel cs e -> Image arr cs e -> Image arr X Bit

(.<=.) :: (Ord (Pixel cs e), Array arr cs e, Array arr X Bit) => Pixel cs e -> Image arr cs e -> Image arr X Bit

(.>.) :: (Ord (Pixel cs e), Array arr cs e, Array arr X Bit) => Pixel cs e -> Image arr cs e -> Image arr X Bit

(.>=.) :: (Ord (Pixel cs e), Array arr cs e, Array arr X Bit) => Pixel cs e -> Image arr cs e -> Image arr X Bit

Array arr X Bit => Thresholding (Image arr) Pixel arr

Defined in Graphics.Image.Processing.Binary

Methods

(!==!) :: (Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Image arr cs e -> Pixel cs e -> Image arr cs Bit

(!/=!) :: (Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Image arr cs e -> Pixel cs e -> Image arr cs Bit

(!<!) :: (Ord e, Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Image arr cs e -> Pixel cs e -> Image arr cs Bit

(!<=!) :: (Ord e, Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Image arr cs e -> Pixel cs e -> Image arr cs Bit

(!>!) :: (Ord e, Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Image arr cs e -> Pixel cs e -> Image arr cs Bit

(!>=!) :: (Ord e, Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Image arr cs e -> Pixel cs e -> Image arr cs Bit

(.==.) :: (Array arr cs e, Array arr X Bit) => Image arr cs e -> Pixel cs e -> Image arr X Bit

(./=.) :: (Array arr cs e, Array arr X Bit) => Image arr cs e -> Pixel cs e -> Image arr X Bit

(.<.) :: (Ord (Pixel cs e), Array arr cs e, Array arr X Bit) => Image arr cs e -> Pixel cs e -> Image arr X Bit

(.<=.) :: (Ord (Pixel cs e), Array arr cs e, Array arr X Bit) => Image arr cs e -> Pixel cs e -> Image arr X Bit

(.>.) :: (Ord (Pixel cs e), Array arr cs e, Array arr X Bit) => Image arr cs e -> Pixel cs e -> Image arr X Bit

(.>=.) :: (Ord (Pixel cs e), Array arr cs e, Array arr X Bit) => Image arr cs e -> Pixel cs e -> Image arr X Bit

Thresholding (Image arr) (Image arr) arr

Defined in Graphics.Image.Processing.Binary

Methods

(!==!) :: (Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Image arr cs e -> Image arr cs e -> Image arr cs Bit

(!/=!) :: (Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Image arr cs e -> Image arr cs e -> Image arr cs Bit

(!<!) :: (Ord e, Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Image arr cs e -> Image arr cs e -> Image arr cs Bit

(!<=!) :: (Ord e, Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Image arr cs e -> Image arr cs e -> Image arr cs Bit

(!>!) :: (Ord e, Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Image arr cs e -> Image arr cs e -> Image arr cs Bit

(!>=!) :: (Ord e, Applicative (Pixel cs), Array arr cs e, Array arr cs Bit) => Image arr cs e -> Image arr cs e -> Image arr cs Bit

(.==.) :: (Array arr cs e, Array arr X Bit) => Image arr cs e -> Image arr cs e -> Image arr X Bit

(./=.) :: (Array arr cs e, Array arr X Bit) => Image arr cs e -> Image arr cs e -> Image arr X Bit

(.<.) :: (Ord (Pixel cs e), Array arr cs e, Array arr X Bit) => Image arr cs e -> Image arr cs e -> Image arr X Bit

(.<=.) :: (Ord (Pixel cs e), Array arr cs e, Array arr X Bit) => Image arr cs e -> Image arr cs e -> Image arr X Bit

(.>.) :: (Ord (Pixel cs e), Array arr cs e, Array arr X Bit) => Image arr cs e -> Image arr cs e -> Image arr X Bit

(.>=.) :: (Ord (Pixel cs e), Array arr cs e, Array arr X Bit) => Image arr cs e -> Image arr cs e -> Image arr X Bit

Bitwise operations

or :: Array arr X Bit => Image arr X Bit -> Bool

Disjunction of all pixels in a Binary image

and :: Array arr X Bit => Image arr X Bit -> Bool

Conjunction of all pixels in a Binary image

(!&&!) :: Array arr cs Bit => Image arr cs Bit -> Image arr cs Bit -> Image arr cs Bit infixr 3

Pixel wise AND operator on binary images.

(!||!) :: Array arr cs Bit => Image arr cs Bit -> Image arr cs Bit -> Image arr cs Bit infixr 2

Pixel wise OR operator on binary images.

(.&&.) :: (Array arr cs Bit, Array arr X Bit) => Image arr cs Bit -> Image arr cs Bit -> Image arr X Bit infixr 3

Pixel wise AND operator on binary images. Unlike !&&! this operator will also AND pixel componenets.

(.||.) :: (Array arr cs Bit, Array arr X Bit) => Image arr cs Bit -> Image arr cs Bit -> Image arr X Bit infixr 2

Pixel wise OR operator on binary images. Unlike !||! this operator will also OR pixel componenets.

invert :: Array arr cs Bit => Image arr cs Bit -> Image arr cs Bit

Complement each pixel in a binary image

disjunction :: (Array arr cs Bit, Array arr X Bit) => Image arr cs Bit -> Image arr X Bit

Join each component of a pixel with a binary .|. operator.

conjunction :: (Array arr cs Bit, Array arr X Bit) => Image arr cs Bit -> Image arr X Bit

Join each component of a pixel with a binary .&. operator.

Binary Morphology

In order to demonstrate how morphological operations work, a binary source image = B constructed here together with a structuring element = S will be used in examples that follow. Origin of the structuring element is always at it's center, eg. (1,1) for the one below.

figure :: Image VU X Bit
figure = fromLists [[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
                    [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
                    [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0],
                    [0,0,0,0,0,0,1,1,0,0,0,0,0,1,1,1,0],
                    [0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0],
                    [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0],
                    [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0],
                    [0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0],
                    [0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0],
                    [0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0],
                    [0,0,0,0,0,0,1,1,1,1,0,0,0,1,0,0,0],
                    [0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0],
                    [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0],
                    [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0],
                    [0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0],
                    [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
                    [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]
struct :: Image VU X Bit
struct = fromLists [[0,1,0],[1,1,0],[0,1,0]]

erode

Arguments

:: Array arr X Bit

=> Image arr X Bit

Structuring element.

-> Image arr X Bit

Binary source image.

-> Image arr X Bit

Erosion is defined as: {E = B ⊖ S = {m,n|Sₘₙ⊆B}

>>> writeImageExact PNG [] "images/figure_erode.png" $ pixelGrid 10 $ fromImageBinary $ erode struct figure

eroded with is

dialate

Arguments

:: Array arr X Bit

=> Image arr X Bit

Structuring element.

-> Image arr X Bit

Binary source image.

-> Image arr X Bit

Dialation is defined as: {D = B ⊕ S = {m,n|Sₘₙ∩B≠∅}

>>> writeImageExact PNG [] "images/figure_dialate.png" $ pixelGrid 10 $ fromImageBinary $ dialate struct figure

dialated with is

open

Arguments

:: Array arr X Bit

=> Image arr X Bit

Structuring element.

-> Image arr X Bit

Binary source image.

-> Image arr X Bit

Opening is defined as: {B ○ S = (B ⊖ S) ⊕ S}

>>> writeImageExact PNG [] "images/figure_open.png" $ pixelGrid 10 $ fromImageBinary $ open struct figure

opened with is

close

Arguments

:: Array arr X Bit

=> Image arr X Bit

Structuring element.

-> Image arr X Bit

Binary source image.

-> Image arr X Bit

Closing is defined as: {B ● S = (B ⊕ S) ⊖ S}

>>> writeImageExact PNG [] "images/figure_close.png" $ pixelGrid 10 $ fromImageBinary $ close struct figure

closed with is