Starting MATLAB

Variables, vectors, and matrices

When the MATLAB interpreter is waiting for a command from the user, the command prompt >> appears in the Command Window. Try entering the following commands that create some variables and assign these variables to values. The printout below also shows the MATLAB response (the phrases preceded by % are comments that should not be entered):

>> format compact         % removes extra vertical space from MATLAB printout
>> a = 10
a =
    10                    % MATLAB prints the value of each expression
>> b = [1 2 3]
b =                       % 1D vector of values
    1    2    3           
>> c = [4 5 6; 7 8 9]
c =                       % 2D matrix of values - a semicolon separates row contents
    4    5    6           
    7    8    9
>> d = [-1 0; 6 -7]
d =
   -1    0
    6   -7
>> e = [c d];             % semicolon at the end of a statement suppresses
>> e                             % the printout of its value
e =
    4    5    6    -1    0
    7    8    9     6   -7

MATLAB was originally designed to work efficiently with large matrices of numbers, which are common in many science and engineering applications. The name MATLAB is derived from MATrix LABoratory. A matrix is essentially an array of numbers in one or more dimensions, although operations on matrices such as multiplication follow certain mathematical rules. A 2D matrix with M rows and N columns is referred to as an MxN matrix. In the above examples, the first variable, a, is assigned to a single scalar value that is stored in a 1x1 matrix. The variable b is assigned to a row vector of three elements that are arranged horizontally. b is represented as a 1x3 matrix. You can think of b as a one-dimensional array. Brackets are used to enter the contents of a matrix, but these brackets are not shown when the value is printed.

The variable c is assigned to a 2x3 matrix that you can think of as a two-dimensional array. In the assignment statement, the elements within each row are separated by spaces (or optionally, commas) and the contents of the two rows are separated by a semicolon. You can create a column vector in which the elements are arranged vertically, by placing semicolons between the successive elements, as in the following example:

>> f = [1; 2; 3]
f =
    1
    2
    3

The earlier assignment of the variable e illustrates that new matrices can be formed out of existing ones, by concatenating the parts. This assignment statement is also terminated by a semicolon, which suppresses the printout of the returned value. The value of a variable can be printed by typing the name of the variable at the command prompt.

At any time, you can enter the clc command to clear the Command Window.

The built-in size function returns the dimensions of a matrix:

>> size(b)           % returns a vector containing the two dimensions, 1x3
ans =
    1    3
>> size(e)
ans = 
    2    5
>> size(e,1)         % note the optional second input - returns the first dimension
ans =
    2
>> size(e,2)         % returns the second dimension
ans =
    5
>> [rows, cols] = size(e)     % assigns dimensions to separate variables
rows =
    2
cols =
    3

When a value is returned, but not assigned to an explicit variable name, the value is assigned to a default variable named ans. The built-in function length returns the largest dimension of a matrix, e.g. length(e) returns 5.

The elements of a 1D matrix can be accessed by specifying a single index in parentheses, while the elements of a 2D matrix can be accessed by placing two indices inside parentheses and separated by commas, as shown in the following examples:

>> b(2)
ans =              % indices begin with 1 (not 0, as in Python, Java, and C)
    2
>> d(2,2)
ans =
    -7
>> d(1,2)
ans =
    0
>> d(2,2) = 10     % assigning new contents to a matrix location
d =
   -1    0
    6   10
>> d(4,4) = 3
d =
   -1    0    0    0
    6   10    0    0
    0    0    0    0
    0    0    0    3

The last example shows that if a value is assigned to a matrix location that is outside the current bounds of the matrix, MATLAB automatically expands the matrix, padding it with zeros in locations where a value is not specified. When expanding the matrix, the old contents are copied to the new matrix, so this is not an efficient operation if performed many times.

zeros and ones

An initial matrix containing all 0's or all 1's can be created with the functions zeros or ones, as shown in the following examples:

