Introduction to Image Processing Image Processing Basics

512 x 

512 

pixels 

128 x 

128 

pixels 

Introduction to Image 

Processing 

Lecture_IP 1 

Gray Scale Images, MATLAB 

Image Processing Basics 

256 x 

256 

pixels 

64 x 64 

pixels 

All images 

interpolated 

to 512 x 512 

format 

64 x 64image 

interpolated 

to 512 x 512 

format 


iimage f( x, y) 

− xy , are spatial coordinates 

− f is image amplitude (intensity, gray level, color level) 

i digital image 

− xyf , y , f finite and discrete 

− f( x , y ) called a picture element (pel) or pixel 

0 0 


• Why do we care about images, image 

processing? 

– “A picture is worth 1000 words” rich 

information source from visual data 

512 x 512 

image 

2010-09-01 

1


• Image types: 

– natural photographic images (jpg) 

– artistic and hand done drawings (pdf) 

– scientific images (satellite photos photos, medical images 

such as X‐rays and MRIs, cat scans, UV scans) 

– engineering drawings, technical specifications, etc. 

Why Digital Image Processing 

• Lossless representations of images 

– no degradation and perfect reproduction 

– ability to duplicate without any loss of quality 

• Sophisticated and powerful digital signal processing 

algorithms l ith 

‐‐ Adobe Photoshop; Photoshop Elements 

‐‐ easy to process and manipulate images 

• Low cost of storage and transmission 

‐‐ modern compression methods can reduce storage rate by 

factors of 30 or more with almost no loss of perceived quality 

‐‐ single CD can store thousands of photos 

Why Process Images 

• Enhancement and Restoration 

– removal of artifacts and scratches from old photos 

– improve contrast and lighting of existing photos 

– correct blurring due to motion in photos 

• Transmission and Storage 

– compression for reduced storage and transmission costs (e.g., from 

outer space) 

– encoding for efficient transmission 

• Image Understanding 

– analysis and classification of image components 

– face recognition and classification 

– object identification (e.g., people, beach, sunset) 

• Security and Rights Protection 

– encryption and watermarking 

Processed Images 

Famous processed image from World Trade Center 

9/11/2001 

Images From Outer Space Images From Outer Space 

2010-09-01 

2

Applications of Digital Image Processing 

• Compression 

– standards‐based, JBIG, JPEG, JPEG2000 

• Manipulation and Restoration 

– noise removal 

– noise reduction 

– morphing hi pairs i of f images i 

– restoration of blurred and damaged images 

• Other 

– visual mosaicing and virtual views 

– face detection 

– visible and invisible watermarking 

– error concealment and resilience in transmission 

Original Image (8-bit 

gray scale) 

24 bit 

Image Quantization 


gray scale) 


gray scale) 

Image Compression 

Original Image (4-bit color 

scale, pseudo-color) 

1 bit 

0.5 bit 0.25 bit 

Image/Video Compression 

• Color image with 600x800 pixels 

– without compression each pixel needs 8 bits for red, green and 

blue components 

– total bit rate of 600*800*24 bits/pixel =1.44 megabytes 

– after JPEG compression can achieve almost lossless 

(perceptually) compression using 89 kilobytes giving a 

compression ratio of about 16:1 

• Movie with 720x480 pixels per frame, 30 frames/sec, 24 

bits/pixel (color frames) 

– without compression the total bit rate is 720x480x30x24=243 

megbits/second or 30 megabytes per second 

– with MPEG compression (for DVD) can compress video to about 

5 megabits/second or a compression ratio of about 48:1 


8 bit 0.5 bit 

0.33 bit 0.25 bit 


2010-09-01 

3

Examples of Image Processing 

Enhancement, Denoising, 

Deblurring, Sampling Rate 

Conversion 

Image Denoising Denoising‐Median Median Filtering 

% Read in the image g and display p y it. % Add noise to the image. g 

% Filter the noisy y image g with an 

I = imread('eight.tif'); 

imshow(I,'border','tight'); 

J = imnoise(I,'salt & pepper',0.02); 

figure, imshow(J,'border','tight') 

averaging filter and display the 

results. 

K=filter2(fspecial('average',3),J)/255; 

figure, imshow(K,'border','tight') 

% Now use a median filter to filter the noisy image and display the 

% results. Notice that medfilt2 does a better job of removing noise, 

% with less blurring of edges. 

L = medfilt2(J,[3 3]); 

figure, imshow(L,'border','tight') 

