OpenCV计算机视觉入门案例

案例一：

//显示图像
#include<opencv2\opencv.hpp>
#include<iostream>
using namespace std;
using namespace cv;

int main()
{
    Mat image = imread("E:\\8.jpg"); //存放自己图像的位置
    imshow("显示图像", image);
    waitKey(0);
    return 0;

}

案例二：
OpeCV基本知识点：基本概念
图像处理是用计算机对图像进行分析，以达到所需要的结果的技术，图像处理技术一般包括图像压缩、增强和复原，匹配、描述和识别3个部分。
计算机视觉是一门如何使机器“看”的科学，是用摄影机和电脑对目标进行识别、跟踪和测量等机器视觉

OpenCV可用户解决一下领域的问题：
    人机交互
    物体识别
    图像分区
    人脸识别
    动作识别
    运动跟踪
    机器人

OpenCV计算机视觉库的包含内容：
calib3d-->这个模块主要是相机校准和三维重建相关的内容，包括基本的多视角集几何算法、单个立体摄像头标定、物体姿态估计、立体相似性算法、3D信息的重建等
contrib-->这个模块包含了一下最近添加的不太稳定的功能，例如人脸识别、立体匹配、人工视网膜模型等技术
core-->核心功能模块
    OpenCV基本数据结构
    动态数据结构
    绘图函数
    数组操作相关函数
    辅助功能与系统函数和宏
    与OpenGL的互相操作
imgproc-->图像处理模块
    线性和非线性的图像滤波
    图像的几何变换
    其他图像变换
    直方图相关
    结构分析和形状描述
    运动分析和对象跟踪
    特征检测
    目标检测
features2d-->2D功能框架
    特征检测和描述
    特征检测器通用接口
    描述符提取器通用接口
    描述匹配器通用接口
    通用描述符匹配器通用接口
    关键点绘制函数和匹配功能绘制函数
flann-->高维的近似近邻快速搜索算法
    快速近似最近邻搜索
    聚类
gpu-->运用GPU加速计算机视觉模块
hihgui-->高层GUI图形用户界面，包含媒体的输入和输出、视频捕捉、图形和视频的编码解码、图形交互界面的接口等内容
legacy-->一些已经废弃的代码块，保留下来作为向下兼容，包含以下内容：
    运动分析
    期望最大化
    直方图
    平面细分
    特征检测和描述
    描述符提取器的通用接口
    通用描述符的常用接口
    匹配器

ml-->Machine Learning 机器学习模块，基本上是统计模型和分类算法
    统计模型(Statistical Models)
    一般贝叶斯分类(Normal Bayes Classifier)
    K-近邻(K-Nearest Neighbors)
    支持向量机（Support Vector Machines）
    决策树（Decision Trees）
    提升（Boosting）
    梯度提高树（Gradient Boosted Trees）
    随机树（Random Trees）
    超随机树（Extremely randomized Trees）
    期望最大化（Expectation Maximization）
    神经网络（Neural Networks）
    MLData
nonfree-->一些具有专利的算法模块，包含特征检测和GPU相关的内容，最好不要商用
objdetect-->目标检测模块，包含Cascade Classification(级联分类)
    和LatentSVM两个部分
ocl-->运用OpenGL加速的计算机视觉组件模块
photo-->包含图像修复和图像去燥两部分
stitching-->images stitching 图像拼接模块：
    拼接流水线
    特点寻找和匹配图像
    估计旋转
    自动校准
    图片歪斜
    接缝估测
    曝光补偿
    图片混合
superres-->超分辨率技术的相关功能模块
ts-->OpenCV测试相关代码（不用去管）
video-->视频分析组件，该模块包括运动估计，背景分离，对象跟踪等视频处理相关内容
Videostab-->视频稳定相关的组件

//图像腐蚀操作
#include <opencv2\highgui\highgui.hpp>  //highgui模块头文件
#include<opencv2\imgproc\imgproc.hpp>   //OpenCV图像处理头文件
using namespace cv; //包含cv命名空间

int main()
{
    //载入原图 
    Mat srcImage = imread("E:\\8.jpg");
        //显示原图
    imshow("[原图]腐蚀操作", srcImage);
    //进行腐蚀操作
    Mat element = getStructuringElement(MORPH_RECT, Size(15, 15));

    Mat dstImage;
    erode(srcImage, dstImage, element);
    //显示效果图
    imshow("[效果图]腐蚀操作", dstImage);
    waitKey(0);
    return 0;
}

案例三：图像模糊

