Legacy Documentation

Digital Image Processing (2000)

This is documentation for an obsolete product.
Current products and services
User's Guide / Image Representation /
Previous section-----Next section

2.4 A Data Structure for Color Images

While it is very convenient to manipulate images as matrices in the case of monochrome data, this is not the case with color images. The Digital Image Processing package resolves this problem by defining a common data structure for monochrome and color images. The image data structure is encapsulated in an ImageData Mathematica expression. ImageData is like a generalization of the graphics primitive Raster, because it also facilitates the easy manipulation and handling of single and multichannel images. As a consequence, users usually do not need to concern themselves with the complexities of the structural organization of the color information since all ImageProcessing functions and selected built-in Mathematica functions will handle color image data in a transparent manner. To learn about the structure of an ImageData expression consider rgb.tif, a small RGB color image found in $ImageProcessingDataDirectory. This directory is added to the search path when the package is loaded. All the example images are located in this directory.

ImageProcessing file system symbols.

This loads the package.
In[1]:=
Here we load the demonstration color image. Note that the default output form of an ImageData expression is the string ImageData.
In[2]:=
Out[2]=Out[2]=
ImageData like other graphics primitives may be displayed using the Graphics command.
In[3]:=
Out[3]=Out[3]=
The structure of ImageData is very simple. It consists of the raw image data, followed by two rules defining a pixel interleaving method and a color function.
ImageData[mat, PixelInterleave→None, ColorFunction→cf]
format of single-channel (i.e., monochrome) image
ImageData[{{{r0,0,g0,0,b0,0}, {r0,1,g0,1,b0,1}...}}, PixelInterleave→True, ColorFunction→cf]
format
ImageData[{mat1, mat2, ...}, PixelInterleave→False, ColorFunction→cf]
format of multichannel ( image in planar configuration

ImageData expressions.

Consider the input form of rgb.
In[4]:=
Out[4]//InputForm=Out[4]//InputForm=
A small number of functions are available to extract the raw image data, switch between interleaving schemes, and split and merge ImageData expressions.

Structure conversion functions.

Here we show the example image organized in a planar format.
In[5]:=
Out[5]//InputForm=Out[5]//InputForm=
Here we split the rgb image into three single-color GrayLevel channels. Each channel is defined by an ImageData expression.
In[6]:=
Out[6]//InputForm=Out[6]//InputForm=
This returns an RGBColor meshed image from the three individual channels.
In[7]:=
Out[7]//InputForm=Out[7]//InputForm=
The structure of an ImageData object may be interrogated with a number of simple functions.

ImageData structure interrogation functions.

Here is the default meshed raw data format of the example color image.
In[8]:=
Out[8]//MatrixForm=Out[8]//MatrixForm=
Alternatively, here is the raw rgb data shown in a planar format, namely as a list of three matrices.
In[9]:=
Out[9]=Out[9]=
Note that a second method of extracting the raw data is to use the Part command. Since the first element of the ImageData expression contains the raw image data, it is easier, if somewhat more cryptic to use the Part specification on an ImageData object.
In[10]:=
Out[10]=Out[10]=
Raw image data in one of the formats defined by Equations (2.2.1), (2.3.1), and (2.3.2) may be conveniently converted into an ImageData expression, in effect, performing an inverse operation to the one in RawImageData. For details see Section 3.5.
The concept of image size has two common interpretations. It may mean either the amount of storage occupied by the image or the spatial extent of the image (i.e., the number of rows and columns). The former is measured in units of computer storage, typically bits or bytes, while the latter is usually specified in units of pixels. The function ImageDimensions uses the latter definition.
In[11]:=
Out[11]=Out[11]=
Having described the structure of ImageData, we now turn our attention to the problem of using the expression as an argument to other ImageProcessing and Mathematica functions. The goal of making ImageData objects easy to use requires that built-in Mathematica functions, to the degree that this makes sense, accept these expressions as valid arguments. Consider first the group of arithmetic operators. Here are a couple of examples. The basic arithmetic and logic operations (Plus, Times, Subract, Divide, Power, BitAnd, BitOr, BitXor) between a scalar and an ImageData expression or two ImageData expressions work as expected.
In[12]:=
Out[12]//InputForm=Out[12]//InputForm=
In[13]:=
Out[13]//InputForm=Out[13]//InputForm=
This returns the value of 128 for pixels greater or equal to 128 and 0 otherwise.
In[14]:=
Out[14]//InputForm=Out[14]//InputForm=
When the operands are combinations of a matrix and ImageData then, because of the listability attribute of these operators, the following ImageProcessing arithmetic and logic functions should be used.

ImageProcessing arithmetic and logic operators.

For example, we may want to subtract a matrix of samples from an image.
In[15]:=
Out[15]//InputForm=Out[15]//InputForm=
A selected number of Mathematica unitary numeric functions and extremum functions will transparently take an ImageData argument. This list includes N, Abs, Round, Floor, Ceiling, IntegerPart, Log, Mod, Max, and Min.
In[16]:=
Out[16]//InputForm=Out[16]//InputForm=
The array operators Reverse, Transpose, RotateRight, and RotateLeft have been extended to accept ImageData expressions.
In[17]:=
Out[17]=Out[17]=
In addition to the previously described extensions to arithmetic and logic commands, the package includes other functions that greatly enhance the ease-of-use of ImageData objects. The ImageTake function adapts the functionality of Take, while ImageThread allows the user to easily apply functions to individual channels of an image. The function ImageTakeGUI uses a graphical user interface to simplify the selection of one or more subregions of a given example image.

Extensions to Take and Thread.

Consider the following examples of ImageTake. First we extract the center subregion of the example image.
In[18]:=
Out[18]//InputForm=Out[18]//InputForm=
This takes the last three rows.
In[19]:=
Out[19]//InputForm=Out[19]//InputForm=
Finally, we demonstrate the use of ImageThread to take different subregions from each of the color channels.
In[20]:=
Out[20]//InputForm=Out[20]//InputForm=