[关闭]
@FE40536 2019-07-21T13:27:53.000000Z 字数 30518 阅读 830

opencv学习笔记

列表项

C++ opencv

  1. 解释框
  2. //###########################explanation##########################
  4. //################################################################

My Clion project structure（Just for reference, adjust the structure as you need）

project //工程名

bin //可执行文件

cmake-build-debug //调试

img //存放图片

include //头文件

src //.c,.cpp文件

CMakeLists.txt //src中的CMakeLists文件

CMakeLists.txt //project中的CMakeLists文件



  1. #src中的CMakeLists.txt
  2. aux_source_directory (. SRC_LIST)
  3. add_definitions (-DBOOST_ERROR_CODE_HEADER_ONLY -DBOOST_THREAD_USE_LIB)
  5. find_package (OpenCV REQUIRED)
  6. find_package (Threads REQUIRED)
  7. find_package (Boost REQUIRED)
  9. include_directories (../include ${OpenCV_INCLUDE_DIRS})
  11. link_directories (/usr/local/lib)
  13. set (EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)
  14. set (OpenCV_DIR /usr/local/share/OpenCV)
  15. set (CMAKE_CXX_STANDARD 11)
  16. set (BOOST_ROOT /usr/local/inlcude/boost)
  18. add_executable (main ${SRC_LIST})
  19. target_link_libraries (main ${OpenCV_LIBS}  ${BOOST_LIBRARYDIR} boost_thread boost_system Threads::Threads)



  1. #project中的CMakeLists.txt文件
  2. cmake_minimum_required(VERSION 2.8)
  4. project(untitled)
  6. add_subdirectory(src)

Load and Display an Image

Source Code & Analyzing

Mat

imread

namedWindow

imshow

waitKey

  1. #include <opencv2/core.hpp>
  2. #include <opencv2/imgcodecs.hpp>
  3. #include <opencv2/highgui.hpp>
  4. #include <iostream>
  5. #include <string>
  6. using namespace cv;
  7. using namespace std;
  8. int main( int argc, char** argv )
  9. {
  12. //###########################explanation##########################
  13. //设置默认文件名，若含有参数图片则用参数图片，无则用默认的
  14. //################################################################
  15.     String imageName( "./fall.jpg" ); // by default
  16.     if( argc > 1)
  17.     {
  18.         imageName = argv[1];
  19.     }
  23. //###########################explanation##########################
  24. //Mat类用于存放图片，再用imread来读取图片，imread有三种形式
  25. //IMREAD_UNCHANGED (<0) 不做变化的载入图片
  26. //IMREAD_GRAYSCALE (=0) 以纯灰度的格式载入图片
  27. //IMREAD_COLOR () 以RGB格式载入图片
  28. //################################################################
  29.     Mat image;
  30.     image = imread( imageName, IMREAD_COLOR ); // Read the file
  34. //###########################explanation##########################
  35. //判断是否有图像文件
  36. //################################################################
  37.     if( image.empty() )                      // Check for invalid input
  38.     {
  39.         cout <<  "Could not open or find the image" << std::endl ;
  40.         return -1;
  41.     }
  45. //###########################explanation##########################
  46. //namedWindow("Display window",WINDOW_AUTOSIZE);
  47. //第二个参数WINDOW_AUTOSIZE表示按图像原大小展示，且窗口不能缩放
  48. //WINDOW_NORMAL  窗口可以缩放
  49. //WINDOW_KEEPRATIO 保持比例缩放
  50. //WINDOW_FREERATIO 允许不按比例缩放
  51. //################################################################
  52.     namedWindow( "Display window", WINDOW_AUTOSIZE ); // Create a window for display.
  56. //###########################explanation##########################
  57. //imshow("窗口名称",存储图像的容器);
  58. //该函数用于在用namedWindow命名好的窗口展示Mat类image对象存储的图片，窗口名称以imshow里的名称为主
  59. //当namedWindow里的窗口名字和imshow的窗口名字不一样时会有两个窗口出现，最好让名字保持一致，可以用一个变量来统一一下
  60. //################################################################
  61.     imshow( "Display window", image );                // Show our image inside it.
  65. //###########################explanation##########################
  66. //waitKey(0); 用来防止窗口关闭，括号内参数按毫秒来计算，0代表一直开启知道按下任意键
  67. //################################################################
  68.     waitKey(0); // Wait for a keystroke in the window
  69.     return 0;
  70. }



Load, Modify, and Save an Image

code

cvtColor

imwrite

这段代码运行的时候用控制台运行并加上图片文件才会有效果

  1. #include <opencv2/opencv.hpp>
  3. using namespace cv;
  5. int main(int argc, char **argv) {
  6. //###########################explanation##########################
  7. //得到图片参数的名字
  8. //################################################################
  9.     char *imageName = argv[1];
  12. //###########################explanation##########################
  13.  //用Mat容器存储imread得到的图片
  14. //################################################################   
  15.     Mat image;
  16.     image = imread(imageName, IMREAD_COLOR);
  18. //###########################explanation##########################    
  19. //判断是否得到图片
  20. //################################################################   
  21.     if (argc != 2 || !image.data) {
  22.         printf(" No image data \n ");
  23.         return -1;
  24.     }
  28. //###########################explanation##########################
  29. //用Mat类创建一个新的灰度图对象gray_image
  30. //################################################################  
  31.     Mat gray_image;
  35. //###########################explanation##########################
  36. //ctvColor函数需要三个参数(源图像，目标图像，转换方式)
  37. //COLOR_BGR2GRAY 是BGR图像转化为灰度图
  38. //################################################################  
  39.     cvtColor(image, gray_image, COLOR_BGR2GRAY);
  44. //###########################explanation##########################  
  45. //得到了灰度图后用imwrite函数进行保存
  46. //参数为(保存路径,图像对象)
  47. //################################################################  
  48.     imwrite("../../images/Gray_Image.jpg", gray_image);
  49.     namedWindow(imageName, WINDOW_AUTOSIZE);
  50.     namedWindow("Gray image", WINDOW_AUTOSIZE);
  51.     imshow(imageName, image);
  52.     imshow("Gray image", gray_image);
  53.     waitKey(0);
  54.     return 0;
  55. }

