{"id":192,"date":"2008-01-28T10:46:08","date_gmt":"2008-01-28T15:46:08","guid":{"rendered":"https:\/\/blogs.mathworks.com\/steve\/2008\/01\/28\/logical-indexing\/"},"modified":"2019-10-24T13:53:27","modified_gmt":"2019-10-24T17:53:27","slug":"logical-indexing","status":"publish","type":"post","link":"https:\/\/blogs.mathworks.com\/steve\/2008\/01\/28\/logical-indexing\/","title":{"rendered":"Logical indexing"},"content":{"rendered":"
\r\n

This is the first post in a short series on index techniques that are particularly useful for image processing in MATLAB.\r\n I'll start with logical indexing today. Later I'll cover linear indexing, and then a technique I like to call neighbor indexing.\r\n <\/p>\r\n

Every MATLAB user is familiar with ordinary matrix indexing notation.<\/p>

A = magic(5)<\/pre>
\r\nA =\r\n\r\n    17    24     1     8    15\r\n    23     5     7    14    16\r\n     4     6    13    20    22\r\n    10    12    19    21     3\r\n    11    18    25     2     9\r\n\r\n<\/pre>
A(2,3)<\/pre>
\r\nans =\r\n\r\n     7\r\n\r\n<\/pre>
A(2,3)<\/tt> extracts the 2nd row, 3rd column of the matrix A<\/tt>. You can extract more than one row and column at the same time:\r\n   <\/p>
A(2:4, 3:5)<\/pre>
\r\nans =\r\n\r\n     7    14    16\r\n    13    20    22\r\n    19    21     3\r\n\r\n<\/pre>
When an indexing expression appears on the left-hand side of the equals sign, it's assignment:<\/p>
A(5,5) = 100<\/pre>
\r\nA =\r\n\r\n    17    24     1     8    15\r\n    23     5     7    14    16\r\n     4     6    13    20    22\r\n    10    12    19    21     3\r\n    11    18    25     2   100\r\n\r\n<\/pre>
About every 13.6 days, someone asks this question on comp.soft-sys.matlab<\/a>:\r\n   <\/p>
 How do I replace all the NaNs in my matrix B with 0s?<\/pre>
This is generally followed 4.8 minutes later with this reply from one of the newsgroup regulars:<\/p>
 B(isnan(B)) = 0;<\/pre>
For example:<\/p>
B = rand(3,3);\r\nB(2, 2:3) = NaN<\/pre>
\r\nB =\r\n\r\n    0.5470    0.1890    0.3685\r\n    0.2963       NaN       NaN\r\n    0.7447    0.1835    0.7802\r\n\r\n<\/pre>
Replace the NaNs with zeros:<\/p>
B(isnan(B)) = 0<\/pre>
\r\nB =\r\n\r\n    0.5470    0.1890    0.3685\r\n    0.2963         0         0\r\n    0.7447    0.1835    0.7802\r\n\r\n<\/pre>
The expression<\/p>
 B(isnan(B))<\/pre>
is an example of logical indexing<\/i>.  Logical indexing is a compact and expressive notation that's very useful for many image processing operations.\r\n   <\/p>\r\n   
Let's talk about the basic rules of logical indexing, and then we'll reexamine the expression B(isnan(B))<\/tt>.\r\n   <\/p>\r\n   
If C<\/tt> and D<\/tt> are matrices, then C(D)<\/tt> is a logical indexing expression if C<\/tt> and D<\/tt> are the same size, and D<\/tt> is a logical<\/i> matrix.\r\n   <\/p>\r\n   
\"Logical\" is one of the builtin types, or classes, of MATLAB matrices.  Relational operators, such as ==<\/tt> or ><\/tt>, produce logical matrices.\r\n   <\/p>
C = hilb(4)<\/pre>
\r\nC =\r\n\r\n    1.0000    0.5000    0.3333    0.2500\r\n    0.5000    0.3333    0.2500    0.2000\r\n    0.3333    0.2500    0.2000    0.1667\r\n    0.2500    0.2000    0.1667    0.1429\r\n\r\n<\/pre>
D = C > 0.4<\/pre>
\r\nD =\r\n\r\n     1     1     0     0\r\n     1     0     0     0\r\n     0     0     0     0\r\n     0     0     0     0\r\n\r\n<\/pre>
whos D<\/span><\/pre>
  Name      Size            Bytes  Class      Attributes\r\n\r\n  D         4x4                16  logical              \r\n\r\n<\/pre>
You can see from the output of whos that the class of the variable D<\/tt> is logical<\/i>.  The logical indexing expression C(D)<\/tt> extracts all the values of C<\/tt> corresponding to nonzero values of D<\/tt> and returns them as a column vector.\r\n   <\/p>
C(D)<\/pre>
\r\nans =\r\n\r\n    1.0000\r\n    0.5000\r\n    0.5000\r\n\r\n<\/pre>
Now we know enough to break down the B(isnan(B)) example to see how it works.<\/p>
B = rand(3,3);\r\nB(2, 2:3) = NaN;\r\n\r\nnan_locations = isnan(B)<\/pre>
\r\nnan_locations =\r\n\r\n     0     0     0\r\n     0     1     1\r\n     0     0     0\r\n\r\n<\/pre>
whos nan_locations<\/span><\/pre>
  Name               Size            Bytes  Class      Attributes\r\n\r\n  nan_locations      3x3                 9  logical              \r\n\r\n<\/pre>
B(nan_locations)<\/pre>
\r\nans =\r\n\r\n   NaN\r\n   NaN\r\n\r\n<\/pre>
B(nan_locations) = 0<\/pre>
\r\nB =\r\n\r\n    0.0811    0.4868    0.3063\r\n    0.9294         0         0\r\n    0.7757    0.4468    0.5108\r\n\r\n<\/pre>
Functions in the Image Processing Toolbox, as well as the MATLAB functions imread<\/tt> and imwrite<\/tt>, follow the convention that logical matrices are treated as binary (black and white) images.  For example, when you read\r\n      a 1-bit image file using imread, it returns a logical matrix:\r\n   <\/p>
bw = imread('text.png'<\/span>);\r\nwhos bw<\/span><\/pre>
  Name        Size             Bytes  Class      Attributes\r\n\r\n  bw        256x256            65536  logical              \r\n\r\n<\/pre>
This convention, together with logical indexing, makes it very convenient and expressive to use binary images as pixel masks\r\n      for extracting or operating on sets of pixels.\r\n   <\/p>\r\n   
Here's an example showing how to use logical indexing to compute the histogram of a subset of image pixels. Specifically,\r\n      given a gray-scale image and a binary segmentation, compute the histogram of just the foreground pixels in the image.\r\n   <\/p>\r\n   
Here's our original image:<\/p>
I = imread('rice.png'<\/span>);\r\nimshow(I)<\/pre> 
Here's a segmentation result (computed and saved earlier), represented as a binary image:<\/p>
url = 'https:\/\/blogs.mathworks.com\/images\/steve\/192\/rice_bw.png'<\/span>;\r\nbw = imread(url);\r\nimshow(bw)<\/pre> 
Now use the segmentation result as a logical index into the original image to extract the foreground pixel values.<\/p>
foreground_pixels = I(bw);\r\nwhos foreground_pixels<\/span><\/pre>
  Name                       Size            Bytes  Class    Attributes\r\n\r\n  foreground_pixels      17597x1             17597  uint8              \r\n\r\n<\/pre>
Finally, compute the histogram of the foreground pixels.<\/p>
imhist(foreground_pixels)<\/pre> 
Or use logical indexing with the complement of the segmentation result to compute the histogram of the background pixels.<\/p>
imhist(I(~bw))<\/pre>