图像金字塔及尺寸缩放

旧城等待， 2022-06-17 08:06 473阅读 0赞 
  1. 对图像尺度变换方法：resize函数可以直接。pyrUp()(拉普拉斯) ,pyrUDown()函数（高斯）（图像金字塔）。
  3. 图像金字塔：主要用于图像分割，是一种以多分辨率来解释图像的有效但概念简单的结构。
  5. 是一系列以金字塔形状排列的，分辨率逐渐降低接来源于同一张原始图的图像集合。通过梯次向下采样获得，直到达到某个终止条件才停止采样。

金字塔的底部是待处理图像的高分辨率表示，而顶部是低分辨率的近似。将一层一层的图像比喻成金字塔，层级越高，则图像越小，分辨率越低。

金字塔有两种：

1、高斯金字塔—————-用来向下采样（主要）。

2、拉普拉斯金字塔———————用来从金字塔低层图像重建上层未采样图像即最大程度的还原图像，配合高斯金字塔使用。

  1. 高斯金字塔原理：从金字塔i层生成i+1层（Gi+1），先用高斯核对Gi进行卷积，然后删除所有偶数行和偶数列，所得图像面积会变成原图的1/4。

当图像金字塔向上移动时，尺寸和分辨率会降低。向下采样，向上就是图像尺寸加倍，向下就是图像尺寸减半。

高斯金字塔：

它是通过高斯平滑核亚采样获得一系列采样图像即第K层高斯金字塔通过平滑、亚采样可获得K+1层高斯图像。高斯金字塔包含了一系列低通滤波器，其截止频率从上一层到下一层一因子2逐渐增加，so高斯金字塔可以跨越很大的频率范围。

1、向下取样（缩小图像）

对图像Gi进行高斯核卷积且去除偶数行和列。

2、向上取样（放大图像）

  1. 将图像在每个方向扩大为原来的两倍，新增的行和列以0补充。使用先前同样的内核（乘以4）与放大后的图像卷积，获得“新增像素”的近似值。得到的图像极为放大的图像，但与原来的图像相比会发现比较模糊（丢失部分信息）采用拉普拉斯金字塔。