>> image1 = zeros(3,4)        % create a 3x4 matrix of zeros
image1 =
    0    0    0    0
    0    0    0    0
    0    0    0    0
>> image2 = ones(3,3)         % create a 3x3 matrix of ones
image2 =
    1    1    1
    1    1    1
    1    1    1
>> image3 = 5*ones(2,3)       % all matrix elements are scaled by 5
image3 =
    5    5    5
    5    5    5
>> image1D = 2*ones(1,6)      % to create a 1D matrix (vector) of zeros or ones,
image1D =                         % you still need to specify two dimensions
    2    2    2    2    2    2

The zeros and ones functions can also be used to create 3D matrices. This is illustrated in the following example, which also shows how to access the dimensions and elements of a 3D matrix:

>> image3D = zeros(10,10,3);
>> [xdim ydim zdim] = size(image3D)
xdim =
    10
ydim =
    10
zdim =
    10
>> image3D(3,6,2) = 100;

colon notation

It is often desirable to create a set of equally spaced numbers or access a range of indices in a matrix all at once. A range of numbers can be specified using colon notation. The expression a:b denotes a sequence of consecutive numbers from a to b, incrementing by 1. The expression a:b:c denotes a sequence of numbers from a to c, changing by b. In the following examples, some sample sequences of numbers are placed in 1D matrices:

>> g = 2:6
g =
    2    3    4    5    6
>> h = 3:2:11
h =
    3    5    7    9    11
>> k = 2:-1:-3
k =
    2    1    0    -1   -2   -3
>> m = 0.2:0.4:2.2
m =
    0.2000   0.6000   1.0000   1.4000   1.8000   2.2000

The last example created a matrix of floating point numbers, and by default, MATLAB prints these numbers with 4 digits after the decimal point. Colon notation can be used to specify a range of indices for a matrix. Inside a matrix reference, a single colon by itself specifies an entire row or column. The keyword end inside a reference to the indices of a matrix specifies the upper limit of a particular dimension. The following examples illustrate these concepts:

>> e
e =
    4    5    6   -1    0
    7    8    9    6   -7
>> e(1,2:4)
ans =                   % row 1, column indices 2 through 4
    5    6   -1   
>> e(1:2,4:5)
ans =                   % rows 1 and 2, columns 4 and 5
   -1    0
    6   -7
>> e(:,2)
ans =                   % all rows in column 2
    5
    8
>> e(2,:)
ans =                   % all columns in row 2
    7    8    9    6   -7
>> e(1,3:end)
ans =                   % row 1, from column 3 to the last column
    6   -1    0
>> e(:,3) = 0           % assign all rows in column 3 to zero
e =
    4    5    0   -1    0
    7    8    0    6   -7

The contents of one matrix can be copied into another, using colon notation to specify regions of the matrices:

>> im1 = zeros(5,5)
im1 =
    0    0    0    0    0
    0    0    0    0    0
    0    0    0    0    0
    0    0    0    0    0
    0    0    0    0    0
>> im2 = ones(3,3)
im2 =
    1    1    1
    1    1    1
    1    1    1
>> im1(2:4,3:5) = im2           % copy all of im2 into im1, starting at 
im1 =                              % row 2, column 1 of im1
    0    0    0    0    0
    0    0    1    1    1
    0    0    1    1    1
    0    0    1    1    1
    0    0    0    0    0
>> im1(4:5,1:2) = im2(1:2,1:2)   % copy a subregion of im2 into im1
im1 =
    0    0    0    0    0
    0    0    1    1    1
    0    0    1    1    1
    1    1    1    1    1
    1    1    0    0    0
>> subimage = im1(2:4,1:3)      % create a separate matrix that is a
subimage =                               % subregion of im1
    0    0    1
    0    0    1
    1    1    1

matrix arithmetic and operations

If two matrices have the same dimensions, their contents can be added, subtracted, multiplied, and divided on an element-by-element basis:

other useful MATLAB functions: sum, min, max, linspace, find