Mat - The Basic Image Container

definition

  1. Mat A, C;                          // creates just the header parts
  2. A = imread(argv[1], IMREAD_COLOR); // here we'll know the method used (allocate matrix)
  3. Mat B(A);                                 // Use the copy constructor
  4. C = A;                                    // Assignment operator

ABC全部指向同一个矩阵，但是头部却不一样



devide Mat

  1. Mat D (A, Rect(10, 10, 100, 100) ); // using a rectangle
  2. Mat E = A(Range::all(), Range(1,3)); // using row and column boundaries

可以用Mat存储原图像的一小部分，用长方形或行列来确定边界



copy Mat

  1. Mat F = A.clone();
  2. Mat G;
  3. A.copyTo(G);




Creating a Mat object explicitly

cv::Mat::Mat Constructor

  1. //###########################explanation##########################  
  2. //2,2表示2*2矩阵，CV_8UC3表示用3个数来表示矩阵的一个位置，同理CV_8UC4用4个数表示矩阵的一个位置
  3. //CV_[The number of bits per item][Signed or Unsigned][Type Prefix]C[The channel number]
  4. //################################################################ 
  5. Mat M(2,2, CV_8UC3, Scalar(0,0,255));
  6. cout << "M = " << endl << " " << M << endl << endl;


Use C/C++ arrays and initialize via constructor

  1. int sz[3] = {2,2,2};
  2. Mat L(3,sz, CV_8UC(1), Scalar::all(0));


cv::Mat::create function

不能初始化矩阵，只能重新分配矩阵大小

  1. M.create(4,4, CV_8UC(2));
  2. cout << "M = "<< endl << " "  << M << endl << endl;


MATLAB style initializer: cv::Mat::zeros , cv::Mat::ones , cv::Mat::eye

  1. Mat E = Mat::eye(4, 4, CV_64F);
  2. cout << "E = " << endl << " " << E << endl << endl;
  3. Mat O = Mat::ones(2, 2, CV_32F);
  4. cout << "O = " << endl << " " << O << endl << endl;
  5. Mat Z = Mat::zeros(3,3, CV_8UC1);
  6. cout << "Z = " << endl << " " << Z << endl << endl;


For small matrices you may use comma separated initializers or initializer lists

  1. Mat C = (Mat_<double>(3,3) << 0, -1, 0, -1, 5, -1, 0, -1, 0);
  2. cout << "C = " << endl << " " << C << endl << endl;
  3. C = (Mat_<double>({0, 1, -1, 0, -1, 2, 5, -1, 0, 5, -1, 0, 1, 0, -1, 0})).reshape(4);
  4. cout << "C = " << endl << " " << C << endl << endl;


Create a new header for an existing Mat object and cv::Mat::clone or cv::Mat::copyTo it

  1. Mat RowClone = C.row(1).clone();
  2. cout << "RowClone = " << endl << " " << RowClone << endl << endl;


random fill

  1. Mat R = Mat(3, 2, CV_8UC3);
  2. randu(R, Scalar::all(0), Scalar::all(255));
  3. cout << "R (default) = " << endl << R << endl << endl;


Output formatting

Default

  1. cout << "R (default) = " << endl << R << endl << endl;


Python

  1. cout << "R (python)  = " << endl << format(R, Formatter::FMT_PYTHON) << endl << endl;


Comma separated values (CSV)

  1. cout << "R (csv)     = " << endl << format(R, Formatter::FMT_CSV ) << endl << endl;


Numpy

  1. cout << "R (numpy)   = " << endl << format(R, Formatter::FMT_NUMPY ) << endl << endl;


C

  1. cout << "R (c) = " << endl << format(R, Formatter::FMT_C ) << endl << endl;


Output of other commom items

2D Point

  1. Point2f P(5, 1);
  2. cout << "Point (2D) = " << P << endl << endl;


3D Point

  1. Point3f P3f(2, 6, 7);
  2. cout << "Point (3D) = " << P3f << endl << endl;


std::vector voa cv::Mat

  1. vector<float> v;
  2. v.push_back( (float)CV_PI);   
  3. v.push_back(2);  
  4. v.push_back(3.01f);
  5. cout << "Vector of floats via Mat = " << Mat(v) << endl << endl;


std::vector of points

  1. vector<Point2f> vPoints(20);
  2. for (size_t i = 0; i < vPoints.size(); ++i)
  3. vPoints[i] = Point2f((float)(i * 5), (float)(i % 7));
  4. cout << "A vector of 2D Points = " << vPoints << endl << endl;

How to scan images, lookup tables and time measurement with OpenCV


