Image Processing Library for MzScheme

Constructors
Predicates
Accessors
File I/O functions
Helper functions
Color functions
Convolution functions
Fourier transform functions
Binary image morphology functions
Grey level functions
How the library displays images

Constructors

(make-image rows cols . f)
Creates an image with rows rows and cols columns. The optional parameter f is a function that takes two integers, the row index and the column index, and returns either a real number (to create a grey image), a complex number (to create a complex image), or a list of three real numbers (to create a color image). With no optional parameter, the image is initialized to 0 everywhere.
(make-filter rows cols . f)
Similar to make-image, except that to match the periodicity of the 2D discrete Fourier spectrum, the value of the result image at location (i, j) is computed by applying f to x and y, where x equals i if i is less than m/2 and i - m otherwise, and y equals j if j is less than n/2 and j - n otherwise. For example, the value at location (0, 0) is the result of applying f to 0 and 0, the value at (m-1, n-1) is the result of applying f to -1 and -1.

Predicates

(image? image)
returns #t if the parameter is an image, #f if not.
(grey-image? image)
returns #t if the parameter is a grey image, #f if not.
(complex-image? image)
returns #t if the parameter is a complex image, #f if not.
(color-image? image)
returns #t if the parameter is a color image, #f if not.

Accessors

(image-ref image i j)
Returns the value of the pixel at (i, j), where i and j are integers (does not do on-the-fly interpolation).
(image-rows image)
Returns the number of rows in an image.
(image-cols image)
Returns the number of columns in an image.

File I/O Functions

(read-image filename)
Reads PGMA and PPMA files, returning a grey or color image, respectively.
(write-image image filename)
First normalizes the pixel values to [0,255] (maximizes contrast) and then writes PGMA and PPMA files for grey and color images, respectively. If image is complex, write-image first converts from complex to color, using Hue-Saturation-Value to RGB conversion with the phase of each pixel as the hue, and the magnitude of each pixel as the value.

Helper functions

(image-map f image)
Maps the function f to each pixel in the image.
(image-crop image i0 j0 m n)
Returns an image with m rows and n columns, cropped from the input image starting at (i0,j0).
(image-pad image m n)
Returns an image with m rows and n columns, where the value at (i,j) is the same as the original image if i is less than the number of rows in the input image and j is less than the number of columns in the input image, and 0 otherwise.
(image-normalize image)
Maps grey and color image pixel values to [0,1]

(image->vector image)

image->vector