#include <opencv2\highgui\highgui.hpp>  //highgui模块头文件
#include <opencv2\imgproc\imgproc.hpp>  //OpenCv处理图像的头文件
using namespace cv;


int main()
{
    Mat srcImage = imread("E:\\6.bmp");         //1、载入原图
    imshow("均值滤波【原图】", srcImage);       //2、显示原始图像
    Mat dstImage;   //3、进行均值滤波操作
    blur(srcImage, dstImage, Size(7, 7));
    imshow("均值滤波【效果图】", dstImage);
    waitKey(0);


}

案例四：Canny边缘检测

#include <opencv2\highgui\highgui.hpp>  //highgui模块头文件
#include <opencv2\imgproc\imgproc.hpp>  //OpenCv处理图像的头文件
using namespace cv;

int main()
{
    Mat srcImage = imread("E:\\6.bmp");         //1、载入原图
    imshow("【原始图】Canny边缘检测", srcImage);     //显示原始图像
    Mat dstImage,edge, grayImage;//参数定义

    //2、创建与src同类型和大小的矩阵（dst）
    dstImage.create(srcImage.size(), srcImage.type());
    //3、将原始图像转换为灰度图像
    //此句代码的OpenCv2版为
    //cvtColor(srcImage, grayImage, CV_BGR2GRAY);
    //此句代码的OpenCv3版为
    cvtColor(srcImage, grayImage, COLOR_BGR2GRAY);

    //4、先使用3*3内核来降噪
    blur(grayImage, edge, Size(3, 3));

    //5、运行Canny算子
    Canny(edge, edge, 3, 9, 3);
    //6、显示效果图
    imshow("【效果图】Canny边缘检测", edge);
    waitKey(0);
    return 0;

}

案例五：视频播放

#include <opencv2\opencv.hpp>  
using namespace cv;

//-----------------------------------【main( )函数】--------------------------------------------
//      描述：控制台应用程序的入口函数，我们的程序从这里开始
//-------------------------------------------------------------------------------------------------
int main()
{
    //【1】读入视频
    VideoCapture capture("1.avi");

    //【2】循环显示每一帧
    while (1)
    {
        Mat frame;//定义一个Mat变量，用于存储每一帧的图像
        capture >> frame;  //读取当前帧
        if (!frame.empty()) {
            imshow("读取视频", frame);  //显示当前帧
        }

        waitKey(30);  //延时30ms
    }
    return 0;
}

案例六：调用摄像头采集图像

//调用摄像头采集图像
#include<opencv2\opencv.hpp>
using namespace cv;

int main()
{
    //从摄像头读取视频
    VideoCapture capture(0);
    //循环显示每一帧
    while (1)
    {
        //1、读入图像
        Mat frame;  //定义一个Mat变量，用于存储每一帧图像
        capture >> frame;//读取当前帧


        if (!frame.empty()) {
            imshow("被canny后的视频", frame); //显示经过处理后的当前帧
        }

        if (waitKey(30) >= 0)
        {
            break;  //延时30ms
        }

    }

    return 0;
}

案例七：调用摄像头实现canny边缘检测，得到Canny边缘检测并高斯模糊后的摄像头采集视频

#include<opencv2\opencv.hpp>
using namespace cv;

int main()
{
    //从摄像头读取视频
    VideoCapture capture(0);
    Mat edges;
    //循环显示每一帧
    while (1)
    {
        //1、读入图像
        Mat frame;  //定义一个Mat变量，用于存储每一帧图像
        capture >> frame;//读取当前帧

        //2、将原图像转换为灰度图像
        cvtColor(frame, edges, CV_BGR2GRAY);    //将BGR彩色图转换为灰度图

        //3、使用3*3内核来降噪（2*4+1=7）
        blur(edges, edges, Size(7, 7)); //进行模糊

        //4、进行canny边缘检测并显示
        Canny(edges, edges, 0, 30, 3);
        if (!edges.empty()) {
            imshow("被canny后的视频", edges); //显示经过处理后的当前帧

        }

        if (waitKey(30)>=0)
        {
            break;  //延时30ms
        }

    }

    return 0;
}

案例八：彩色目标跟踪：Camshift算法
程序的用法是根据鼠标框选区域的色度光谱进行摄像头读入视频目标的跟踪，其主要采用CamShift算法，是对MeanShift算法的改进，被称为连续自适应的MeanShift算法。

#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()
{
    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"
            "   ./camshiftdemo [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();
        return 0;
    }
    int camNum = parser.get<int>(0);
    cap.open(camNum);

    if( !cap.isOpened() )
    {
        help();
        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;
}