source code

  1. #include <opencv2/core.hpp>
  2. #include <opencv2/core/utility.hpp>
  3. #include "opencv2/imgcodecs.hpp"
  4. #include <opencv2/highgui.hpp>
  5. #include <iostream>
  6. #include <sstream>
  8. using namespace std;
  9. using namespace cv;
  11. static void help()
  12. {
  13.     cout
  14.         << "\n--------------------------------------------------------------------------" << endl
  15.         << "This program shows how to scan image objects in OpenCV (cv::Mat). As use case"
  16.         << " we take an input image and divide the native color palette (255) with the "  << endl
  17.         << "input. Shows C operator[] method, iterators and at function for on-the-fly item address calculation."<< endl
  18.         << "Usage:"                                                                       << endl
  19.         << "./how_to_scan_images <imageNameToUse> <divideWith> [G]"                       << endl
  20.         << "if you add a G parameter the image is processed in gray scale"                << endl
  21.         << "--------------------------------------------------------------------------"   << endl
  22.         << endl;
  23. }
  25. Mat& ScanImageAndReduceC(Mat& I, const uchar* table);
  26. Mat& ScanImageAndReduceIterator(Mat& I, const uchar* table);
  27. Mat& ScanImageAndReduceRandomAccess(Mat& I, const uchar * table);
  29. int main( int argc, char* argv[])
  30. {
  31.     help();
  32.     if (argc < 3)
  33.     {
  34.         cout << "Not enough parameters" << endl;
  35.         return -1;
  36.     }
  38. //###########################explanation##########################
  39. //读取图像
  40. //################################################################
  41.     Mat I, J;
  42.     if( argc == 4 && !strcmp(argv[3],"G") )
  43.         I = imread(argv[1], IMREAD_GRAYSCALE);
  44.     else
  45.         I = imread(argv[1], IMREAD_COLOR);
  47.     if (I.empty())
  48.     {
  49.         cout << "The image" << argv[1] << " could not be loaded." << endl;
  50.         return -1;
  51.     }
  55. //###########################explanation##########################
  56. //用stringstream来得到int型的dividewidth
  57. //################################################################
  58.     //! [dividewith]
  59.     int divideWith = 0; // convert our input string to number - C++ style
  60.     stringstream s;
  61.     s << argv[2];
  62.     s >> divideWith;
  63.     if (!s || !divideWith)
  64.     {
  65.         cout << "Invalid number entered for dividing. " << endl;
  66.         return -1;
  67.     }
  71. //###########################explanation##########################
  72. //lookup table
  73. //################################################################
  74.     uchar table[256];
  75.     for (int i = 0; i < 256; ++i)
  76.        table[i] = (uchar)(divideWith * (i/divideWith));
  77.     //! [dividewith]
  79.     const int times = 100;
  80.     double t;
  83. //###########################explanation##########################
  84. //检测时间
  85. //################################################################
  86.     t = (double)getTickCount();
  88.     for (int i = 0; i < times; ++i)
  89.     {
  90.         cv::Mat clone_i = I.clone();
  91.         J = ScanImageAndReduceC(clone_i, table);
  92.     }
  94.     t = 1000*((double)getTickCount() - t)/getTickFrequency();
  95.     t /= times;
  97.     cout << "Time of reducing with the C operator [] (averaged for "
  98.          << times << " runs): " << t << " milliseconds."<< endl;
  100.     t = (double)getTickCount();
  102.     for (int i = 0; i < times; ++i)
  103.     {
  104.         cv::Mat clone_i = I.clone();
  105.         J = ScanImageAndReduceIterator(clone_i, table);
  106.     }
  108.     t = 1000*((double)getTickCount() - t)/getTickFrequency();
  109.     t /= times;
  111.     cout << "Time of reducing with the iterator (averaged for "
  112.         << times << " runs): " << t << " milliseconds."<< endl;
  114.     t = (double)getTickCount();
  116.     for (int i = 0; i < times; ++i)
  117.     {
  118.         cv::Mat clone_i = I.clone();
  119.         ScanImageAndReduceRandomAccess(clone_i, table);
  120.     }
  122.     t = 1000*((double)getTickCount() - t)/getTickFrequency();
  123.     t /= times;
  125.     cout << "Time of reducing with the on-the-fly address generation - at function (averaged for "
  126.         << times << " runs): " << t << " milliseconds."<< endl;
  128.     //! [table-init]
  129.     Mat lookUpTable(1, 256, CV_8U);
  130.     uchar* p = lookUpTable.ptr();
  131.     for( int i = 0; i < 256; ++i)
  132.         p[i] = table[i];
  133.     //! [table-init]
  135.     t = (double)getTickCount();
  137.     for (int i = 0; i < times; ++i)
  138.         //! [table-use]
  139.         LUT(I, lookUpTable, J);
  140.         //! [table-use]
  142.     t = 1000*((double)getTickCount() - t)/getTickFrequency();
  143.     t /= times;
  145.     cout << "Time of reducing with the LUT function (averaged for "
  146.         << times << " runs): " << t << " milliseconds."<< endl;
  147.     return 0;
  148. }
  150. //! [scan-c]
  151. Mat& ScanImageAndReduceC(Mat& I, const uchar* const table)
  152. {
  153.     // accept only char type matrices
  154.     CV_Assert(I.depth() == CV_8U);
  156.     int channels = I.channels();
  158.     int nRows = I.rows;
  159.     int nCols = I.cols * channels;
  161.     if (I.isContinuous())
  162.     {
  163.         nCols *= nRows;
  164.         nRows = 1;
  165.     }
  167.     int i,j;
  168.     uchar* p;
  169.     for( i = 0; i < nRows; ++i)
  170.     {
  171.         p = I.ptr<uchar>(i);
  172.         for ( j = 0; j < nCols; ++j)
  173.         {
  174.             p[j] = table[p[j]];
  175.         }
  176.     }
  177.     return I;
  178. }
  179. //! [scan-c]
  181. //! [scan-iterator]
  182. Mat& ScanImageAndReduceIterator(Mat& I, const uchar* const table)
  183. {
  184.     // accept only char type matrices
  185.     CV_Assert(I.depth() == CV_8U);
  187.     const int channels = I.channels();
  188.     switch(channels)
  189.     {
  190.     case 1:
  191.         {
  192.             MatIterator_<uchar> it, end;
  193.             for( it = I.begin<uchar>(), end = I.end<uchar>(); it != end; ++it)
  194.                 *it = table[*it];
  195.             break;
  196.         }
  197.     case 3:
  198.         {
  199.             MatIterator_<Vec3b> it, end;
  200.             for( it = I.begin<Vec3b>(), end = I.end<Vec3b>(); it != end; ++it)
  201.             {
  202.                 (*it)[0] = table[(*it)[0]];
  203.                 (*it)[1] = table[(*it)[1]];
  204.                 (*it)[2] = table[(*it)[2]];
  205.             }
  206.         }
  207.     }
  209.     return I;
  210. }
  211. //! [scan-iterator]
  213. //! [scan-random]
  214. Mat& ScanImageAndReduceRandomAccess(Mat& I, const uchar* const table)
  215. {
  216.     // accept only char type matrices
  217.     CV_Assert(I.depth() == CV_8U);
  219.     const int channels = I.channels();
  220.     switch(channels)
  221.     {
  222.     case 1:
  223.         {
  224.             for( int i = 0; i < I.rows; ++i)
  225.                 for( int j = 0; j < I.cols; ++j )
  226.                     I.at<uchar>(i,j) = table[I.at<uchar>(i,j)];
  227.             break;
  228.         }
  229.     case 3:
  230.         {
  231.          Mat_<Vec3b> _I = I;
  233.          for( int i = 0; i < I.rows; ++i)
  234.             for( int j = 0; j < I.cols; ++j )
  235.                {
  236.                    _I(i,j)[0] = table[_I(i,j)[0]];
  237.                    _I(i,j)[1] = table[_I(i,j)[1]];
  238.                    _I(i,j)[2] = table[_I(i,j)[2]];
  239.             }
  240.          I = _I;
  241.          break;
  242.         }
  243.     }
  245.     return I;
  246. }
  247. //! [scan-random]