(vector->image #(#(...)...))
Constructs an image from a vector of vector, where each "inner" vector is a row. Also implemented as vector->image
(image-product img1 img2)
Returns the matrix product of two images (as if they were matrices).
(downsample img)
Discard even rows and columns of an image.
(downsample-rows img)
Discard even rows of an image.
(downsample-cols img)
Discard even columns of an image
(upsample img)
Construct an image with twice as many rows, and twice as many columns, where the pixel at (i*2,j*2) is the value of the input image at (i,j), and all other pixels are 0.
(upsample-rows img)
Construct an image with twice as many rows, where the pixel at (i*2,j) is the value of the input image at (i,j), and all other pixels are 0.
(upsample-cols img)
Construct an image with twice as many columns, where the pixel at (i,j*2) is the value of the input image at (i,j), and all other pixels are 0.
(left-to-right img . rest)
Concatenate images from left to right.
(top-to-bottom img . rest)
Concatenate images from top to bottom.
(image-rotate img)
Rotate an image 90 degrees clockwise.
(image-flip img)
Flip an image vertically.
(image-flop img)
Flip an image horizontally.

Color functions

(color-image-red img)
Return the red color component of an image.
(color-image-green img)
Return the green color component of an image.
(color-image-blue img)
Return the blue color component of an image.
(color-image->rgb img)
Return the red, green, and blue color components as a list.
(rgb->color-image r g b)
Construct a color image from a the red, green and blue component images.
(rgb->hsi r g b)
Convert red, green, blue numeric values (not images) to hue, saturation, intensity.
(hsi->rgb)
Convert hue, saturation, intensity numeric values (not images) to red, green, blue.
(hsi->color-image h s i)
Construct a color image from a the hue, saturation and intensity component images.
(color-image->hsi img)
Return the hue, saturation and intensity component images as a list.
(rgb->hsv r g b)
Convert red, green, blue numeric values (not images) to hue, saturation, value.
(hsv->rgb h s v)
Convert hue, saturation, value numeric values (not images) to red, green, blue.
(hsv->color-image h s v)
Construct a color image from a the hue, saturation and value component images.
(color-image->hsv img)
Return the hue, saturation and value component images as a list.
(rgb->hsl r g b)
Convert red, green, blue numeric values (not images) to hue, saturation, lightness.
(hsl->rgb h s l)
Convert hue, saturation, lightness numeric values (not images) to red, green, blue.
(hsl->color-image)
Construct a color image from a the hue, saturation and lightness component images.
(color-image->hsl img)
Return the hue, saturation and value component images as a list.
(make-hot-image)
Use a false coloring scheme to convert a grey image to color, where the black to white spectrum is mapped to a spectrum including shades of black, red, orange, yellow, and white, in that order.

Convolution functions

(convolve-rows img kernel)
Compute the 1D discrete periodic convolution of each row with the given kernel vector.
(convolve-cols img kernel)
Compute the 1D discrete periodic convolution of each column with the given kernel vector.
(convolve img kernel)
Compute the 2D discrete periodic convolution of the image with the given kernel vector of vectors.

Fourier transform functions

(fft img)
Compute the Fourier Transform using the Cooley-Tukey FFT algorithm.
(ifft img)
Compute the inverse Fourier Transform using the Cooley-Tukey FFT algorithm.
(dft img)
Compute the Fourier Transform using the (glacially slow) naive algorithm.
(idft img)
Compute the inverse Fourier Transform using the (glacially slow) naive algorithm.

Binary image morphology functions

Grey images are passed to binary image morphology functions. Those pixels with value 0 are considered "off" and others are considered "on".

(outline img . x y)
Return an image whose pixel values are x if the pixel was an edge pixel, and y otherwise. Pixel (i,j) is considered an edge pixel if its value is different than the value of either pixel (i,j+1) or pixel (i+1,j).
(erode img . element)
Return the morphological erosion of an image with a structuring element. The default element is #(#(1 1)#(1 1)).
(dilate img . element)
Return the morphological dilation of an image with a structuring element. The default element is #(#(1 1)#(1 1)).
(open img . element)
Return the morphological opening of an image with a structuring element. The default element is #(#(1 1)#(1 1)).
(close img . element)
Return the morphological closing of an image with a structuring element. The default element is #(#(1 1)#(1 1)).
(label img)
Assign different integer values to each 4-neighborhood connected component.
(distance-transform)
Compute the 2D distance transform of an image.

Grey level functions

(areas)
Return a vector whose n-th element equals the number of pixels with value n.
(perimeters)
Return a vector whose n-th element equals the number of pixels with value n that are adjacent to pixels with value 0. The 0th element equals the sum of the other elements.

How the library displays images

By default, the library does not render images. Any sexpr that evaulates to an image is displayed as:
#<struct:image>
Evaluating the sexpr (image-repl) will hot-wire the Read-Eval-Print Loop to output something like:
#<image (color): rows = 200 cols = 300>
and then try to spawn a subprocess to render the image.
The rendering is performed by spawning a subprocess. By default, /usr/bin/display is used, which is (hopefully) ImageMagick's simple X-Window display binary. The image (in PGMA or PPMA format) in then piped to that process.

Alternately, you can set! the following variables:

display-image-exe	string	full path to display executable
display-image-stdin	boolean	if not `#f`, pass "-" as last command line parameter to subprocess, and write the image (PGMA or PPMA) to its stdin. if `#f`, create a temporary file and pass that file as the last command line parameter to the subprocess.
display-image-dotitle	boolean	if `#t`, pass "-title" and some useful information to the subprocess. ImageMagick's `display` command will set the window title to this string.
display-image-tmpdir	string	full path (including trailing slash) to use for temporary files. Used only if display-image-stdin is `#f`
display-image-total	integer	modulus to use for temporary filenames. Default is 10. Used only if display-image-stdin is `#f`.

rlpm [ -at- ] cs.unm.edu