Some additional built-in MATLAB functions that will come in handy include sum, min, max, linspace, and find, illustrated in the following code:

>> test1D = [3 5 1 7];
>> sum(test1D)       % returns the sum of the contents of a 1D matrix
ans =
    16
>> test = [1 2 3; 4 5 6; 7 8 9]
test =
    1    2    3
    4    5    6
    7    8    9
>> sum(test)         % for a 2D matrix, sum returns a 1D matrix of
ans =                   % the sums of the values in each column
   12   15   18
>> sum(sum(test))    % invoke sum twice to obtain the sum of all the
ans =                   % contents of a 2D matrix
   45
>> min(test1D)       % returns the minimum value in a 1D matrix
ans =
    1
>> min(test)         % returns vector of minimum values in each column
ans =
    1    2    3
>> min(min(test))    % returns the minimum value in a 2D matrix
ans =
    1
>> max(test1D)       % returns the maximum values
ans =
    7
>> max(test)
ans =
    7    8    9
>> max(max(test))
ans =
    9

linspace(x1,x2,n) returns a 1D matrix containing n values that are evenly spaced between x1 and x2:

>> linspace(2,15,5)
ans =
   2.0000   5.25000   8.5000   11.7500   15.0000

Finally, the find function returns the locations (indices) of values in a matrix that satisfy an input logical expression:

>> nums = rand(1,7)      % create a 1D matrix of random numbers between 0 and 1
nums =
   0.9355   0.9169   0.4103   0.8936   0.0579   0.3529   0.8132
>> find(nums>0.5)        % returns the indices of numbers larger than 0.5
ans =
    1    2    4    7
>> nums = rand(4,4)      % create a 2D matrix of random numbers
nums = 
   0.0099   0.6038   0.7468   0.4186
   0.1389   0.2722   0.4451   0.8462
   0.2028   0.1988   0.9318   0.5252
   0.1987   0.0153   0.4660   0.2026
                             % find numbers between 0.33 and 0.67
>> [r, c] = find((nums > 0.33) & (nums < 0.67))
r =                      % r is a column vector of the row coordinates
    1                         % of numbers in this range
    2
    4
    1
    3
c =                      % c is a vector of the column coordinates
    2                         % of numbers in this range
    3
    3
    4
    4

The two vectors r and c indicate that there are numbers between 0.33 and 0.67 at (row, column) locations (1,2), (2,3), (4,3), (1,4), and (3,4).

An implication of the above examples is that a conditional expression like (nums > 0.5) can be applied to an entire vector or matrix of values all at once. This expression returns a vector or matrix of logical values 1 and 0 that represent true and false, respectively. For example:

>> test = [1 2 3; 4 5 6; 7 8 9];
test =
    1    2    3
    4    5    6
    7    8    9
>> odds = (rem(test,2) == 1);    % rem is the remainder function
odds =
    1    0    1
    0    1    0
    1    0    1

A sequence of MATLAB commands can be stored in a file and executed by entering the first name of the file in the Command Window. The file must have a filename extension of .m and is referred to as an M-File. One type of M-file is a script. Although any text editor can be used to create an M-File, MATLAB provides its own editor that is convenient to use. There are at least three ways to open an initial editor window to start a new script:

• type edit in the Command Window
• click on the New Script icon near the upper left corner of the MATLAB window
• select Script from the New menu to the right of the New Script icon

An existing M-file can be opened in the MATLAB editor through the Open menu near the upper left corner of the MATLAB window, or by clicking on the folder above this menu. You can also double-click on the file name in the Current Folder window, or invoke the edit command in the Command Window, for example:

     edit myCodeFile

In this case, the myCodeFile.m file must be stored in the Current Folder, or exist somewhere on MATLAB's search path described later in this section.

Multiple files can be open in the editor at one time - the files are overlaid and can be selected by clicking on the tab with their name near the top of the editor window. You can type commands in the editor, and the code will be formatted automatically with indentation to make the code more readable.