Image Enhancement (enhance_image.m 

( enhance_image.m) 

% read and display dark image 

I=imread('pout.tif'); 

imshow(I); 

% enhance contrast and 

display by computing image 

histogram and equalizing 

histogram levels 

figure,imhist(I); 

I2=histeq(I); 

% display enhanced image 

% display enhanced image 

histogram 

figure,imshow(I2,'border','tight'); 

figure,imhist(I2); 

Image Denoising Denoising‐Adaptive Adaptive Filtering 

(1) Original Saturn 

Image – Color Image 

(3) Saturn Image 

with Additive 

Gaussian Noise 

(1) (2) (3) 

(2) Gray Scale Saturn 

Image 

(4) Noise Removed 

Image Using Wiener 

Filter 

Image Denoising Image Deblurring 

2010-09-01 

(4) 

4

Image Deblurring –Lucy Lucy‐Richardson Richardson Filter 

% Read an image into the MATLAB 

workspace.; crop image 

I = imread('board.tif'); 

I = I(50+[1:256],2+[1:256],:); 

figure;imshow(I,'border','tight'); 

title('Original Image'); 

% Use deconvlucy to restore the blurred and 

noisy image 

luc1 = deconvlucy(BlurredNoisy,PSF,5); 

figure; imshow(luc1,'border','tight'); 

% Create the PSF. 

PSF = fspecial('gaussian',5,5); 

% Create a simulated blur in the image and add noise. 

Blurred =imfilter(I,PSF,'symmetric','conv'); 

V = .002; 

BlurredNoisy = imnoise(Blurred,'gaussian',0,V); 

figure;imshow(BlurredNoisy,'border','tight'); 

title('Blurred and Noisy Image'); 

Other Image Processing Effects 

Visual Mosaic, Watermarking, Error 

Concealment, Resampling 

Watermarks 

• A visible watermark is a visible translucent image which is 

overlaid on the primary image. 

• A watermark allows the primary image to be viewed, but still 

marks it clearly as the property of the owning organization. 

• It is important to overlay the watermark in a way which makes 

it difficult to remove, if the goal of indicating property rights is 

to be achieved. 

(a) Original Image 

(c) Original Image Down- 

Sampled by 2:1, then Up- 

Sampled by 2:1 

(b) Original Image 

Down-Sampled by 2:1 

Image Sampling 

Rate Changes 

Visual Mosaic 

Watermarks 

(d) Original Image Up-Sampled by 2:1 

2010-09-01 

(e) Original Image 

Up-Sampled by 

2:1, then Down- 

Sampled by 2:1 

• An invisible watermark is an overlaid image which cannot be seen, 

but which can be detected algorithmically. 

• Different applications of this technology call for two very different 

types of invisible watermarks: 

– A watermark which is destroyed when the image is manipulated 

digitally in any way may be useful in proving authenticity of an image. 

If the watermark is still intact, intact then the image has not been 

"doctored." If the watermark has been destroyed, then the image has 

been tampered with. Such a technology might be important, for 

example, in admitting digital images as evidence in court. 

– An invisible watermark which is very resistant to destruction under 

any image manipulation might be useful in verifying ownership of an 

image suspected of misappropriation. Digital detection of the 

watermark would indicate the source of the image. 

5

Visible Digital Watermarks 

Courtesy IBM Watson web page “Vatican 

Digital Library 

Invisible Watermark 

Upper right half of image invisibly 

watermarked, lower left half not 

watermarked. 

Upper pattern is watermark detected 

from upper right half of image; lower 

pattern is watermark detected from 

lower left half of image. 

Error Error Concealment Error Concealment 

Under Sampling of Image 

Proper sampling of image Under sampling of image –note the Moire 

patterns due to image aliasing 

Image Processing Processing Using MATLAB 

2010-09-01 

6

Related Fields to Image Processing 

• Image analysis 

– determine image properties (type of image 

(photo, drawing, medical image) 

– determine image components (objects in image, 

scene ddescription) i ti ) 

• Computer vision 

– analyze image to determine impediments to 

motion of autonomous vehicles 

– identify faces in images 

– identify fish in coral reef (Joe Wilder vision 

lecture) 

Image Processing Levels 

• Low Level Processing (input and output are images) 

– noise reduction – denoising of images 

– contrast enhancement –improve lighting for viewing images 

– image enhancement –sharpen image at edges or in points of maximal 

interest 

• Mid Level Processing (input is an image, output is a set of image attributes) 

‐‐ image segmentation (partition into regions or objects); edge detection 

‐‐ object description (e.g., size, color, orientation) 

‐‐ object classification (recognition, e.g., faces) 

• High Level Processing 

‐‐ making sense of ensemble of recognized objects (e.g., path planning, 

alerting, alarming) 

MATLAB Image Processing MATLAB Image Processing Fundamentals 

MATLAB Image Processing 

⎡ f(0,0) f(0,1) ... f(0, N −1) 

⎤ 

⎢ 

f(1, 0) f(1,1) ... f(1, N −1) 

⎥ 

f( x, y) 

= ⎢ ⎥ 

⎢ ⎥ 

⎢ ⎥ 

⎣f( M,1) f( M,2) ... f( M −1, N −1) 

⎦ 

⎡f(1,1) f(1,2) ... f(1,N) ⎤ 

⎢ 

f(2,1) f(2,2) ... f(2,N) 

⎥ 

f= ⎢ ⎥ 

⎢ ⎥ 

⎢ ⎥ 

⎣f(M,1) f(M,2) ... f(M,N) ⎦ 

MATLAB Image Indexing 

Conventional Image Indexing 

f(1, 1) = f(0,0) 

f(M, N) = f(M-1,N-1) 

Equivalence of 

MATLAB and 

Conventional 

Image Indexing 

f( x, y) →M rows, N columns ⇒ M× N size image 

conventional indexing (0 : M − 1× 0 : N −1) 

MATLAB Image: 

f(r,c) ↔ (1: M,1: N) 

Conventional image 

coordinates 

MATLAB image 

coordinates 

Image Formats for MATLAB 

2010-09-01 

7

Image IO in MATLAB 

• Image read command: 

– f = imread(‘filename’); % f = imread(‘lena.tif’); 

– [M,N] = size(f); % M=512, N=512, ; pixels‐8 bits 

• IImage di display l command: d 

‐‐ imshow(f, [low, high]); % display as black image 

intensity at or below low; display as white image 

intensity at or above high; 

‐‐ imshow(f, [ ]); % expands dynamic range so that 

max=white, min=black 

‐‐ impixelinfo; % uses cursor to read image 

coordinates and pixel intensity values 

f = imread(‘saturn.tif’); 

[M,N] = size(f); % M=328, N=448 

imshow(f); 

M=size(f,1); number of rows in f 

N=size(f,2); number of columns in f 

Example 

Example 

imshow(f, [64,128]); 

• f=[255 230 180; 155 130 105; 80 50 0]; 

• imshow(f,[ ],’InitialMagnification’,’fit’); 

f=imread(‘lena.tif’); 

whos 

name: f 

size: 512 x 512 

bytes: 262144 

class: uint8 

imshow(f); 

Example 

Full path read: f=imread(‘C:\data\matlab\image files\lena.tif’); 

Overview 

f=imread(‘rose.tif’); 

imtool(f); 

Example 

Image Tool 

Pixel Value 

Cropped Image 

Pixel Region g 

2010-09-01 

8


imtool is extremely useful tool for gaining an 

understanding of image properties 

Image IO IO in MATLAB MATLAB 

• Image write command: 

– imwrite(f, ’filename’); % writes to filename (must have valid 

extension) 

– imwrite(f,’filename’,’tif’); % writes to filename.tif 

– imwrite(f, ’filename.jpg’, ’quality’, q); % 0 ≤q≤100 

• File size information: 

– imfinfo filename; imfinfo(‘filename’); 

– K=imfinfo(‘filename’); % K is structure variable 

– K.Height, K.Width; 

• Export figure images to disk: 

– print –fno –dfileformat –rresno filename; % no is figure number; 

fileformat from list; resno=dpi resolution of file 

– print ‐f1 –dtiff –r300 saturn_clip.tif; % save figure 1, in tiff format, 

using 300 dpi resolution, to filename ‘saturn_clip.tif’ 


pseudo-color with 

colormap l set tt to ‘hot’; ‘ht’ filename:’rose_hot.jpg’ 

Example ‐ imfinfo imfinfo(‘saturn.tif’); 

(‘saturn.tif’); 

Filename: 'saturn.tif' 

FileModDate: '07‐Jul‐2004 15:31:54' 

FileSize: 144184 

Format: 'tif' 

FormatVersion: [] 

Width: 438 

Height: 328 

BitD BitDepth: th 8 

ColorType: 'grayscale' 

FormatSignature: [73 73 42 0] 

ByteOrder: 'little‐endian' 

NewSubFileType: 0 

BitsPerSample: 8 

Compression: 'Uncompressed' 

PhotometricInterpretation: 'BlackIsZero' 

StripOffsets: [19x1 double] 

SamplesPerPixel: 1 

RowsPerStrip: 18 

Example Example 

StripByteCounts: [19x1 double] 

XResolution: 72 

YResolution: 72 

ResolutionUnit: 'Inch' 

Colormap: [] 

PlanarConfiguration: 'Chunky' 

TileWidth: [] 

TileLength: [] 

TileOffsets: [] 

TileByteCounts: [] 

Orientation: 1 

FillOrder: 1 

GrayResponseUnit: 0.0100 

MaxSampleValue: 255 

MinSampleValue: 0 

Thresholding: 1 

ImageDescription: [1x168 char] 

2010-09-01 

9

Image Size 

• f=imread(‘circuitboard.tif’); 

• imwrite(f,’circuitboard_r300.tif’,’compre 

ssion’,’none’,’resolution’,[300 300]); 

• K=imfinfo(‘circuitboard_r300.tif’); 

• K.XResolution=300; K.YResolution=300; 

1.5 x 1.5 inches 

• imwrite(f,’circuitboard_r200.tif’,’compre 

ssion’,’none’,’resolution’,[200 200]); 

• K=imfinfo(‘circuitboard_r200.tif’); 

• K.XResolution=200; K.YResolution=200; 

2.25 x 225 inches 

Image Data Classes 

• f=imread(‘lena.tif’); 

• whos 

– Name Size Bytes Class Attributes 

– f 512x512 262144 uint8 

• max (f(:))=245; min(f(:))=24; 

• g=double(f); 

• whos 

– Name Size Bytes Class Attributes 

– f 512x512 262144 uint8 

– g 512x512 2097152 double 

• max(g(:))=245; min(g(:))=24; 

Image Types 

• Intensity images ‐ generally gray scale images 

whose values represent image intensity; class can be 

double (floating point), uint8 (integers from 0 to 

255), uint16 (integers from 0 to 65535) or scaled 

double in the range [0,1] 

• Binary inary images images ‐ logical array of 0s and 1s; s; obtained 

using function logical on a numeric array of ones and 

zeros (halftone) 

• Indexed images ‐ image with two components, 

namely a data matrix of integers, X, and a color map 

matrix, map. 

• RGB images ‐ image with 3 complementary color sets 

of intensity 


Data classes double through single are numeric data classes; 

Data class char is a character class and data class logical is a 

logical class. 


• All numeric computations in MATLAB are 

done using using double double quantities 

• Data class uint8 is mostly used for reading and 

storing t i iimages as 88‐bit bit images i 

• Data class double requires 8 bytes per 

number; data class uint8 requires 1 byte per 

number 


• to convert from gray‐scale image to binary 

image: 

– f=imread(‘image.tif’); 

g=f; 

– g=f; 

– g(find(f >= 128))=1; 

– g(find(f < 128))=0; 

– b=logical(g); 

– islogical(b) 

1 

2010-09-01 

10

f, Gray 

Scale 

Image, 

uint8 

[0 255] 


lena.tif (512 x 512 x 8 bits) lena_binary.tif (512 x 512 x 1 bits) 

g=mat2gray(f) 

Image Conversions 

g, Gray 

Scale 


double 

[0 1] Image 

Processing 

h, Gray 

Scale 


double 

[0 1] 

p=im2uint8(f) 

p, Gray 

Scale 


uint8 

[0 255] 

Image Conversions –im2uint8 im2uint8 

im2uint8 scales an image in the range [0 1] to an 

image in the range [0 255] by scaling the image 

values by 255 and clipping below 0 and above 255 

• f = [‐0.5 [ 0505;0 0.5; 0.75 51.5]; 5]; 

• g = im2uint8(f); What is g? 

g=[0 128; 191 255]; 

f11; % 1.5 goes to 255 

scale by 255; 0.5 goes to 128, 0.75 goes to 191 


• Images classified according to both class_image 

(double, uint8, …) and type_image (intensity, binary, 

indexed, RGB) 

• Can readily convert between data classes and image 

types, e.g., 

– Data class conversions: B = class_name(A); 

– A: class uint8 image 

– B = double(A) converts from uint8 to double 

– C: class double image 

– D = uint8(C) converts from double [0 255] to uint8 (integers 

in [0 255]); uint8 truncates below 0 and above 255 

– g = im2uint8(f) scales f to [0 255] then converts to integer 

values 


• uint8: converts double to integers in 

range of [0 255] 

• im2uint8: scales by 255 and integerizes to 

range [0 255] 

• mat2gray: scale to range [0 1] 

• im2double: convert to double precision 

Image Conversions – im2double 

• im2double converts input to class double 

– if input of class uint8, uint16 or logical, im2double 

converts to class double with values in range [0 1] 

– if input of class single or double, double im2double 

returns array of class double, but numerically 

equal to the input 

– mat2gray can be used to convert an array of any 

class to a double array with values in range [0 1] 

2010-09-01 

11

Image Conversions – im2double 

• Example: 

– h = uint8([25 50; 128 200]); 

– g = im2double(h); 

– g g=[0.0980 [0 0980 00.1961;0.5020 1961;0 5020 00.7843]; 7843]; % converts 

integers to double precision values in range [0 1]; 

Image Conversion Examples –mat2gray mat2gray 

• h = uint8([25 50; 128 200]); 

• g = mat2gray(h); % what is g? 

g = [0 0.1429; 0.5886 1]; Amin=25; Amax=200 

25 0; 50 (50‐25)/175=0.1429; 

128 (128‐25)/175=0.5886; 200 (200‐25)/175=1 

• g = im2bw(f,T); % produces a binary image, g, 

from intensity image, f, by thresholding such 

that all pixels < T go to 0, all others go to 1 

Image Conversion Examples –im2bw im2bw 

• im2bw performs conversion to class logical 

where nonzero elements are converted to 1s 

and zero elements are converted to 0s in the 

output 

• equivalently l l we could ld ddo the h following: f ll 

‐ g = f > T; % where T is the threshold for conversion 

to 1s and below T inputs converted to 0s 

‐ g = im2bw(f, T); performs same operations as 

above; threshold T must be in range [0 1]; for uint8 

input, threshold is T*255 

Image Conversions –mat2gray mat2gray 

• mat2gray converts image of any class to array 

of class double scaled to the range [0 1] 

• calling sequence is: 

– g = mat2gray(A, t2 (A [A [Amin, i A Amax]); ]) % g has h values l iin 

range 0 (black) to 1 (white) with clipping below 

Amin and above Amax; Amin and Amax need not 

be specified –routine finds min and max prior to 

conversion and treats them as Amin and Amax 

f=imread(‘lena.tif’); 

figure,imshow(f); 

max(f(:))=245; 

min(f(:))=24; 

Simple Example 

f1=mat2gray(f); 

f2=im2uint8(f1); 

figure,imshow(f2); 

max(f2(:))=255; 

min(f2(:))=0; 

Image Conversion Examples 

• f=[1 2; 3 4]; 

• convert to binary such that values 1 and 2 become 0 and the 

other two values become 1 

– first convert to range [0 1] 

– g = mat2gray(f) ; g= [0 0.3333; 0.6667 1.0]; 

– next convert to binary using threshold of 0.6 

– gb = im2bw(g, 0.6); gb= [0 0; 1 1] 

• alternatively can use 

– gb = f > 2; gb=[0 0; 1 1] 

• convert gb to numerical array of 0s and 1s: 

– gbd = im2double(gb); gbd=[0 0; 1 1] 

• gbd=im2double(im2bw(mat2gray(f), 0.6)); 

• gbd = double(f > 2); 

2010-09-01 

12


⎡25 50 ⎤ ⎡ 0.5 0.75⎤ 

f1 = ⎢ (double) g1 

(double) 

75 100 

⎥ = ⎢ 

0.85 0.99 

⎥ 

⎣ ⎦ ⎣ ⎦ 

⎡25 50 ⎤ 

f2= uint8( f1) 

= ⎢ 

75 100 

⎥ 

⎣ ⎦ 

⎡1 1⎤ 

g2= uint8( g1) 

= ⎢ (integerize to [0 255] range) 

1 1 

⎥ 

⎣ ⎦ 

⎡ 255 

f3= im2uint8( f1) 

= ⎢ 

⎣255 255 ⎤ 

255 

⎥ 

⎦ 

⎡ 128 

g3= im2uint8( g1) 

= ⎢ 

⎣217 191 ⎤ 

(scale by 255 and integerize) 

252 

⎥ 

⎦ 

⎡ 0 

f4= mat2gray( f1) 

= ⎢ 

⎣0.66 0.33⎤ 

⎡ 0 

1 

⎥ g4= mat2gray( g1) 

= ⎢ 

⎦ 

⎣0.71 0.51⎤ 

(scale to [0 1] range) 

1 

⎥ 

⎦ 

⎡25 50 ⎤ 

f5= im2double( f1) 

= ⎢ 

75 100 

⎥ 

⎣ ⎦ 

⎡ 0.5 0.75⎤ 

g5= im2double( g1) 

= ⎢ (convert to double) 

0.85 0.99 

⎥ 

⎣ ⎦ 


original lena.tif image 

f = imread(‘lena.tif’); % 

image is 512 x 512 gray 

scale image (8 bits/pixel) 


hnd = im2bw(g); % 

convert to black-andwhite 

image without 

dithering 


⎡25 f 1 = ⎢ 

⎣75 50 ⎤ 

(uint8) 

100 

⎥ 

⎦ 

⎡25 f2= uint8( f1) 

= ⎢ 

⎣75 50 ⎤ 

100 

⎥ 

⎦ 

⎡ 255 

f3= im2uint8( f1) 

= ⎢ 

⎣255 255 ⎤ 

255 

⎥ 

⎦ 

⎡ 0 

f4= mat2gray( f1) 

= ⎢ 

⎣0.66 0.33⎤ 

1 

⎥ 

⎦ 

⎡25 50 ⎤ 

f5= im2double( f1) 

= ⎢ 

75 100 

⎥ 

⎣ ⎦ 


f = imread(‘lena.tif’); % 

image is 512 x 512 gray 

scale image (8 bits/pixel) 

g = mat2gray(f); % 

convert scale from [0 [ 255] ] 

to [0 1] 

h = dither(g); % convert to 

black-and-white image 

using dithering, 512 x 512 

bits 


2010-09-01 

13

Image Conversion Examples Image Conversion Examples 

Array Indexing 

• V = [1 3 5 7 9]; % 1 row, 5 columns 

• V’ = V(:) = [1; 3; 5; 7; 9]; % 5 rows, 1 column 

• V(1:3) = [1 3 5]; % 1 row, 3 columns 

• V(3:end) = [5 7 9]; % 1 row row, 3 columns 

• V(end:‐2:1) = [9 5 1]; % 1 row, 3 columns 

• V([1 4 5]) = [1 7 9]; % 1 row, 3 columns 

• V = linspace(a,b,n); generates row vector beginning 

at a, ending at b, with n equi‐spaced elements 

• V = linspace(1,9,5) = [1 3 5 7 9]; % 1 row, 5 columns 

Matrix Matrix Operations – matrix sums 

• matrix sums (3 possible ways of computing) 

– A = [1 2 3; 4 5 6; 7 8 9]; % 3 rows, 3 columns 

– col_sums = sum(A); % col_sums=[12 15 18] 

– total_sum = sum(col_sums); % total_sum=45 

– total_sum1 = sum(A(:)); % total_sum1=45; 

– total_sum2 = sum(sum(A)); % total_sum2=45 

Matrix Indexing 

• A = [1 2 3; 4 5 6; 7 8 9]; % 3 rows, 3 columns 

• A(2, 3) = 6; % second row, third column entry 

• A(:, 3) = [3; 6; 9]; % third column, all entries 

• A(2, :) = [4 5 6]; % second row, all entries 

• A(1:2, 1:3) = [1 2 3; 4 5 6]; % first and second rows, all three 

columns 

• A(end, end) = 9; % last entry in matrix 

• A(end, end –2)=7; % entry in end row, end column ‐2 

• A(2:end, end:‐2:1) = [6 4; 9 7]; rows 2‐3, columns 3 and 1 

(backwards) 

• A([1 3], [2 3]) = [2 3;8 9]; % rows 1 and 3, columns 2 and 3 

• A(:)=[1; 4; 7; 2; 5; 8; 3; 6; 9]; % columns concatenated 

Max Operator 

• C = max(A); % C = row vector with max of each 

column 

• C = max(A, B); % C = array of largest elements of 

A or B 

• C = max(A, [ ], dim); % C has the largest 

elements along dimension of A specified by 

scalar dim 

• [C, I] = max(A); % C is a row vector with max of 

each column, and I is a row vector with row index 

for each column max 

2010-09-01 

14

Max Operator Examples 

• A = [1 4 7;2 5 8; 3 6 9]; B = [9 6 3;8 5 2; 7 4 1]; 

• C = max(A) = [3 6 9]; % maximum of each column 

• C = max(A, B) = [9 6 7; 8 5 8; 7 6 9]; % largest 

elements of A or B at each row and column index 

• C = max(A max(A, [ ], ] 2) = [7; 8; 9]; % largest elements 

along dimension of A specified by last argument 

(2=rows, 1=columns) 

• C= max(A, [ ], 1) = [3 6 9]; 

• [C, I] = max(A)=max(A, [ ], 1); C = [3 6 9]; I = [3 3 3]; % 

I = indices of maximums 

• [C, I]=max(A, [ ], 2); C=[7; 8; 9], I=[3 3 3]; 

Matrix Operations – linear indexing 

• MATLAB functions sub2ind and ind2sub 

convert back and forth between row‐column 

subscripts and linear indices 

‐ linear_indices = sub2ind(size(H), r, c); % r is the 

row index (or array of indices), indices) c is the column 

