OpenCV函数cvRemap源代码

最新推荐文章于 2024-08-22 16:29:20 发布
最新推荐文章于 2024-08-22 16:29:20 发布
阅读量8.9k 收藏 12
点赞数 2
文章标签： float dst input

cvRemap源代码

void cv::remap( InputArray _src, OutputArray _dst,
                InputArray _map1, InputArray _map2,
                int interpolation, int borderType, const Scalar& borderValue )
{
    static RemapNNFunc nn_tab[] =
    {
        remapNearest<uchar>, remapNearest<schar>, remapNearest<ushort>, remapNearest<short>,
        remapNearest<int>, remapNearest<float>, remapNearest<double>, 0
    };

    static RemapFunc linear_tab[] =
    {
        remapBilinear<FixedPtCast<int, uchar, INTER_REMAP_COEF_BITS>, RemapVec_8u, short>, 0,
        remapBilinear<Cast<float, ushort>, RemapNoVec, float>,
        remapBilinear<Cast<float, short>, RemapNoVec, float>, 0,
        remapBilinear<Cast<float, float>, RemapNoVec, float>,
        remapBilinear<Cast<double, double>, RemapNoVec, float>, 0
    };

    static RemapFunc cubic_tab[] =
    {
        remapBicubic<FixedPtCast<int, uchar, INTER_REMAP_COEF_BITS>, short, INTER_REMAP_COEF_SCALE>, 0,
        remapBicubic<Cast<float, ushort>, float, 1>,
        remapBicubic<Cast<float, short>, float, 1>, 0,
        remapBicubic<Cast<float, float>, float, 1>,
        remapBicubic<Cast<double, double>, float, 1>, 0
    };

    static RemapFunc lanczos4_tab[] =
    {
        remapLanczos4<FixedPtCast<int, uchar, INTER_REMAP_COEF_BITS>, short, INTER_REMAP_COEF_SCALE>, 0,
        remapLanczos4<Cast<float, ushort>, float, 1>,
        remapLanczos4<Cast<float, short>, float, 1>, 0,
        remapLanczos4<Cast<float, float>, float, 1>,
        remapLanczos4<Cast<double, double>, float, 1>, 0
    };

    Mat src = _src.getMat(), map1 = _map1.getMat(), map2 = _map2.getMat();
    
    CV_Assert( (!map2.data || map2.size() == map1.size()));
    
    _dst.create( map1.size(), src.type() );
    Mat dst = _dst.getMat();
    if( dst.data == src.data )
        src = src.clone();

    int depth = src.depth(), map_depth = map1.depth();
    RemapNNFunc nnfunc = 0;
    RemapFunc ifunc = 0;
    const void* ctab = 0;
    bool fixpt = depth == CV_8U;
    bool planar_input = false;

    if( interpolation == INTER_NEAREST )
    {
        nnfunc = nn_tab[depth];
        CV_Assert( nnfunc != 0 );

        if( map1.type() == CV_16SC2 && !map2.data ) // the data is already in the right format
        {
            nnfunc( src, dst, map1, borderType, borderValue );
            return;
        }
    }
    else
    {
        if( interpolation == INTER_AREA )
            interpolation = INTER_LINEAR;

        if( interpolation == INTER_LINEAR )
            ifunc = linear_tab[depth];
        else if( interpolation == INTER_CUBIC )
            ifunc = cubic_tab[depth];
        else if( interpolation == INTER_LANCZOS4 )
            ifunc = lanczos4_tab[depth];
        else
            CV_Error( CV_StsBadArg, "Unknown interpolation method" );
        CV_Assert( ifunc != 0 );
        ctab = initInterTab2D( interpolation, fixpt );
    }

    const Mat *m1 = &map1, *m2 = &map2;

    if( (map1.type() == CV_16SC2 && (map2.type() == CV_16UC1 || map2.type() == CV_16SC1)) ||
        (map2.type() == CV_16SC2 && (map1.type() == CV_16UC1 || map1.type() == CV_16SC1)) )
    {
        if( map1.type() != CV_16SC2 )
            std::swap(m1, m2);
        if( ifunc )
        {
            ifunc( src, dst, *m1, *m2, ctab, borderType, borderValue );
            return;
        }
    }
    else
    {
        CV_Assert( (map1.type() == CV_32FC2 && !map2.data) ||
            (map1.type() == CV_32FC1 && map2.type() == CV_32FC1) );
        planar_input = map1.channels() == 1;
    }

    int x, y, x1, y1;
    const int buf_size = 1 << 14;
    int brows0 = std::min(128, dst.rows);
    int bcols0 = std::min(buf_size/brows0, dst.cols);
    brows0 = std::min(buf_size/bcols0, dst.rows);
#if CV_SSE2
    bool useSIMD = checkHardwareSupport(CV_CPU_SSE2);
#endif

    Mat _bufxy(brows0, bcols0, CV_16SC2), _bufa;
    if( !nnfunc )
        _bufa.create(brows0, bcols0, CV_16UC1);

    for( y = 0; y < dst.rows; y += brows0 )
    {
        for( x = 0; x < dst.cols; x += bcols0 )
        {
            int brows = std::min(brows0, dst.rows - y);
            int bcols = std::min(bcols0, dst.cols - x);
            Mat dpart(dst, Rect(x, y, bcols, brows));
            Mat bufxy(_bufxy, Rect(0, 0, bcols, brows));

            if( nnfunc )
            {
                if( map_depth != CV_32F )
                {
                    for( y1 = 0; y1 < brows; y1++ )
                    {
                        short* XY = (short*)(bufxy.data + bufxy.step*y1);
                        const short* sXY = (const short*)(m1->data + m1->step*(y+y1)) + x*2;
                        const ushort* sA = (const ushort*)(m2->data + m2->step*(y+y1)) + x;

                        for( x1 = 0; x1 < bcols; x1++ )
                        {
                            int a = sA[x1] & (INTER_TAB_SIZE2-1);
                            XY[x1*2] = sXY[x1*2] + NNDeltaTab_i[a][0];
                            XY[x1*2+1] = sXY[x1*2+1] + NNDeltaTab_i[a][1];
                        }
                    }
                }
                else if( !planar_input )
                    map1(Rect(0,0,bcols,brows)).convertTo(bufxy, bufxy.depth());
                else
                {
                    for( y1 = 0; y1 < brows; y1++ )
                    {
                        short* XY = (short*)(bufxy.data + bufxy.step*y1);
                        const float* sX = (const float*)(map1.data + map1.step*(y+y1)) + x;
                        const float* sY = (const float*)(map2.data + map2.step*(y+y1)) + x;
                        x1 = 0;

                    #if CV_SSE2
                        if( useSIMD )
                        {
                            for( ; x1 <= bcols - 8; x1 += 8 )
                            {
                                __m128 fx0 = _mm_loadu_ps(sX + x1);
                                __m128 fx1 = _mm_loadu_ps(sX + x1 + 4);
                                __m128 fy0 = _mm_loadu_ps(sY + x1);
                                __m128 fy1 = _mm_loadu_ps(sY + x1 + 4);
                                __m128i ix0 = _mm_cvtps_epi32(fx0);
                                __m128i ix1 = _mm_cvtps_epi32(fx1);
                                __m128i iy0 = _mm_cvtps_epi32(fy0);
                                __m128i iy1 = _mm_cvtps_epi32(fy1);
                                ix0 = _mm_packs_epi32(ix0, ix1);
                                iy0 = _mm_packs_epi32(iy0, iy1);
                                ix1 = _mm_unpacklo_epi16(ix0, iy0);
                                iy1 = _mm_unpackhi_epi16(ix0, iy0);
                                _mm_storeu_si128((__m128i*)(XY + x1*2), ix1);
                                _mm_storeu_si128((__m128i*)(XY + x1*2 + 8), iy1);
                            }
                        }
                    #endif

                        for( ; x1 < bcols; x1++ )
                        {
                            XY[x1*2] = saturate_cast<short>(sX[x1]);
                            XY[x1*2+1] = saturate_cast<short>(sY[x1]);
                        }
                    }
                }
                nnfunc( src, dpart, bufxy, borderType, borderValue );
                continue;
            }

            Mat bufa(_bufa, Rect(0,0,bcols, brows));
            for( y1 = 0; y1 < brows; y1++ )
            {
                short* XY = (short*)(bufxy.data + bufxy.step*y1);
                ushort* A = (ushort*)(bufa.data + bufa.step*y1);

                if( planar_input )
                {
                    const float* sX = (const float*)(map1.data + map1.step*(y+y1)) + x;
                    const float* sY = (const float*)(map2.data + map2.step*(y+y1)) + x;

                    x1 = 0;
                #if CV_SSE2
                    if( useSIMD )
                    {
                        __m128 scale = _mm_set1_ps((float)INTER_TAB_SIZE);
                        __m128i mask = _mm_set1_epi32(INTER_TAB_SIZE-1);
                        for( ; x1 <= bcols - 8; x1 += 8 )
                        {
                            __m128 fx0 = _mm_loadu_ps(sX + x1);
                            __m128 fx1 = _mm_loadu_ps(sX + x1 + 4);
                            __m128 fy0 = _mm_loadu_ps(sY + x1);
                            __m128 fy1 = _mm_loadu_ps(sY + x1 + 4);
                            __m128i ix0 = _mm_cvtps_epi32(_mm_mul_ps(fx0, scale));
                            __m128i ix1 = _mm_cvtps_epi32(_mm_mul_ps(fx1, scale));
                            __m128i iy0 = _mm_cvtps_epi32(_mm_mul_ps(fy0, scale));
                            __m128i iy1 = _mm_cvtps_epi32(_mm_mul_ps(fy1, scale));
                            __m128i mx0 = _mm_and_si128(ix0, mask);
                            __m128i mx1 = _mm_and_si128(ix1, mask);
                            __m128i my0 = _mm_and_si128(iy0, mask);
                            __m128i my1 = _mm_and_si128(iy1, mask);
                            mx0 = _mm_packs_epi32(mx0, mx1);
                            my0 = _mm_packs_epi32(my0, my1);
                            my0 = _mm_slli_epi16(my0, INTER_BITS);
                            mx0 = _mm_or_si128(mx0, my0);
                            _mm_storeu_si128((__m128i*)(A + x1), mx0);
                            ix0 = _mm_srai_epi32(ix0, INTER_BITS);
                            ix1 = _mm_srai_epi32(ix1, INTER_BITS);
                            iy0 = _mm_srai_epi32(iy0, INTER_BITS);
                            iy1 = _mm_srai_epi32(iy1, INTER_BITS);
                            ix0 = _mm_packs_epi32(ix0, ix1);
                            iy0 = _mm_packs_epi32(iy0, iy1);
                            ix1 = _mm_unpacklo_epi16(ix0, iy0);
                            iy1 = _mm_unpackhi_epi16(ix0, iy0);
                            _mm_storeu_si128((__m128i*)(XY + x1*2), ix1);
                            _mm_storeu_si128((__m128i*)(XY + x1*2 + 8), iy1);
                        }
                    }
                #endif

                    for( ; x1 < bcols; x1++ )
                    {
                        int sx = cvRound(sX[x1]*INTER_TAB_SIZE);
                        int sy = cvRound(sY[x1]*INTER_TAB_SIZE);
                        int v = (sy & (INTER_TAB_SIZE-1))*INTER_TAB_SIZE + (sx & (INTER_TAB_SIZE-1));
                        XY[x1*2] = (short)(sx >> INTER_BITS);
                        XY[x1*2+1] = (short)(sy >> INTER_BITS);
                        A[x1] = (ushort)v;
                    }
                }
                else
                {
                    const float* sXY = (const float*)(map1.data + map1.step*(y+y1)) + x*2;

                    for( x1 = 0; x1 < bcols; x1++ )
                    {
                        int sx = cvRound(sXY[x1*2]*INTER_TAB_SIZE);
                        int sy = cvRound(sXY[x1*2+1]*INTER_TAB_SIZE);
                        int v = (sy & (INTER_TAB_SIZE-1))*INTER_TAB_SIZE + (sx & (INTER_TAB_SIZE-1));
                        XY[x1*2] = (short)(sx >> INTER_BITS);
                        XY[x1*2+1] = (short)(sy >> INTER_BITS);
                        A[x1] = (ushort)v;
                    }
                }
            }
            ifunc(src, dpart, bufxy, bufa, ctab, borderType, borderValue);
        }
    }
}


