devbox
酷酷是懒虫
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

OpenCV函数cvRemap源代码_opencv remap源码

作者：酷酷是懒虫 | 2024-07-07 05:44:10

赞

踩

opencv remap源码

cvRemap源代码

  1. void cv::remap( InputArray _src, OutputArray _dst,
  2.                 InputArray _map1, InputArray _map2,
  3.                 int interpolation, int borderType, const Scalar& borderValue )
  4. {
  5.     static RemapNNFunc nn_tab[] =
  6.     {
  7.         remapNearest<uchar>, remapNearest<schar>, remapNearest<ushort>, remapNearest<short>,
  8.         remapNearest<int>, remapNearest<float>, remapNearest<double>, 0
  9.     };
  10.  
  11.     static RemapFunc linear_tab[] =
  12.     {
  13.         remapBilinear<FixedPtCast<int, uchar, INTER_REMAP_COEF_BITS>, RemapVec_8u, short>, 0,
  14.         remapBilinear<Cast<float, ushort>, RemapNoVec, float>,
  15.         remapBilinear<Cast<float, short>, RemapNoVec, float>, 0,
  16.         remapBilinear<Cast<float, float>, RemapNoVec, float>,
  17.         remapBilinear<Cast<double, double>, RemapNoVec, float>, 0
  18.     };
  19.  
  20.     static RemapFunc cubic_tab[] =
  21.     {
  22.         remapBicubic<FixedPtCast<int, uchar, INTER_REMAP_COEF_BITS>, short, INTER_REMAP_COEF_SCALE>, 0,
  23.         remapBicubic<Cast<float, ushort>, float, 1>,
  24.         remapBicubic<Cast<float, short>, float, 1>, 0,
  25.         remapBicubic<Cast<float, float>, float, 1>,
  26.         remapBicubic<Cast<double, double>, float, 1>, 0
  27.     };
  28.  
  29.     static RemapFunc lanczos4_tab[] =
  30.     {
  31.         remapLanczos4<FixedPtCast<int, uchar, INTER_REMAP_COEF_BITS>, short, INTER_REMAP_COEF_SCALE>, 0,
  32.         remapLanczos4<Cast<float, ushort>, float, 1>,
  33.         remapLanczos4<Cast<float, short>, float, 1>, 0,
  34.         remapLanczos4<Cast<float, float>, float, 1>,
  35.         remapLanczos4<Cast<double, double>, float, 1>, 0
  36.     };
  37.  
  38.     Mat src = _src.getMat(), map1 = _map1.getMat(), map2 = _map2.getMat();
  39.     
  40.     CV_Assert( (!map2.data || map2.size() == map1.size()));
  41.     
  42.     _dst.create( map1.size(), src.type() );
  43.     Mat dst = _dst.getMat();
  44.     if( dst.data == src.data )
  45.         src = src.clone();
  46.  
  47.     int depth = src.depth(), map_depth = map1.depth();
  48.     RemapNNFunc nnfunc = 0;
  49.     RemapFunc ifunc = 0;
  50.     const void* ctab = 0;
  51.     bool fixpt = depth == CV_8U;
  52.     bool planar_input = false;
  53.  
  54.     if( interpolation == INTER_NEAREST )
  55.     {
  56.         nnfunc = nn_tab[depth];
  57.         CV_Assert( nnfunc != 0 );
  58.  
  59.         if( map1.type() == CV_16SC2 && !map2.data ) // the data is already in the right format
  60.         {
  61.             nnfunc( src, dst, map1, borderType, borderValue );
  62.             return;
  63.         }
  64.     }
  65.     else
  66.     {
  67.         if( interpolation == INTER_AREA )
  68.             interpolation = INTER_LINEAR;
  69.  
  70.         if( interpolation == INTER_LINEAR )
  71.             ifunc = linear_tab[depth];
  72.         else if( interpolation == INTER_CUBIC )
  73.             ifunc = cubic_tab[depth];
  74.         else if( interpolation == INTER_LANCZOS4 )
  75.             ifunc = lanczos4_tab[depth];
  76.         else
  77.             CV_Error( CV_StsBadArg, "Unknown interpolation method" );
  78.         CV_Assert( ifunc != 0 );
  79.         ctab = initInterTab2D( interpolation, fixpt );
  80.     }
  81.  
  82.     const Mat *m1 = &map1, *m2 = &map2;
  83.  
  84.     if( (map1.type() == CV_16SC2 && (map2.type() == CV_16UC1 || map2.type() == CV_16SC1)) ||
  85.         (map2.type() == CV_16SC2 && (map1.type() == CV_16UC1 || map1.type() == CV_16SC1)) )
  86.     {
  87.         if( map1.type() != CV_16SC2 )
  88.             std::swap(m1, m2);
  89.         if( ifunc )
  90.         {
  91.             ifunc( src, dst, *m1, *m2, ctab, borderType, borderValue );
  92.             return;
  93.         }
  94.     }
  95.     else
  96.     {
  97.         CV_Assert( (map1.type() == CV_32FC2 && !map2.data) ||
  98.             (map1.type() == CV_32FC1 && map2.type() == CV_32FC1) );
  99.         planar_input = map1.channels() == 1;
  100.     }
  101.  
  102.     int x, y, x1, y1;
  103.     const int buf_size = 1 << 14;
  104.     int brows0 = std::min(128, dst.rows);
  105.     int bcols0 = std::min(buf_size/brows0, dst.cols);
  106.     brows0 = std::min(buf_size/bcols0, dst.rows);
  107. #if CV_SSE2
  108.     bool useSIMD = checkHardwareSupport(CV_CPU_SSE2);
  109. #endif
  110.  
  111.     Mat _bufxy(brows0, bcols0, CV_16SC2), _bufa;
  112.     if( !nnfunc )
  113.         _bufa.create(brows0, bcols0, CV_16UC1);
  114.  
  115.     for( y = 0; y < dst.rows; y += brows0 )
  116.     {
  117.         for( x = 0; x < dst.cols; x += bcols0 )
  118.         {
  119.             int brows = std::min(brows0, dst.rows - y);
  120.             int bcols = std::min(bcols0, dst.cols - x);
  121.             Mat dpart(dst, Rect(x, y, bcols, brows));
  122.             Mat bufxy(_bufxy, Rect(0, 0, bcols, brows));
  123.  
  124.             if( nnfunc )
  125.             {
  126.                 if( map_depth != CV_32F )
  127.                 {
  128.                     for( y1 = 0; y1 < brows; y1++ )
  129.                     {
  130.                         short* XY = (short*)(bufxy.data + bufxy.step*y1);
  131.                         const short* sXY = (const short*)(m1->data + m1->step*(y+y1)) + x*2;
  132.                         const ushort* sA = (const ushort*)(m2->data + m2->step*(y+y1)) + x;
  133.  
  134.                         for( x1 = 0; x1 < bcols; x1++ )
  135.                         {
  136.                             int a = sA[x1] & (INTER_TAB_SIZE2-1);
  137.                             XY[x1*2] = sXY[x1*2] + NNDeltaTab_i[a][0];
  138.                             XY[x1*2+1] = sXY[x1*2+1] + NNDeltaTab_i[a][1];
  139.                         }
  140.                     }
  141.                 }
  142.                 else if( !planar_input )
  143.                     map1(Rect(0,0,bcols,brows)).convertTo(bufxy, bufxy.depth());
  144.                 else
  145.                 {
  146.                     for( y1 = 0; y1 < brows; y1++ )
  147.                     {
  148.                         short* XY = (short*)(bufxy.data + bufxy.step*y1);
  149.                         const float* sX = (const float*)(map1.data + map1.step*(y+y1)) + x;
  150.                         const float* sY = (const float*)(map2.data + map2.step*(y+y1)) + x;
  151.                         x1 = 0;
  152.  
  153.                     #if CV_SSE2
  154.                         if( useSIMD )
  155.                         {
  156.                             for( ; x1 <= bcols - 8; x1 += 8 )
  157.                             {
  158.                                 __m128 fx0 = _mm_loadu_ps(sX + x1);
  159.                                 __m128 fx1 = _mm_loadu_ps(sX + x1 + 4);
  160.                                 __m128 fy0 = _mm_loadu_ps(sY + x1);
  161.                                 __m128 fy1 = _mm_loadu_ps(sY + x1 + 4);
  162.                                 __m128i ix0 = _mm_cvtps_epi32(fx0);
  163.                                 __m128i ix1 = _mm_cvtps_epi32(fx1);
  164.                                 __m128i iy0 = _mm_cvtps_epi32(fy0);
  165.                                 __m128i iy1 = _mm_cvtps_epi32(fy1);
  166.                                 ix0 = _mm_packs_epi32(ix0, ix1);
  167.                                 iy0 = _mm_packs_epi32(iy0, iy1);
  168.                                 ix1 = _mm_unpacklo_epi16(ix0, iy0);
  169.                                 iy1 = _mm_unpackhi_epi16(ix0, iy0);
  170.                                 _mm_storeu_si128((__m128i*)(XY + x1*2), ix1);
  171.                                 _mm_storeu_si128((__m128i*)(XY + x1*2 + 8), iy1);
  172.                             }
  173.                         }
  174.                     #endif
  175.  
  176.                         for( ; x1 < bcols; x1++ )
  177.                         {
  178.                             XY[x1*2] = saturate_cast<short>(sX[x1]);
  179.                             XY[x1*2+1] = saturate_cast<short>(sY[x1]);
  180.                         }
  181.                     }
  182.                 }
  183.                 nnfunc( src, dpart, bufxy, borderType, borderValue );
  184.                 continue;
  185.             }
  186.  
  187.             Mat bufa(_bufa, Rect(0,0,bcols, brows));
  188.             for( y1 = 0; y1 < brows; y1++ )
  189.             {
  190.                 short* XY = (short*)(bufxy.data + bufxy.step*y1);
  191.                 ushort* A = (ushort*)(bufa.data + bufa.step*y1);
  192.  
  193.                 if( planar_input )
  194.                 {
  195.                     const float* sX = (const float*)(map1.data + map1.step*(y+y1)) + x;
  196.                     const float* sY = (const float*)(map2.data + map2.step*(y+y1)) + x;
  197.  
  198.                     x1 = 0;
  199.                 #if CV_SSE2
  200.                     if( useSIMD )
  201.                     {
  202.                         __m128 scale = _mm_set1_ps((float)INTER_TAB_SIZE);
  203.                         __m128i mask = _mm_set1_epi32(INTER_TAB_SIZE-1);
  204.                         for( ; x1 <= bcols - 8; x1 += 8 )
  205.                         {
  206.                             __m128 fx0 = _mm_loadu_ps(sX + x1);
  207.                             __m128 fx1 = _mm_loadu_ps(sX + x1 + 4);
  208.                             __m128 fy0 = _mm_loadu_ps(sY + x1);
  209.                             __m128 fy1 = _mm_loadu_ps(sY + x1 + 4);
  210.                             __m128i ix0 = _mm_cvtps_epi32(_mm_mul_ps(fx0, scale));
  211.                             __m128i ix1 = _mm_cvtps_epi32(_mm_mul_ps(fx1, scale));
  212.                             __m128i iy0 = _mm_cvtps_epi32(_mm_mul_ps(fy0, scale));
  213.                             __m128i iy1 = _mm_cvtps_epi32(_mm_mul_ps(fy1, scale));
  214.                             __m128i mx0 = _mm_and_si128(ix0, mask);
  215.                             __m128i mx1 = _mm_and_si128(ix1, mask);
  216.                             __m128i my0 = _mm_and_si128(iy0, mask);
  217.                             __m128i my1 = _mm_and_si128(iy1, mask);
  218.                             mx0 = _mm_packs_epi32(mx0, mx1);
  219.                             my0 = _mm_packs_epi32(my0, my1);
  220.                             my0 = _mm_slli_epi16(my0, INTER_BITS);
  221.                             mx0 = _mm_or_si128(mx0, my0);
  222.                             _mm_storeu_si128((__m128i*)(A + x1), mx0);
  223.                             ix0 = _mm_srai_epi32(ix0, INTER_BITS);
  224.                             ix1 = _mm_srai_epi32(ix1, INTER_BITS);
  225.                             iy0 = _mm_srai_epi32(iy0, INTER_BITS);
  226.                             iy1 = _mm_srai_epi32(iy1, INTER_BITS);
  227.                             ix0 = _mm_packs_epi32(ix0, ix1);
  228.                             iy0 = _mm_packs_epi32(iy0, iy1);
  229.                             ix1 = _mm_unpacklo_epi16(ix0, iy0);
  230.                             iy1 = _mm_unpackhi_epi16(ix0, iy0);
  231.                             _mm_storeu_si128((__m128i*)(XY + x1*2), ix1);
  232.                             _mm_storeu_si128((__m128i*)(XY + x1*2 + 8), iy1);
  233.                         }
  234.                     }
  235.                 #endif
  236.  
  237.                     for( ; x1 < bcols; x1++ )
  238.                     {
  239.                         int sx = cvRound(sX[x1]*INTER_TAB_SIZE);
  240.                         int sy = cvRound(sY[x1]*INTER_TAB_SIZE);
  241.                         int v = (sy & (INTER_TAB_SIZE-1))*INTER_TAB_SIZE + (sx & (INTER_TAB_SIZE-1));
  242.                         XY[x1*2] = (short)(sx >> INTER_BITS);
  243.                         XY[x1*2+1] = (short)(sy >> INTER_BITS);
  244.                         A[x1] = (ushort)v;
  245.                     }
  246.                 }
  247.                 else
  248.                 {
  249.                     const float* sXY = (const float*)(map1.data + map1.step*(y+y1)) + x*2;
  250.  
  251.                     for( x1 = 0; x1 < bcols; x1++ )
  252.                     {
  253.                         int sx = cvRound(sXY[x1*2]*INTER_TAB_SIZE);
  254.                         int sy = cvRound(sXY[x1*2+1]*INTER_TAB_SIZE);
  255.                         int v = (sy & (INTER_TAB_SIZE-1))*INTER_TAB_SIZE + (sx & (INTER_TAB_SIZE-1));
  256.                         XY[x1*2] = (short)(sx >> INTER_BITS);
  257.                         XY[x1*2+1] = (short)(sy >> INTER_BITS);
  258.                         A[x1] = (ushort)v;
  259.                     }
  260.                 }
  261.             }
  262.             ifunc(src, dpart, bufxy, bufa, ctab, borderType, borderValue);
  263.         }
  264.     }
  265. }


声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号