注意：上面所说的向上（拉普拉斯图像重建—加倍，倒金字塔）向下（高斯图像缩减—减半，正金字塔，）是针对图像尺寸的（和金字塔的方向相反）。

  1. void cv::pyrUp( InputArray _src, OutputArray _dst, const Size& _dsz, int borderType )
  3. void cv::pyrUp( InputArray _src, OutputArray _dst, const Size& _dsz, int borderType )
  4. {
  5.     CV_Assert(borderType == BORDER_DEFAULT);
  7.     CV_OCL_RUN(_src.dims() <= 2 && _dst.isUMat(),
  8.                ocl_pyrUp(_src, _dst, _dsz, borderType))
  10.     Mat src = _src.getMat();
  11.     Size dsz = _dsz.area() == 0 ? Size(src.cols*2, src.rows*2) : _dsz;
  12.     _dst.create( dsz, src.type() );
  13.     Mat dst = _dst.getMat();
  14.     int depth = src.depth();
  16. #ifdef HAVE_TEGRA_OPTIMIZATION
  17.     if(borderType == BORDER_DEFAULT && tegra::useTegra() && tegra::pyrUp(src, dst))
  18.         return;
  19. #endif
  21. #if IPP_VERSION_X100 >= 801 && 0
  22.     CV_IPP_CHECK()
  23.     {
  24.         bool isolated = (borderType & BORDER_ISOLATED) != 0;
  25.         int borderTypeNI = borderType & ~BORDER_ISOLATED;
  26.         if (borderTypeNI == BORDER_DEFAULT && (!src.isSubmatrix() || isolated) && dsz == Size(src.cols*2, src.rows*2))
  27.         {
  28.             typedef IppStatus (CV_STDCALL * ippiPyrUp)(const void* pSrc, int srcStep, void* pDst, int dstStep, IppiSize srcRoi, Ipp8u* buffer);
  29.             int type = src.type();
  30.             CV_SUPPRESS_DEPRECATED_START
  31.             ippiPyrUp pyrUpFunc = type == CV_8UC1 ? (ippiPyrUp) ippiPyrUp_Gauss5x5_8u_C1R :
  32.                                   type == CV_8UC3 ? (ippiPyrUp) ippiPyrUp_Gauss5x5_8u_C3R :
  33.                                   type == CV_32FC1 ? (ippiPyrUp) ippiPyrUp_Gauss5x5_32f_C1R :
  34.                                   type == CV_32FC3 ? (ippiPyrUp) ippiPyrUp_Gauss5x5_32f_C3R : 0;
  35.             CV_SUPPRESS_DEPRECATED_END
  37.             if (pyrUpFunc)
  38.             {
  39.                 int bufferSize;
  40.                 IppiSize srcRoi = { src.cols, src.rows };
  41.                 IppDataType dataType = depth == CV_8U ? ipp8u : ipp32f;
  42.                 CV_SUPPRESS_DEPRECATED_START
  43.                 IppStatus ok = ippiPyrUpGetBufSize_Gauss5x5(srcRoi.width, dataType, src.channels(), &bufferSize);
  44.                 CV_SUPPRESS_DEPRECATED_END
  45.                 if (ok >= 0)
  46.                 {
  47.                     Ipp8u* buffer = ippsMalloc_8u(bufferSize);
  48.                     ok = pyrUpFunc(src.data, (int) src.step, dst.data, (int) dst.step, srcRoi, buffer);
  49.                     ippsFree(buffer);
  51.                     if (ok >= 0)
  52.                     {
  53.                         CV_IMPL_ADD(CV_IMPL_IPP);
  54.                         return;
  55.                     }
  56.                     setIppErrorStatus();
  57.                 }
  58.             }
  59.         }
  60.     }
  61. #endif
  63.     PyrFunc func = 0;
  64.     if( depth == CV_8U )
  65.         func = pyrUp_<FixPtCast<uchar, 6>, PyrUpVec_32s8u >;
  66.     else if( depth == CV_16S )
  67.         func = pyrUp_<FixPtCast<short, 6>, PyrUpVec_32s16s >;
  68.     else if( depth == CV_16U )
  69.         func = pyrUp_<FixPtCast<ushort, 6>, PyrUpVec_32s16u >;
  70.     else if( depth == CV_32F )
  71.         func = pyrUp_<FltCast<float, 6>, PyrUpVec_32f >;
  72.     else if( depth == CV_64F )
  73.         func = pyrUp_<FltCast<double, 6>, PyrUpNoVec<double, double> >;
  74.     else
  75.         CV_Error( CV_StsUnsupportedFormat, "" );
  77.     func( src, dst, borderType );
  78. }

