OpenCV 中的 warpAffine

客官°小女子只卖身不卖艺 2023-01-13 10:25 408阅读 0赞

[warpAffine][] 是图像处理中比较常见的一种变换，可以将图像校正或对齐。

对于线性插值方式，OpenCV 首先将坐标映射保存成两张图，然后调用 [remap][] 函数。第二步是比较耗时的部分，并且 [warpPerspective][] 亦采用此处理。

[remap][] 通过构建查找表来存储系数乘积，这样减少了乘法运算次数。

由于篇幅过长，将文章分成 [warpAffine][] 和 [remap][] 两部分。

warpAffine

remap

WarpPerspective

## [cv::warpAffine][cv_warpAffine] ##

cv::warpAffine

hal::warpAffine

检查输入通道数量以及插值类型。  
如果目的矩阵为空则创建内存，如果是原地操作则复制一份源数据。

CV_INSTRUMENT_REGION();
    
        int interpolation = flags & INTER_MAX;
        CV_Assert( _src.channels() <= 4 || (interpolation != INTER_LANCZOS4 &&
                                            interpolation != INTER_CUBIC) );
    
        CV_OCL_RUN(_src.dims() <= 2 && _dst.isUMat() &&
                   _src.cols() <= SHRT_MAX && _src.rows() <= SHRT_MAX,
                   ocl_warpTransform_cols4(_src, _dst, _M0, dsize, flags, borderType,
                                           borderValue, OCL_OP_AFFINE))
    
        CV_OCL_RUN(_src.dims() <= 2 && _dst.isUMat(),
                   ocl_warpTransform(_src, _dst, _M0, dsize, flags, borderType,
                                     borderValue, OCL_OP_AFFINE))
    
        Mat src = _src.getMat(), M0 = _M0.getMat();
        _dst.create( dsize.empty() ? src.size() : dsize, src.type() );
        Mat dst = _dst.getMat();
        CV_Assert( src.cols > 0 && src.rows > 0 );
        if( dst.data == src.data )
            src = src.clone();

如果未设置`WARP_INVERSE_MAP`，则对参数矩阵`M`求逆。

double M[6] = {
        0};
        Mat matM(2, 3, CV_64F, M);
        if( interpolation == INTER_AREA )
            interpolation = INTER_LINEAR;
    
        CV_Assert( (M0.type() == CV_32F || M0.type() == CV_64F) && M0.rows == 2 && M0.cols == 3 );
        M0.convertTo(matM, matM.type());
    
        if( !(flags & WARP_INVERSE_MAP) )
        {
        
            double D = M[0]*M[4] - M[1]*M[3];
            D = D != 0 ? 1./D : 0;
            double A11 = M[4]*D, A22=M[0]*D;
            M[0] = A11; M[1] *= -D;
            M[3] *= -D; M[4] = A22;
            double b1 = -M[0]*M[2] - M[1]*M[5];
            double b2 = -M[3]*M[2] - M[4]*M[5];
            M[2] = b1; M[5] = b2;
        }