Mask operations on matrices


code

  1. #include <opencv2/imgcodecs.hpp>
  2. #include <opencv2/highgui.hpp>
  3. #include <opencv2/imgproc.hpp>
  4. #include <iostream>
  5. using namespace std;
  6. using namespace cv;
  7. static void help(char* progName)
  8. {
  9.     cout << endl
  10.         <<  "This program shows how to filter images with mask: the write it yourself and the"
  11.         << "filter2d way. " << endl
  12.         <<  "Usage:"                                                                        << endl
  13.         << progName << " [image_path -- default ../data/lena.jpg] [G -- grayscale] "        << endl << endl;
  14. }
  15. void Sharpen(const Mat& myImage,Mat& Result);
  16. int main( int argc, char* argv[])
  17. {
  18.     help(argv[0]);
  19.     const char* filename = argc >=2 ? argv[1] : "../data/lena.jpg";
  20.     Mat src, dst0, dst1;
  21.     if (argc >= 3 && !strcmp("G", argv[2]))
  22.         src = imread( filename, IMREAD_GRAYSCALE);
  23.     else
  24.         src = imread( filename, IMREAD_COLOR);
  25.     if (src.empty())
  26.     {
  27.         cerr << "Can't open image ["  << filename << "]" << endl;
  28.         return -1;
  29.     }
  30.     namedWindow("Input", WINDOW_AUTOSIZE);
  31.     namedWindow("Output", WINDOW_AUTOSIZE);
  32.     imshow( "Input", src );
  33.     double t = (double)getTickCount();
  34.     Sharpen( src, dst0 );
  35.     t = ((double)getTickCount() - t)/getTickFrequency();
  36.     cout << "Hand written function time passed in seconds: " << t << endl;
  37.     imshow( "Output", dst0 );
  38.     waitKey();
  39.     Mat kernel = (Mat_<char>(3,3) <<  0, -1,  0,
  40.                                    -1,  5, -1,
  41.                                     0, -1,  0);
  42.     t = (double)getTickCount();
  46. //###########################explanation##########################
  47. //filter2D在opencv2/imgproc.hpp里
  48. //参数为(输入图像对象，输出图像对象，输入图像的depth()，kernel（算法之类的东西）)
  49. //################################################################
  50.     filter2D( src, dst1, src.depth(), kernel );
  51.     t = ((double)getTickCount() - t)/getTickFrequency();
  52.     cout << "Built-in filter2D time passed in seconds:     " << t << endl;
  53.     imshow( "Output", dst1 );
  54.     waitKey();
  55.     return 0;
  56. }
  58. void Sharpen(const Mat& myImage,Mat& Result)
  59. {
  60.     CV_Assert(myImage.depth() == CV_8U);  // accept only uchar images
  61.     const int nChannels = myImage.channels();
  65. //###########################explanation##########################
  66. //用size和type就可以确定一个Mat的样子
  67. //################################################################
  68.     Result.create(myImage.size(),myImage.type());
  69.     for(int j = 1 ; j < myImage.rows-1; ++j)
  70.     {
  71.         const uchar* previous = myImage.ptr<uchar>(j - 1);
  72.         const uchar* current  = myImage.ptr<uchar>(j    );
  73.         const uchar* next     = myImage.ptr<uchar>(j + 1);
  74.         uchar* output = Result.ptr<uchar>(j);
  75.         for(int i= nChannels;i < nChannels*(myImage.cols-1); ++i)
  76.         {
  77.             *output++ = saturate_cast<uchar>(5*current[i]
  78.                          -current[i-nChannels] - current[i+nChannels] - previous[i] - next[i]);
  79.         }
  80.     }
  81.     Result.row(0).setTo(Scalar(0));
  82.     Result.row(Result.rows-1).setTo(Scalar(0));
  83.     Result.col(0).setTo(Scalar(0));
  84.     Result.col(Result.cols-1).setTo(Scalar(0));
  85. }


Operations with images

Input/Output

imread

  1. imread(filename, IMREAD_COLOR);

imwrite

  1. imwite( filename, img );


Basic operations with images

Accessing pixel intensity values

  1. Scalar intensity = img.at<uchar>(y, x);
  3. Scalar intensity = img.at<uchar>(Point(x, y));
  5. //3 channels
  6. Vec3b intensity = img.at<Vec3b>(y, x);
  7. uchar blue = intensity.val[0];
  8. uchar green = intensity.val[1];
  9. uchar red = intensity.val[2];
  11. //float
  12. Vec3f intensity = img.at<Vec3f>(y, x);
  13. float blue = intensity.val[0];
  14. float green = intensity.val[1];
  15. float red = intensity.val[2];
  17. //同样可以用该方法修改像素点的信息
  18. img.at<uchar>(y, x) = 128;
  22. //这里的Mat只有一列
  23. vector<Point2f> points{{3,  2},
  24.                        {2,  2},
  25.                        {89, 3}};
  26. //... fill the array
  27. Mat pointsMat = Mat(points);
  28. Point2f point = pointsMat.at<Point2f>(2, 0);
  29. cout << "x:" << point.x << " y:" << point.y << endl;

Memory management and reference counting

  1. Mat img = imread(argv[1]);
  2. Mat sobelx;
  3. Sobel(img, sobelx, CV_32F, 1, 0);