拉普拉斯金字塔：

  1. 数学定义：Li=Gi-UP（Gi+1）\*g
  3. 将源图像中位置（x，y）的像素映射到目标图像的（2x+1，2y+1）位置，即在进行向上取样。拉普拉斯金字塔是通过源图像减去先缩小后放大的图像的一系列图像构成。
  5. void cv::pyrDown( InputArray _src, OutputArray _dst, const Size& _dsz, int borderType )
  10. void cv::pyrDown( InputArray _src, OutputArray _dst, const Size& _dsz, int borderType )
  11. {
  12.     CV_Assert(borderType != BORDER_CONSTANT);
  15.     CV_OCL_RUN(_src.dims() <= 2 && _dst.isUMat(),
  16.                ocl_pyrDown(_src, _dst, _dsz, borderType))
  19.     Mat src = _src.getMat();
  20.     Size dsz = _dsz.area() == 0 ? Size((src.cols + 1)/2, (src.rows + 1)/2) : _dsz;
  21.     _dst.create( dsz, src.type() );
  22.     Mat dst = _dst.getMat();
  23.     int depth = src.depth();
  26. #ifdef HAVE_TEGRA_OPTIMIZATION
  27.     if(borderType == BORDER_DEFAULT && tegra::useTegra() && tegra::pyrDown(src, dst))
  28.         return;
  29. #endif
  32. #if IPP_VERSION_X100 >= 801 && 0
  33.     CV_IPP_CHECK()
  34.     {
  35.         bool isolated = (borderType & BORDER_ISOLATED) != 0;
  36.         int borderTypeNI = borderType & ~BORDER_ISOLATED;
  37.         if (borderTypeNI == BORDER_DEFAULT && (!src.isSubmatrix() || isolated) && dsz == Size((src.cols + 1)/2, (src.rows + 1)/2))
  38.         {
  39.             typedef IppStatus (CV_STDCALL * ippiPyrDown)(const void* pSrc, int srcStep, void* pDst, int dstStep, IppiSize srcRoi, Ipp8u* buffer);
  40.             int type = src.type();
  41.             CV_SUPPRESS_DEPRECATED_START
  42.             ippiPyrDown pyrDownFunc = type == CV_8UC1 ? (ippiPyrDown) ippiPyrDown_Gauss5x5_8u_C1R :
  43.                                       type == CV_8UC3 ? (ippiPyrDown) ippiPyrDown_Gauss5x5_8u_C3R :
  44.                                       type == CV_32FC1 ? (ippiPyrDown) ippiPyrDown_Gauss5x5_32f_C1R :
  45.                                       type == CV_32FC3 ? (ippiPyrDown) ippiPyrDown_Gauss5x5_32f_C3R : 0;
  46.             CV_SUPPRESS_DEPRECATED_END
  49.             if (pyrDownFunc)
  50.             {
  51.                 int bufferSize;
  52.                 IppiSize srcRoi = { src.cols, src.rows };
  53.                 IppDataType dataType = depth == CV_8U ? ipp8u : ipp32f;
  54.                 CV_SUPPRESS_DEPRECATED_START
  55.                 IppStatus ok = ippiPyrDownGetBufSize_Gauss5x5(srcRoi.width, dataType, src.channels(), &bufferSize);
  56.                 CV_SUPPRESS_DEPRECATED_END
  57.                 if (ok >= 0)
  58.                 {
  59.                     Ipp8u* buffer = ippsMalloc_8u(bufferSize);
  60.                     ok = pyrDownFunc(src.data, (int) src.step, dst.data, (int) dst.step, srcRoi, buffer);
  61.                     ippsFree(buffer);
  64.                     if (ok >= 0)
  65.                     {
  66.                         CV_IMPL_ADD(CV_IMPL_IPP);
  67.                         return;
  68.                     }
  69.                     setIppErrorStatus();
  70.                 }
  71.             }
  72.         }
  73.     }
  74. #endif
  77.     PyrFunc func = 0;
  78.     if( depth == CV_8U )
  79.         func = pyrDown_<FixPtCast<uchar, 8>, PyrDownVec_32s8u>;
  80.     else if( depth == CV_16S )
  81.         func = pyrDown_<FixPtCast<short, 8>, PyrDownVec_32s16s >;
  82.     else if( depth == CV_16U )
  83.         func = pyrDown_<FixPtCast<ushort, 8>, PyrDownVec_32s16u >;
  84.     else if( depth == CV_32F )
  85.         func = pyrDown_<FltCast<float, 8>, PyrDownVec_32f>;
  86.     else if( depth == CV_64F )
  87.         func = pyrDown_<FltCast<double, 8>, PyrDownNoVec<double, double> >;
  88.     else
  89.         CV_Error( CV_StsUnsupportedFormat, "" );
  92.     func( src, dst, borderType );
  93. }
  99. 可以理解拉普拉斯金字塔是高斯金字塔的逆行式。