index (or array of indices) 

- linear_indices = sub2ind([4 4],[1 2 4], [3 4 3]); 

% linear_indices = [9 14 12]; 

‐ [r, c] = ind2sub(size(H), linear_indices); 

- [r, c]=ind2sub([4 4], [9 14 12]); 

% r=[1 2 4], c=[3 4 3] 

Standard MATLAB Arrays 

• zeros(M, N) – generates an M row, N column array of 

0s of class double 

• ones(M, N) – generates an M row, N column array 

of 1s of class double 

• rand(M, d( N) ) – generates an M row, N column l array 

whose entries are uniformly distributed random 

numbers in the interval [0 1] 

• randn(M, N) – generates an M row, N column array 

whose numbers are normally distributed (i.e., 

Gaussian) random numbers with mean 0 and 

variance 1 

Matrix Operations – linear indexing 

• use a single subscript to index a matrix 

• example: 

⎡ 1 0.5 0.3333 0.25 ⎤ 

⎢ 

0.5 0.3333 0.25 0.2 

⎥ 

H= ⎢ ⎥ 

⎢0.3333 0.25 0.2 0.1667⎥ 

⎢ ⎥ 

⎣ 00.25 25 00.2 2 00.1667 1667 00.1429 1429 ⎦ 

• H([2 11]); % H=[0.5 0.2] –extracts 2nd and 11th elements of H; elements counted by columns 

