External module "types/opencv/imgproc_transform"

$\\texttt{(CV_32FC1, CV_32FC1)} \\rightarrow \\texttt{(CV_16SC2, CV_16UC1)}$. This is the most frequently used conversion operation, in which the original floating-point maps (see remap ) are converted to a more compact and much faster fixed-point representation. The first output array contains the rounded coordinates and the second array (created only when nninterpolation=false ) contains indices in the interpolation tables. $\\texttt{(CV_32FC2)} \\rightarrow \\texttt{(CV_16SC2, CV_16UC1)}$. The same as above but the original maps are stored in one 2-channel matrix. Reverse conversion. Obviously, the reconstructed floating-point maps will not be exactly the same as the originals.

[remap], [undistort], [initUndistortRectifyMap]

\\[\\begin{bmatrix} x'_i \\\\ y'_i \\end{bmatrix} = \\texttt{map_matrix} \\cdot \\begin{bmatrix} x_i \\\\ y_i \\\\ 1 \\end{bmatrix}\\]

where

\\[dst(i)=(x'_i,y'_i), src(i)=(x_i, y_i), i=0,1,2\\]

[warpAffine], [transform]

\\[\\begin{bmatrix} t_i x'_i \\\\ t_i y'_i \\\\ t_i \\end{bmatrix} = \\texttt{map_matrix} \\cdot \\begin{bmatrix} x_i \\\\ y_i \\\\ 1 \\end{bmatrix}\\]

where

\\[dst(i)=(x'_i,y'_i), src(i)=(x_i, y_i), i=0,1,2,3\\]

[findHomography], [warpPerspective], [perspectiveTransform]

`\[patch(x, y) = src(x + \texttt{center.x} - ( \texttt{dst.cols} -1)*0.5, y + \texttt{center.y}

• ( \texttt{dst.rows} -1)*0.5)\]`

where the values of the pixels at non-integer coordinates are retrieved using bilinear interpolation. Every channel of multi-channel images is processed independently. Also the image should be a single channel or three channel image. While the center of the rectangle must be inside the image, parts of the rectangle may be outside.

[warpAffine], [warpPerspective]

\\[\\begin{bmatrix} \\alpha & \\beta & (1- \\alpha ) \\cdot \\texttt{center.x} - \\beta \\cdot \\texttt{center.y} \\\\ - \\beta & \\alpha & \\beta \\cdot \\texttt{center.x} + (1- \\alpha ) \\cdot \\texttt{center.y} \\end{bmatrix}\\]

where

\\[\\begin{array}{l} \\alpha = \\texttt{scale} \\cdot \\cos \\texttt{angle} , \\\\ \\beta = \\texttt{scale} \\cdot \\sin \\texttt{angle} \\end{array}\\]

The transformation maps the rotation center to itself. If this is not the target, adjust the shift.

[getAffineTransform], [warpAffine], [transform]

\\[\\begin{bmatrix} a_{11} & a_{12} & b_1 \\\\ a_{21} & a_{22} & b_2 \\end{bmatrix}\\]

The result is also a $2 \\times 3$ matrix of the same type as M.

\\[\\texttt{dst} (x,y) = \\texttt{src} (map_x(x,y),map_y(x,y))\\]

where values of pixels with non-integer coordinates are computed using one of available interpolation methods. $map_x$ and $map_y$ can be encoded as separate floating-point maps in $map_1$ and $map_2$ respectively, or interleaved floating-point maps of $(x,y)$ in $map_1$, or fixed-point maps created by using convertMaps. The reason you might want to convert from floating to fixed-point representations of a map is that they can yield much faster (2x) remapping operations. In the converted case, $map_1$ contains pairs (cvFloor(x), cvFloor(y)) and $map_2$ contains indices in a table of interpolation coefficients.

This function cannot operate in-place.

Due to current implementation limitations the size of an input and output images should be less than 32767x32767.

// explicitly specify dsize=dst.size(); fx and fy will be computed from that.
resize(src, dst, dst.size(), 0, 0, interpolation);

