Home
Contact
Sitemap
Bookmark us
Home
Services
Products
Biometrics
eFinance
Company
Binary Images
Binary images are images whose
pixels
have only two possible
intensity values
. They are normally displayed as black and white. Numerically, the two values are often 0 for black, and either 1 or 255 for white.
Binary images are often produced by
thresholding
a
grayscale
or
color image
, in order to separate an object in the image from the background. The color of the object (usually white) is referred to as the
foreground color
. The rest (usually black) is referred to as the
background color
. However, depending on the image which is to be thresholded, this
polarity
might be inverted, in which case the object is displayed with 0 and the background is with a non-zero value.
Some
morphological
operators assume a certain polarity of the binary input image so that if we process an image with inverse polarity the operator will have the opposite effect. For example, if we apply a
closing
operator to a black text on white background, the text will be
opened
.
Grayscale Images
A grayscale (or graylevel) image is simply one in which the only colors are shades of gray. The reason for differentiating such images from any other sort of color image is that less information needs to be provided for each pixel. In fact a `gray' color is one in which the red, green and blue components all have equal intensity in
RGB space
, and so it is only necessary to specify a single intensity value for each pixel, as opposed to the three intensities needed to specify each pixel in a
full color image
.
Often, the grayscale intensity is stored as an 8-bit integer giving 256 possible different shades of gray from black to white. If the levels are evenly spaced then the difference between successive graylevels is significantly better than the graylevel resolving power of the human eye.
Grayscale images are very common, in part because much of today's display and image capture hardware can only support 8-bit images. In addition, grayscale images are entirely sufficient for many tasks and so there is no need to use more complicated and harder-to-process color images.
8-bit Color Images
Full
RGB
color requires that the intensities of three color components be specified for each and every pixel. It is common for each component intensity to be stored as an 8-bit integer, and so each pixel requires 24 bits to completely and accurately specify its color. If this is done, then the image is known as a
24-bit color image
. However there are two problems with this approach:
Storing 24 bits for every pixel leads to very large image files that with current technology are cumbersome to store and manipulate. For instance a 24-bit 512×512 image takes up 750KB in uncompressed form.
Many monitor displays use
colormaps
with 8-bit index numbers, meaning that they can only display 256 different colors at any one time. Thus it is often wasteful to store more than 256 different colors in an image anyway, since it will not be possible to display them all on screen.
Because of this, many image formats (
e.g.
8-bit GIF and TIFF) use 8-bit
colormaps
to restrict the maximum number of different colors to 256. Using this method, it is only necessary to store an 8-bit index into the colormap for each pixel, rather than the full 24-bit color value. Thus 8-bit image formats consist of two parts: a colormap describing what colors are present in the image, and the array of index values for each pixel in the image.
When a 24-bit full color image is turned into an 8-bit image, it is usually necessary to throw away some of the colors, a process known as
color quantization
. This leads to some degradation in image quality, but in practice the observable effect can be quite small, and in any case, such degradation is inevitable if the image output device (
e.g.
screen or printer) is only capable of displaying 256 colors or less.
The use of 8-bit images with colormaps does lead to some problems in image processing. First of all, each image has to have its own colormap, and there is usually no guarantee that each image will have exactly the same colormap. Thus on 8-bit displays it is frequently impossible to correctly display two different color images that have different colormaps
at the same time
. Note that in practice 8-bit images often use reduced size colormaps with less than 256 colors in order to avoid this problem.
Another problem occurs when the output image from an image processing operation contains different colors to the input image or images. This can occur very easily, as for instance when two color images are
added together
pixel-by-pixel. Since the output image contains different colors from the input images, it ideally needs a new colormap, different from those of the input images, and this involves further color quantization which will degrade the image quality. Hence the resulting output is usually only an approximation of the desired output. Repeated image processing operations will continually degrade the image colors. And of course we still have the problem that it is not possible to display the images simultaneously with each other on the same 8-bit display.
Because of these problems it is to be expected that as computer storage and processing power become cheaper, there will be a shift away from 8-bit images and towards full 24-bit image processing.
Color Images
It is possible to construct (almost) all visible colors by combining the three
primary colors
red, green and blue, because the human eye has only three different color receptors, each of them sensible to one of the three colors. Different combinations in the stimulation of the receptors enable the human eye to distinguish approximately
350000
colors. A
RGB
color image is a
multi-spectral
image with one band for each color red, green and blue, thus producing a weighted combination of the three primary colors for each pixel.
A full
24-bit color
image contains one 8-bit value for each color, thus being able to display
different colors.
However, it is computationally expensive and often not necessary to use the full 24-bit image to store the color for each pixel. Therefore, the color for each pixel is often encoded in a single byte, resulting in an
8-bit color
image. The process of reducing the color representation from 24-bits to 8-bits, known as
color quantization
, restricts the number of possible colors to 256. However, there is normally no visible difference between a 24-color image and the same image displayed with 8 bits. An 8-bit color images are based on
colormaps
, which are
look-up tables
taking the 8-bit pixel value as index and providing an output value for each color.
24-bit Color Images
Full
RGB
color requires that the intensities of three color components be specified for each and every pixel. It is common for each component intensity to be stored as an 8-bit integer, and so each pixel requires 24 bits to completely and accurately specify its color. Image formats that store a full 24 bits to describe the color of each and every pixel are therefore known as
24-bit color images
.
Using 24 bits to encode color information allows
different colors to be represented, and this is sufficient to cover the full range of human color perception fairly well.
The term 24-bit is also used to describe monitor displays that use 24 bits per pixel in their display memories, and which are hence capable of displaying a full range of colors.
There are also some disadvantages to using 24-bit images. Perhaps the main one is that it requires three times as much memory, disk space and processing time to store and manipulate 24-bit color images as compared to
8-bit color images
. In addition, there is often not much point in being able to store all those different colors if the final output device (
e.g.
screen or printer) can only actually produce a fraction of them. Since it is possible to use
colormaps
to produce
8-bit color images
that look almost as good, at the time of writing 24-bit displays are relatively little used. However it is to be expected that as the technology becomes cheaper, their use in image processing will grow.
Logical Operators
Logical operators are generally derived from
Boolean algebra
, which is a mathematical way of manipulating the
truth values
of concepts in an abstract way without bothering about what the concepts actually
mean
. The truth value of a concept in Boolean value can have just one of two possible values: true or false. Boolean algebra allows you to represent things like:
The block is both red and large
by something like:
A
AND
B
where
A
represents `The block is red', and
B
represents `The block is large'. Now each of these sub-phrases has its own truth value in any given situation: each sub-phrase is either true or false. Moreover, the entire composite phrase also has a truth value: it is true if both of the sub-phrases are true, and false in any other case. We can write this
AND
combination rule (and its dual operation
NAND
) using a
truth-table
as shown in Figure 1, in which we conventionally represent true by 1, and false by zero.
Figure 1
Truth-tables for AND and NAND
The left hand table shows each of the possible combinations of truth values of
A
and
B
, and the the resulting truth value of
A
AND
B
. Similar truth-tables can be set up for the other logical operators:
NAND
,
OR
,
NOR
,
XOR
,
XNOR
and
NOT
.
Turning now to an image processing context, the pixel values in a
binary image
, which are either 0 or 1, can be interpreted as truth values as above. Using this convention we can carry out logical operations on images simply by applying the truth-table combination rules to the pixel values from a pair of input images (or a single input image in the case of NOT). Normally, corresponding pixels from each of two identically sized binary input images are compared to produce the output image, which is another binary image of the same size. As with other image arithmetic operations, it is also possible to logically combine a single input image with a constant logical value, in which case each pixel in the input image is compared to the same constant in order to produce the corresponding output pixel. See the individual logical operator descriptions for examples of these operations.
Logical operations can also be carried out on images with integer pixel values. In this extension the logical operations are normally carried out in
bitwise
fashion on binary representations of those integers, comparing corresponding bits with corresponding bits to produce the output pixel value. For instance, suppose that we wish to
XOR
the integers 47 and 255 together using 8-bit integers. 47 is 00101111 in binary and 255 is 11111111. XORing these together in bitwise fashion, we have 11010000 in binary or 208 in decimal.
Note that not all implementations of logical operators work in such bitwise fashion. For instance some will treat zero as false and any non-zero value as true and will then apply the conventional 1-bit logical functions to derive the output image. The output may be a simple binary image itself, or it may be a graylevel image formed perhaps by multiplying what would be the binary output image (containing 0's and 1's) with one of the input images.
Look-up Tables and Colormaps
Look-Up Tables or
LUTs
are fundamental to many aspects of image processing. An LUT is simply a table of cross-references linking
index numbers
to
output values
. The most common use is to determine the colors and intensity values with which a particular image will be displayed, and in this context the LUT is often called simply a
colormap
.
The idea behind the colormap is that instead of storing a definite color for each pixel in an image, for instance in
24-bit RGB format
, each pixel's value is instead treated as an index number into the colormap. When the image is to be displayed or otherwise processed, the colormap is used to look up the actual colors corresponding to each index number. Typically, the output values stored in the LUT would be
RGB color values
.
There are two main advantages to doing things this way. Firstly, the index number can be made to use fewer bits than the output value in order to save storage space. For instance an 8-bit index number can be used to look up a 24-bit RGB color value in the LUT. Since only the 8-bit index number needs to be stored for each pixel, such
8-bit color images
take up less space than a full 24-bit image of the same size. Of course the image can only contain 256 different colors (the number of entries in an 8-bit LUT), but this is sufficient for many applications and usually the observable image degradation is small.
Secondly the use of a color table allows the user to experiment easily with different color labeling schemes for an image.
One disadvantage of using a colormap is that it introduces additional complexity into an image format. It is usually necessary for each image to carry around its own colormap, and this LUT must be continually consulted whenever the image is displayed or processed.
Another problem is that in order to convert from a full color image to (say) an 8-bit color image using a color image, it is usually necessary to throw away many of the original colors, a process known as
color quantization
. This process is lossy, and hence the image quality is degraded during the quantization process. Additionally, when performing further image processing on such images, it is frequently necessary to generate a new colormap for the new images, which involves further color quantization, and hence further image degradation.
As well as their use in colormaps, LUTs are often used to remap the pixel values within an image. This is the basis of many common image processing
point operations
such as thresholding, gamma correction and contrast stretching. The process is often referred to as
anamorphosis
.
Masking
A mask is a
binary image
consisting of zero- and non-zero values. If a mask is applied to another binary or to a
grayscale
image of the same size, all pixels which are zero in the mask are set to zero in the output image. All others remain unchanged.
Masking can be implemented either using
pixel multiplication
or
logical AND
, the latter in general being faster.
Masking is often used to restrict a
point
or
arithmetic operator
to an area defined by the mask. We can, for example, accomplish this by first masking the desired area in the input image and processing it with the operator, then masking the original input image with the
inverted
mask to obtain the unprocessed area of the image and finally recombining the two partial images using
image addition
. An example can be seen in the worksheet on the
logical AND
operator. In some image processing packages, a mask can directly be defined as an optional input to a point operator, so that automatically the operator is only applied to the pixels defined by the mask .