• extract values of H at (1,3), (2,4) and (4,3) –we do 

this by extracting row and column indices of the three 

pixels, i.e., (1,3) maps to 9; (2,4) maps to 14; (4,3) 

maps to 12 

f = imread(‘rose.tif’); 

imshow(f); 

Matrix Indexing Example 

fp=f(end:‐1:1,:); 

flip vertically 

(c) - fc=f(257:768,257:768); 

% image section 

(d) – fs=f(1:2:end,1:2:end); 

% subsampled image 

(e) = plot(f(512,:)); horizontal 

% scan line 

Standard MATLAB Arrays Arrays 

• A = 5*ones(3, 3); % A=[5 5 5;5 5 5; 5 5 5] 

• B = randn(1, 5000); hist(B, 100); 

2010-09-01 

15

Array and Matrix Arithmetic Operators 

MATLAB m function 

• write MATLAB function that blends two input images in equal 

weight 

function [w, wmax, wmin]=imblend(f, g) 

% w is a blend of f and g with wmax and wmin the maximum and 

minimum values of the blend 

w1 = 0.5 * f; 

w2 = 0.5 * g; 

w = w1 + w2; 

wmax = max (w(:)); 

wmin = min(w(:)); 

f = [1 2; 3 4]; g = [1 2; 2 1]; 

