Product Overview

In this section. Introduction on page 1-2 Configuration Notes on page 1-3 Related Products on page 1-4 Compilability on page 1-4
Image Processing Toolbox provides a comprehensive set of reference-standard algorithms and graphical tools for image processing, analysis, visualization, and algorithm development. You can perform image enhancement, image deblurring, feature detection, noise reduction, image segmentation, spatial transformations, and image registration. Many functions in the toolbox are multithreaded to take advantage of multicore and multiprocessor computers. Image Processing Toolbox supports a diverse set of image types, including high dynamic range, gigapixel resolution, ICC-compliant color, and tomographic images. Graphical tools let you explore an image, examine a region of pixels, adjust the contrast, create contours or histograms, and manipulate regions of interest (ROIs). With the toolbox algorithms you can restore degraded images, detect and measure features, analyze shapes and textures, and adjust the color balance of images. The Image Processing Toolbox software is a collection of functions that extend the capability of the MATLAB numeric computing environment. The toolbox supports a wide range of image processing operations, including: Image enhancement, filtering, and deblurring Image analysis, including segmentation, morphology, feature extraction, and measurement Spatial transformations and image registration Image transforms, including FFT, DCT, Radon, and fan-beam projection
Workflows for processing, displaying, and navigating arbitrarily large images Modular interactive tools, including ROI selections, histograms, and distance measurements ICC color management Multidimensional image processing Image-sequence and video display DICOM import and export Many of the toolbox functions are MATLAB files with a series of MATLAB statements that implement specialized image processing algorithms. You can view the MATLAB code for these functions using the statement

type function_name

You can extend the capabilities of the toolbox by writing your own files, or by using the toolbox in combination with other toolboxes, such as the Signal Processing Toolbox software and the Wavelet Toolbox software. For a list of the new features in this version of the toolbox, see the Release Notes documentation.

Configuration Notes

To determine if the Image Processing Toolbox software is installed on your system, type this command at the MATLAB prompt.

RGB2 = im2uint8(RGB1);

Losing Information in Conversions
When you convert to a class that uses fewer bits to represent numbers, you generally lose some of the information in your image. For example, a uint16 grayscale image is capable of storing up to 65,536 distinct shades of gray, but a uint8 grayscale image can store only 256 distinct shades of gray. When you convert a uint16 grayscale image to a uint8 grayscale image, im2uint8 quantizes the gray shades in the original image. In other words, all values from 0 to 127 in the original image become 0 in the uint8 image, values from 128 to 385 all become 1, and so on.
Converting Indexed Images
It is not always possible to convert an indexed image from one storage class to another. In an indexed image, the image matrix contains only indices into
a colormap, rather than the color data itself, so no quantization of the color data is possible during the conversion. For example, a uint16 or double indexed image with 300 colors cannot be converted to uint8, because uint8 arrays have only 256 distinct values. If you want to perform this conversion, you must first reduce the number of the colors in the image using the imapprox function. This function performs the quantization on the colors in the colormap, to reduce the number of distinct colors in the image. See Reducing Colors Using imapprox on page 14-10 for more information.
Working with Image Sequences
In this section. Overview of Toolbox Functions That Work with Image Sequences on page 2-20 Example: Processing Image Sequences on page 2-23 Multi-Frame Image Arrays on page 2-24
Overview of Toolbox Functions That Work with Image Sequences
Some applications work with collections of images related by time, such as frames in a movie, or by spatial location, such as magnetic resonance imaging (MRI) slices. These collections of images are referred to by a variety of names, such as image sequences or image stacks. The ability to create N-dimensional arrays can provide a convenient way to store image sequences. For example, an m-by-n-by-p array can store an array of p two-dimensional images, such as grayscale or binary images, as shown in the following figure. An m-by-n-by-3-by-p array can store truecolor images where each image is made up of three planes.
Multidimensional Array Containing an Image Sequence
Many toolbox functions can operate on multi-dimensional arrays and, consequently, can operate on image sequences. For example, if you pass a multi-dimensional array to the imtransform function, it applies the same 2-D transformation to all 2-D planes along the higher dimension.
Some toolbox functions that accept multi-dimensional arrays, however, do not by default interpret an m-by-n-by-p or an m-by-n-by-3-by-p array as an image sequence. To use these functions with image sequences, you must use particular syntax and be aware of other limitations. The following table lists these toolbox functions and provides guidelines about how to use them to process image sequences. For information about displaying image sequences, see Viewing Image Sequences on page 4-55. Image Sequence Dimensions m-by-n-by-p only m-by-n-by-p or m-by-n-by-3-by-p m-by-n-by-p or m-by-n-by-3-by-p m-by-n-by-p or m-by-n-by-3-by-p m-by-n-by-p only m-by-n-by-p or m-by-n-by-3-by-p m-by-n-by-p or m-by-n-by-3-by-p m-by-n-by-p only m-by-n-by-p only m-by-n-by-p only m-by-n-by-p or m-by-n-by-3-by-p m-by-n-by-p only m-by-n-by-p only Guideline When Used with an Image Sequence Must use the bwlabeln(BW,conn) syntax with a 2-D connectivity.

