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

opencv 插值方式_opencv 像素灰度值的插值方法 海康威视

作者：小蓝xlanll | 2024-04-14 16:30:28

赞

踩

opencv 像素灰度值的插值方法 海康威视

一、插值方式与resize()的关系

resize()函数里面包含插值的几种方式：

  1. void resize(InputArray src,//输入，原图像，即待改变大小的图像；
  2.  OutputArray dst,  //输出，改变大小之后的图像，这个图像和原图像具有相同的内容，只是大小和原图像不一样而已；
  3.  Size dsize,  //输出图像的大小。如果这个参数不为0，那么就代表将原图像缩放到这个Size(width，height)指定的大小；如果这个参数为0，那么原图像缩放之后的大小就要通过下面的公式来计算：
  4.  double fx=0, // width方向的缩放比例，如果它是0，那么它就会按照(double)dsize.width/src.cols来计算；
  5.  double fy=0, //height方向的缩放比例，如果它是0，那么它就会按照(double)dsize.height/src.rows来计算；
  6.  int interpolation=INTER_LINEAR// 这个是指定插值的方式，图像缩放之后，肯定像素要进行重新计算的，就靠这个参数来指定重新计算像素的方式，有以下几种：
  7.       INTER_NEAREST - 最邻近插值
  8.       INTER_LINEAR - 双线性插值，如果最后一个参数你不指定，默认使用这种方法
  9.       INTER_AREA -区域插值 resampling using pixel area relation. It may be a preferred method for image decimation, as it gives moire’-free results. But when the image is zoomed, it is similar to the INTER_NEAREST method.
  10.       INTER_CUBIC - 4x4像素邻域内的双立方插值
  11.       INTER_LANCZOS4 - 8x8像素邻域内的Lanczos插值
  12.  );
  13.  使用注意事项：
  14.    dsize和fx/fy不能同时为0，

 ​

 

二、近邻插值INTER_NEAREST

最近邻插值法， 找到与之距离最相近的邻居（原来就存在的像素点， 黑点）， 赋值与其相同。

实现opencv中常用的三种插值算法 - 简书 