Primitive operations

  1. img = Scalar(0);
  2. Rect r(10, 10, 100, 100);
  3. Mat smallImg = img(r);
  5. //从类转换到结构体
  6. Mat img = imread("image.jpg");
  7. IplImage img1 = img;
  8. CvMat m = img;
  10. //切割图像
  11. Mat img = imread(argv[1]);
  12. Rect r(10, 500, 1000, 1000);
  13. Mat small_img = img(r);
  14. namedWindow("small_img", WINDOW_NORMAL);
  15. imshow("small_img", small_img);
  16. waitKey();
  19. //格式转换
  20. Mat img = imread("image.jpg"); // loading a 8UC3 image
  21. Mat grey;
  22. cvtColor(img, grey, COLOR_BGR2GRAY);
  25. //Change image type from 8UC1 to 32FC1:
  26. src.convertTo(dst, CV_32F);


Visualizing images

  1. Mat img = imread("image.jpg");
  2. Mat grey;
  3. cvtColor(img, grey, COLOR_BGR2GRAY);
  4. Mat sobelx;
  5. Sobel(grey, sobelx, CV_32F, 1, 0);
  6. double minVal, maxVal;
  7. minMaxLoc(sobelx, &minVal, &maxVal); //find minimum and maximum intensities
  8. Mat draw;
  9. sobelx.convertTo(draw, CV_8U, 255.0/(maxVal - minVal), -minVal * 255.0/(maxVal - minVal));
  10. namedWindow("image", WINDOW_AUTOSIZE);
  11. imshow("image", draw);
  12. waitKey();

Adding (blending) two images using OpenCV

source code

核心公式： 


  1. #include "opencv2/imgcodecs.hpp"
  2. #include "opencv2/highgui.hpp"
  3. #include <iostream>
  5. using namespace cv;
  6. using namespace std;
  8. int main(void) {
  9.     double alpha = 0.5;
  10.     double beta;
  11.     double input;
  12.     Mat src1, src2, dst;
  13.     cout << " Simple Linear Blender " << endl;
  14.     cout << "-----------------------" << endl;
  15.     cout << "* Enter alpha [0.0-1.0]: ";
  16.     cin >> input;
  17.     // We use the alpha provided by the user if it is between 0 and 1
  18.     if (input >= 0 && input <= 1) { alpha = input; }
  19.     src1 = imread("../img/phos.jpg");
  20.     src2 = imread("../img/fall.jpg");
  25. //###########################explanation##########################
  26. //对图像进行切割达到同样大小         
  27. //################################################################
  28.     //Rect_(_Tp _x, _Tp _y, _Tp _width, _Tp _height);
  29.     Rect r(500, 500, 1000, 200);
  30.     src1 = src1(r);
  31.     src2 = src2(r);
  33.     if (src1.empty()) {
  34.         cout << "Error loading src1" << endl;
  35.         return -1;
  36.     }
  37.     if (src2.empty()) {
  38.         cout << "Error loading src2" << endl;
  39.         return -1;
  40.     }
  41.     beta = (1.0 - alpha);
  42.     addWeighted(src1, alpha, src2, beta, 0.0, dst);
  43.     namedWindow("Linear Blend", WINDOW_NORMAL);
  44.     imshow("Linear Blend", dst);
  45.     waitKey(0);
  46.     return 0;
  47. }


Changing the contrast and brightness of an image!

Image Processing

Pixel Transforms

Brightness and contrast adjustments


Code as 

  1. #include "opencv2/imgcodecs.hpp"
  2. #include "opencv2/highgui.hpp"
  3. #include <iostream>
  4. using namespace std;
  5. using namespace cv;
  6. int main( int argc, char** argv )
  7. {
  8.     double alpha = 1.0; /*< Simple contrast control */
  9.     int beta = 0;       /*< Simple brightness control */
  10.     String imageName("../data/lena.jpg"); // by default
  11.     if (argc > 1)
  12.     {
  13.         imageName = argv[1];
  14.     }
  15.     Mat image = imread( imageName );
  20. //###########################explanation##########################
  21. //得到和原图像矩阵同样规格的0矩阵     
  22. //################################################################
  23.     Mat new_image = Mat::zeros( image.size(), image.type() );
  27.     cout << " Basic Linear Transforms " << endl;
  28.     cout << "-------------------------" << endl;
  29.     cout << "* Enter the alpha value [1.0-3.0]: "; cin >> alpha;
  30.     cout << "* Enter the beta value [0-100]: ";    cin >> beta;
  34. //###########################explanation##########################
  35. //对每一个像素点的每一个通道进行变换
  36. //saturate_cast用来保证每个变化后的是有效的
  37. //################################################################
  38. #if 0
  39.     for (int y = 0; y < image.rows; y++) {
  40.         for (int x = 0; x < image.cols; x++) {
  41.             for (int c = 0; c < 3; c++) {
  42.                 new_image.at<Vec3b>(y, x)[c] =
  43.                         saturate_cast<uchar>(alpha * (image.at<Vec3b>(y, x)[c]) + beta);
  44.             }
  45.         }
  46.     }
  47. #endif
  51. //###########################explanation##########################
  52. //另一种实现方式
  53. //################################################################
  54.     image.convertTo(new_image, -1, alpha, beta);
  55.     namedWindow("Original Image", WINDOW_AUTOSIZE);
  56.     namedWindow("New Image", WINDOW_AUTOSIZE);
  57.     imshow("Original Image", image);
  58.     imshow("New Image", new_image);
  59.     waitKey();
  60.     return 0;
  61. }

Practical example

Brightness and contrast adjustments


调整了以后，会得到图中黑色部分的直方图，发现会使直方图整体右移，图像的明度提高了，右边就会出现一条很高的线（由饱和引起）


调整了以后，得到如下图中黑色部分，这时直方图被转移到了中间，图像的对比度提高了


由于引起的饱和，图像可能会丢失一些信息

Gamma correction


修正的核心函数：



由于修正是非线性的，所以每个像素点的修复程度都和本身属性决定

correction Plot


当时，图像的明度会提高，直方图会右移，反之左移

Correct an underexposed image


先用，修正


再用修正


直方图对比(从左到右依次为修正，原图，修正):