尺寸调整：resize（）函数

  1. void resize( InputArray src, OutputArray dst, Size dsize, double fx = 0, double fy = 0, int interpolation = INTER_LINEAR );
  7. void cv::resize( InputArray _src, OutputArray _dst, Size dsize,
  8.                  double inv_scale_x, double inv_scale_y, int interpolation )
  9. {
  10.     static ResizeFunc linear_tab[] =
  11.     {
  12.         resizeGeneric_<
  13.             HResizeLinear<uchar, int, short,
  14.                 INTER_RESIZE_COEF_SCALE,
  15.                 HResizeLinearVec_8u32s>,
  16.             VResizeLinear<uchar, int, short,
  17.                 FixedPtCast<int, uchar, INTER_RESIZE_COEF_BITS*2>,
  18.                 VResizeLinearVec_32s8u> >,
  19.         0,
  20.         resizeGeneric_<
  21.             HResizeLinear<ushort, float, float, 1,
  22.                 HResizeLinearVec_16u32f>,
  23.             VResizeLinear<ushort, float, float, Cast<float, ushort>,
  24.                 VResizeLinearVec_32f16u> >,
  25.         resizeGeneric_<
  26.             HResizeLinear<short, float, float, 1,
  27.                 HResizeLinearVec_16s32f>,
  28.             VResizeLinear<short, float, float, Cast<float, short>,
  29.                 VResizeLinearVec_32f16s> >,
  30.         0,
  31.         resizeGeneric_<
  32.             HResizeLinear<float, float, float, 1,
  33.                 HResizeLinearVec_32f>,
  34.             VResizeLinear<float, float, float, Cast<float, float>,
  35.                 VResizeLinearVec_32f> >,
  36.         resizeGeneric_<
  37.             HResizeLinear<double, double, float, 1,
  38.                 HResizeNoVec>,
  39.             VResizeLinear<double, double, float, Cast<double, double>,
  40.                 VResizeNoVec> >,
  41.         0
  42.     };
  44.     static ResizeFunc cubic_tab[] =
  45.     {
  46.         resizeGeneric_<
  47.             HResizeCubic<uchar, int, short>,
  48.             VResizeCubic<uchar, int, short,
  49.                 FixedPtCast<int, uchar, INTER_RESIZE_COEF_BITS*2>,
  50.                 VResizeCubicVec_32s8u> >,
  51.         0,
  52.         resizeGeneric_<
  53.             HResizeCubic<ushort, float, float>,
  54.             VResizeCubic<ushort, float, float, Cast<float, ushort>,
  55.             VResizeCubicVec_32f16u> >,
  56.         resizeGeneric_<
  57.             HResizeCubic<short, float, float>,
  58.             VResizeCubic<short, float, float, Cast<float, short>,
  59.             VResizeCubicVec_32f16s> >,
  60.         0,
  61.         resizeGeneric_<
  62.             HResizeCubic<float, float, float>,
  63.             VResizeCubic<float, float, float, Cast<float, float>,
  64.             VResizeCubicVec_32f> >,
  65.         resizeGeneric_<
  66.             HResizeCubic<double, double, float>,
  67.             VResizeCubic<double, double, float, Cast<double, double>,
  68.             VResizeNoVec> >,
  69.         0
  70.     };
  72.     static ResizeFunc lanczos4_tab[] =
  73.     {
  74.         resizeGeneric_<HResizeLanczos4<uchar, int, short>,
  75.             VResizeLanczos4<uchar, int, short,
  76.             FixedPtCast<int, uchar, INTER_RESIZE_COEF_BITS*2>,
  77.             VResizeNoVec> >,
  78.         0,
  79.         resizeGeneric_<HResizeLanczos4<ushort, float, float>,
  80.             VResizeLanczos4<ushort, float, float, Cast<float, ushort>,
  81.             VResizeLanczos4Vec_32f16u> >,
  82.         resizeGeneric_<HResizeLanczos4<short, float, float>,
  83.             VResizeLanczos4<short, float, float, Cast<float, short>,
  84.             VResizeLanczos4Vec_32f16s> >,
  85.         0,
  86.         resizeGeneric_<HResizeLanczos4<float, float, float>,
  87.             VResizeLanczos4<float, float, float, Cast<float, float>,
  88.             VResizeLanczos4Vec_32f> >,
  89.         resizeGeneric_<HResizeLanczos4<double, double, float>,
  90.             VResizeLanczos4<double, double, float, Cast<double, double>,
  91.             VResizeNoVec> >,
  92.         0
  93.     };
  95.     static ResizeAreaFastFunc areafast_tab[] =
  96.     {
  97.         resizeAreaFast_<uchar, int, ResizeAreaFastVec<uchar, ResizeAreaFastVec_SIMD_8u> >,
  98.         0,
  99.         resizeAreaFast_<ushort, float, ResizeAreaFastVec<ushort, ResizeAreaFastVec_SIMD_16u> >,
  100.         resizeAreaFast_<short, float, ResizeAreaFastVec<short, ResizeAreaFastVec_SIMD_16s> >,
  101.         0,
  102.         resizeAreaFast_<float, float, ResizeAreaFastVec_SIMD_32f>,
  103.         resizeAreaFast_<double, double, ResizeAreaFastNoVec<double, double> >,
  104.         0
  105.     };
  107.     static ResizeAreaFunc area_tab[] =
  108.     {
  109.         resizeArea_<uchar, float>, 0, resizeArea_<ushort, float>,
  110.         resizeArea_<short, float>, 0, resizeArea_<float, float>,
  111.         resizeArea_<double, double>, 0
  112.     };
  114.     Size ssize = _src.size();
  116.     CV_Assert( ssize.area() > 0 );
  117.     CV_Assert( dsize.area() > 0 || (inv_scale_x > 0 && inv_scale_y > 0) );
  118.     if( dsize.area() == 0 )
  119.     {
  120.         dsize = Size(saturate_cast<int>(ssize.width*inv_scale_x),
  121.                      saturate_cast<int>(ssize.height*inv_scale_y));
  122.         CV_Assert( dsize.area() > 0 );
  123.     }
  124.     else
  125.     {
  126.         inv_scale_x = (double)dsize.width/ssize.width;
  127.         inv_scale_y = (double)dsize.height/ssize.height;
  128.     }
  130.     CV_OCL_RUN(_src.dims() <= 2 && _dst.isUMat() && _src.cols() > 10 && _src.rows() > 10,
  131.                ocl_resize(_src, _dst, dsize, inv_scale_x, inv_scale_y, interpolation))
  133.     Mat src = _src.getMat();
  134.     _dst.create(dsize, src.type());
  135.     Mat dst = _dst.getMat();
  137. #ifdef HAVE_TEGRA_OPTIMIZATION
  138.     if (tegra::useTegra() && tegra::resize(src, dst, (float)inv_scale_x, (float)inv_scale_y, interpolation))
  139.         return;
  140. #endif
  142.     int type = src.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
  143.     double scale_x = 1./inv_scale_x, scale_y = 1./inv_scale_y;
  144.     int k, sx, sy, dx, dy;
  146.     int iscale_x = saturate_cast<int>(scale_x);
  147.     int iscale_y = saturate_cast<int>(scale_y);
  149.     bool is_area_fast = std::abs(scale_x - iscale_x) < DBL_EPSILON &&
  150.             std::abs(scale_y - iscale_y) < DBL_EPSILON;
  152. #if IPP_VERSION_X100 >= 701
  153.     CV_IPP_CHECK()
  154.     {
  155. #define IPP_RESIZE_EPS 1e-10
  157.         double ex = fabs((double)dsize.width / src.cols  - inv_scale_x) / inv_scale_x;
  158.         double ey = fabs((double)dsize.height / src.rows - inv_scale_y) / inv_scale_y;
  160.         if ( ((ex < IPP_RESIZE_EPS && ey < IPP_RESIZE_EPS && depth != CV_64F) || (ex == 0 && ey == 0 && depth == CV_64F)) &&
  161.              (interpolation == INTER_LINEAR || interpolation == INTER_CUBIC) &&
  162.              !(interpolation == INTER_LINEAR && is_area_fast && iscale_x == 2 && iscale_y == 2 && depth == CV_8U))
  163.         {
  164.             int mode = -1;
  165.             if (interpolation == INTER_LINEAR && src.rows >= 2 && src.cols >= 2)
  166.                 mode = ippLinear;
  167.             else if (interpolation == INTER_CUBIC && src.rows >= 4 && src.cols >= 4)
  168.                 mode = ippCubic;
  170.             if( mode >= 0 && (cn == 1 || cn == 3 || cn == 4) &&
  171.                 (depth == CV_16U || depth == CV_16S || depth == CV_32F ||
  172.                 (depth == CV_64F && mode == ippLinear)))
  173.             {
  174.                 bool ok = true;
  175.                 Range range(0, src.rows);
  176.                 IPPresizeInvoker invoker(src, dst, inv_scale_x, inv_scale_y, mode, &ok);
  177.                 parallel_for_(range, invoker, dst.total()/(double)(1<<16));
  178.                 if( ok )
  179.                 {
  180.                     CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
  181.                     return;
  182.                 }
  183.                 setIppErrorStatus();
  184.             }
  185.         }
  186. #undef IPP_RESIZE_EPS
  187.     }
  188. #endif
  190.     if( interpolation == INTER_NEAREST )
  191.     {
  192.         resizeNN( src, dst, inv_scale_x, inv_scale_y );
  193.         return;
  194.     }
  196.     {
  197.         // in case of scale_x && scale_y is equal to 2
  198.         // INTER_AREA (fast) also is equal to INTER_LINEAR
  199.         if( interpolation == INTER_LINEAR && is_area_fast && iscale_x == 2 && iscale_y == 2 )
  200.             interpolation = INTER_AREA;
  202.         // true "area" interpolation is only implemented for the case (scale_x <= 1 && scale_y <= 1).
  203.         // In other cases it is emulated using some variant of bilinear interpolation
  204.         if( interpolation == INTER_AREA && scale_x >= 1 && scale_y >= 1 )
  205.         {
  206.             if( is_area_fast )
  207.             {
  208.                 int area = iscale_x*iscale_y;
  209.                 size_t srcstep = src.step / src.elemSize1();
  210.                 AutoBuffer<int> _ofs(area + dsize.width*cn);
  211.                 int* ofs = _ofs;
  212.                 int* xofs = ofs + area;
  213.                 ResizeAreaFastFunc func = areafast_tab[depth];
  214.                 CV_Assert( func != 0 );
  216.                 for( sy = 0, k = 0; sy < iscale_y; sy++ )
  217.                     for( sx = 0; sx < iscale_x; sx++ )
  218.                         ofs[k++] = (int)(sy*srcstep + sx*cn);
  220.                 for( dx = 0; dx < dsize.width; dx++ )
  221.                 {
  222.                     int j = dx * cn;
  223.                     sx = iscale_x * j;
  224.                     for( k = 0; k < cn; k++ )
  225.                         xofs[j + k] = sx + k;
  226.                 }
  228.                 func( src, dst, ofs, xofs, iscale_x, iscale_y );
  229.                 return;
  230.             }
  232.             ResizeAreaFunc func = area_tab[depth];
  233.             CV_Assert( func != 0 && cn <= 4 );
  235.             AutoBuffer<DecimateAlpha> _xytab((ssize.width + ssize.height)*2);
  236.             DecimateAlpha* xtab = _xytab, *ytab = xtab + ssize.width*2;
  238.             int xtab_size = computeResizeAreaTab(ssize.width, dsize.width, cn, scale_x, xtab);
  239.             int ytab_size = computeResizeAreaTab(ssize.height, dsize.height, 1, scale_y, ytab);
  241.             AutoBuffer<int> _tabofs(dsize.height + 1);
  242.             int* tabofs = _tabofs;
  243.             for( k = 0, dy = 0; k < ytab_size; k++ )
  244.             {
  245.                 if( k == 0 || ytab[k].di != ytab[k-1].di )
  246.                 {
  247.                     assert( ytab[k].di == dy );
  248.                     tabofs[dy++] = k;
  249.                 }
  250.             }
  251.             tabofs[dy] = ytab_size;
  253.             func( src, dst, xtab, xtab_size, ytab, ytab_size, tabofs );
  254.             return;
  255.         }
  256.     }
  258.     int xmin = 0, xmax = dsize.width, width = dsize.width*cn;
  259.     bool area_mode = interpolation == INTER_AREA;
  260.     bool fixpt = depth == CV_8U;
  261.     float fx, fy;
  262.     ResizeFunc func=0;
  263.     int ksize=0, ksize2;
  264.     if( interpolation == INTER_CUBIC )
  265.         ksize = 4, func = cubic_tab[depth];
  266.     else if( interpolation == INTER_LANCZOS4 )
  267.         ksize = 8, func = lanczos4_tab[depth];
  268.     else if( interpolation == INTER_LINEAR || interpolation == INTER_AREA )
  269.         ksize = 2, func = linear_tab[depth];
  270.     else
  271.         CV_Error( CV_StsBadArg, "Unknown interpolation method" );
  272.     ksize2 = ksize/2;
  274.     CV_Assert( func != 0 );
  276.     AutoBuffer<uchar> _buffer((width + dsize.height)*(sizeof(int) + sizeof(float)*ksize));
  277.     int* xofs = (int*)(uchar*)_buffer;
  278.     int* yofs = xofs + width;
  279.     float* alpha = (float*)(yofs + dsize.height);
  280.     short* ialpha = (short*)alpha;
  281.     float* beta = alpha + width*ksize;
  282.     short* ibeta = ialpha + width*ksize;
  283.     float cbuf[MAX_ESIZE];
  285.     for( dx = 0; dx < dsize.width; dx++ )
  286.     {
  287.         if( !area_mode )
  288.         {
  289.             fx = (float)((dx+0.5)*scale_x - 0.5);
  290.             sx = cvFloor(fx);
  291.             fx -= sx;
  292.         }
  293.         else
  294.         {
  295.             sx = cvFloor(dx*scale_x);
  296.             fx = (float)((dx+1) - (sx+1)*inv_scale_x);
  297.             fx = fx <= 0 ? 0.f : fx - cvFloor(fx);
  298.         }
  300.         if( sx < ksize2-1 )
  301.         {
  302.             xmin = dx+1;
  303.             if( sx < 0 && (interpolation != INTER_CUBIC && interpolation != INTER_LANCZOS4))
  304.                 fx = 0, sx = 0;
  305.         }
  307.         if( sx + ksize2 >= ssize.width )
  308.         {
  309.             xmax = std::min( xmax, dx );
  310.             if( sx >= ssize.width-1 && (interpolation != INTER_CUBIC && interpolation != INTER_LANCZOS4))
  311.                 fx = 0, sx = ssize.width-1;
  312.         }
  314.         for( k = 0, sx *= cn; k < cn; k++ )
  315.             xofs[dx*cn + k] = sx + k;
  317.         if( interpolation == INTER_CUBIC )
  318.             interpolateCubic( fx, cbuf );
  319.         else if( interpolation == INTER_LANCZOS4 )
  320.             interpolateLanczos4( fx, cbuf );
  321.         else
  322.         {
  323.             cbuf[0] = 1.f - fx;
  324.             cbuf[1] = fx;
  325.         }
  326.         if( fixpt )
  327.         {
  328.             for( k = 0; k < ksize; k++ )
  329.                 ialpha[dx*cn*ksize + k] = saturate_cast<short>(cbuf[k]*INTER_RESIZE_COEF_SCALE);
  330.             for( ; k < cn*ksize; k++ )
  331.                 ialpha[dx*cn*ksize + k] = ialpha[dx*cn*ksize + k - ksize];
  332.         }
  333.         else
  334.         {
  335.             for( k = 0; k < ksize; k++ )
  336.                 alpha[dx*cn*ksize + k] = cbuf[k];
  337.             for( ; k < cn*ksize; k++ )
  338.                 alpha[dx*cn*ksize + k] = alpha[dx*cn*ksize + k - ksize];
  339.         }
  340.     }
  342.     for( dy = 0; dy < dsize.height; dy++ )
  343.     {
  344.         if( !area_mode )
  345.         {
  346.             fy = (float)((dy+0.5)*scale_y - 0.5);
  347.             sy = cvFloor(fy);
  348.             fy -= sy;
  349.         }
  350.         else
  351.         {
  352.             sy = cvFloor(dy*scale_y);
  353.             fy = (float)((dy+1) - (sy+1)*inv_scale_y);
  354.             fy = fy <= 0 ? 0.f : fy - cvFloor(fy);
  355.         }
  357.         yofs[dy] = sy;
  358.         if( interpolation == INTER_CUBIC )
  359.             interpolateCubic( fy, cbuf );
  360.         else if( interpolation == INTER_LANCZOS4 )
  361.             interpolateLanczos4( fy, cbuf );
  362.         else
  363.         {
  364.             cbuf[0] = 1.f - fy;
  365.             cbuf[1] = fy;
  366.         }
  368.         if( fixpt )
  369.         {
  370.             for( k = 0; k < ksize; k++ )
  371.                 ibeta[dy*ksize + k] = saturate_cast<short>(cbuf[k]*INTER_RESIZE_COEF_SCALE);
  372.         }
  373.         else
  374.         {
  375.             for( k = 0; k < ksize; k++ )
  376.                 beta[dy*ksize + k] = cbuf[k];
  377.         }
  378.     }
  380.     func( src, dst, xofs, fixpt ? (void*)ialpha : (void*)alpha, yofs,
  381.           fixpt ? (void*)ibeta : (void*)beta, xmin, xmax, ksize );
  382. }

发表评论

表情：
评论列表 （有 0 条评论，473人围观）

还没有评论，来说两句吧...

相关阅读

    相关 模型尺寸与缩放问题

    前要：前段时间因为项目开发，3d美术做的模型是非人形模型，不需要绑定骨骼，美术做的了第一版后面需要修改，但是替换的时候发现美术的子物体缩放值都没有统一，美术每次修改都会变换，但

    雨点打透心脏的1/2处雨点打透心脏的1/2处/ 0 赞/ 84 阅读

    相关 图像缩放算法

    怎样计算缩放比例？ 有四种方法：1.对角线法，以对角线长度为准，其伸长者为放大，缩短者为缩小，其底边并行线即为新尺寸。2.计算器法，先输入欲缩放宽度，按除键，再输入原稿尺

    淡淡的烟草味﹌淡淡的烟草味﹌/ 0 赞/ 35 阅读

    相关 OpenCV 几何变换-图像缩放

    图像的缩放主要用于改变图像的大小，缩放后图像的图像的宽度和高度会发生变化。在图像处理中是一种很基础的几何变换，但是具有很重要的作用，比如：当输入图片尺寸过大时，处理速度会很慢，

    灰太狼灰太狼/ 0 赞/ 495 阅读