#if defined (HAVE_IPP) && IPP_VERSION_X100 >= 810 && !IPP_DISABLE_WARPAFFINE
        CV_IPP_CHECK()
        {
        
            int type = src.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
            if( ( depth == CV_8U || depth == CV_16U || depth == CV_32F ) &&
               ( cn == 1 || cn == 3 || cn == 4 ) &&
               ( interpolation == INTER_NEAREST || interpolation == INTER_LINEAR || interpolation == INTER_CUBIC) &&
               ( borderType == cv::BORDER_TRANSPARENT || borderType == cv::BORDER_CONSTANT) )
            {
        
                ippiWarpAffineBackFunc ippFunc = 0;
                if ((flags & WARP_INVERSE_MAP) != 0)
                {
        
                    ippFunc =
                    type == CV_8UC1 ? (ippiWarpAffineBackFunc)ippiWarpAffineBack_8u_C1R :
                    type == CV_8UC3 ? (ippiWarpAffineBackFunc)ippiWarpAffineBack_8u_C3R :
                    type == CV_8UC4 ? (ippiWarpAffineBackFunc)ippiWarpAffineBack_8u_C4R :
                    type == CV_16UC1 ? (ippiWarpAffineBackFunc)ippiWarpAffineBack_16u_C1R :
                    type == CV_16UC3 ? (ippiWarpAffineBackFunc)ippiWarpAffineBack_16u_C3R :
                    type == CV_16UC4 ? (ippiWarpAffineBackFunc)ippiWarpAffineBack_16u_C4R :
                    type == CV_32FC1 ? (ippiWarpAffineBackFunc)ippiWarpAffineBack_32f_C1R :
                    type == CV_32FC3 ? (ippiWarpAffineBackFunc)ippiWarpAffineBack_32f_C3R :
                    type == CV_32FC4 ? (ippiWarpAffineBackFunc)ippiWarpAffineBack_32f_C4R :
                    0;
                }
                else
                {
        
                    ippFunc =
                    type == CV_8UC1 ? (ippiWarpAffineBackFunc)ippiWarpAffine_8u_C1R :
                    type == CV_8UC3 ? (ippiWarpAffineBackFunc)ippiWarpAffine_8u_C3R :
                    type == CV_8UC4 ? (ippiWarpAffineBackFunc)ippiWarpAffine_8u_C4R :
                    type == CV_16UC1 ? (ippiWarpAffineBackFunc)ippiWarpAffine_16u_C1R :
                    type == CV_16UC3 ? (ippiWarpAffineBackFunc)ippiWarpAffine_16u_C3R :
                    type == CV_16UC4 ? (ippiWarpAffineBackFunc)ippiWarpAffine_16u_C4R :
                    type == CV_32FC1 ? (ippiWarpAffineBackFunc)ippiWarpAffine_32f_C1R :
                    type == CV_32FC3 ? (ippiWarpAffineBackFunc)ippiWarpAffine_32f_C3R :
                    type == CV_32FC4 ? (ippiWarpAffineBackFunc)ippiWarpAffine_32f_C4R :
                    0;
                }
                int mode =
                interpolation == INTER_LINEAR ? IPPI_INTER_LINEAR :
                interpolation == INTER_NEAREST ? IPPI_INTER_NN :
                interpolation == INTER_CUBIC ? IPPI_INTER_CUBIC :
                0;
                CV_Assert(mode && ippFunc);
    
                double coeffs[2][3];
                for( int i = 0; i < 2; i++ )
                    for( int j = 0; j < 3; j++ )
                        coeffs[i][j] = matM.at<double>(i, j);
    
                bool ok;
                Range range(0, dst.rows);
                IPPWarpAffineInvoker invoker(src, dst, coeffs, mode, borderType, borderValue, ippFunc, &ok);
                parallel_for_(range, invoker, dst.total()/(double)(1<<16));
                if( ok )
                {
        
                    CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
                    return;
                }
                setIppErrorStatus();
            }
        }
    #endif

调用命名空间中的 [hal::warpAffine][hal_warpAffine] 函数，各参数独立传入。

hal::warpAffine(src.type(), src.data, src.step, src.cols, src.rows, dst.data, dst.step, dst.cols, dst.rows,
                        M, interpolation, borderType, borderValue.val);

## [hal::warpAffine][hal_warpAffine] ##

hal::warpAffine

parallel\_for\_

WarpAffineInvoker

d s t ( x , y ) = s r c ( M 11 x + M 12 y + M 13 , M 21 x + M 22 y + M 23 ) \\mathrm\{dst\}(x,y)=\\mathrm\{src\}(M\_\{11\}x+M\_\{12\}y+M\_\{13\}, M\_\{21\}x+M\_\{22\}y+M\_\{23\}) dst(x,y)=src(M11x\+M12y\+M13,M21x\+M22y\+M23)

OpenCV 屏蔽了 Carotene 中的实现。  
根据描述构建出源和目的矩阵。  
[INTER\_BITS][INTER_BITS] 为5，即插值所用比特数。  
预先计算行元素变换系数，`adelta`为  M 11 x M\_\{11\}x M11x，`bdelta`为  M 21 x M\_\{21\}x M21x。

