.. _remap:
Remapping
***** *** *
Goal
====
In this tutorial you will learn how to:
a. Use the OpenCV function :remap: `remap <>` to implement simple remapping routines.
Theory
======
What is remapping?
------------------
* It is the process of taking pixels from one place in the image and locating them in another position in a new image.
* To accomplish the mapping process, it might be necessary to do some interpolation for non-integer pixel locations, since there will not always be a one-to-one-pixel correspondence between source and destination images.
* We can express the remap for every pixel location :math: `(x,y)` as:
.. math ::
g(x,y) = f ( h(x,y) )
where :math: `g()` is the remapped image, :math: `f()` the source image and :math: `h(x,y)` is the mapping function that operates on :math: `(x,y)` .
* Let's think in a quick example. Imagine that we have an image :math: `I` and, say, we want to do a remap such that:
.. math ::
h(x,y) = (I.cols - x, y )
What would happen? It is easily seen that the image would flip in the :math: `x` direction. For instance, consider the input image:
.. image :: images/Remap_Tutorial_Theory_0.jpg
:alt: Original test image
:width: 120pt
:align: center
observe how the red circle changes positions with respect to x (considering :math: `x` the horizontal direction):
.. image :: images/Remap_Tutorial_Theory_1.jpg
:alt: Original test image
:width: 120pt
:align: center
* In OpenCV, the function :remap: `remap <>` offers a simple remapping implementation.
Code
====
#. **What does this program do?**
* Loads an image
* Each second, apply 1 of 4 different remapping processes to the image and display them indefinitely in a window.
* Wait for the user to exit the program
#. The tutorial code's is shown lines below. You can also download it from `here <http://code.opencv.org/projects/opencv/repository/revisions/master/raw/samples/cpp/tutorial_code/ImgTrans/Remap_Demo.cpp> `_
.. code-block :: cpp
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include <iostream>
#include <stdio.h>
using namespace cv;
/// Global variables
Mat src, dst;
Mat map_x, map_y;
char* remap_window = "Remap demo";
int ind = 0;
/// Function Headers
void update_map( void );
/**
* @function main
*/
int main( int argc, char** argv )
{
/// Load the image
src = imread( argv[1], 1 );
/// Create dst, map_x and map_y with the same size as src:
dst.create( src.size(), src.type() );
map_x.create( src.size(), CV_32FC1 );
map_y.create( src.size(), CV_32FC1 );
/// Create window
namedWindow( remap_window, CV_WINDOW_AUTOSIZE );
/// Loop
while( true )
{
/// Each 1 sec. Press ESC to exit the program
int c = waitKey( 1000 );
if( (char)c == 27 )
{ break; }
/// Update map_x & map_y. Then apply remap
update_map();
remap( src, dst, map_x, map_y, CV_INTER_LINEAR, BORDER_CONSTANT, Scalar(0,0, 0) );
/// Display results
imshow( remap_window, dst );
}
return 0;
}
/**
* @function update_map
* @brief Fill the map_x and map_y matrices with 4 types of mappings
*/
void update_map( void )
{
ind = ind%4;
for( int j = 0; j < src.rows; j++ )
{ for( int i = 0; i < src.cols; i++ )
{
switch( ind )
{
case 0:
if( i > src.cols*0.25 && i < src.cols* 0.75 && j > src.rows*0.25 && j < src.rows* 0.75 )
{
map_x.at<float>(j,i) = 2*( i - src.cols* 0.25 ) + 0.5 ;
map_y.at<float>(j,i) = 2*( j - src.rows* 0.25 ) + 0.5 ;
}
else
{ map_x.at<float>(j,i) = 0 ;
map_y.at<float>(j,i) = 0 ;
}
break;
case 1:
map_x.at<float>(j,i) = i ;
map_y.at<float>(j,i) = src.rows - j ;
break;
case 2:
map_x.at<float>(j,i) = src.cols - i ;
map_y.at<float>(j,i) = j ;
break;
case 3:
map_x.at<float>(j,i) = src.cols - i ;
map_y.at<float>(j,i) = src.rows - j ;
break;
} // end of switch
}
}
ind++;
}
Explanation
===========
#. Create some variables we will use:
.. code-block :: cpp
Mat src, dst;
Mat map_x, map_y;
char* remap_window = "Remap demo";
int ind = 0;
#. Load an image:
.. code-block :: cpp
src = imread( argv[1], 1 );
#. Create the destination image and the two mapping matrices (for x and y )
.. code-block :: cpp
dst.create( src.size(), src.type() );
map_x.create( src.size(), CV_32FC1 );
map_y.create( src.size(), CV_32FC1 );
#. Create a window to display results
.. code-block :: cpp
namedWindow( remap_window, CV_WINDOW_AUTOSIZE );
#. Establish a loop. Each 1000 ms we update our mapping matrices (*mat_x* and *mat_y* ) and apply them to our source image:
.. code-block :: cpp
while( true )
{
/// Each 1 sec. Press ESC to exit the program
int c = waitKey( 1000 );
if( (char)c == 27 )
{ break; }
/// Update map_x & map_y. Then apply remap
update_map();
remap( src, dst, map_x, map_y, CV_INTER_LINEAR, BORDER_CONSTANT, Scalar(0,0, 0) );
/// Display results
imshow( remap_window, dst );
}
The function that applies the remapping is :remap: `remap <>` . We give the following arguments:
* **src** : Source image
* **dst** : Destination image of same size as *src*
* **map_x** : The mapping function in the x direction. It is equivalent to the first component of :math: `h(i,j)`
* **map_y** : Same as above, but in y direction. Note that *map_y* and *map_x* are both of the same size as *src*
* **CV_INTER_LINEAR** : The type of interpolation to use for non-integer pixels. This is by default.
* **BORDER_CONSTANT** : Default
How do we update our mapping matrices *mat_x* and *mat_y* ? Go on reading:
#. **Updating the mapping matrices:** We are going to perform 4 different mappings:
a. Reduce the picture to half its size and will display it in the middle:
.. math ::
h(i,j) = ( 2*i - src.cols/2 + 0.5, 2* j - src.rows/2 + 0.5)
for all pairs :math: `(i,j)` such that: :math: `\dfrac{src.cols}{4}<i<\dfrac{3 \cdot src.cols}{4}` and :math: `\dfrac{src.rows}{4}<j<\dfrac{3 \cdot src.rows}{4}`
b. Turn the image upside down: :math: `h( i, j ) = (i, src.rows - j)`
c. Reflect the image from left to right: :math: `h(i,j) = ( src.cols - i, j )`
d. Combination of b and c: :math: `h(i,j) = ( src.cols - i, src.rows - j )`
This is expressed in the following snippet. Here, *map_x* represents the first coordinate of *h(i,j)* and *map_y* the second coordinate.
.. code-block :: cpp
for( int j = 0; j < src.rows; j++ )
{ for( int i = 0; i < src.cols; i++ )
{
switch( ind )
{
case 0:
if( i > src.cols*0.25 && i < src.cols* 0.75 && j > src.rows*0.25 && j < src.rows* 0.75 )
{
map_x.at<float>(j,i) = 2*( i - src.cols* 0.25 ) + 0.5 ;
map_y.at<float>(j,i) = 2*( j - src.rows* 0.25 ) + 0.5 ;
}
else
{ map_x.at<float>(j,i) = 0 ;
map_y.at<float>(j,i) = 0 ;
}
break;
case 1:
map_x.at<float>(j,i) = i ;
map_y.at<float>(j,i) = src.rows - j ;
break;
case 2:
map_x.at<float>(j,i) = src.cols - i ;
map_y.at<float>(j,i) = j ;
break;
case 3:
map_x.at<float>(j,i) = src.cols - i ;
map_y.at<float>(j,i) = src.rows - j ;
break;
} // end of switch
}
}
ind++;
}
Result
======
#. After compiling the code above, you can execute it giving as argument an image path. For instance, by using the following image:
.. image :: images/Remap_Tutorial_Original_Image.jpg
:alt: Original test image
:width: 250pt
:align: center
#. This is the result of reducing it to half the size and centering it:
.. image :: images/Remap_Tutorial_Result_0.jpg
:alt: Result 0 for remapping
:width: 250pt
:align: center
#. Turning it upside down:
.. image :: images/Remap_Tutorial_Result_1.jpg
:alt: Result 0 for remapping
:width: 250pt
:align: center
#. Reflecting it in the x direction:
.. image :: images/Remap_Tutorial_Result_2.jpg
:alt: Result 0 for remapping
:width: 250pt
:align: center
#. Reflecting it in both directions:
.. image :: images/Remap_Tutorial_Result_3.jpg
:alt: Result 0 for remapping
:width: 250pt
:align: center