Gamma Correction Code

  1. Mat lookUpTable(1, 256, CV_8U);
  2. uchar* p = lookUpTable.ptr();
  3. for( int i = 0; i < 256; ++i)
  4.     p[i] = saturate_cast<uchar>(pow(i / 255.0, gamma) * 255.0);
  5. Mat res = img.clone();
  6. LUT(img, lookUpTable, res);


Basic Drawing

OpenCV Theory

Point

  1. //2D像素点
  2. Point pt;
  3. pt.x = 10;
  4. pt.y = 8;
  6. //or
  7. Point pt =  Point(10, 8);

Scalar

  1. //Blue = a, Green = b and Red = c   对于第四个参数，不需要用到的时候可以不用添加
  2. Scalar( a, b, c )

Code

  1. #include <opencv2/core.hpp>
  2. #include <opencv2/imgproc.hpp>
  3. #include <opencv2/highgui.hpp>
  5. #define w 400
  6. using namespace cv;
  8. void MyEllipse(Mat img, double angle);
  10. void MyFilledCircle(Mat img, Point center);
  12. void MyPolygon(Mat img);
  14. void MyLine(Mat img, Point start, Point end);
  16. int main(void) {
  17. //###########################explanation##########################
  18. //建立空白图像和窗口名称
  19. //################################################################
  20.     char atom_window[] = "Drawing 1: Atom";
  21.     char rook_window[] = "Drawing 2: Rook";
  22.     Mat atom_image = Mat::zeros(w, w, CV_8UC3);
  23.     Mat rook_image = Mat::zeros(w, w, CV_8UC3);
  27. //###########################explanation##########################
  28. //画图
  29. //################################################################
  30.     MyEllipse(atom_image, 90);
  31.     MyEllipse(atom_image, 0);
  32.     MyEllipse(atom_image, 45);
  33.     MyEllipse(atom_image, -45);
  34.     MyFilledCircle(atom_image, Point(w / 2, w / 2));
  35.     MyPolygon(rook_image);
  36.     rectangle(rook_image,
  37.               Point(0, 7 * w / 8),
  38.               Point(w, w),
  39.               Scalar(0, 255, 255),
  40.               FILLED,
  41.               LINE_8);
  42.     MyLine(rook_image, Point(0, 15 * w / 16), Point(w, 15 * w / 16));
  43.     MyLine(rook_image, Point(w / 4, 7 * w / 8), Point(w / 4, w));
  44.     MyLine(rook_image, Point(w / 2, 7 * w / 8), Point(w / 2, w));
  45.     MyLine(rook_image, Point(3 * w / 4, 7 * w / 8), Point(3 * w / 4, w));
  46.     imshow(atom_window, atom_image);
  47.     moveWindow(atom_window, 0, 200);
  48.     imshow(rook_window, rook_image);
  49.     moveWindow(rook_window, w, 200);
  50.     waitKey(0);
  51.     return (0);
  52. }
  54. void MyEllipse(Mat img, double angle) {
  55.     int thickness = 2;
  56.     int lineType = 8;
  57.     ellipse(img,
  58.             Point(w / 2, w / 2),
  59.             Size(w / 4, w / 16),
  60.             angle,
  61.             0,
  62.             360,
  63.             Scalar(255, 0, 0),
  64.             thickness,
  65.             lineType);
  66. }
  68. void MyFilledCircle(Mat img, Point center) {
  69.     circle(img,
  70.            center,
  71.            w / 32,
  72.            Scalar(0, 0, 255),
  73.            FILLED,
  74.            LINE_8);
  75. }
  77. void MyPolygon(Mat img) {
  78.     int lineType = LINE_8;
  79.     Point rook_points[1][20];
  80.     rook_points[0][0] = Point(w / 4, 7 * w / 8);
  81.     rook_points[0][1] = Point(3 * w / 4, 7 * w / 8);
  82.     rook_points[0][2] = Point(3 * w / 4, 13 * w / 16);
  83.     rook_points[0][3] = Point(11 * w / 16, 13 * w / 16);
  84.     rook_points[0][4] = Point(19 * w / 32, 3 * w / 8);
  85.     rook_points[0][5] = Point(3 * w / 4, 3 * w / 8);
  86.     rook_points[0][6] = Point(3 * w / 4, w / 8);
  87.     rook_points[0][7] = Point(26 * w / 40, w / 8);
  88.     rook_points[0][8] = Point(26 * w / 40, w / 4);
  89.     rook_points[0][9] = Point(22 * w / 40, w / 4);
  90.     rook_points[0][10] = Point(22 * w / 40, w / 8);
  91.     rook_points[0][11] = Point(18 * w / 40, w / 8);
  92.     rook_points[0][12] = Point(18 * w / 40, w / 4);
  93.     rook_points[0][13] = Point(14 * w / 40, w / 4);
  94.     rook_points[0][14] = Point(14 * w / 40, w / 8);
  95.     rook_points[0][15] = Point(w / 4, w / 8);
  96.     rook_points[0][16] = Point(w / 4, 3 * w / 8);
  97.     rook_points[0][17] = Point(13 * w / 32, 3 * w / 8);
  98.     rook_points[0][18] = Point(5 * w / 16, 13 * w / 16);
  99.     rook_points[0][19] = Point(w / 4, 13 * w / 16);
  100.     const Point *ppt[1] = {rook_points[0]};
  101.     int npt[] = {20};
  102.     fillPoly(img,
  103.              ppt,
  104.              npt,
  105.              1,
  106.              Scalar(255, 255, 255),
  107.              lineType);
  108. }
  110. void MyLine(Mat img, Point start, Point end) {
  111.     int thickness = 2;
  112.     int lineType = LINE_8;
  113.     line(img,
  114.          start,
  115.          end,
  116.          Scalar(0, 0, 0),
  117.          thickness,
  118.          lineType);
  119. }

ellipse

  1. CV_EXPORTS_W void ellipse(InputOutputArray img, Point center, Size axes,
  2.                         double angle, double startAngle, double endAngle,
  3.                         const Scalar& color, int thickness = 1,
  4.                         int lineType = LINE_8, int shift = 0);

Circle

  1. CV_EXPORTS_W void circle(InputOutputArray img, Point center, int radius,
  2.                        const Scalar& color, int thickness = 1,
  3.                        int lineType = LINE_8, int shift = 0);