CALL_HAL(warpAffine, cv_hal_warpAffine, src_type, src_data, src_step, src_width, src_height, dst_data, dst_step, dst_width, dst_height, M, interpolation, borderType, borderValue);
    
        Mat src(Size(src_width, src_height), src_type, const_cast<uchar*>(src_data), src_step);
        Mat dst(Size(dst_width, dst_height), src_type, dst_data, dst_step);
    
        int x;
        AutoBuffer<int> _abdelta(dst.cols*2);
        int* adelta = &_abdelta[0], *bdelta = adelta + dst.cols;
        const int AB_BITS = MAX(10, (int)INTER_BITS);
        const int AB_SCALE = 1 << AB_BITS;
    
        for( x = 0; x < dst.cols; x++ )
        {
        
            adelta[x] = saturate_cast<int>(M[0]*x*AB_SCALE);
            bdelta[x] = saturate_cast<int>(M[3]*x*AB_SCALE);
        }

创建调用者 [WarpAffineInvoker][]，[parallel\_for\_][parallel_for] 函数并行调用。

Range range(0, dst.rows);
        WarpAffineInvoker invoker(src, dst, interpolation, borderType,
                                  Scalar(borderValue[0], borderValue[1], borderValue[2], borderValue[3]),
                                  adelta, bdelta, M);
        parallel_for_(range, invoker, dst.total()/(double)(1<<16));

## [WarpAffineInvoker][] ##

WarpAffineInvoker

ParallelLoopBody

public:
        WarpAffineInvoker(const Mat &_src, Mat &_dst, int _interpolation, int _borderType,
                          const Scalar &_borderValue, int *_adelta, int *_bdelta, const double *_M) :
            ParallelLoopBody(), src(_src), dst(_dst), interpolation(_interpolation),
            borderType(_borderType), borderValue(_borderValue), adelta(_adelta), bdelta(_bdelta),
            M(_M)
        {
        
        }

### [operator()][operator] ###

处理操作符函数。

`BLOCK_SZ`指定分块大小。  
`XY`存储源图上对应的坐标，`A`为辅助系数。  
[INTER\_BITS][INTER_BITS] 为5。  
[INTER\_TAB\_SIZE][INTER_TAB_SIZE] 为  2 I N T E R \_ B I T S = 32 2^\{\\mathrm\{INTER\\\_BITS\}\}=32 2INTER\_BITS=32，这样双线性插值表大小为32x32x4。  
`AB_SCALE`为  2 10 2^\{10\} 210。这样计算结果的 10.6 的格式存储。  
处理区域为`BLOCK_SZ/2`行、`BLOCK_SZ*2`列的矩形。为什么？

