{"id":4355,"date":"2021-01-05T17:31:16","date_gmt":"2021-01-05T22:31:16","guid":{"rendered":"https:\/\/blogs.mathworks.com\/steve\/?p=4355"},"modified":"2021-01-05T17:31:16","modified_gmt":"2021-01-05T22:31:16","slug":"how-imshowpair-and-imfuse-work","status":"publish","type":"post","link":"https:\/\/blogs.mathworks.com\/steve\/2021\/01\/05\/how-imshowpair-and-imfuse-work\/","title":{"rendered":"How imshowpair and imfuse work"},"content":{"rendered":"
In this post, I'll explore how <\/span>imshowpair<\/span> and <\/span>imfuse<\/span> work.<\/span><\/div>
Reason: I was curious.<\/span><\/div>
Last month, I wrote about registering several hand-held photographs together. In that post, I used <\/span>imshowpair<\/span> several times.<\/span><\/div>
Here are two of the images:<\/span><\/div>
A = imread(<\/span>'A.jpg'<\/span>);<\/span><\/span><\/div><\/div>
imshow(<\/span>'A.jpg'<\/span>)<\/span><\/span><\/div>
<\/div><\/div><\/div><\/div><\/div>
B = imread(<\/span>'B.jpg'<\/span>);<\/span><\/span><\/div><\/div>
imshow(B)<\/span><\/span><\/div>
<\/div><\/div><\/div><\/div><\/div>
And here is <\/span>imshowpair<\/span> in use:<\/span><\/div>
imshowpair(A,B)<\/span><\/span><\/div>
<\/div><\/div><\/div><\/div><\/div>
I wanted to know how this function works. Today, I thought I would share with you what I found and how I found it.<\/span><\/div>
Many functions in Image Processing Toolbox ship as MATLAB source code. When this is the case, I always start my code exploration by using the Debugger to follow the code as it executes, a step at a time. Here is the beginning of my code dive:<\/span><\/div>
\"imshowpair-screenshot-1.png\"<\/img><\/div>
The first thing I notice is that the parsed input arguments are all passed along immediately to <\/span>imfuse<\/span>. A few lines later, the results from <\/span>imfuse<\/span> are displayed using <\/span>imshow<\/span>.<\/span><\/div>
Aha! The function <\/span>imfuse<\/span> must be really how this is all computed. So, I continue to follow execution in the Debugger by stepping into <\/span>imfuse<\/span>:<\/span><\/div>
\"imfuse-screenshot-1.png\"<\/img><\/div>
The first interesting-looking step is <\/span>calculateOverlayImages<\/span>. (Note: the variables <\/span>RA<\/span> and <\/span>RB<\/span> are the <\/span>spatial references<\/span> that define where each image lies in space. Since I didn't provide this information as input arguments, these simply set up the default spatial references, where the horizontal and vertical coordinates are the same as the pixel subscripts.) This is a local function inside of <\/span>imfuse.m<\/span>. From looking over its code, I can see that it does the following:<\/span><\/div>
  1. Finds an output grid in space that is big enough to cover the location of image A as well as image B.<\/span><\/li>
  2. Sets each pixel size (width and height) in the output grid to be the smallest of the corresponding pixel sizes in A and B.<\/span><\/li>
  3. Resamples each image into that output grid.<\/span><\/li>
  4. Computes two mask images that correspond to the location of images A and B within the output grid.<\/span><\/li><\/ol>
    Continuing to follow the code execution, I see that the next interesting point is the call to the local function <\/span>local_createRGB<\/span>. Here is that function:<\/span><\/div>
    \"imfuse-screenshot-3.png\"<\/img><\/div>
    The two images are both converted to grayscale (if necessary), and then each image is scaled. The independent scaling method, which I also peeked at, simply scales each image to take up the full black-to-white dynamic range. Then, the images are converted to the <\/span>uint8<\/span> data type using the appropriate type-specific scaling as provided by <\/span>im2uint8<\/span>.<\/span><\/div>
    Finally, the now-grayscale images A and B are inserted directly into the red, green, and blue channels of the output image. By default, image A is inserted into the green channel, and image B is inserted into the red and blue channels.<\/span><\/div>
    The function <\/span>imshowpair<\/span> is convenient when you just want to display the fused result, but you don't need the result to save or for further computation. If you need the fused result, then call <\/span>imfuse<\/span> directly.<\/span><\/div>
    The functions <\/span>imshowpair<\/span> and <\/span>imfuse<\/span> support other fusion methods as well. I'll leave you with the results of the <\/span>'checkerboard'<\/span> method.<\/span><\/div>
    imshowpair(A,B,<\/span>'checkerboard'<\/span>)<\/span><\/span><\/div>
    <\/div><\/div><\/div><\/div><\/div>\r\n<\/div>