opencv的典型基础应用例子(附源码和解释)

最新推荐文章于 2024-05-17 10:10:24 发布

李乐逸.

最新推荐文章于 2024-05-17 10:10:24 发布

阅读量557

点赞数

分类专栏： opencv 文章标签： opencv c++ 计算机视觉人工智能目标跟踪

本文链接：https://blog.csdn.net/m0_62519898/article/details/123503368

版权

opencv 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

2.1-1彩色目标追踪: Camshift

 #include "opencv2/core/utility.hpp"
 #include "opencv2/video/tracking.hpp"
 #include "opencv2/imgproc.hpp"
 #include "opencv2/videoio.hpp"
 #include "opencv2/highgui.hpp"
 
 #include <iostream>
 #include <ctype.h>
 
 using namespace cv;
 using namespace std;
 
 Mat image;
 
 bool backprojMode = false;
 bool selectObject = false;
 int trackObject = 0;
 bool showHist = true;
 Point origin;
 Rect selection;
 int vmin = 10, vmax = 256, smin = 30;
 
 // User draws box around object to track. This triggers CAMShift to start tracking
 static void onMouse(int event, int x, int y, int, void*)
 {
     if (selectObject)
     {
         selection.x = MIN(x, origin.x);
         selection.y = MIN(y, origin.y);
         selection.width = std::abs(x - origin.x);
         selection.height = std::abs(y - origin.y);
 
         selection &= Rect(0, 0, image.cols, image.rows);
     }
 
     switch (event)
     {
     case EVENT_LBUTTONDOWN:
         origin = Point(x, y);
         selection = Rect(x, y, 0, 0);
         selectObject = true;
         break;
     case EVENT_LBUTTONUP:
         selectObject = false;
         if (selection.width > 0 && selection.height > 0)
             trackObject = -1;   // Set up CAMShift properties in main() loop
         break;
     }
 }
 
 string hot_keys =
 "\n\nHot keys: \n"
 "\tESC - quit the program\n"
 "\tc - stop the tracking\n"
 "\tb - switch to/from backprojection view\n"
 "\th - show/hide object histogram\n"
 "\tp - pause video\n"
 "To initialize tracking, select the object with mouse\n";
 
 static void help(const char** argv)
 {
     cout << "\nThis is a demo that shows mean-shift based tracking\n"
         "You select a color objects such as your face and it tracks it.\n"
         "This reads from video camera (0 by default, or the camera number the user enters\n"
         "Usage: \n\t";
     cout << argv[0] << " [camera number]\n";
     cout << hot_keys;
 }
 
 const char* keys =
 {
     "{help h | | show help message}{@camera_number| 0 | camera number}"
 };
 
 int main(int argc, const char** argv)
 {
     VideoCapture cap;
     Rect trackWindow;
     int hsize = 16;
     float hranges[] = { 0,180 };
     const float* phranges = hranges;
     CommandLineParser parser(argc, argv, keys);
     if (parser.has("help"))
     {
         help(argv);
         return 0;
     }
     int camNum = parser.get<int>(0);
     cap.open(camNum);
 
     if (!cap.isOpened())
     {
         help(argv);
         cout << "***Could not initialize capturing...***\n";
         cout << "Current parameter's value: \n";
         parser.printMessage();
         return -1;
     }
     cout << hot_keys;
     namedWindow("Histogram", 0);
     namedWindow("CamShift Demo", 0);
     setMouseCallback("CamShift Demo", onMouse, 0);
     createTrackbar("Vmin", "CamShift Demo", &vmin, 256, 0);
     createTrackbar("Vmax", "CamShift Demo", &vmax, 256, 0);
     createTrackbar("Smin", "CamShift Demo", &smin, 256, 0);
 
     Mat frame, hsv, hue, mask, hist, histimg = Mat::zeros(200, 320, CV_8UC3), backproj;
     bool paused = false;
 
     for (;;)
     {
         if (!paused)
         {
             cap >> frame;
             if (frame.empty())
                 break;
         }
 
         frame.copyTo(image);
 
         if (!paused)
         {
             cvtColor(image, hsv, COLOR_BGR2HSV);
 
             if (trackObject)
             {
                 int _vmin = vmin, _vmax = vmax;
 
                 inRange(hsv, Scalar(0, smin, MIN(_vmin, _vmax)),
                     Scalar(180, 256, MAX(_vmin, _vmax)), mask);
                 int ch[] = { 0, 0 };
                 hue.create(hsv.size(), hsv.depth());
                 mixChannels(&hsv, 1, &hue, 1, ch, 1);
 
                 if (trackObject < 0)
                 {
                     // Object has been selected by user, set up CAMShift search properties once
                     Mat roi(hue, selection), maskroi(mask, selection);
                     calcHist(&roi, 1, 0, maskroi, hist, 1, &hsize, &phranges);
                     normalize(hist, hist, 0, 255, NORM_MINMAX);
 
                     trackWindow = selection;
                     trackObject = 1; // Don't set up again, unless user selects new ROI
 
                     histimg = Scalar::all(0);
                     int binW = histimg.cols / hsize;
                     Mat buf(1, hsize, CV_8UC3);
                     for (int i = 0; i < hsize; i++)
                         buf.at<Vec3b>(i) = Vec3b(saturate_cast<uchar>(i * 180. / hsize), 255, 255);
                     cvtColor(buf, buf, COLOR_HSV2BGR);
 
                     for (int i = 0; i < hsize; i++)
                     {
                         int val = saturate_cast<int>(hist.at<float>(i) * histimg.rows / 255);
                         rectangle(histimg, Point(i * binW, histimg.rows),
                             Point((i + 1) * binW, histimg.rows - val),
                             Scalar(buf.at<Vec3b>(i)), -1, 8);
                     }
                 }
 
                 // Perform CAMShift
                 calcBackProject(&hue, 1, 0, hist, backproj, &phranges);
                 backproj &= mask;
                 RotatedRect trackBox = CamShift(backproj, trackWindow,
                     TermCriteria(TermCriteria::EPS | TermCriteria::COUNT, 10, 1));
                 if (trackWindow.area() <= 1)
                 {
                     int cols = backproj.cols, rows = backproj.rows, r = (MIN(cols, rows) + 5) / 6;
                     trackWindow = Rect(trackWindow.x - r, trackWindow.y - r,
                         trackWindow.x + r, trackWindow.y + r) &
                         Rect(0, 0, cols, rows);
                 }
 
                 if (backprojMode)
                     cvtColor(backproj, image, COLOR_GRAY2BGR);
                 ellipse(image, trackBox, Scalar(0, 0, 255), 3, LINE_AA);
             }
         }
         else if (trackObject < 0)
             paused = false;
 
         if (selectObject && selection.width > 0 && selection.height > 0)
         {
             Mat roi(image, selection);
             bitwise_not(roi, roi);
         }
 
         imshow("CamShift Demo", image);
         imshow("Histogram", histimg);
 
         char c = (char)waitKey(10);
         if (c == 27)
             break;
         switch (c)
         {
         case 'b':
             backprojMode = !backprojMode;
             break;
         case 'c':
             trackObject = 0;
             histimg = Scalar::all(0);
             break;
         case 'h':
             showHist = !showHist;
             if (!showHist)
                 destroyWindow("Histogram");
             else
                 namedWindow("Histogram", 1);
             break;
         case 'p':
             paused = !paused;
             break;
         default:
             ;
         }
     }
 
     return 0;
 }