​

 

  1. //最近邻域插值
  2. //根据目标图像的像素点（浮点坐标）找到原始图像中的4个像素点，取距离该像素点最近的一个原始像素值作为该点的值。
  3.  
  4. #include<opencv2/opencv.hpp>
  5. #include<cassert>
  6.  
  7. namespace mycv {
  8.     void nearestIntertoplation(cv::Mat& src, cv::Mat& dst, const int rows, const int cols);
  9. }//mycv
  10.  
  11. double distance(const double x1, const double y1, const double x2, const double y2);//两点之间距离，这里用欧式距离
  12.  
  13. int main()
  14. {
  15.     cv::Mat img = cv::imread("lena.jpg", 0);
  16.     if (img.empty()) return -1;
  17.     cv::Mat dst;
  18.     mycv::nearestIntertoplation(img, dst, 600, 600);
  19.     cv::imshow("img", img);
  20.     cv::imshow("dst", dst);
  21.     cv::waitKey(0);
  22.     return 0;
  23.     return 0;
  24. }//main
  25.  
  26. void mycv::nearestIntertoplation(cv::Mat& src, cv::Mat& dst, const int rows, const int cols)
  27. {
  28.     //比例尺
  29.     const double scale_row = static_cast<double>(src.rows) / rows;
  30.     const double scale_col = static_cast<double>(src.rows) / cols;
  31.  
  32.     //扩展src到dst
  33.     dst = cv::Mat(rows, cols, src.type());
  34.     assert(src.channels() == 1 && dst.channels() == 1);
  35.  
  36.     for (int i = 0; i < rows; ++i)//dst的行
  37.         for (int j = 0; j < cols; ++j)//dst的列
  38.         {
  39.             //求插值的四个点
  40.             double y = (i + 0.5) * scale_row + 0.5;
  41.             double x = (j + 0.5) * scale_col + 0.5;
  42.             int x1 = static_cast<int>(x);//col对应x
  43.             if (x1 >= (src.cols - 2)) x1 = src.cols - 2;//防止越界
  44.             int x2 = x1 + 1;
  45.             int y1 = static_cast<int>(y);//row对应y
  46.             if (y1 >= (src.rows - 2))  y1 = src.rows - 2;
  47.             int y2 = y1 + 1;
  48.             //根据目标图像的像素点（浮点坐标）找到原始图像中的4个像素点，取距离该像素点最近的一个原始像素值作为该点的值。
  49.             assert(0 < x2 && x2 < src.cols && 0 < y2 &&  y2 < src.rows);
  50.             std::vector<double> dist(4);
  51.             dist[0] = distance(x, y, x1, y1);
  52.             dist[1] = distance(x, y, x2, y1);
  53.             dist[2] = distance(x, y, x1, y2);
  54.             dist[3] = distance(x, y, x2, y2);
  55.  
  56.             int min_val = dist[0];
  57.             int min_index = 0;
  58.             for (int i = 1; i < dist.size(); ++i)
  59.                 if (min_val > dist[i])
  60.                 {
  61.                     min_val = dist[i];
  62.                     min_index = i;
  63.                 }
  64.  
  65.             switch (min_index)
  66.             {
  67.             case 0:
  68.                 dst.at<uchar>(i, j) = src.at<uchar>(y1, x1);
  69.                 break;
  70.             case 1:
  71.                 dst.at<uchar>(i, j) = src.at<uchar>(y1, x2);
  72.                 break;
  73.             case 2:
  74.                 dst.at<uchar>(i, j) = src.at<uchar>(y2, x1);
  75.                 break;
  76.             case 3:
  77.                 dst.at<uchar>(i, j) = src.at<uchar>(y2, x2);
  78.                 break;
  79.             default:
  80.                 assert(false);
  81.             }           
  82.         }
  83. }
  84.  
  85. double distance(const double x1, const double y1, const double x2, const double y2)//两点之间距离，这里用欧式距离
  86. {
  87.     return (x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2);//只需比较大小，返回距离平方即可
  88. }

 三、线性插值

已知两点（红色） ，在给出一个蓝点的x坐标， 求y。

 

  1. //线性内插（双线性插值)
  2. #include<opencv2/opencv.hpp>
  3. #include<opencv2/core/matx.hpp>
  4. #include<cassert>
  5.  
  6. namespace mycv {
  7.     void bilinearIntertpolatioin(cv::Mat& src, cv::Mat& dst, const int rows, const int cols);
  8. }//mycv
  9.  
  10. int main()
  11. {
  12.     cv::Mat img = cv::imread("lena.jpg", 0);
  13.     if (img.empty()) return -1;
  14.     cv::Mat dst;
  15.     mycv::bilinearIntertpolatioin(img, dst, 600, 600);
  16.     cv::imshow("img", img);
  17.     cv::imshow("dst", dst);
  18.     cv::waitKey(0);
  19.     return 0;
  20. }//main
  21.  
  22. void mycv::bilinearIntertpolatioin(cv::Mat& src, cv::Mat& dst, const int rows, const int cols)
  23. {
  24.     //比例尺
  25.     const double scale_row = static_cast<double>(src.rows) / rows;
  26.     const double scale_col = static_cast<double>(src.rows) / cols;
  27.  
  28.     //扩展src到dst
  29.     dst = cv::Mat(rows, cols, src.type());
  30.     assert(src.channels() == 1 && dst.channels() == 1);
  31.     
  32.     for(int i = 0; i < rows; ++i)//dst的行
  33.         for (int j = 0; j < cols; ++j)//dst的列
  34.         {
  35.             //求插值的四个点
  36.             double y = (i + 0.5) * scale_row + 0.5;
  37.             double x = (j + 0.5) * scale_col + 0.5;
  38.             int x1 = static_cast<int>(x);//col对应x
  39.             if (x1 >= (src.cols - 2)) x1 = src.cols - 2;//防止越界
  40.             int x2 = x1 + 1;
  41.             int y1 = static_cast<int>(y);//row对应y
  42.             if (y1 >= (src.rows - 2))  y1 = src.rows - 2;
  43.             int y2 = y1 + 1;
  44.  
  45.             assert(0 < x2 && x2 < src.cols && 0 < y2 &&  y2 < src.rows);
  46.             //插值公式,参考维基百科矩阵相乘的公式https://zh.wikipedia.org/wiki/%E5%8F%8C%E7%BA%BF%E6%80%A7%E6%8F%92%E5%80%BC
  47.     
  48.             cv::Matx12d matx = { x2 - x, x - x1 };
  49.             cv::Matx22d matf = { static_cast<double>(src.at<uchar>(y1, x1)), static_cast<double>(src.at<uchar>(y2, x1)),
  50.                                  static_cast<double>(src.at<uchar>(y1, x2)), static_cast<double>(src.at<uchar>(y2, x2)) };
  51.             cv::Matx21d maty = {
  52.                 y2 - y,
  53.                 y - y1
  54.             };
  55.  
  56.             auto  val = (matx * matf * maty);
  57.             dst.at<uchar>(i, j) = val(0,0);
  58.         }
  59.  
  60. }