A code file can be saved by clicking on the floppy disk icon labeled Save along the top of the editor window, or through the Save menu below this icon. When a file is first created, a dialog box will appear where the name of the file can be entered. Either type the full file name (e.g. myCodeFile.m) or first file name (e.g. myCodeFile) in the text box labeled Save As: and click on the Save button. Unless otherwise specified, the file will be stored in the Current Folder.

Suppose a file is created, named testFile.m. The sequence of commands in this file can then be executed by entering the name testFile in the Command Window. From the editor, the script can also be run by clicking on the green arrow along the top menu bar.

A comment can be placed in an M-File by preceding the text with %, as shown in the above code samples. Multiple lines of text can be put in comments by surrounding the block of text with %{ and %} placed on separate lines, as shown in the following script:

%{
This script creates a simple image with
two patches of constant intensity against
a black background
%}
image = zeros(50,50);
image(10:20,10:30) = 100;
image(25:40,15:45) = 200;

A script is executed as if the individual commands were entered, one-by-one, in the Command Window. As a consequence, existing variables in the MATLAB workspace can be altered by a script that uses variables of the same name, and new variables created by a script will remain in the workspace after execution is complete.

MATLAB apps and Live Scripts

MATLAB has an extensive library of built-in functions that are documented through the help system. Just enter help or doc followed by the name of a function:

>> help exist
...
>> doc magic

The help command can also be used to print information about user-defined scripts and functions. In the case of scripts, any comments at the top of the script file that are preceded with a % are printed. For example, suppose the following script were stored in a file named helpTest.m:

% this script illustrates the application of the
% help command to user-defined script files
a = 10;
b = 3;

The comments can then be accessed through the Command Window:

>> help helpTest
    this script illustrates the application of the
    help command to user-defined script files

You can also search for information through the search box at the top of the MATLAB desktop.

Conditionals and loops

MATLAB provides if and switch statements for conditionals, and for and while statements for loops. This section introduces if and for statements. The if statement can follow one of three patterns:

if conditional-expression
     <commands to evaluate if true>
end

if conditional-expression
     <commands to evaluate if true>
else
     <commands to evaluate if false>
end

if conditional-expression1
     <commands to evaluate if conditional-expression1 is true>
elseif conditional-expression2
     <commands to evaluate if conditional-expression2 is true>
elseif conditional-expression3
     <commands to evaluate if conditional-expression3 is true>
...
else
     <commands to evaluate if all conditional expressions are false>
end

The expressions in the above patterns are logical expressions that can be created using the following relational operators, similar to Python, Java, and C: > < >= <= == ~= & | && || (note that == is used to test for equality - the single equals = is used only for assignment).

The general pattern for the for statement is:

for variable = values
     <commands to evaluate for each value of variable>
end

It is common to use the colon operator or an existing 1D matrix to specify the values for the variable that controls the number of times that the body of the loop is executed. The following examples illustrate the use of if and for statements. The statements are formatted as they would appear when entered into an M-File in the editor. Semicolons are typed at the end of each assignment statement so that the MATLAB output is suppressed during execution:

randomNums = rand(1,7);         % create a 1D matrix of random numbers
numbers = zeros(1,7);               % between 0.0 and 1.0
for i = 1:7                     % loop is executed 7 times, with i assigned
    if (randomNums(i) < 0.33)   % to consecutive integers from 1 to 7
        numbers(i) = 0;
    elseif (randomNums(i) < 0.66)
        numbers(i) = i;
    else
        numbers(i) = 1;
    end
end

for i = 1:3:7                   % loop is executed 3 times, with i assigned 
    numbers(i) = numbers(i) + 100;     % to 1, 4 and 7
end

numbers2D = rand(3,6);
for i = 1:3                     % nested for statements can be used to loop
    for j = 1:6                    % through a 2D matrix
        if numbers2D(i,j) < 0.5) | (j == 3)
            numbers2D(i,j) = 0.0;
        end
    end
end