用法:根据鼠标框选区域的色度光谱来进行摄像头读入的视频目标的跟踪
算法:Camshift算法(被称为: 连续自适应的MeanShift算法)

2.1-2 光流 optical flow

目前图像分析的重要方法
光流用来表示图像中模式的运动速度

2.1-3 点追踪 lkdemo

 #include "opencv2/video/tracking.hpp"
 #include "opencv2/imgproc.hpp"
 #include "opencv2/videoio.hpp"
 #include "opencv2/highgui.hpp"
 
 #include <iostream>
 #include <ctype.h>
 
 using namespace cv;
 using namespace std;
 
 static void help()
 {
     // print a welcome message, and the OpenCV version
     cout << "\nThis is a demo of Lukas-Kanade optical flow lkdemo(),\n"
             "Using OpenCV version " << CV_VERSION << endl;
     cout << "\nIt uses camera by default, but you can provide a path to video as an argument.\n";
     cout << "\nHot keys: \n"
             "\tESC - quit the program\n"
             "\tr - auto-initialize tracking\n"
             "\tc - delete all the points\n"
             "\tn - switch the \"night\" mode on/off\n"
             "To add/remove a feature point click it\n" << endl;
 }
 
 Point2f point;
 bool addRemovePt = false;
 
 static void onMouse( int event, int x, int y, int /*flags*/, void* /*param*/ )
 {
     if( event == EVENT_LBUTTONDOWN )
     {
         point = Point2f((float)x, (float)y);
         addRemovePt = true;
     }
 }
 
 int main( int argc, char** argv )
 {
     VideoCapture cap;
     TermCriteria termcrit(TermCriteria::COUNT|TermCriteria::EPS,20,0.03);
     Size subPixWinSize(10,10), winSize(31,31);
 
     const int MAX_COUNT = 500;
     bool needToInit = false;
     bool nightMode = false;
 
     help();
     cv::CommandLineParser parser(argc, argv, "{@input|0|}");
     string input = parser.get<string>("@input");
 
     if( input.size() == 1 && isdigit(input[0]) )
         cap.open(input[0] - '0');
     else
         cap.open(input);
 
     if( !cap.isOpened() )
     {
         cout << "Could not initialize capturing...\n";
         return 0;
     }
 
     namedWindow( "LK Demo", 1 );
     setMouseCallback( "LK Demo", onMouse, 0 );
 
     Mat gray, prevGray, image, frame;
     vector<Point2f> points[2];
 
     for(;;)
     {
         cap >> frame;
         if( frame.empty() )
             break;
 
         frame.copyTo(image);
         cvtColor(image, gray, COLOR_BGR2GRAY);
 
         if( nightMode )
             image = Scalar::all(0);
 
         if( needToInit )
         {
             // automatic initialization
             goodFeaturesToTrack(gray, points[1], MAX_COUNT, 0.01, 10, Mat(), 3, 3, 0, 0.04);
             cornerSubPix(gray, points[1], subPixWinSize, Size(-1,-1), termcrit);
             addRemovePt = false;
         }
         else if( !points[0].empty() )
         {
             vector<uchar> status;
             vector<float> err;
             if(prevGray.empty())
                 gray.copyTo(prevGray);
             calcOpticalFlowPyrLK(prevGray, gray, points[0], points[1], status, err, winSize,
                                  3, termcrit, 0, 0.001);
             size_t i, k;
             for( i = k = 0; i < points[1].size(); i++ )
             {
                 if( addRemovePt )
                 {
                     if( norm(point - points[1][i]) <= 5 )
                     {
                         addRemovePt = false;
                         continue;
                     }
                 }
 
                 if( !status[i] )
                     continue;
 
                 points[1][k++] = points[1][i];
                 circle( image, points[1][i], 3, Scalar(0,255,0), -1, 8);
             }
             points[1].resize(k);
         }
 
         if( addRemovePt && points[1].size() < (size_t)MAX_COUNT )
         {
             vector<Point2f> tmp;
             tmp.push_back(point);
             cornerSubPix( gray, tmp, winSize, Size(-1,-1), termcrit);
             points[1].push_back(tmp[0]);
             addRemovePt = false;
         }
 
         needToInit = false;
         imshow("LK Demo", image);
 
         char c = (char)waitKey(10);
         if( c == 27 )
             break;
         switch( c )
         {
         case 'r':
             needToInit = true;
             break;
         case 'c':
             points[0].clear();
             points[1].clear();
             break;
         case 'n':
             nightMode = !nightMode;
             break;
         }
 
         std::swap(points[1], points[0]);
         cv::swap(prevGray, gray);
     }
 
     return 0;
 }