virtual void operator() (const Range& range) const CV_OVERRIDE
        {
        
            const int BLOCK_SZ = 64;
            AutoBuffer<short, 0> __XY(BLOCK_SZ * BLOCK_SZ * 2), __A(BLOCK_SZ * BLOCK_SZ);
            short *XY = __XY.data(), *A = __A.data();
            const int AB_BITS = MAX(10, (int)INTER_BITS);
            const int AB_SCALE = 1 << AB_BITS;
            int round_delta = interpolation == INTER_NEAREST ? AB_SCALE/2 : AB_SCALE/INTER_TAB_SIZE/2, x, y, x1, y1;
        #if CV_TRY_AVX2
            bool useAVX2 = CV_CPU_HAS_SUPPORT_AVX2;
        #endif
        #if CV_TRY_SSE4_1
            bool useSSE4_1 = CV_CPU_HAS_SUPPORT_SSE4_1;
        #endif
    
            int bh0 = std::min(BLOCK_SZ/2, dst.rows);
            int bw0 = std::min(BLOCK_SZ*BLOCK_SZ/bh0, dst.cols);
            bh0 = std::min(BLOCK_SZ*BLOCK_SZ/bw0, dst.rows);

`xy`指向结果矩阵的当前行行首。  
`X0`为  M 12 y + M 13 M\_\{12\}y+M\_\{13\} M12y\+M13  
`Y0`为  M 22 x + M 23 M\_\{22\}x+M\_\{23\} M22x\+M23  
`round_delta`为16。  
`_XY`将缓冲区`__XY`封装成了矩阵。  
`dpart`为结果的 RoI 区域。

for( y = range.start; y < range.end; y += bh0 )
            {
        
                for( x = 0; x < dst.cols; x += bw0 )
                {
        
                    int bw = std::min( bw0, dst.cols - x);
                    int bh = std::min( bh0, range.end - y);
    
                    Mat _XY(bh, bw, CV_16SC2, XY), matA;
                    Mat dpart(dst, Rect(x, y, bw, bh));
    
                    for( y1 = 0; y1 < bh; y1++ )
                    {
        
                        short* xy = XY + y1*bw*2;
                        int X0 = saturate_cast<int>((M[1]*(y + y1) + M[2])*AB_SCALE) + round_delta;
                        int Y0 = saturate_cast<int>((M[4]*(y + y1) + M[5])*AB_SCALE) + round_delta;

如果是最近邻方法。  
[WarpAffineInvoker\_Blockline\_SSE41][WarpAffineInvoker_Blockline_SSE41]

if( interpolation == INTER_NEAREST )
                        {
        
                            x1 = 0;
                            #if CV_TRY_SSE4_1
                            if( useSSE4_1 )
                                opt_SSE4_1::WarpAffineInvoker_Blockline_SSE41(adelta + x, bdelta + x, xy, X0, Y0, bw);
                            else
                            #endif
                            {
        
                                #if CV_SIMD128
                                {
        
                                    v_int32x4 v_X0 = v_setall_s32(X0), v_Y0 = v_setall_s32(Y0);
                                    int span = v_uint16x8::nlanes;
                                    for( ; x1 <= bw - span; x1 += span )
                                    {
        
                                        v_int16x8 v_dst[2];
                                        #define CV_CONVERT_MAP(ptr,offset,shift) v_pack(v_shr<AB_BITS>(shift+v_load(ptr + offset)),\
                                                                                        v_shr<AB_BITS>(shift+v_load(ptr + offset + 4)))
                                        v_dst[0] = CV_CONVERT_MAP(adelta, x+x1, v_X0);
                                        v_dst[1] = CV_CONVERT_MAP(bdelta, x+x1, v_Y0);
                                        #undef CV_CONVERT_MAP
                                        v_store_interleave(xy + (x1 << 1), v_dst[0], v_dst[1]);
                                    }
                                }
                                #endif
                                for( ; x1 < bw; x1++ )
                                {
        
                                    int X = (X0 + adelta[x+x1]) >> AB_BITS;
                                    int Y = (Y0 + bdelta[x+x1]) >> AB_BITS;
                                    xy[x1*2] = saturate_cast<short>(X);
                                    xy[x1*2+1] = saturate_cast<short>(Y);
                                }
                            }
                        }

对于双线性插值。  
`alpha`指向当前行。  
avx2可以调用 [warpAffineBlockline][]  
`v_mask`为向量掩码。  
每次处理`span*2`个数。  
[v\_setall\_s32][v_setall_s32] 通过 [OPENCV\_HAL\_IMPL\_NEON\_INIT][OPENCV_HAL_IMPL_NEON_INIT] 宏来定义。  
[v\_load][v_load] 从存储器中加载寄存器内容。  
计算  M 11 x + M 12 y + M 13 M\_\{11\}x+M\_\{12\}y+M\_\{13\} M11x\+M12y\+M13 和  M 21 x + M 22 y + M 23 M\_\{21\}x+M\_\{22\}y+M\_\{23\} M21x\+M22y\+M23 时，是两个`v_int32x4`相加（[vaddq\_s32][vaddq_s32]），得到`v_int32x4`的结果。然后右移 （10-5）位。  
[v\_shr][v_shr] 右移。  
[v\_pack][v_pack] 将两个数据宽度减半后拼到一起。  
两次右移后  
[v\_store\_interleave][v_store_interleave] 将2个寄存器中的数据交错存储到内存中。  
[v\_shl][v_shl] 左移。  
[v\_store][v_store] 将寄存器内容存储到内存中。  
`v_Y0`和`v_X0`合并。

else
                        {
        
                            short* alpha = A + y1*bw;
                            x1 = 0;
                            #if CV_TRY_AVX2
                            if ( useAVX2 )
                                x1 = opt_AVX2::warpAffineBlockline(adelta + x, bdelta + x, xy, alpha, X0, Y0, bw);
                            #endif
                            #if CV_SIMD128
                            {
        
                                v_int32x4 v__X0 = v_setall_s32(X0), v__Y0 = v_setall_s32(Y0);
                                v_int32x4 v_mask = v_setall_s32(INTER_TAB_SIZE - 1);
                                int span = v_float32x4::nlanes;
                                for( ; x1 <= bw - span * 2; x1 += span * 2 )
                                {
        
                                    v_int32x4 v_X0 = v_shr<AB_BITS - INTER_BITS>(v__X0 + v_load(adelta + x + x1));
                                    v_int32x4 v_Y0 = v_shr<AB_BITS - INTER_BITS>(v__Y0 + v_load(bdelta + x + x1));
                                    v_int32x4 v_X1 = v_shr<AB_BITS - INTER_BITS>(v__X0 + v_load(adelta + x + x1 + span));
                                    v_int32x4 v_Y1 = v_shr<AB_BITS - INTER_BITS>(v__Y0 + v_load(bdelta + x + x1 + span));
    
                                    v_int16x8 v_xy[2];
                                    v_xy[0] = v_pack(v_shr<INTER_BITS>(v_X0), v_shr<INTER_BITS>(v_X1));
                                    v_xy[1] = v_pack(v_shr<INTER_BITS>(v_Y0), v_shr<INTER_BITS>(v_Y1));
                                    v_store_interleave(xy + (x1 << 1), v_xy[0], v_xy[1]);
    
                                    v_int32x4 v_alpha0 = v_shl<INTER_BITS>(v_Y0 & v_mask) | (v_X0 & v_mask);
                                    v_int32x4 v_alpha1 = v_shl<INTER_BITS>(v_Y1 & v_mask) | (v_X1 & v_mask);
                                    v_store(alpha + x1, v_pack(v_alpha0, v_alpha1));
                                }
                            }
                            #endif

`X`和`Y`为映射到源图上的像素坐标。`alpha`将`Y`和`X`的小数部分合并存储。

for( ; x1 < bw; x1++ )
                            {
        
                                int X = (X0 + adelta[x+x1]) >> (AB_BITS - INTER_BITS);
                                int Y = (Y0 + bdelta[x+x1]) >> (AB_BITS - INTER_BITS);
                                xy[x1*2] = saturate_cast<short>(X >> INTER_BITS);
                                xy[x1*2+1] = saturate_cast<short>(Y >> INTER_BITS);
                                alpha[x1] = (short)((Y & (INTER_TAB_SIZE-1))*INTER_TAB_SIZE +
                                        (X & (INTER_TAB_SIZE-1)));
                            }
                        }
                    }

[cv::remap][cv_remap] 从`src`中找到`dpart`的源值。最近邻方式不需要第二张图。

if( interpolation == INTER_NEAREST )
                        remap( src, dpart, _XY, Mat(), interpolation, borderType, borderValue );
                    else
                    {
        
                        Mat _matA(bh, bw, CV_16U, A);
                        remap( src, dpart, _XY, _matA, interpolation, borderType, borderValue );
                    }
                }
            }
        }