C_arm
关注
OpenCV重新映射Remap的实例(附完整代码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-01 629
OpenCV重新映射Remap的实例OpenCV重新映射Remap的实例 OpenCV重新映射Remap的实例 #include "opencv2/imgcodecs.hpp" #include "opencv2/highgui.hpp" #include "opencv2/imgproc.hpp" #include <iostream> using namespace cv; /// Function Headers void update_map( int &ind, Mat &am
opencv摄像头标定学习总结
bcbobo21cn的专栏
03-16 1万+
摄像机标定 利用摄像机所拍摄到的图像来还原空间中的物体。在这里，不妨假设摄像机所拍摄到的图像与三维空间 中的物体之间存在以下一种简单的线性关系：[像]=M[物],这里，矩阵M可以看成是摄像机成像的几何模 型。 M中的参数就是摄像机参数。通常，这些参数是要通过实验与计算来得到的。这个求解参数的过程 就称为摄像机标定。 摄像机标定 camera calibratio
OpenCV 中的 remap 函数
yiran103的专栏
04-18 7185
上一篇文章中提到 warpAffine 会分块处理，将坐标映射和插值系数分别存储下来，然后借助 remap 来实现最终的映射。而 remap 会根据映射关系取源像素并加权计算出目的像素值。其最核心的计算为 RemapVec_8u。 cv::remap #mermaid-svg-lLtejyb6R6MyZRLO .label{font-family:'trebuchet ms', verdana, arial;font-family:var(--mermaid-font-family);fill:#333;c
OpenCV几何图像变换（7）重映射函数 remap()的使用
最新发布
jndingxin的专栏
08-22 885
在OpenCV中，remap()函数是一个非常强大的工具，用于对图像进行任意形式的重映射。这意味着你可以通过提供映射函数来自定义每个像素的新位置，从而实现各种各样的图像变换效果。
毛星云opencv之7.3重映射函数remap()及其实现代码
weixin_52634719的博客
11-05 771
#include <opencv2/opencv.hpp> #include<opencv2/core/core.hpp> #include"opencv2/highgui/highgui.hpp" #include<opencv2/imgproc/imgproc.hpp> #include<iostream> #include<time.h> #include<vector> using namespace std; using n.
OpenCV代码提取：remap函数的实现
Trent1985的专栏
06-21 2643
转载一篇关于opencv中remap代码提取实现的文章，分享一下！
OpenCV 图像重映射函数remap()实例详解
billliu66的博客
03-13 2303
本文详细介绍了OpenCV 图像重映射函数，并以实例演示了其常见用法。
opencv-第六章-图像变换-重映射、仿射变换、透视变换
never give up的博客
10-28 5896
opencv-第六章-图像变换-重映射、仿射变换、透视变换
基于OpenCV立体视觉标定和校正
热门推荐
lijiayu2015的博客
11-08 1万+
立体标定时计算空间上的两台摄像机几何关系的过程，立体校正则是对个体图像进行纠正，保证这些图像可以从平面对准的两幅图像获得。双目视觉标定，通常会使用了两种工具：OpenCV和Matlab。Matlab的效果非常稳定，但是一开始OpenCV的效果很糟糕，要不是出现中断就是标定出来的结果数值很大。经过了几天的不断调试和更改，终于把OpenCV的立体视觉标定和校正的程序写出来了。总结了引起这些异常的原因以及排查标定过程异常的方法。
OpenCV学习之路（十六） 重映射与仿射
菜鸡程序猿的博客
09-04 751
  目录 重映射 仿射变换 简单示例代码： 重映射 仿射变换   重映射 重映射就是把一个图像中某位置的像素放置到另一个图片指定位置过程。为了完成重映射过程有必要获得一些插值作为非整数像素坐标，因为原图像与目标图像的像素坐标不是一一对应的。我们通过重映射来表达每个像素的位置(x, y):                                               ...
OpenCV实现remap函数用法示例（C++实现）.zip
04-12
C++ OpenCV驱动程序，OpenCV beta工程环境。 项目代码可直接编译运行~
学习opencv 中文版及源码
11-04
学习opencv中文版完整书籍和随书所附源代码, 书籍很清晰, 代码完整
【双目视觉探索路3】分析整理Learning OpenCV3书中立体标定、校正以及对应代码（1）之总体
JDeng的编程应用入门
12-15 2236
双目立体视觉的书上代码分析与相关实现（1）
OpenCV代码提取 remap函数的实现
hddryjv的博客
02-11 863
OpenCV代码提取 remap函数的实现
CodeIgniter 源码解读之 _remap
丿做个好人的博客
03-07 298
_remap 童鞋们，之前在看源码时，大家有没有注意到 CodeIgniter.php 文件中，在URI路由处理完成的后，实例化控制器类及调用方法时，我们可以看到程序做了一下判断： elseif (method_exists($class, '_remap')) 那这个为什么要介么判断类？ _remap 介个方法有什么作用类？ 如果，当前控制器类中存在 _remap 方法，则： $params ...
Opencv remap函数
Misakaya的博客
10-20 1957
OpenCV remap函数使用实例
OpenCV-Python|图像处理模块 — cv2.remap()函数的使用
weixin_43917574的博客
08-26 9723
OpenCV-Python|图像处理模块 — Remapping-重映射
opencv remap
hujian_的专栏
04-17 2811
什么叫做重映射呢？ 重映射，就是把一幅图像中的某个位置上的像素放到另一个图像中指定位置上的过程。为了完成这样的映射，我们需要一个重映射函数来讲源图像与目标图像的坐标对应起来。 像这样：g(x,y)=f(h(x,y)) g函数是目标图像上的坐标点，f是原图像的，而h函数是作用于原图像上的函数。remap( )函数会根据我们指定的映射形式，将源图像进行重映射几何变换，基于的式子如下： void r
opencv 图像重映射cv::remap()（图像上下、左右镜像）
weixin_44901043的博客
04-01 2623
文章目录概念opencv 函数支持 cv::remap()1.函数原型：2.参数说明测试代码：程序运行效果： 概念 什么是重映射？ 这是从图像中的一个位置获取像素并将它们定位到新图像中的另一个位置的过程。 为了完成映射过程，可能需要对非整数像素位置进行一些插值，因为源图像和目标图像之间并不总是存在一对一的像素对应关系。 我们可以表达每个像素位置的重映射( x , y)作为： 其中g()是映射的图像，f()是源图像，h(x,y)是作用于(x,y)的映射函数。 opencv 函数支持 cv::remap()
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值