% Create an array of filenames that make up the image sequence fileFolder = fullfile(matlabroot,'toolbox','images','imdemos'); dirOutput = dir(fullfile(fileFolder,'AT3_1m4_*.tif')); fileNames = {dirOutput.name}'; numFrames = numel(fileNames);
I = imread(fileNames{1}); % Preallocate the array sequence = zeros([size(I) numFrames],class(I)); sequence(:,:,1) = I; % Create image sequence array for p = 2:numFrames sequence(:,:,p) = imread(fileNames{p}); end % Process sequence sequenceNew = stdfilt(sequence,ones(3)); % View results figure; for k = 1:numFrames imshow(sequence(:,:,k)); title(sprintf('Original Image # %d',k)); pause(1); imshow(sequenceNew(:,:,k),[]); title(sprintf('Processed Image # %d',k)); pause(1); end

Multi-Frame Image Arrays

The toolbox includes two functions, immovie and montage, that work with a specific type of multi-dimensional array called a multi-frame array. In this array, images, called frames in this context, are concatenated along the fourth dimension. Multi-frame arrays are either m-by-n-by-1-by-p, for grayscale, binary, or indexed images, or m-by-n-by-3-by-p, for truecolor images, where p is the number of frames. For example, a multi-frame array containing five, 480-by-640 grayscale or indexed images would be 480-by-640-by-1-by-5. An array with five 480-by-640 truecolor images would be 480-by-640-by-3-by-5.
Note To process a multi-frame array of grayscale images as an image sequence, as described in Working with Image Sequences on page 2-20, you can use the squeeze function to remove the singleton dimension. You can use the cat command to create a multi-frame array. For example, the following stores a group of images (A1, A2, A3, A4, and A5) in a single array.
A = cat(4,A1,A2,A3,A4,A5)
You can also extract frames from a multiframe image. For example, if you have a multiframe image MULTI, this command extracts the third frame.

FRM3 = MULTI(:,:,:,3)

Note that, in a multiframe image array, each image must be the same size and have the same number of planes. In a multiframe indexed image, each image must also use the same colormap.

the image. You can fine-tune the crop rectangle by moving and resizing the crop rectangle using the mouse. Or, if you want to crop a different region, move to the new location and click and drag again. To zoom in or out on the image while the Crop Image tool is active, use Ctrl+Plus or Ctrl+Minus keys. Note that these are the Plus(+) and Minus(-) keys on the numeric keypad of your keyboard. The following figure shows a crop rectangle being defined using the Crop Image tool.

Crop Image button

Crop rectangle

Resize handles

4 When you are finished defining the crop region, perform the crop operation.
Double-click the left mouse button or right-click inside the region and select Crop Image from the context menu. The Image Tool displays the cropped image. If you have other modular interactive tools open, they will update to show the newly cropped image.
5 To save the cropped image, use the Save as option or the Export to
Workspace option on the Image Tool File menu.

Viewing Image Sequences