成员变量。

private:
        Mat src;
        Mat dst;
        int interpolation, borderType;
        Scalar borderValue;
        int *adelta, *bdelta;
        const double *M;

## 参考资料： ##

*  [Warp Affine][]
 *  [How to work with OpenCV application based on OpenVX API][]
 *  [OpenVX sample \#7163][OpenVX sample _7163]
 *  [opencv/cmake/FindOpenVX.cmake][opencv_cmake_FindOpenVX.cmake]
 *  [Hybrid CV/DL pipelines with OpenCV 4.4 G-API][Hybrid CV_DL pipelines with OpenCV 4.4 G-API]
 *  [opencv和openvx][opencv_openvx]
 *  [Showing our vision with OpenVX™ 1.1 support for PowerVR GPUs][Showing our vision with OpenVX_ 1.1 support for PowerVR GPUs]
 *  [Amdovx Core][]
 *  [OpenVX 1.3 is Here!][OpenVX 1.3 is Here]
 *  [Color Copy OpenVX\* Sample][Color Copy OpenVX_ Sample]
 *  [opencv ncnn warpaffine 性能测试][opencv ncnn warpaffine]
 *  [OpenCV warpAffine的天坑][OpenCV warpAffine]
 *  [Geometric Transformations of Images][]
 *  [Decompose a 2D arbitrary transform into only scaling and rotation][]
 *  [Decompose affine transformation (including shear in x and y)][Decompose affine transformation _including shear in x and y]
 *  [Decomposing an Affine transformation][]
 *  [Decomposing an Affine transformation][]
 *  [Given this transformation matrix, how do I decompose it into translation, rotation and scale matrices?][Given this transformation matrix_ how do I decompose it into translation_ rotation and scale matrices]
 *  [Opencv 仿射变换原理代码解析][Opencv]
 *  [如何通俗地讲解「仿射变换」这个概念？][Link 1]
 *  [OpenCV代码提取：warpAffine函数的实现][OpenCV_warpAffine]
 *  [NEON优化——OpenCV WarpAffine最近邻][NEON_OpenCV WarpAffine]
 *  [Subtracting 0x8000 from an int][]
 *  [OpenCV2:Mat属性type，depth，step][OpenCV2_Mat_type_depth_step]
 *  [OpenCV中如何获取Mat类型中的步长stride及分析 C++实现][OpenCV_Mat_stride_ C]
 *  [NEON is the new black: fast JPEG optimization on ARM server][NEON is the new black_ fast JPEG optimization on ARM server]
 *  [大端序与小端序][Link 2]
 *  [Remapping][]
 *  [C++ 命令模式讲解和代码示例][C_]
 *  [Specify an origin to warpPerspective() function in OpenCV 2.x][Specify an origin to warpPerspective_ function in OpenCV 2.x]
 *  [计算机视觉2D几何基元及其变换介绍和OpenCV WarpPerspective源码分析][2D_OpenCV WarpPerspective]

[warpAffine]: https://docs.opencv.org/master/da/d54/group__imgproc__transform.html#ga0203d9ee5fcd28d40dbc4a1ea4451983
[remap]: https://docs.opencv.org/master/da/d54/group__imgproc__transform.html#gab75ef31ce5cdfb5c44b6da5f3b908ea4
[warpPerspective]: https://docs.opencv.org/master/da/d54/group__imgproc__transform.html#gaf73673a7e8e18ec6963e3774e6a94b87
[cv_warpAffine]: https://github.com/opencv/opencv/blob/master/modules/imgproc/src/imgwarp.cpp#L2573
[hal_warpAffine]: https://github.com/opencv/opencv/blob/master/modules/imgproc/src/imgwarp.cpp#L2540
[INTER_BITS]: https://github.com/opencv/opencv/blob/master/modules/imgproc/include/opencv2/imgproc.hpp#L287
[WarpAffineInvoker]: https://github.com/opencv/opencv/blob/master/modules/imgproc/src/imgwarp.cpp#L2155
[parallel_for]: https://github.com/opencv/opencv/blob/master/modules/core/src/parallel.cpp#L485
[operator]: https://github.com/opencv/opencv/blob/master/modules/imgproc/src/imgwarp.cpp#L2167
[INTER_TAB_SIZE]: https://github.com/opencv/opencv/blob/master/modules/imgproc/include/opencv2/imgproc.hpp#L289
[WarpAffineInvoker_Blockline_SSE41]: https://github.com/opencv/opencv/blob/master/modules/imgproc/src/imgwarp.sse4_1.cpp#L176
[warpAffineBlockline]: https://github.com/opencv/opencv/blob/master/modules/imgproc/src/imgwarp.avx2.cpp#L58
[v_setall_s32]: https://docs.opencv.org/master/df/d91/group__core__hal__intrin.html#gadca754bb3ca01900243f154ee793d992
[OPENCV_HAL_IMPL_NEON_INIT]: https://github.com/opencv/opencv/blob/master/modules/core/include/opencv2/core/hal/intrin_neon.hpp#L337
[v_load]: https://docs.opencv.org/master/df/d91/group__core__hal__intrin.html#ga05bb5c33c35c2aa1d1c5809b9220d268
[vaddq_s32]: https://developer.arm.com/architectures/instruction-sets/simd-isas/neon/intrinsics?search=vaddq_s32
[v_shr]: https://docs.opencv.org/master/df/d91/group__core__hal__intrin.html#ga3310a655662adf707fa342f486b234c4
[v_pack]: https://docs.opencv.org/master/df/d91/group__core__hal__intrin.html#ga3b932d695f5b07c4d22094f853f443ae
[v_store_interleave]: https://docs.opencv.org/master/df/d91/group__core__hal__intrin.html#gaa809d0656c94b2bb24b9be06295f037e
[v_shl]: https://docs.opencv.org/master/df/d91/group__core__hal__intrin.html#ga3b761c44138ceb7cbb84b2250420f24e
[v_store]: https://docs.opencv.org/master/df/d91/group__core__hal__intrin.html#ga275dfa9c8935f5e9a1031121cde460f4
[cv_remap]: https://github.com/opencv/opencv/blob/master/modules/imgproc/src/imgwarp.cpp#L1664
[Warp Affine]: https://www.khronos.org/registry/OpenVX/specs/1.0/html/d5/d5f/group__group__vision__function__warp__affine.html
[How to work with OpenCV application based on OpenVX API]: https://community.khronos.org/t/how-to-work-with-opencv-application-based-on-openvx-api/7483
[OpenVX sample _7163]: https://github.com/opencv/opencv/pull/7163
[opencv_cmake_FindOpenVX.cmake]: https://github.com/opencv/opencv/blob/master/cmake/FindOpenVX.cmake
[Hybrid CV_DL pipelines with OpenCV 4.4 G-API]: https://opencv.org/hybrid-cv-dl-pipelines-with-opencv-4-4-g-api/
[opencv_openvx]: https://blog.csdn.net/weixin_44124323/article/details/104564573
[Showing our vision with OpenVX_ 1.1 support for PowerVR GPUs]: https://www.imgtec.com/blog/openvx-1-1-support-powervr-gpus/
[Amdovx Core]: https://awesomeopensource.com/project/GPUOpen-ProfessionalCompute-Libraries/amdovx-core
[OpenVX 1.3 is Here]: https://www.khronos.org/openvx/
[Color Copy OpenVX_ Sample]: https://software.intel.com/content/www/us/en/develop/documentation/sample-color-copy/top/color-copy-pipeline/color-copy-pipeline-the-scan-pre-process-openvx-graph.html
[opencv ncnn warpaffine]: https://zhuanlan.zhihu.com/p/355147243
[OpenCV warpAffine]: https://zhuanlan.zhihu.com/p/89684929
[Geometric Transformations of Images]: https://docs.opencv.org/master/dd/d52/tutorial_js_geometric_transformations.html
[Decompose a 2D arbitrary transform into only scaling and rotation]: https://math.stackexchange.com/questions/861674/decompose-a-2d-arbitrary-transform-into-only-scaling-and-rotation
[Decompose affine transformation _including shear in x and y]: https://math.stackexchange.com/questions/1415854/decompose-affine-transformation-including-shear-in-x-and-y
[Decomposing an Affine transformation]: https://math.stackexchange.com/questions/612006/decomposing-an-affine-transformation
[Given this transformation matrix_ how do I decompose it into translation_ rotation and scale matrices]: https://math.stackexchange.com/questions/237369/given-this-transformation-matrix-how-do-i-decompose-it-into-translation-rotati
[Opencv]: https://blog.csdn.net/u010796650/article/details/90313491
[Link 1]: https://www.zhihu.com/question/20666664
[OpenCV_warpAffine]: https://blog.csdn.net/fengbingchun/article/details/51923392
[NEON_OpenCV WarpAffine]: https://blog.csdn.net/dingjikerbo/article/details/84403588
[Subtracting 0x8000 from an int]: https://stackoverflow.com/questions/21321740/subtracting-0x8000-from-an-int
[OpenCV2_Mat_type_depth_step]: https://www.cnblogs.com/wangguchangqing/p/4016179.html
[OpenCV_Mat_stride_ C]: https://blog.csdn.net/yl_best/article/details/94563317
[NEON is the new black_ fast JPEG optimization on ARM server]: https://blog.cloudflare.com/neon-is-the-new-black/
[Link 2]: https://www.cnblogs.com/graphics/archive/2011/04/22/2010662.html
[Remapping]: https://docs.opencv.org/master/d1/da0/tutorial_remap.html
[C_]: https://refactoringguru.cn/design-patterns/command/cpp/example
[Specify an origin to warpPerspective_ function in OpenCV 2.x]: https://stackoverflow.com/questions/4279008/specify-an-origin-to-warpperspective-function-in-opencv-2-x
[2D_OpenCV WarpPerspective]: https://www.cnblogs.com/Philip-Tell-Truth/p/8034019.html