line

  1. CV_EXPORTS_W void line(InputOutputArray img, Point pt1, Point pt2, const Scalar& color,
  2.                      int thickness = 1, int lineType = LINE_8, int shift = 0);


Random generator and text with OpenCV

Code

  1. #include <opencv2/core.hpp>
  2. #include <opencv2/imgproc.hpp>
  3. #include <opencv2/highgui.hpp>
  4. #include <iostream>
  5. #include <stdio.h>
  7. using namespace cv;
  9. /// Global Variables
  10. const int NUMBER = 100;
  11. const int DELAY = 5;
  13. const int window_width = 900;
  14. const int window_height = 600;
  15. int x_1 = -window_width/2;
  16. int x_2 = window_width*3/2;
  17. int y_1 = -window_width/2;
  18. int y_2 = window_width*3/2;
  20. /// Function headers
  21. static Scalar randomColor( RNG& rng );
  22. int Drawing_Random_Lines( Mat image, char* window_name, RNG rng );
  23. int Drawing_Random_Rectangles( Mat image, char* window_name, RNG rng );
  24. int Drawing_Random_Ellipses( Mat image, char* window_name, RNG rng );
  25. int Drawing_Random_Polylines( Mat image, char* window_name, RNG rng );
  26. int Drawing_Random_Filled_Polygons( Mat image, char* window_name, RNG rng );
  27. int Drawing_Random_Circles( Mat image, char* window_name, RNG rng );
  28. int Displaying_Random_Text( Mat image, char* window_name, RNG rng );
  29. int Displaying_Big_End( Mat image, char* window_name, RNG rng );
  32. /**
  33.  * @function main
  34.  */
  35. int main( void )
  36. {
  37.   int c;
  39.   /// Start creating a window
  40.   char window_name[] = "Drawing_2 Tutorial";
  42.   /// Also create a random object (RNG)
  43.   RNG rng( 0xFFFFFFFF );
  45.   /// Initialize a matrix filled with zeros
  46.   Mat image = Mat::zeros( window_height, window_width, CV_8UC3 );
  47.   /// Show it in a window during DELAY ms
  48.   imshow( window_name, image );
  49.   waitKey( DELAY );
  51.   /// Now, let's draw some lines
  52.   c = Drawing_Random_Lines(image, window_name, rng);
  53.   if( c != 0 ) return 0;
  55.   /// Go on drawing, this time nice rectangles
  56.   c = Drawing_Random_Rectangles(image, window_name, rng);
  57.   if( c != 0 ) return 0;
  59.   /// Draw some ellipses
  60.   c = Drawing_Random_Ellipses( image, window_name, rng );
  61.   if( c != 0 ) return 0;
  63.   /// Now some polylines
  64.   c = Drawing_Random_Polylines( image, window_name, rng );
  65.   if( c != 0 ) return 0;
  67.   /// Draw filled polygons
  68.   c = Drawing_Random_Filled_Polygons( image, window_name, rng );
  69.   if( c != 0 ) return 0;
  71.   /// Draw circles
  72.   c = Drawing_Random_Circles( image, window_name, rng );
  73.   if( c != 0 ) return 0;
  75.   /// Display text in random positions
  76.   c = Displaying_Random_Text( image, window_name, rng );
  77.   if( c != 0 ) return 0;
  79.   /// Displaying the big end!
  80.   c = Displaying_Big_End( image, window_name, rng );
  81.   if( c != 0 ) return 0;
  83.   waitKey(0);
  84.   return 0;
  85. }
  87. /// Function definitions
  89. /**
  90.  * @function randomColor
  91.  * @brief Produces a random color given a random object
  92.  */
  93. static Scalar randomColor( RNG& rng )
  94. {
  95.   int icolor = (unsigned) rng;
  96.   return Scalar( icolor&255, (icolor>>8)&255, (icolor>>16)&255 );
  97. }
  100. /**
  101.  * @function Drawing_Random_Lines
  102.  */
  103. int Drawing_Random_Lines( Mat image, char* window_name, RNG rng )
  104. {
  105.   Point pt1, pt2;
  107.   for( int i = 0; i < NUMBER; i++ )
  108.   {
  109.     pt1.x = rng.uniform( x_1, x_2 );
  110.     pt1.y = rng.uniform( y_1, y_2 );
  111.     pt2.x = rng.uniform( x_1, x_2 );
  112.     pt2.y = rng.uniform( y_1, y_2 );
  114.     line( image, pt1, pt2, randomColor(rng), rng.uniform(1, 10), 8 );
  115.     imshow( window_name, image );
  116.     if( waitKey( DELAY ) >= 0 )
  117.       { return -1; }
  118.   }
  120.   return 0;
  121. }
  123. /**
  124.  * @function Drawing_Rectangles
  125.  */
  126. int Drawing_Random_Rectangles( Mat image, char* window_name, RNG rng )
  127. {
  128.   Point pt1, pt2;
  129.   int lineType = 8;
  130.   int thickness = rng.uniform( -3, 10 );
  132.   for( int i = 0; i < NUMBER; i++ )
  133.   {
  134.     pt1.x = rng.uniform( x_1, x_2 );
  135.     pt1.y = rng.uniform( y_1, y_2 );
  136.     pt2.x = rng.uniform( x_1, x_2 );
  137.     pt2.y = rng.uniform( y_1, y_2 );
  139.     rectangle( image, pt1, pt2, randomColor(rng), MAX( thickness, -1 ), lineType );
  141.     imshow( window_name, image );
  142.     if( waitKey( DELAY ) >= 0 )
  143.       { return -1; }
  144.   }
  146.   return 0;
  147. }
  149. /**
  150.  * @function Drawing_Random_Ellipses
  151.  */
  152. int Drawing_Random_Ellipses( Mat image, char* window_name, RNG rng )
  153. {
  154.   int lineType = 8;
  156.   for ( int i = 0; i < NUMBER; i++ )
  157.   {
  158.     Point center;
  159.     center.x = rng.uniform(x_1, x_2);
  160.     center.y = rng.uniform(y_1, y_2);
  162.     Size axes;
  163.     axes.width = rng.uniform(0, 200);
  164.     axes.height = rng.uniform(0, 200);
  166.     double angle = rng.uniform(0, 180);
  168.     ellipse( image, center, axes, angle, angle - 100, angle + 200,
  169.              randomColor(rng), rng.uniform(-1,9), lineType );
  171.     imshow( window_name, image );
  173.     if( waitKey(DELAY) >= 0 )
  174.       { return -1; }
  175.   }
  177.   return 0;
  178. }
  180. /**
  181.  * @function Drawing_Random_Polylines
  182.  */
  183. int Drawing_Random_Polylines( Mat image, char* window_name, RNG rng )
  184. {
  185.   int lineType = 8;
  187.   for( int i = 0; i< NUMBER; i++ )
  188.   {
  189.     Point pt[2][3];
  190.     pt[0][0].x = rng.uniform(x_1, x_2);
  191.     pt[0][0].y = rng.uniform(y_1, y_2);
  192.     pt[0][1].x = rng.uniform(x_1, x_2);
  193.     pt[0][1].y = rng.uniform(y_1, y_2);
  194.     pt[0][2].x = rng.uniform(x_1, x_2);
  195.     pt[0][2].y = rng.uniform(y_1, y_2);
  196.     pt[1][0].x = rng.uniform(x_1, x_2);
  197.     pt[1][0].y = rng.uniform(y_1, y_2);
  198.     pt[1][1].x = rng.uniform(x_1, x_2);
  199.     pt[1][1].y = rng.uniform(y_1, y_2);
  200.     pt[1][2].x = rng.uniform(x_1, x_2);
  201.     pt[1][2].y = rng.uniform(y_1, y_2);
  203.     const Point* ppt[2] = {pt[0], pt[1]};
  204.     int npt[] = {3, 3};
  206.     polylines(image, ppt, npt, 2, true, randomColor(rng), rng.uniform(1,10), lineType);
  208.     imshow( window_name, image );
  209.     if( waitKey(DELAY) >= 0 )
  210.       { return -1; }
  211.   }
  212.   return 0;
  213. }
  215. /**
  216.  * @function Drawing_Random_Filled_Polygons
  217.  */
  218. int Drawing_Random_Filled_Polygons( Mat image, char* window_name, RNG rng )
  219. {
  220.   int lineType = 8;
  222.   for ( int i = 0; i < NUMBER; i++ )
  223.   {
  224.     Point pt[2][3];
  225.     pt[0][0].x = rng.uniform(x_1, x_2);
  226.     pt[0][0].y = rng.uniform(y_1, y_2);
  227.     pt[0][1].x = rng.uniform(x_1, x_2);
  228.     pt[0][1].y = rng.uniform(y_1, y_2);
  229.     pt[0][2].x = rng.uniform(x_1, x_2);
  230.     pt[0][2].y = rng.uniform(y_1, y_2);
  231.     pt[1][0].x = rng.uniform(x_1, x_2);
  232.     pt[1][0].y = rng.uniform(y_1, y_2);
  233.     pt[1][1].x = rng.uniform(x_1, x_2);
  234.     pt[1][1].y = rng.uniform(y_1, y_2);
  235.     pt[1][2].x = rng.uniform(x_1, x_2);
  236.     pt[1][2].y = rng.uniform(y_1, y_2);
  238.     const Point* ppt[2] = {pt[0], pt[1]};
  239.     int npt[] = {3, 3};
  241.     fillPoly( image, ppt, npt, 2, randomColor(rng), lineType );
  243.     imshow( window_name, image );
  244.     if( waitKey(DELAY) >= 0 )
  245.        { return -1; }
  246.   }
  247.   return 0;
  248. }
  250. /**
  251.  * @function Drawing_Random_Circles
  252.  */
  253. int Drawing_Random_Circles( Mat image, char* window_name, RNG rng )
  254. {
  255.   int lineType = 8;
  257.   for (int i = 0; i < NUMBER; i++)
  258.   {
  259.     Point center;
  260.     center.x = rng.uniform(x_1, x_2);
  261.     center.y = rng.uniform(y_1, y_2);
  263.     circle( image, center, rng.uniform(0, 300), randomColor(rng),
  264.             rng.uniform(-1, 9), lineType );
  266.     imshow( window_name, image );
  267.     if( waitKey(DELAY) >= 0 )
  268.       { return -1; }
  269.   }
  271.   return 0;
  272. }
  274. /**
  275.  * @function Displaying_Random_Text
  276.  */
  277. int Displaying_Random_Text( Mat image, char* window_name, RNG rng )
  278. {
  279.   int lineType = 8;
  281.   for ( int i = 1; i < NUMBER; i++ )
  282.   {
  283.     Point org;
  284.     org.x = rng.uniform(x_1, x_2);
  285.     org.y = rng.uniform(y_1, y_2);
  287.     putText( image, "Testing text rendering", org, rng.uniform(0,8),
  288.              rng.uniform(0,100)*0.05+0.1, randomColor(rng), rng.uniform(1, 10), lineType);
  290.     imshow( window_name, image );
  291.     if( waitKey(DELAY) >= 0 )
  292.       { return -1; }
  293.   }
  295.   return 0;
  296. }
  298. /**
  299.  * @function Displaying_Big_End
  300.  */
  301. int Displaying_Big_End( Mat image, char* window_name, RNG )
  302. {
  303.   Size textsize = getTextSize("OpenCV forever!", FONT_HERSHEY_COMPLEX, 3, 5, 0);
  304.   Point org((window_width - textsize.width)/2, (window_height - textsize.height)/2);
  305.   int lineType = 8;
  307.   Mat image2;
  309.   for( int i = 0; i < 255; i += 2 )
  310.   {
  311.     image2 = image - Scalar::all(i);
  312.     putText( image2, "OpenCV forever!", org, FONT_HERSHEY_COMPLEX, 3,
  313.              Scalar(i, i, 255), 5, lineType );
  315.     imshow( window_name, image2 );
  316.     if( waitKey(DELAY) >= 0 )
  317.        { return -1; }
  318.   }
  320.   return 0;
  321. }































添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注