In this section. Overview on page 4-55 Viewing Image Sequences in the Movie Player on page 4-55 Viewing Image Sequences as a Montage on page 4-64 Converting a Multiframe Image to a Movie on page 4-65
Some applications create collections of images related by time, such as frames in a movie, or by (spatial location, such as magnetic resonance imaging (MRI) slices. These collections of images are referred to by a variety of names, such as image sequences, image stacks, or videos. The toolbox represents image sequences as four-dimensional arrays, where each separate image is called a frame, all frames are the same size, and the frames are concatenated along the fourth dimension. imtool and imshow can display one frame at a time, using standard MATLAB array indexing syntax, but cannot animate the sequence or provide any navigation within the sequence. A better choice to view image sequences is the Movie Player (implay). The Movie Player can animate the display of frames in an image sequence and provides playback controls that you can use to navigate among the frames in the sequence. To get a static view of all the frames in an image sequence at one time, use the montage function. For more information, see these additional topics. Viewing Image Sequences in the Movie Player on page 4-55 Viewing Image Sequences as a Montage on page 4-64. Converting a Multiframe Image to a Movie on page 4-65

RGB = imread('saturn.png'); I = rgb2gray(RGB); h = [1; 0; -1 -2 -1]; I2 = filter2(h,I); imshow(I2,'DisplayRange',[]), colorbar

Printing Images

If you want to output a MATLAB image to use in another application (such as a word-processing program or graphics editor), use imwrite to create a file in the appropriate format. See Writing Image Data to a File on page 3-5 for details. If you want to print an image, use imshow to display the image in a MATLAB figure window. If you are using the Image Tool, you must use the Print to Figure option on the Image Tool File menu. When you choose this option, the Image Tool opens a separate figure window and displays the image in it. You can access the standard MATLAB printing capabilities in this figure window. You can also use the Print to Figure option to print the image displayed in the Overview tool and the Pixel Region tool. Once the image is displayed in a figure window, you can use either the MATLAB print command or the Print option from the File menu of the figure window to print the image. When you print from the figure window, the output includes nonimage elements such as labels, titles, and other annotations.
Printing and Handle Graphics Object Properties
The output reflects the settings of various properties of Handle Graphic objects. In some cases, you might need to change the settings of certain properties to get the results you want. Here are some tips that could be helpful when you print images: Image colors print as shown on the screen. This means that images are not affected by the figure objects InvertHardcopy property. To ensure that printed images have the proper size and aspect ratio, set the figure objects PaperPositionMode property to auto. When PaperPositionMode is set to auto, the width and height of the printed figure are determined by the figures dimensions on the screen. By default, the value of PaperPositionMode is manual. If you want the default value of PaperPositionMode to be auto, you can add this line to your startup.m file.

The following figure shows the target image in a figure with the Pixel Information tool in the lower left corner of the window. The Pixel Information tool automatically sets up a connection to the target image: when you move the pointer over the image, the tool displays the x- and y-coordinates and value of the pixel under the pointer.
Figure Window with Pixel Information Tool
Associating Modular Tools with a Particular Image
You can specify the target image of the modular tool when you create it by passing a handle to the target image as an argument to the modular tool creation function. You can also specify a handle to a figure, axes, or uipanel object that contains the target image. Continuing the example in the previous section, you might want to add the Display Range tool to the figure window that already contains the Pixel Information tool. To do this, call the imdisplayrange function, specifying the
handle to the target image. You could also have specified the handle of the figure, axes, or uipanel object containing the target image.
himage = imshow('pout.tif'); hpixelinfopanel = impixelinfo(himage); hdrangepanel = imdisplayrange(himage);
Note that the example retrieves handles to the uipanel objects created by the impixelinfo and imdisplayrange functions; both tools are uipanel objects. It can be helpful to get handles to the tools if you want to change their positioning. See Positioning the Modular Tools in a GUI on page 5-18 for more information. The following figure shows the target image in a figure with the Pixel Information tool in the lower left corner and the Display Range tool in the lower right corner of the window. The Display Range tool automatically sets up a connection to the target image: when you move the pointer over the image (or images) in the figure, the Display Range tool shows the display range of the image.
Figure Window with Pixel Information and Display Range Tools
Getting the Handle of the Target Image
The examples in the previous section use the optional imshow syntax that returns a handle to the image displayed, himage. When creating GUIs with the modular tools, having a handle to the target image can be useful. You can get the handle when you first display the image, using this optional imshow syntax. You can also get a handle to the target image using the imhandles function. The imhandles function returns all the image objects that are children of a specified figure, axes, uipanel, or image object.

Understanding Scroll Panels
When you display an image in a scroll panel, it changes the object hierarchy of your displayed image. This diagram illustrates the typical object hierarchy for an image displayed in an axes object in a figure object.
hfig = figure; himage = imshow('concordaerial.png');
The following figure shows this object hierarchy.
Object Hierarchy of Image Displayed in a Figure
When you call the imscrollpanel function to put the target image in a scrollable window, this object hierarchy changes. For example, this code adds a scroll panel to an image displayed in a figure window, specifying the parent of the scroll panel and the target image as arguments. The example suppresses the figure window toolbar and menu bar because they are not compatible with the scroll panel navigation tools.
hfig = figure('Toolbar','none',. 'Menubar', 'none'); himage = imshow('concordaerial.png'); hpanel = imscrollpanel(hfig,himage);
The following figure shows the object hierarchy after the call to imscrollpanel. Note how imscrollpanel inserts new objects (shaded in gray) into the hierarchy between the figure object and the axes object containing the image. (To change the image data displayed in the scroll bar, use the replaceImage function in the imscrollpanel API.)
Object Hierarchy of Image Displayed in Scroll Panel
The following figure shows how these graphics objects appear in the scrollable image as it is displayed on the screen.
Components of a Scroll Panel
Example: Building a Navigation GUI for Large Images
If your work typically requires that you view large images, you might want to create a custom image display function that includes the modular navigation tools. This example creates a tool that accepts an image as an argument and displays the image in a scroll panel with an Overview tool and a Magnification box.
Note Because the toolbox scrollable navigation is incompatible with standard MATLAB figure window navigation tools, the example suppresses the toolbar and menu bar in the figure window.
function my_large_image_display(im) % Create a figure without toolbar and menubar. hfig = figure('Toolbar','none',. 'Menubar', 'none',. 'Name','My Large Image Display Tool',. 'NumberTitle','off',. 'IntegerHandle','off'); % Display the image in a figure with imshow. himage = imshow(im); % Add the scroll panel. hpanel = imscrollpanel(hfig,himage); % Position the scroll panel to accommodate the other tools. set(hpanel,'Units','normalized','Position',[0.1 1.9]); % Add the Magnification box. hMagBox = immagbox(hfig,himage); % Position the Magnification box pos = get(hMagBox,'Position'); set(hMagBox,'Position',[pos(3) pos(4)]); % Add the Overview tool. hovervw = imoverview(himage);

Rotating an Image

To rotate an image, use the imrotate function. When you rotate an image, you specify the image to be rotated and the rotation angle, in degrees. If you specify a positive rotation angle, imrotate rotates the image counterclockwise; if you specify a negative rotation angle, imrotate rotates the image clockwise. By default, imrotate creates an output image large enough to include the entire original image. Pixels that fall outside the boundaries of the original image are set to 0 and appear as a black background in the output image. You can, however, specify that the output image be the same size as the input image, using the 'crop' argument. Similarly, imrotate uses nearest-neighbor interpolation by default to determine the value of pixels in the output image, but you can specify other interpolation methods. See the imrotate reference page for a list of supported interpolation methods. This example rotates an image 35 counterclockwise and specifies bilinear interpolation.
I = imread('circuit.tif'); J = imrotate(I,35,'bilinear'); imshow(I) figure, imshow(J)

Cropping an Image

Note You can also crop an image interactively using the Image Tool see Cropping an Image Using the Crop Image Tool on page 4-52. To extract a rectangular portion of an image, use the imcrop function. Using imcrop, you can specify the crop region interactively using the mouse or programmatically by specifying the size and position of the crop region. This example illustrates an interactive syntax. The example reads an image into the MATLAB workspace and calls imcrop specifying the image as an argument. imcrop displays the image in a figure window and waits for you to draw the crop rectangle on the image. When you move the pointer over the image, the shape of the pointer changes to cross hairs. Click and drag the pointer to specify the size and position of the crop rectangle. You can move and adjust the size of the crop rectangle using the mouse. When you are satisfied with the crop rectangle, double-click to perform the crop operation, or right-click inside the crop rectangle and select Crop Image from the context menu. imcrop returns the cropped image in J.
I = imread('circuit.tif') J = imcrop(I);

Example: Performing Image Registration
In this section. Step 1: Read in Base and Unregistered Images on page 6-22 Step 2: Display the Unregistered Image on page 6-22 Step 3: Create a TFORM Structure on page 6-23 Step 4: Transform the Unregistered Image on page 6-23 Step 5: Overlay Base Image Over Registered Image on page 6-24 Step 6: Using XData and YData Input Parameters on page 6-25 Step 7: Using xdata and ydata Output Values on page 6-26
Step 1: Read in Base and Unregistered Images
This example is intended to clarify the spatial relationship between the output image and the base image in image registration. The example illustrates use of the optional 'XData' and 'YData' input parameters and the optional xdata and ydata output values. To begin the example, read the base and unregistered images from sample data files that come with the Image Processing Toolbox software.
base = imread('westconcordorthophoto.png'); unregistered = imread('westconcordaerial.png');
Step 2: Display the Unregistered Image
Display the unregistered image.
iptsetpref('ImshowAxesVisible','on') imshow(unregistered) text(size(unregistered,2),size(unregistered,1)+30,. 'Image courtesy of mPower3/Emerge',. 'FontSize',7,'HorizontalAlignment','right');
Step 3: Create a TFORM Structure
Create a TFORM structure using preselected control points. Start by loading a MAT-file that contains preselected control points for the base and unregistered images.
load westconcordpoints tform = cp2tform(input_points, base_points, 'projective');
Step 4: Transform the Unregistered Image
Use imtransform to perform the transformation necessary to register the unregistered image with the base image. This code uses the optional FillValues input parameter to specify a fill value (white). The white background will help when the base image is placed on the transformed image to check registration.
registered = imtransform(unregistered, tform,. 'FillValues', 255);
Display the registered image.
figure; imshow(registered);

hold on

Notice two things: (1) the full content of the unregistered image is present, although spatially transformed, and (2) there are no blank rows or columns. Neither of these things is a coincidence. imtransform carefully "followed" the image data as it transformed, in order to include everything there is to see and nothing more.

imshow(BW1) figure, imshow(BW2)
Combining Dilation and Erosion
Dilation and erosion are often used in combination to implement image processing operations. For example, the definition of a morphological opening of an image is an erosion followed by a dilation, using the same structuring element for both operations. The related operation, morphological closing of an image, is the reverse: it consists of dilation followed by an erosion with the same structuring element. The following section uses imdilate and imerode to illustrate how to implement a morphological opening. Note, however, that the toolbox already includes the imopen function, which performs this processing. The toolbox includes functions that perform many common morphological operations. See Dilation- and Erosion-Based Functions on page 10-14 for a complete list.

Morphological Opening

You can use morphological opening to remove small objects from an image while preserving the shape and size of larger objects in the image. For example, you can use the imopen function to remove all the circuit lines from the original circuit image, circbw.tif, creating an output image that contains only the rectangular shapes of the microchips. To morphologically open the image, perform these steps:
2 Create a structuring element.
SE = strel('rectangle',[40 30]);
The structuring element should be large enough to remove the lines when you erode the image, but not large enough to remove the rectangles. It should consist of all 1s, so it removes everything but large contiguous patches of foreground pixels.
3 Erode the image with the structuring element.
BW2 = imerode(BW1,SE); imshow(BW2)
This removes all the lines, but also shrinks the rectangles.
4 To restore the rectangles to their original sizes, dilate the eroded image
using the same structuring element, SE.
BW3 = imdilate(BW2,SE); imshow(BW3)
Dilation- and Erosion-Based Functions
This section describes two common image processing operations that are based on dilation and erosion: Skeletonization Perimeter determination This table lists other functions in the toolbox that perform common morphological operations that are based on dilation and erosion. For more information about these functions, see their reference pages. Dilation- and Erosion-Based Functions Function

Accounting for Nonuniform Image Quality
Another complication of real-life image restoration is that the data might include bad pixels, or that the quality of the receiving pixels might vary with time and position. By specifying the WEIGHT array parameter with the deconvlucy function, you can specify that certain pixels in the image be ignored. To ignore a pixel, assign a weight of zero to the element in the WEIGHT array that corresponds to the pixel in the image. The algorithm converges on predicted values for the bad pixels based on the information from neighborhood pixels. The variation in the detector response from pixel to pixel (the so-called flat-field correction) can also be accommodated by the WEIGHT array. Instead of assigning a weight of 1.0 to the good pixels, you can specify fractional values and weight the pixels according to the amount of the flat-field correction.
Handling Camera Read-Out Noise
Noise in charge coupled device (CCD) detectors has two primary components: Photon counting noise with a Poisson distribution Read-out noise with a Gaussian distribution The Lucy-Richardson iterations intrinsically account for the first type of noise. You must account for the second type of noise; otherwise, it can cause pixels with low levels of incident photons to have negative values. The deconvlucy function uses the READOUT input parameter to handle camera read-out noise. The value of this parameter is typically the sum of the read-out noise variance and the background noise (e.g., number of counts
from the background radiation). The value of the READOUT parameter specifies an offset that ensures that all values are positive.
Handling Undersampled Images
The restoration of undersampled data can be improved significantly if it is done on a finer grid. The deconvlucy function uses the SUBSMPL parameter to specify the subsampling rate, if the PSF is known to have a higher resolution. If the undersampled data is the result of camera pixel binning during image acquisition, the PSF observed at each pixel rate can serve as a finer grid PSF. Otherwise, the PSF can be obtained via observations taken at subpixel offsets or via optical modeling techniques. This method is especially effective for images of stars (high signal-to-noise ratio), because the stars are effectively forced to be in the center of a pixel. If a star is centered between pixels, it is restored as a combination of the neighboring pixels. A finer grid redirects the consequent spreading of the star flux back to the center of the stars image.

myfun = @(block_struct) imresize(block_struct.data,0.15); I = imread('tire.tif'); I2 = blockproc(I,[25 25],myfun);
Note Due to block edge effects, resizing an image using blockproc does not produce the same results as resizing the entire image at once.
The example below uses the blockproc function to set every pixel in each 32-by-32 block of an image to the average of the elements in that block. The anonymous function computes the mean of the block, and then multiplies the result by a matrix of ones, so that the output block is the same size as the input block. As a result, the output image is the same size as the input image. The blockproc function does not require that the images be the same size. If this is the result you want, make sure that the function you specify returns blocks of the appropriate size:
myfun = @(block_struct). uint8(mean2(block_struct.data)*. ones(size(block_struct.data))); I2 = blockproc('moon.tif',[32 32],myfun); figure; imshow('moon.tif'); figure; imshow(I2,[]);
Image with Pixels Set to Average Value
Note Many operations that blockproc can implement run much faster if the computations are performed on matrix columns rather than rectangular blocks. For information about this approach, see Using Columnwise Processing to Speed Up Sliding Neighborhood or Distinct Block Operations on page 15-24.

Applying Padding

When processing an image in blocks, you may wish to add padding for two reasons: To address the issue of partial blocks To create overlapping borders As described in Understanding Distinct Block Processing on page 15-8, if blocks do not fit exactly over an image, partial blocks occur along the bottom and right edges of the image. By default, these partial blocks are processed as is, with no additional padding. Set the 'PadPartialBlocks' parameter to true to pad the right or bottom edges of the image and make the blocks full-sized. You can also add borders to each block. Use the 'BorderSize' parameter to specify extra rows and columns of pixels outside the block whose values are taken into account when processing the block. When there is a border, blockproc passes the expanded block, including the border, to the specified function.
Image Divided into Distinct Blocks with Specified Borders

Image Processing Toolbox 7.1
Perform image processing, analysis, and algorithm development
Image Processing Toolbox provides a comprehensive set of reference-standard algorithms and graphical tools for image processing, analysis, visualization, and algorithm development. You can perform image enhancement, image deblurring, feature detection, noise reduction, image segmentation, spatial transformations, and image registration. Many functions in the toolbox are multithreaded to take advantage of multicore and multiprocessor computers. Image Processing Toolbox supports a diverse set of image types, including high dynamic range, gigapixel resolution, ICC-compliant color, and tomographic images. Graphical tools let you explore an image, examine a region of pixels, adjust the contrast, create contours or histograms, and manipulate regions of interest (ROIs). With the toolbox algorithms you can restore degraded images, detect and measure features, analyze shapes and textures, and adjust the color balance of images. Key Features Image enhancement, filtering, and deblurring Image analysis, including segmentation, morphology, feature extraction, and measurement Spatial transformations and image registration Image transforms, including FFT, DCT, Radon, and fan-beam projection Workflows for processing, displaying, and navigating arbitrarily large images Modular interactive tools, including ROI selections, histograms, and distance measurements ICC color management Multidimensional image processing Image-sequence and video display DICOM import and export Importing and Exporting Images Image Processing Toolbox supports images generated by a wide range of devices, including digital cameras, satellite and airborne sensors, medical imaging devices, microscopes, telescopes, and other scientific instruments. You can visualize, analyze, and process these images in many data types, including single- and double-precision floating-point and signed and unsigned 8-, 16-, and 32-bit integers. There are several ways to import and export images into and out of the MATLAB environment for processing. You can use Image Acquisition Toolbox to acquire live images from Web cameras, frame grabbers, DCAM-compatible cameras, and other devices. Using Database Toolbox, you can access images stored in ODBC/JDBC-compliant databases. MATLAB supports standard data and image formats, including JPEG, JPEG-2000, TIFF, PNG, HDF, HDF-EOS, FITS, Microsoft Excel, ASCII, and binary files. It also supports the multiband image formats BIP and BIL, as used by LANDSAT for example. Low-level I/O and memory mapping functions enable you to develop custom routines for working with any data format.
Image Processing Toolbox supports a number of specialized image file formats. For medical images, it supports the DICOM file format, including associated metadata, as well as the Analyze 7.5 and Interfile formats. The toolbox can also read geospatial images in the NITF format and high dynamic range images in the HDR format.
A display of MRI slices from a series of DICOM files, enabling visualization and exploration of medical images in MATLAB.
Displaying and Exploring Images Image Processing Toolbox extends MATLAB graphics to provide image display capabilities that are highly customizable. You can create displays with multiple images in a single window, annotate displays with text and graphics, and create specialized displays such as histograms, profiles, and contour plots. In addition to display functions, the toolbox provides a suite of interactive tools for exploring images and building GUIs. You can view image information, zoom and pan around the image, and closely examine a region of pixels. You can interactively place and manipulate ROIs, including points, lines, rectangles, polygons, ellipses, and freehand shapes. You can also interactively crop, adjust the contrast, and measure distances. The suite of tools is available within Image Tool or from individual functions that can be used to create customized GUIs.
A typical interactive session using Image Tool. The Overview window (left) is used to navigate when looking at magnified views in the Image Tool. The Pixel Region window (right) superimposes pixel values on a highly magnified view. LANDSAT image of Paris courtesy of Space Imaging, LLC.

Using region-of-interest tools to create a mask. Items in the original image (top) are selected to create the mask (bottom).
The toolbox includes tools for displaying video and sequences in either a time-lapsed video viewer or an image montage. Volume visualization tools in MATLAB let you create isosurface displays of multidimensional image data sets.
Video viewer paused on an individual frame of a video sequence.
Preprocessing and Postprocessing Images Image Processing Toolbox provides reference-standard algorithms for preprocessing and postprocessing tasks that solve frequent system problems, such as interfering noise, low dynamic range, out-of-focus optics, and the difference in color representation between input and output devices. Image enhancement techniques in Image Processing Toolbox enable you to increase the signal-to-noise ratio and accentuate image features by modifying the colors or intensities of an image. You can: Perform histogram equalization Perform decorrelation stretching Remap the dynamic range Adjust the gamma value Perform linear, median, or adaptive filtering The toolbox includes specialized filtering routines and a generalized multidimensional filtering function that handles integer image types, offers multiple boundary-padding options, and performs convolution and correlation. Predefined filters and functions for designing and implementing your own linear filters are also provided.
Performing connected components analysis on an image with nonuniform background intensity using MATLAB and Image Processing Toolbox.
Image deblurring algorithms in Image Processing Toolbox include blind, Lucy-Richardson, Wiener, and regularized filter deconvolution, as well as conversions between point spread and optical transfer functions. These functions help correct blurring caused by out-of-focus optics, movement by the camera or the subject during image capture, atmospheric conditions, short exposure time, and other factors. All deblurring functions work with multidimensional images.
Image of the sun using deblurring algorithms. Image courtesy of the SOHO EIT Consortium.

Device-independent color management in Image Processing Toolbox enables you to accurately represent color independently from input and output devices. This is useful when analyzing the characteristics of a device, quantitatively measuring color accuracy, or developing algorithms for several different devices. With specialized functions in the toolbox, you can convert images between device-independent color spaces, such as sRGB, XYZ, xyY, L*a*b*, uvL, and L*ch. For more flexibility and control, the toolbox supports profile-based color space conversions using a color management system based on ICC version 4. For example, you can import n-dimensional ICC color profiles, create new or modify existing ICC color profiles for specific input and output devices, specify the rendering intent, and find all compliant profiles on your machine. Image transforms such as FFT and DCT play a critical role in many image processing tasks, including image enhancement, analysis, restoration, and compression. Image Processing Toolbox provides several image transforms, including Radon and fan-beam projections. You can reconstruct images from parallel-beam and fan-beam projection data (common in tomography applications). Image transforms are also available in MATLAB and Wavelet Toolbox. Image conversions between data classes and image types are a common requirement for imaging applications. Image Processing Toolbox provides a variety of utilities for conversion between data classes, including single- and double-precision floating-point and signed or unsigned 8-, 16-, and 32-bit integers. The toolbox includes algorithms for conversion between image types, including binary, grayscale, indexed color, and truecolor. Specifically for color images, the toolbox supports a variety of color spaces (such as YIQ, HSV, and YCrCb) as well as Bayer pattern encoded and high dynamic range images.
Analyzing Images Image Processing Toolbox provides a comprehensive suite of reference-standard algorithms and graphical tools for image analysis tasks such as statistical analysis, feature extraction, and property measurement. Statistical functions let you analyze the general characteristics of an image by: Computing the mean or standard deviation Determining the intensity values along a line segment Displaying an image histogram Plotting a profile of intensity values

Image with histogram for the red channel.
Edge-detection algorithms let you identify object boundaries in an image. These algorithms include the Sobel, Prewitt, Roberts, Canny, and Laplacian of Gaussian methods. The powerful Canny method can detect true weak edges without being "fooled" by noise. Image segmentation algorithms determine region boundaries in an image. You can explore many different approaches to image segmentation, including automatic thresholding, edge-based methods, and morphology-based methods such as the watershed transform, often used to segment touching objects.
Detection and outlining of an aircraft using segmentation and morphology.
Morphological operators enable you to detect edges, enhance contrast, remove noise, segment an image into regions, thin regions, or perform skeletonization on regions. Morphological functions in Image Processing Toolbox include: Erosion and dilation Opening and closing Labeling of connected components Watershed segmentation Reconstruction Distance transform Image Processing Toolbox also contains advanced image analysis functions that let you: Measure the properties of a specified image region, such as the area, center of mass, and bounding box Detect lines and extract line segments from an image using the Hough transform Measure properties, such as surface roughness or color variation, using texture analysis functions Spatial Transformations and Image Registration Spatial transformations modify the spatial relationships between pixels in an image and are useful for tasks such as rotating an image, creating thumbnails, correcting geometric distortions, and performing image registration. Image Processing Toolbox supports common transformational operations, such as resizing, rotating, and interactive cropping of images, as well as generalized transformations for arbitrary-dimensional arrays. Image registration is important in remote sensing, medical imaging, and other applications where images must be aligned to enable quantitative analysis or qualitative comparison. Using Image Processing Toolbox, you can interactively select points in a pair of images and align the two images by performing a spatial transformation, such as linear conformal, affine, projective, polynomial, piecewise linear, or local weighted mean. You can also perform image registration using normalized 2D cross-correlation.
Choosing control points to register an aerial photo to an orthophoto. The Control Point Selection Tool helps you select landmark points and align images (result, bottom). Color aerial photo (top left) courtesy of mPower3/Emerge. Grayscale orthophoto (top right) courtesy of MassGIS.

Working with Large Images Some images are so large that they are difficult to process and display with standard methods. Image Processing Toolbox provides specific workflows for working with larger images than otherwise possible. Without loading a large image entirely into memory, you can create a reduced-resolution data set (R-Set) that divides an image into spatial tiles and resamples the image at different resolution levels. This workflow improves performance in image display and navigation. You can use a block processing workflow to apply a function to each distinct block of a large image, which significantly reduces memory use. An additional option for working with large images is to use the Parallel Computing Toolbox.
A large multispectral image of Paris. Dividing the image into blocks for processing reduces memory usage. Image courtesy Space Imaging, LLC.

Resources

Product Details, Demos, and System Requirements www.mathworks.com/products/image Trial Software www.mathworks.com/trialrequest Sales www.mathworks.com/contactsales Technical Support www.mathworks.com/support Online User Community www.mathworks.com/matlabcentral Training Services www.mathworks.com/training Third-Party Products and Services www.mathworks.com/connections Worldwide Contacts www.mathworks.com/contact
2010 The MathWorks, Inc. MATLAB and Simulink are registered trademarks of The MathWorks, Inc. See www.mathworks.com/trademarks for a list of additional trademarks. Other product or brand names may be trademarks or registered trademarks of their respective holders.