If you want to decimate the image by factor of 2 in each direction, you can call the function this way:

// specify fx and fy and let the function compute the destination image size.
resize(src, dst, Size(), 0.5, 0.5, interpolation);

To shrink an image, it will generally look best with [INTER_AREA] interpolation, whereas to enlarge an image, it will generally look best with c::INTER_CUBIC (slow) or [INTER_LINEAR] (faster but still looks OK).

[warpAffine], [warpPerspective], [remap]

\\[\\texttt{dst} (x,y) = \\texttt{src} ( \\texttt{M} _{11} x + \\texttt{M} _{12} y + \\texttt{M} _{13}, \\texttt{M} _{21} x + \\texttt{M} _{22} y + \\texttt{M} _{23})\\]

when the flag [WARP_INVERSE_MAP] is set. Otherwise, the transformation is first inverted with [invertAffineTransform] and then put in the formula above instead of M. The function cannot operate in-place.

[warpPerspective], [resize], [remap], [getRectSubPix], [transform]

\\[\\texttt{dst} (x,y) = \\texttt{src} \\left ( \\frac{M_{11} x + M_{12} y + M_{13}}{M_{31} x + M_{32} y + M_{33}} , \\frac{M_{21} x + M_{22} y + M_{23}}{M_{31} x + M_{32} y + M_{33}} \\right )\\]

when the flag [WARP_INVERSE_MAP] is set. Otherwise, the transformation is first inverted with invert and then put in the formula above instead of M. The function cannot operate in-place.

[warpAffine], [resize], [remap], [getRectSubPix], [perspectiveTransform]

where \\[ \\begin{array}{l} \\vec{I} = (x - center.x, \\;y - center.y) \\\\ \\phi = Kangle \\cdot \\texttt{angle} (\\vec{I}) \\\\ \\rho = \\left\\{\\begin{matrix} Klin \\cdot \\texttt{magnitude} (\\vec{I}) & default \\\\ Klog \\cdot log_e(\\texttt{magnitude} (\\vec{I})) & if \\; semilog \\\\ \\end{matrix}\\right. \\end{array} \\]

and \\[ \\begin{array}{l} Kangle = dsize.height / 2\\Pi \\\\ Klin = dsize.width / maxRadius \\\\ Klog = dsize.width / log_e(maxRadius) \\\\ \\end{array} \\]

Polar mapping can be linear or semi-log. Add one of [WarpPolarMode] to flags to specify the polar mapping mode.

Linear is the default mode.

The semilog mapping emulates the human "foveal" vision that permit very high acuity on the line of sight (central vision) in contrast to peripheral vision where acuity is minor.

if both values in dsize <=0 (default), the destination image will have (almost) same area of source bounding circle: \\[\\begin{array}{l} dsize.area \\leftarrow (maxRadius^2 \\cdot \\Pi) \\\\ dsize.width = \\texttt{cvRound}(maxRadius) \\\\ dsize.height = \\texttt{cvRound}(maxRadius \\cdot \\Pi) \\\\ \\end{array}\\] if only dsize.height <= 0, the destination image area will be proportional to the bounding circle area but scaled by Kx * Kx: \\[\\begin{array}{l} dsize.height = \\texttt{cvRound}(dsize.width \\cdot \\Pi) \\\\ \\end{array} \\] if both values in dsize > 0, the destination image will have the given size therefore the area of the bounding circle will be scaled to dsize.

You can get reverse mapping adding [WARP_INVERSE_MAP] to flags

        // 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);

In addiction, to calculate the original coordinate from a polar mapped coordinate $(rho, phi)->(x, y)$:

        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 can not operate in-place. To calculate magnitude and angle in degrees [cartToPolar] is used internally thus angles are measured from 0 to 360 with accuracy about 0.3 degrees. This function uses [remap]. Due to current implementation limitations the size of an input and output images should be less than 32767x32767.

[cv::remap]