四、双三次插值

在数值分析这个数学分支中，双三次插值（英语：Bicubic interpolation）是二维空间中最常用的插值方法。在这种方法中，函数 f 在点 (x, y) 的值可以通过矩形网格中最近的十六个采样点的加权平均得到，在这里需要使用两个多项式插值三次函数，每个方向使用一个

双三次插值计算公式​
 

​ 

 

那么这个a(i, j)便是介绍里面所说的加权系数了，所以关键是要把它求解出来。

求解加权系数的公式如下​

 

  1.  
  2. 求解加强系数代码如下：
  3.  
  4. std::vector<double> mycv::getW(double coor, double a)
  5. {
  6.     std::vector<double> w(4);
  7.     int base = static_cast<int>(coor);//取整作为基准
  8.     double e = coor - static_cast<double>(base);//多出基准的小数部分
  9.     std::vector<double> tmp(4);//存放公式中 |x| <= 1,  1 < |x| < 2四个值
  10.     // 4 x 4的16个点，所以tmp[0]和tmp[4]距离较远，值在[1, 2]区间
  11.     tmp[0] = 1.0 + e;// 1 < x < 2
  12.     tmp[1] = e;//x <= 1
  13.     tmp[2] = 1.0 - e;// x <= 1
  14.     tmp[3] = 2.0 - e;// 1 < x < 2
  15.  
  16.     //按照bicubic公式计算系数w
  17.     // x <= 1
  18.     w[1] = (a + 2.0) * std::abs(std::pow(tmp[1], 3)) - (a + 3.0) * std::abs(std::pow(tmp[1], 2)) + 1;
  19.     w[2] = (a + 2.0) * std::abs(std::pow(tmp[2], 3)) - (a + 3.0) * std::abs(std::pow(tmp[2], 2)) + 1;
  20.     // 1 < x < 2
  21.     w[0] = a * std::abs(std::pow(tmp[0], 3)) - 5.0 * a * std::abs(std::pow(tmp[0], 2)) + 8.0*a*std::abs(tmp[0]) - 4.0*a;
  22.     w[3] = a * std::abs(std::pow(tmp[3], 3)) - 5.0 * a * std::abs(std::pow(tmp[3], 2)) + 8.0*a*std::abs(tmp[3]) - 4.0*a;
  23.  
  24.     return w;
  25. }
  26.  
  27. 求解出来之后，wx和wy就是4x4组成的16个系数，与插值所需要用到4x4的16个点相匹配。插值步骤的关键代码
  28.  
  29.                 //4x4数量的点(rr, cc) -> (y, x)
  30.                 std::vector<std::vector<int> > src_arr = {
  31.                     { src.at<uchar>(rr - 1, cc - 1), src.at<uchar>(rr, cc - 1), src.at<uchar>(rr + 1, cc - 1), src.at<uchar>(rr + 2, cc - 1)},
  32.                     { src.at<uchar>(rr - 1, cc), src.at<uchar>(rr, cc), src.at<uchar>(rr + 1, cc), src.at<uchar>(rr + 2, cc)},
  33.                     { src.at<uchar>(rr - 1, cc + 1), src.at<uchar>(rr, cc + 1), src.at<uchar>(rr + 1, cc + 1), src.at<uchar>(rr + 2, cc + 1)},
  34.                     { src.at<uchar>(rr - 1, cc + 2), src.at<uchar>(rr, cc + 2), src.at<uchar>(rr + 1, cc + 2), src.at<uchar>(rr + 2, cc + 2)}
  35.                 };
  36.                 for(int p = 0; p < 3; ++p)
  37.                     for (int q = 0; q < 3; ++q)
  38.                     {
  39.                         //val(p, q) = w(p,q) * src(p, q)
  40.                         val += wr[p] * wc[q] * static_cast<double>(src_arr[p][q]);
  41.                     }
  42.                 assert(i < dst.rows && j < dst.cols);
  43.                 dst.at<uchar>(i, j) = static_cast<int>(val);
  44.  
  45.  
  46.  
  47.  
  48.  
  49.  
  50.  
  51.  
  52.  
  53.  
  54.  
  55.  
  56.  
  57.  
  58.  
  59. //双三次插值
  60.  
  61. #include<opencv2/opencv.hpp>
  62. #include<iostream>
  63. #include<vector>
  64. #include<cassert>
  65.  
  66. namespace mycv {
  67.     void bicubicInsterpolation(cv::Mat& src, cv::Mat& dst, const int rows, const int cols);
  68.     std::vector<double> getW(double coor, double a = -0.5);//a默认-0.5
  69. }//mycv
  70.  
  71. int main(void)
  72. {
  73.     cv::Mat img = cv::imread("lena.jpg", 0);
  74.     if (img.empty()) return -1;
  75.     cv::Mat dst;
  76.     mycv::bicubicInsterpolation(img, dst, 600, 600);
  77.     cv::imshow("img", img);
  78.     cv::imshow("dst", dst);
  79.     cv::waitKey(0);
  80.     return 0;
  81. }//main
  82.  
  83. void mycv::bicubicInsterpolation(cv::Mat& src, cv::Mat& dst, const int rows, const int cols)
  84. {
  85.     dst = cv::Mat(rows, cols, src.type(), cv::Scalar::all(0));//初始化dst
  86.     //比例尺
  87.     double row_scale = static_cast<double>(src.rows) / rows;
  88.     double col_scale = static_cast<double>(src.cols) / cols;
  89.  
  90.     switch (src.channels())
  91.     {
  92.  
  93.     case 1://灰度
  94.         for(int i = 2; i < dst.rows - 2; ++i)
  95.             for (int j = 2; j < dst.cols - 2; ++j)
  96.             {
  97.                 //计算系数w
  98.                 double r = static_cast<double>(i *  row_scale);
  99.                 double c = static_cast<double>(j *  col_scale);
  100.                 
  101.                 //防止越界
  102.                 if (r < 1.0) r += 1.0;
  103.                 if (c < 1.0) c += 1.0;
  104.             
  105.  
  106.                 std::vector<double> wr = mycv::getW( r);
  107.                 std::vector<double> wc = mycv::getW( c);
  108.                 
  109.                 //最后计算插值得到的灰度值
  110.                 double val = 0;
  111.                 int cc = static_cast<int>(c);
  112.                 int rr = static_cast<int>(r);
  113.                 //防止越界
  114.                 if (cc > src.cols - 3)
  115.                 {
  116.                     cc = src.cols - 3;
  117.                     
  118.                 }
  119.                 if (rr > src.rows - 3) rr = src.rows - 3;
  120.  
  121.                 assert(0 <= (rr - 1) && 0 <= (cc - 1) && (rr + 2) < src.rows && (cc + 2) < src.cols);
  122.  
  123.                 //4x4数量的点(rr, cc) -> (y, x)
  124.                 std::vector<std::vector<int> > src_arr = {
  125.                     { src.at<uchar>(rr - 1, cc - 1), src.at<uchar>(rr, cc - 1), src.at<uchar>(rr + 1, cc - 1), src.at<uchar>(rr + 2, cc - 1)},
  126.                     { src.at<uchar>(rr - 1, cc), src.at<uchar>(rr, cc), src.at<uchar>(rr + 1, cc), src.at<uchar>(rr + 2, cc)},
  127.                     { src.at<uchar>(rr - 1, cc + 1), src.at<uchar>(rr, cc + 1), src.at<uchar>(rr + 1, cc + 1), src.at<uchar>(rr + 2, cc + 1)},
  128.                     { src.at<uchar>(rr - 1, cc + 2), src.at<uchar>(rr, cc + 2), src.at<uchar>(rr + 1, cc + 2), src.at<uchar>(rr + 2, cc + 2)}
  129.                 };
  130.                 for(int p = 0; p < 3; ++p)
  131.                     for (int q = 0; q < 3; ++q)
  132.                     {
  133.                         //val(p, q) = w(p,q) * src(p, q)
  134.                         val += wr[p] * wc[q] * static_cast<double>(src_arr[p][q]);
  135.                     }
  136.                 assert(i < dst.rows && j < dst.cols);
  137.                 dst.at<uchar>(i, j) = static_cast<int>(val);
  138.                 
  139.             }
  140.         break;
  141.     case 3://彩色(原理一样多了两个通道而已)
  142.         break;
  143.     default:
  144.         break;
  145.     }
  146. }
  147.  
  148. std::vector<double> mycv::getW(double coor, double a)
  149. {
  150.     std::vector<double> w(4);
  151.     int base = static_cast<int>(coor);//取整作为基准
  152.     double e = coor - static_cast<double>(base);//多出基准的小数部分
  153.     std::vector<double> tmp(4);//存放公式中 |x| <= 1,  1 < |x| < 2四个值
  154.     // 4 x 4的16个点，所以tmp[0]和tmp[4]距离较远，值在[1, 2]区间
  155.     tmp[0] = 1.0 + e;// 1 < x < 2
  156.     tmp[1] = e;//x <= 1
  157.     tmp[2] = 1.0 - e;// x <= 1
  158.     tmp[3] = 2.0 - e;// 1 < x < 2
  159.  
  160.     //按照bicubic公式计算系数w
  161.     // x <= 1
  162.     w[1] = (a + 2.0) * std::abs(std::pow(tmp[1], 3)) - (a + 3.0) * std::abs(std::pow(tmp[1], 2)) + 1;
  163.     w[2] = (a + 2.0) * std::abs(std::pow(tmp[2], 3)) - (a + 3.0) * std::abs(std::pow(tmp[2], 2)) + 1;
  164.     // 1 < x < 2
  165.     w[0] = a * std::abs(std::pow(tmp[0], 3)) - 5.0 * a * std::abs(std::pow(tmp[0], 2)) + 8.0*a*std::abs(tmp[0]) - 4.0*a;
  166.     w[3] = a * std::abs(std::pow(tmp[3], 3)) - 5.0 * a * std::abs(std::pow(tmp[3], 2)) + 8.0*a*std::abs(tmp[3]) - 4.0*a;
  167.  
  168.     return w;
  169. }

 

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

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

  

闽ICP备14008679号