[w, wmax, wmin] = imblend(f, g); 

w=[1 2; 2.5 2.5]; 

wmax=2.5; 

wmin=1; 

% could use w = 0.5 * (f + g); % however when (f + g) exceeds 

255 (for a uint8 array) the sum saturates and we get a wrong 

result 

Array and Matrix Arithmetic 

Operators for Images (uint8 arrays) 

Array and Matrix Arithmetic Operators 

⎡a1 A= ⎢ 

⎣a3 a2⎤ , 

a4 ⎥ 

⎦ 

⎡b1 B= ⎢ 

⎣b3 b2⎤ 

b4 

⎥ 

⎦ 

i The array product of A and B is: 

⎡ ⎡a 11 b 

A.*B = ⎢ 

⎣ab 33 

a 2 2b b 2 ⎤ 

ab 44 

⎥ 

⎦ 

i whereas the matrix product yields the familiar result: 

⎡ab 11+ a2b3ab 12+ a2b4⎤ A*B= ⎢ 

ab 31+ ab 43 ab 32+ ab 44 

⎥ 

⎣ ⎦ 

MATLAB m function 

• to alleviate the saturation problem use 

MATLAB function 

g = imlincomb(k1, f1, k2, f2) 

k1 = weight for f1; 

f1 = image 1; 

