Use of OpenCV polar transformation function warppolar

OPenCV edition ：4.4

IDE：VS2019

Function description

Remap the image to polar or semi logarithmic polar space , This function is used to realize the polar transformation of the image .

Use the following transformations to convert images ：
$$dst(\rho ,\varphi )=src(x,y)$$
here ：
$$\begin{array}{l}\vec{I}=(x-center.x,y-center.y)\\ \varphi =Kangle\cdot \text{angle}(\vec{I})\\ \rho =\{\begin{array}{cc}Klin\cdot \text{magnitude}(\vec{I})& default\\ Klog\cdot lo{g}_e(\text{magnitude}(\vec{I}))& ifsemilog\end{array}\end{array}$$

also ：
$$\begin{array}{l}Kangle=dsize.height/2\Pi \\ Klin=dsize.width/maxRadius\\ Klog=dsize.width/lo{g}_e(maxRadius)\end{array}$$

Linear and semilogarithmic mapping
Polar mapping can be linear or semilogarithmic , add to WarpPolarMode One of them arrives flags To determine the polar mapping mode ,.
Linear is the default mode .
Semilogarithmic mapping simulates human “ Fovea ” Vision , Allow in sight （ Central vision ） It has a very high sharpness , The sharpness of the surrounding vision is smaller .

dsize The option to :

• If dsize Both values in <=0（ Default ）, The target image will have （ almost ） The same source boundary circle area
  $$\begin{array}{l}dsize.area\leftarrow (maxRadiu{s}^2\cdot \Pi )\\ dsize.width=\text{cvRound}(maxRadius)\\ dsize.height=\text{cvRound}(maxRadius\cdot \Pi )\end{array}$$
• If it's just dsize.height <= 0, The target image area will be proportional to the boundary circle area Kx * Kx: The zoom .
  $$\begin{array}{l}dsize.height=\text{cvRound}(dsize.width\cdot \Pi )\end{array}$$
• If dsize The values of all members are > 0, The target image will have a given size , Therefore, the area of the boundary circle will be scaled to dsize.

Reverse mapping

You can add WARP_INVERSE_MAP To flags Get reverse mapping .

 //  Direct transformation 
 warpPolar(src, lin_polar_img, Size(),center, maxRadius, flags);                     
 //  Linear polar coordinates 
 warpPolar(src, log_polar_img, Size(),center, maxRadius, flags + WARP_POLAR_LOG);  
 //  Semi logarithmic polar coordinates 
 //  Reverse transformation 
 warpPolar(lin_polar_img, recovered_lin_polar_img, src.size(), center, maxRadius, flags + WARP_INVERSE_MAP);
 warpPolar(log_polar_img, recovered_log_polar, src.size(), center, maxRadius, flags + WARP_POLAR_LOG + WARP_INVERSE_MAP);

In programming , adopt （ρ,φ）−>（x,y） Calculate the original coordinates from polar coordinates ：

 double angleRad, magnitude;
 double Kangle = dst.rows / CV_2PI;
 angleRad = phi / Kangle;
 if (flags & WARP_POLAR_LOG)
 {
    
     double Klog = dst.cols / std::log(maxRadius);
     magnitude = std::exp(rho / Klog);
 }
 else
 {
    
     double Klin = dst.cols / maxRadius;
     magnitude = rho / Klin;
 }
 int x = cvRound(center.x + magnitude * cos(angleRad));
 int y = cvRound(center.y + magnitude * sin(angleRad));

The function prototype

void cv::warpPolar	(	InputArray 	src,
	OutputArray 	dst,
	Size 	dsize,
	Point2f 	center,
	double 	maxRadius,
	int 	flags 
)		

Parameters

• src The source image .
• dst Target image , The type and src identical .
• dsize Target image size (see description for valid options).
• center Conversion center The transformation center.
• maxRadius The radius of the boundary circle to be transformed , It also determines the inverse magnitude proportional parameter .
  flags A combination of interpolation methods , InterpolationFlags + WarpPolarMode.
• add to WARP_POLAR_LINEAR Select linear polar mapping ( Default )
• add to WARP_POLAR_LOG Select semi logarithmic polar mapping .
• add to WARP_INVERSE_MAP Select reverse mapping

Note

• This function does not support in place conversion .
• To calculate amplitude and angle , For internal use cartToPolar, Therefore, the measurement range of the angle is 0 To 360 degree , The accuracy is about 0.3 degree .
• This function uses remap. Due to the limitations of the current implementation , The size of input and output images should be less than 32767x32767.

See also
cv::remap

Sample code

#include <iostream>
#include <opencv2/opencv.hpp>
#include <vector>
using namespace cv;
int main(int argc, char** argv)
{
    
    VideoCapture capture;
    Mat log_polar_img, lin_polar_img, recovered_log_polar, recovered_lin_polar_img;
    CommandLineParser parser(argc, argv, "{@input|0| camera device number or video file path}");
    parser.about("\nThis program illustrates usage of Linear-Polar and Log-Polar image transforms\n");
    parser.printMessage();
    std::string arg = parser.get<std::string>("@input");
    //if (arg.size() == 1 && isdigit(arg[0]))
    // capture.open(arg[0] - '0');
    //else
    // capture.open(samples::findFileOrKeep(arg));
    capture.open("D:\\OpenCVtest\\video1.mp4");

    if (!capture.isOpened())
    {
    
        fprintf(stderr, "Could not initialize capturing...\n");
        return -1;
    }
    namedWindow("Linear-Polar", WINDOW_AUTOSIZE);
    namedWindow("Log-Polar", WINDOW_AUTOSIZE);
    namedWindow("Recovered Linear-Polar", WINDOW_AUTOSIZE);
    namedWindow("Recovered Log-Polar", WINDOW_AUTOSIZE);
    moveWindow("Linear-Polar", 20, 20);
    moveWindow("Log-Polar", 700, 20);
    moveWindow("Recovered Linear-Polar", 20, 350);
    moveWindow("Recovered Log-Polar", 700, 350);
    int flags = INTER_LINEAR + WARP_FILL_OUTLIERS;
    Mat src;
    for (;;)
    {
    
        capture >> src;
        if (src.empty())
            break;
        Point2f center((float)src.cols / 2, (float)src.rows / 2);
        double maxRadius = 0.7 * min(center.y, center.x);
#if 0 //deprecated
        double M = frame.cols / log(maxRadius);
        logPolar(frame, log_polar_img, center, M, flags);
        linearPolar(frame, lin_polar_img, center, maxRadius, flags);
        logPolar(log_polar_img, recovered_log_polar, center, M, flags + WARP_INVERSE_MAP);
        linearPolar(lin_polar_img, recovered_lin_polar_img, center, maxRadius, flags + WARP_INVERSE_MAP);
#endif
        // direct transform
        warpPolar(src, lin_polar_img, Size(), center, maxRadius, flags);                     // linear Polar
        warpPolar(src, log_polar_img, Size(), center, maxRadius, flags + WARP_POLAR_LOG);    // semilog Polar
        // inverse transform
        warpPolar(lin_polar_img, recovered_lin_polar_img, src.size(), center, maxRadius, flags + WARP_INVERSE_MAP);
        warpPolar(log_polar_img, recovered_log_polar, src.size(), center, maxRadius, flags + WARP_POLAR_LOG + WARP_INVERSE_MAP);
        // Below is the reverse transformation for (rho, phi)->(x, y) :
        Mat dst;
        if (flags & WARP_POLAR_LOG)
            dst = log_polar_img;
        else
            dst = lin_polar_img;
        //get a point from the polar image
        int rho = cvRound(dst.cols * 0.75);
        int phi = cvRound(dst.rows / 2.0);
        double angleRad, magnitude;
        double Kangle = dst.rows / CV_2PI;
        angleRad = phi / Kangle;
        if (flags & WARP_POLAR_LOG)
        {
    
            double Klog = dst.cols / std::log(maxRadius);
            magnitude = std::exp(rho / Klog);
        }
        else
        {
    
            double Klin = dst.cols / maxRadius;
            magnitude = rho / Klin;
        }
        int x = cvRound(center.x + magnitude * cos(angleRad));
        int y = cvRound(center.y + magnitude * sin(angleRad));
        drawMarker(src, Point(x, y), Scalar(0, 255, 0));
        drawMarker(dst, Point(rho, phi), Scalar(0, 255, 0));
        imshow("Src frame", src);
        imshow("Log-Polar", log_polar_img);
        imshow("Linear-Polar", lin_polar_img);
        imshow("Recovered Linear-Polar", recovered_lin_polar_img);
        imshow("Recovered Log-Polar", recovered_log_polar);
        if (waitKey(10) >= 0)
            break;
    }
    return 0;
}

Running results

Original picture ：

Linear polar mapping ：

Semilogarithmic polar mapping

Restored linear polar mapping ：

Restored semilog polar mapping