使用说明:按"r"启动自动点追踪

2.1-4人脸识别 objectDetection

 #include "opencv2/objdetect.hpp"
 #include "opencv2/highgui.hpp"
 #include "opencv2/imgproc.hpp"
 #include "opencv2/videoio.hpp"
 #include <iostream>
 
 using namespace std;
 using namespace cv;
 
 /** Function Headers */
 void detectAndDisplay( Mat frame );
 
 /** Global variables */
 CascadeClassifier face_cascade;
 CascadeClassifier eyes_cascade;
 
 /** @function main */
 int main( int argc, const char** argv )
 {
     CommandLineParser parser(argc, argv,
                              "{help h||}"
                              "{face_cascade|data/haarcascades/haarcascade_frontalface_alt.xml|Path to face cascade.}"
                              "{eyes_cascade|data/haarcascades/haarcascade_eye_tree_eyeglasses.xml|Path to eyes cascade.}"
                              "{camera|0|Camera device number.}");
 
     parser.about( "\nThis program demonstrates using the cv::CascadeClassifier class to detect objects (Face + eyes) in a video stream.\n"
                   "You can use Haar or LBP features.\n\n" );
     parser.printMessage();
 
     String face_cascade_name = samples::findFile( parser.get<String>("face_cascade") );
     String eyes_cascade_name = samples::findFile( parser.get<String>("eyes_cascade") );
 
     //-- 1. Load the cascades
     if( !face_cascade.load( face_cascade_name ) )
     {
         cout << "--(!)Error loading face cascade\n";
         return -1;
     };
     if( !eyes_cascade.load( eyes_cascade_name ) )
     {
         cout << "--(!)Error loading eyes cascade\n";
         return -1;
     };
 
     int camera_device = parser.get<int>("camera");
     VideoCapture capture;
     //-- 2. Read the video stream
     capture.open( camera_device );
     if ( ! capture.isOpened() )
     {
         cout << "--(!)Error opening video capture\n";
         return -1;
     }
 
     Mat frame;
     while ( capture.read(frame) )
     {
         if( frame.empty() )
         {
             cout << "--(!) No captured frame -- Break!\n";
             break;
         }
 
         //-- 3. Apply the classifier to the frame
         detectAndDisplay( frame );
 
         if( waitKey(10) == 27 )
         {
             break; // escape
         }
     }
     return 0;
 }
 
 /** @function detectAndDisplay */
 void detectAndDisplay( Mat frame )
 {
     Mat frame_gray;
     cvtColor( frame, frame_gray, COLOR_BGR2GRAY );
     equalizeHist( frame_gray, frame_gray );
 
     //-- Detect faces
     std::vector<Rect> faces;
     face_cascade.detectMultiScale( frame_gray, faces );
 
     for ( size_t i = 0; i < faces.size(); i++ )
     {
         Point center( faces[i].x + faces[i].width/2, faces[i].y + faces[i].height/2 );
         ellipse( frame, center, Size( faces[i].width/2, faces[i].height/2 ), 0, 0, 360, Scalar( 255, 0, 255 ), 4 );
 
         Mat faceROI = frame_gray( faces[i] );
 
         //-- In each face, detect eyes
         std::vector<Rect> eyes;
         eyes_cascade.detectMultiScale( faceROI, eyes );
 
         for ( size_t j = 0; j < eyes.size(); j++ )
         {
             Point eye_center( faces[i].x + eyes[j].x + eyes[j].width/2, faces[i].y + eyes[j].y + eyes[j].height/2 );
             int radius = cvRound( (eyes[j].width + eyes[j].height)*0.25 );
             circle( frame, eye_center, radius, Scalar( 255, 0, 0 ), 4 );
         }
     }
 
     //-- Show what you got
     imshow( "Capture - Face detection", frame );
 }