k2 = weight for f2; 

f2 = image 2; 

w = imlincomb(0.5, f, 0.5 g); % this no 

longer saturates on uint8 arrays 

MATLAB Relational and Logical Operators 

A == B; 1 when A(i,j) = B(i,j), 0 otherwise 

A ~= B; 1 when A(i,j) ≠ B(i,j), 0 otherwise 

A >= B; 1 when A(i,j) ≥ B(i,j), 0 otherwise 

A = B = [1 1 0;1 1 1]; 

A

MATLAB Relational Examples 

• A = [1 2 3; 4 5 6; 7 8 9]; 

• B = [0 2 4; 3 5 6; 3 4 9]; 

• A == B; [0 1 0; 0 1 1; 0 0 1]; 

• A >= B; [1 1 0; 1 1 1; 1 1 1]; 

• C = [1 2 0; 0 4 5]; 

• D = [1 ‐2 3; 0 1 1]; 

• C & D; [1 1 0; 0 1 1]; 

• C | D; [1 1 1; 0 1 1]; 

Image 1 – Image 2; tendency to 

blacks (intensities near 0) 

Image Subtraction 

Image 1 – Image 2; histogram 

equalized; improved brightness and 

contrast (still dark image) 

MATLAB Function, fgprod 

Product of two images; again there is 