nums = [3 8 2 9 1 5 8];
sum = 0;
for val = nums                  % loop is executed 7 times, with val assigned
    sum = sum + val;                % to each of the 7 numbers stored in nums
end

Suppose the above statements were saved in an M-File named forTest.m and then executed in the Command Window. An example of the final values stored in the variables randomNums, numbers, numbers2D, and sum is shown in the following printout:

>> randomNums
randomNums =
   0.6992   0.7275   0.4784   0.5548   0.1210    0.4508    0.7159
>> numbers
numbers =
   101    1    3   104    0    6   101
>> numbers2D
numbers2D = 
   0.8928   0.8656      0        0        0        0
        0        0      0        0   0.8439   0.9943
        0   0.8049      0   0.6408        0        0
>> sum
sum =
    36

Aborting a computation and Command Window shortcuts

Now that you know about loops, it's useful to know how to terminate a runaway computation. When MATLAB is busy performing a computation, the word Busy is printed in the lower left corner of the full MATLAB window. The execution of any command can be aborted by typing control-C.

When entering commands in the Command Window, there are a number of handy shortcuts available. The up-arrow and down-arrow keys cycle up and down through previously entered commands, allowing you to repeat the execution of a command. The left- and right-arrow keys move the cursor back and forth through a line to facilitate editing, and the Tab key can be used for command completion. If you type part of a command and decide not to execute this command, press the escape key to erase the line.

A final handy shortcut is that multiple commands can be typed on one line, separated by commas (although this can lead to less readable code):

>> x = 10, y = 15, z = sqrt(x^2 + y^2)
x =
    10
y =
    15
z = 
   18.0278

Managing variables and memory space

Large 2D and 3D matrices can occupy substantial memory space. It is possible for MATLAB to run out of memory, making it impossible to do further work. Fortunately, existing variables that are no longer needed can be eliminated, freeing up memory space for new variables. The who command prints the names of all variables currently defined in the MATLAB workspace, the whos command prints the name, size and type of each variable, and the clear command deletes variables from the workspace:

 >> whos
  Name        Size        Bytes      Class
  ans          1x1            8      double
  im1        10x10          800      double
  im2        20x20         3200      double
  image      50x50        20000      double
>> clear im1 im2
>> who
Your variables are:
ans    image

Executing the command clear all deletes all variables from the workspace.

Defining new functions

A new function can be defined in an M-File whose first file name is the same as the name of the function. To open a file to define a new function, select Function from the New menu near the top of the MATLAB window, and the skeleton of a function definition will appear in the MATLAB editor. The first statement in the file is a declaration line that indicates the name of the function and its inputs and outputs. This declaration line implicitly shows the format for calling the function. The generic pattern for a function definition is:

function <outputs> = <function name> (<inputs>)
<statements comprising the body of the function>

<inputs> is a list of input variable names, separated by commas. Inside the body of the function, the inputs can be accessed by name and assigned to new values. If the function returns a single value, then <outputs> is a single variable name. If multiple values are returned, then <outputs> is a bracketed list of variable names, separated by commas. Inside the body of the function, the output variable name(s) must be assigned to the value(s) to be returned. In recent versions of MATLAB, the initial function skeleton contains an end statement at the end of the function, but this is not essential.

Consider the following function named gaussian:

function g = gaussian(x, sigma)
% returns the value of a Gaussian function for
% a particular input location and spread
g = exp(-1.0*(x^2/sigma^2);

This function must be stored in a file named gaussian.m. The follow examples show how this function can be called:

>> gval = gaussian(3.0,2.0)
gval =
    0.1054
>> gvals = zeros(1,6)
gvals =
    0    0    0    0    0
>> for x = 0:5
gvals(x+1) = gaussian(x,2.0);       % the body of a for statement is not indented
end                                 % when entered directly in the Command Window
>> gvals                             
gvals =
   1.0000   0.7788   0.3679   0.1054   0.0183   0.0019

When a function is called with a particular set of inputs, the values of these inputs are copied into the input variables specified in the declaration line of the function definition. Similarly, values returned by a function are copied into the variables specified in the function call. Local variables created within a function definition only exist during the execution of the function. The following examples illustrate a variety of function definitions and their application.

The function gaussianFun returns a 1D matrix of samples of a Gaussian function. Its definition illustrates the reassignment of an input variable, sigma, and use of a local variable, xvals:

function g = gaussianFun(range, numSamples, sigma)
% returns a 1D matrix of samples of a Gaussian function with spread
% specified by sigma and x ranging from -range to +range
sigma = -1.0/sigma^2;
xvals = linspace(-range, range, numSamples);
xvals = xvals.^2;
g = exp(sigma.*xvals);

using help to obtain information about user-defined functions

It was mentioned earlier that the help command can be used to obtain information about user-defined functions. In this case, any comment lines that immediately follow the function header and appear with a % at the beginning of the line are printed:

>> help gaussian
  returns the value of a Gaussian function for
  a particular input location and spread

It is common to place a comment immediately following the header that illustrates how the function is invoked, so that this information is also accessible through the help command, for example:

function g = gaussian(x, sigma)
% g = gaussian(x, sigma)
% returns the value of a Gaussian function ...

adding user input and output to function definitions

A function can request input from the user with the input function, which has a single input that is a quoted text string that is printed as a prompt to the user. The simplest ways to print out intermediate values during the execution of a function are to omit the semicolon at the end of an assignment statement, or to create a string that contains text and variables, as illustrated in the newGaussian function shown below. The disp function displays in input value without printing a variable name. In the first call to disp, the input is an vector of characters created by concatenating two literal strings and a string representation of the number stored in sigma, created with the num2str function.

function g = newGaussian(x)
% returns a sample of a Gaussian function after prompting the user for a value
% for sigma. also illustrates ways to provide printout of intermediate values
sigma = input('enter a value for sigma: ');     % request user input
disp(['you entered ' num2str(sigma) ' at the prompt']);
disp('the resulting Gaussian value is');
g = exp(-1.0*(x^2/sigma^2))           % note omission of semicolon at the end
disp('have a nice day!');

>> gval = newGaussian(2);
enter a value for sigma: 3.0
you entered 3 at the prompt
the resulting Gaussian value is
g = 
    0.6412
have a nice day!

When concatenating multiple strings to print with disp, square brackets are used to combine the components of the string. To create nicely formatted output, explore the sprintf and fprintf functions, similar to their counterparts in C and C++.

break and return statements

The execution of a break statement inside a loop immediately terminates the loop. The execution of a return statement anywhere in a function immediately terminates the function.

Types of numbers

By default, MATLAB represents numbers as double-precision floating point numbers that each require 8 bytes of storage space. A large 2D or 3D matrix of double-precision floating point numbers occupies a lot of memory space! Fortunately such precision is often not needed and MATLAB provides several other types of numbers that can be represented more compactly:

MATLAB name    size(bytes)      description
uint8             1             integers 0 to 255
uint16            2             integers 0 to 65,545
uint32            4             integers 0 to 4,294,967,295
int8              1             integers -128 to 127
int16             2             integers -32,768 to 32,767
int32             4             integers -2,147,483,648 to 2,147,483,647
single            4             single-precision floating point

For each type, there is a function of the same name that converts an input number to the desired type. In the example below, the function uint8 is used to create a matrix of integers of type uint8 from a matrix of numbers of type double:

>> image = 200*ones(100,100);
>> newImage = uint8(image);
>> whos
  Name          Size        Bytes      Class
  ans            1x1            8      doubl
  image      100x100        80000      double
  newImage   100x100        10000      uint8

The newImage matrix can be created directly, without the intermediate image matrix, by executing the statement newImage = uint8(200*ones(100,100)).

When printing floating point numbers of type double, MATLAB uses scientific notation to print very large or very small numbers, as shown here:

>> number = 1230000000
number =
    1.23e+09
>> number = 0.000789
number =
    7.8900e-04

Note: When computations are performed on matrices that are integer types, the results are converted to the same integer type, as shown in the following examples, which convert all results to the uint8 type (integers between 0 and 255):

>> nums1 = uint8([100 10 200]);
>> nums2 = nums1 + 100
nums2 =
   200   110   255
>> nums3 = nums1 - 100
nums3 =
     0     0   100
>> nums4 = nums1/100
nums4 =
   1   0   2
>> whos
  Name       Size      Bytes  Class 
  nums1      1x3           3  uint8              
  nums2      1x3           3  uint8              
  nums3      1x3           3  uint8              
  nums4      1x3           3  uint8

2D and 3D plotting

The plot function can be used to create 2D graphs. The essential inputs to plot are two 1D matrices containing the x and y coordinates of the points to be plotted. The plot function opens a graphic window called a figure window, draws axes with labels that are scaled to fit the range of the data, and connects the points with straight lines, as shown in the following example:

>> xc = 0.0:0.1:2*pi;      % 1D matrix of evenly spaced x coords from 0 to 2π
>> yc = sin(xc);           % 1D matrix of samples of a sine function
>> plot(xc, yc);           % plot function displays the graph shown below

By default, the plot function draws a new graph in the most recently opened figure window. To create a new window, execute the figure command. The plot function is extremely versatile. For example, you can change the appearance and range of the axes, adjust the appearance of the graph with different line types, symbols and colors, add labels and legends, and display multiple graphs superimposed. Some of these facilities are illustrated below:

xc = 0.0:0.1:2*pi;
yc = sin(xc);
yc2 = cos(xc);
plot(xc, yc, 'b-*')
hold on
plot(xc, yc2, 'r:o')
plot(linspace(0,2*pi,10), linspace(-1,1,10), 'g-.s', 'LineWidth', 2)
axis([-0.5 7.5 -1.3 1.3])
xlabel('x coords')
ylabel('y coords')
title('sample graphs')
legend('sine', 'cosine', 'line', 'Location', 'Best')
hold off

Multiple plots can be displayed within a single figure window using the subplot command, and scatter plots can be created with the scatter function. The contents of figure windows can also be saved for later retrieval or insertion into documents by selecting the Save or Save As... options from the File menu at the top of the figure window.

3D plots can be created with the functions plot3, scatter3, mesh and surf. The following example illustrates the creation of a surface plot:

>> [x,y,z] = peaks(30);    % peaks returns x,y,z coordinates of a surface
>> surf(x,y,z);            % creates the 3D  surface plot shown below

Pictures with arrows can be created with the quiver function, for example, to illustrate how features are moving in an image:

When many figure windows are open, displaying plots or images, the memory storage for all of these windows sometimes interferes with the memory space used for numerical computations, producing erroneous results. For this reason, you should not have too many figure windows open at one time! Individual figure windows can be closed by clicking on the close button in the upper right corner of the window. All of the current windows can be closed at once by executing the following command:

>> close all

You can learn much more about all of the plotting functions through the MATLAB help facility.

Working with images

The basic MATLAB system, combined with the Image Processing Toolbox, provides many functions for reading, writing, displaying and processing 2D and 3D images. This section introduces the basic facilities that we will use extensively in CS332.

image types

reading and writing images

MATLAB can read and write images using many different file formats, obtained from a variety of sources. The most common image file types that we will use are JPEG and PNG. The functions for reading and writing images are imread and imwrite, which are defined in the Image Processing Toolbox. Extensive information about various image file formats and their specification can be obtained through the help pages for these two functions. The imread function has one essential input that is the name of the image file to be loaded into the MATLAB workspace. Often MATLAB can infer the type of file from its contents, so that it is not necessary to provide any further inputs to the imread function:

>> coins = imread('coins.png');
>> peppers = imread('peppers.png');
>> whos
  Name            Size        Bytes      Class
  coins        246x300        73800      uint8
  peppers    384x512x3       589824      uint8

The imfinfo function prints information about the format of an image, for example, try entering imfinfo('coins.png'). The essential inputs to the imwrite function are the image name and file name, with a file name extension that indicates the file format to use:

>> imwrite(image1, 'image1.jpg');
>> imwrite(image2, 'image2.png');

By default, the image is stored in the Current Folder.

displaying images

MATLAB provides two functions for displaying images, imshow and imtool, which are also defined in the Image Processing Toolbox.

>> imshow(coins);

By default, the imshow function displays the image using 256 discrete levels of gray. The number of gray levels can be changed by providing a second integer input, e.g. imshow(coins,64). In the case of an 8-bit image, the value 0 is normally displayed as black and 255 is displayed as white. The imshow function can be called with a specified range of intensities to be displayed from white to black. For example, imshow(coins, [50,200]) displays intensity values of 50 or less as black, and intensities of 200 or higher as white. The values between 50 and 200 are evenly spread over the levels of gray from black to white. imshow can also be used to display binary, indexed and RGB images. If the input image is of type double, MATLAB assumes that the values to be displayed range from 0.0 to 1.0. In this case, any values below 0.0 are displayed as black, values above 1.0 are shown in white, and values between 0.0 and 1.0 are displayed as shades of gray. Again, a different range of intensities can be specified, e.g. imshow(newImage,[1.0,5.0]). If empty brackets are provided as a second input, MATLAB will use the actual minimum and maximum intensity values in the image as the range to be displayed from black to white, e.g. imshow(image,[]).

Multiple images can be displayed in separate figure windows by calling the figure function to create a new window. Keep in mind that MATLAB can become confused if too many figure windows are open, so be sure to close unnecessary windows, either individually or with the close all command. Using the subplot function, multiple images can be displayed inside a single figure window. You can zoom in or out of an image displayed in a figure window, or change the size of the image by changing the window size. It is also possible to add figure annotations and print images that are displayed with imshow.

The imtool function displays the image in a separate window called an Image Tool. The Image Tool provides special tools for navigating around large images and inspecting small regions of pixel values. Similar to imshow, a particular range of intensity values can be specified when calling imtool, e.g. imtool(coins, [50,200]). The main Image Tool window has a menu bar that allows you to open a smaller Overview window containing the full image, and a Pixel Region window that displays the intensity or RGB values within small image regions:

>> imtool(coins);

>> imtool(peppers);

You can zoom in and out of the image to view it at different resolutions, and navigate around the image with the mouse. Expand the Pixel Region Tool window with the mouse to view intensity or RGB values over a larger image region.

RGB color images can be converted to gray-level images using the rgb2gray function:

>> pepper2 = rgb2gray(peppers);
>> imshow(pepper2);

As noted earlier, when displaying any gray-level image with imshow or imtool, a second input can be provided that specifies a desired minimum and maximum intensity to display as the darkest and lightest shades of gray in the display. In the following example, the minimum and maximum intensities are set to 100 and 200, respectively:

>> imshow(pepper2,[100,200]);

Again, if empty brackets are provided as the second input, imshow(pepper2,[]), then the actual minimum and maximum intensity values in the image are used for display. Beware! By default, if a second input is not provided to imshow or imtool, MATLAB assumes that an image stored in a double type matrix has values in the range [0,1], and an image stored in a uint8 type matrix has values in the range [0,255].

The windows created with imtool can be closed all at once by executing the following command:

>> imtool close all

Documentation for the Image Processing Toolbox, available online through the Help menu, provides more detailed information about how to use the Image Tool.

Throughout the course, we will use a mixture of built-in functions from the basic MATLAB system, additional functions from Toolboxes such as the Image Processing, Computer Vision, or Statistics and Machine Learning Toolboxes, and custom-built software for analyzing images. Most of the basic MATLAB facilities that you will use are introduced in this document, and other tools will be presented as needed.