a tendency to black as the product of 

two numbers (both

MATLAB Flow Control ‐ Switch 

switch switch_expression 

case case_expression 

statement(s) 

case {case_expression1, case_expression2, …} 

statement(s) 

otherwise 

statement(s) 

end 

switch newclass 

case ‘uint8’ 

g = im2uint8(f); 

case ‘uint16’ 

g = im2uint16(f); 

case ‘double’ 

g = im2double(f); 

otherwise 

error(‘Unknown or improper image class.’); 

end 

Vectorizing Loops –Example Example 1 

f(x) = Asin(x / 2π), x = 0,1,2,...,M-1 

For loop implementation: 

A =10; 

for x =1:M % Array indices in MATLAB cannot be 0 

f(x) = A * sin((x -1) / (2* pi)); 

end 

Vectorized MATLAB code : 

A =10; 

tpi = 2* pi; 

Ratio of time for loop versus 

vectorized MATLAB code: 1.8 

x = 0 :M-1; 

f = A * sin(x / tpi); 


Vectorize function using meshgrid 

i [C, R] = meshgrid(c, r); 

i c, r vectors of horizontal (column) and 

vertical (row) coordinates 

i meshgrid transforms coordinate vectors 

into arrays C and R that can be used to 

compute function of two variables 

Example : want to evaluate function z= x+ y for 

integer values of x ranging from 1 to 3, and for 

integer values of y ranging from 10 to 14 

[X, Y] = meshgrid(1: 3, 10 :14); 

X = [1 2 3; 1 2 3; 1 2 3; 1 2 3; 1 2 3]; 

Y = [10 10 10; 11 11 11; 12 12 12; 13 13 13; 14 14 14]; 

Z = X + Y = [11 12 13; 12 13 14; 13 14 15; 14 15 16; 15 16 17]; 

MATLAB Timing 

• tic; % sets variable tic to current clock time 

• run MATLAB code to be timed 

• toc; –Elapsed time is 0.xxx seconds 

• for timing function calls can use special 

function s=timeit(f) where f is the function 

handle for the function to be timed, and s is 

the measurement time, in seconds (timeit 

must be retrieved from course website) 


Create MATLAB function to create a synthetic image 

of the form : 

f( x, y) = Asin( u0x+ v0y) First version uses nested "for" loops 

function f = twodsin1(A, u0, v0, M, N) 

f = zeros(M, N); % pre - allocation of memory 

for c = 1:N 

v0y = v0 * (c -1); 

for r = 1:M 

u0x = u0 * (r - 1); 

f(r, c) = A * sin(u0x + v0y); 

end 

end 

Time this version: 

f = twodsin1(1, 1/ (4 *pi), 1/ (4 * pi), 512, 512); 

imshow(f, [ ]); 

Time: 0.0215 seconds 


Rewrite 2 -D sine function without loops 

function f = twodsin2(A, u0, v0, M, N) 

r = 0 :M - 1; % row coordinates 

c = 0 0:N :N - 1; % column coordinates 

[C, R] = meshgrid(c, r); 

f = A * sin(u0 *R + v0 * C); 

Time: 0.0157 seconds 

Ratio of times: 1.369 

2010-09-01 

18

Interactive IO 

• disp(argument) –display on screen 

• A = [1 2;3 4]; disp(A); 

1 2 

3 4 

• sc = ‘text string’; disp(sc); 

‘text text string’ string 

• t = input(‘message:’, ’s’) – accept screen input 

n = input(‘specify value for n:’); 

t = input(‘specify value for n:’,’s’); n=str2num(t); 

• [a,b,c,…] = strread(cstr, ’format’, ’param’, ’value’); 

• format = %f (floating point), %q(character strings), %d (integer) 

t = ’12.6, x2y, z’; [a,b,c] = strread(t, ’%f%q%q’, ’delimiter’, ’,’); 

a = 12.6; b = ‘x2y’, c = ‘z’ (b and c are cells); convert cells to character array 

d = char(b) = x2y, e = char(c) = z 

Cell Arrays and Structures 

• Cell array – multidimensional array whose elements are 

copies of other arrays – signaled by { and } brackets 

c = {‘gauss’, [1 0; 0 1], 3}; 

c{1} = gauss (a character string) 

c{2} = [1 0; 0 1] ( a 2 x 2 matrix) 

c{3} = 3 ( a scalar) 

• Structure – grouping of a collection of dissimilar data into a 

single variable –elements of structures addressed by fields 

S=structure ‐‐ enter elements of S via simple commands, e.g., 

S.char_string = ‘gauss’; 

S.matrix = [1 0; 0 1]; 

S.scalar = 3; 

MATLAB MATLAB Image Processing 

Commands 

• K = imfinfo filename; % get file information in structure K 

– image_bytes = K.Width*K.Heights*K.Depth/8; 

• g = im2uint8(f); % convert from image to uint8 

‐ f ≤ 0 => 0; f ≥ 1 => 1; scale by 255 and round 

• g = mat2gray(A, [Amin Amax]); % converts double [ ] to 

double [0 1] 

• g = im2double(f); % converts image of uint8 or double to 

double 

‐ g = im2double(mat2gray(f)); % converts to [0 1] range 

String Compare 

• We assume that parameter param can have two forms, namely ‘norm1’ ([0 1]) or 

‘norm255’ ([0 255]) 

• Use strcmp to decide which option to use 

f is image input 

f = double(f); % floating point values 

f = f‐min(f(:)); f min(f(:)); % min(f) set to 0 

f = f./max(f(:)); % max(f) set to 1 

if (strcmp(param, ’norm1’) 

g = f; 

elseif strcmp(param, ’norm255’) 

g = 255*f; 

else 

error(‘Unknown value of param.’); 

end 

MATLAB Image Processing 

Commands 

• f = imread(‘filename’); % reads in file to array 

• imshow(f); % displays array as image, [0 255] 

‐ imshow(f, [low high]); % f(i,j) ≤ low => low (black) 

‐ % f(i,j) ≥ high => high (white) 

‐ imshow(f, [ ]); % low = min(min(f)); high = max(max(f)); 

• pixval; % displays intensity values of pixels 

• imwrite(f, ’filename’); % writes image to disk 

‐ imwrite(f, ‘filename’, ‘tif’); 

‐ imwrite(f, ‘filename.jpg’, ‘quality’, q); % q in [0 100] range 

Images on Website 

blood1.tif; 265 

rows, 272 columns, 

min=46, max=255 

breast.tif; 570 


min=21, max=255 

building.tif; 240 


min=21, max=255 

chalk.tif; 1040 rows, 

1040 columns, 

min=0, max=255 

checker.tif; 512 



circuitboard.tif; 450 



FTspectrum.tif; 257 



hardware.tif; 240 



2010-09-01 

19


iris.tif; 600 rows, 

600 columns, 


iris_gray.tif; 600 


min=27 min=27, max=255 

iris_luminence.tif; 

600 rows, 600 

columns, min=22, 

max=255 

lena.gif; 512 rows, 

512 columns, 

min=19, max=191 

lena.tif; 512 rows, 

512 columns, 

min=24, max=245 

lighthou.tif; 240 


min=21, , max=255 

moon.tif; 540 rows, 

466 columns, 


parrots.tif; 256 




peppers.jpg; 512 



rose.tif; 1024 rows, 

1024 columns, 

min=0, i 0 max=255 255 

saturn.tif; 256 



shuttle.tif; 240 


min=32, max=255 

tooth1.jpg; 512 



xray.tif; 240 rows, 

320 columns, 

min=42 min=42, max=255 

2010-09-01 

20

Introduction to Image Processing Image Processing Basics

Create successful ePaper yourself

Delete template?

Save as template?