opencv 特征点匹配和背景识别

最新推荐文章于 2024-08-20 23:13:01 发布
最新推荐文章于 2024-08-20 23:13:01 发布
阅读量2.9k 收藏 9
点赞数 1
分类专栏： opencv 文章标签： opencv
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012526003/article/details/52819527
版权

代码

#include <opencv2/opencv.hpp>
#include <opencv2/features2d/features2d.hpp>
#include<opencv2/nonfree/nonfree.hpp>
#include<opencv2/legacy/legacy.hpp>
#include<vector>

using namespace std;
using namespace cv;

//sift进行特征点匹配
void SiftDemo(string fn1, string fn2)
{
    Mat input1 = imread(fn1, 1);
    Mat input2 = imread(fn2, 1);
    SiftFeatureDetector detector;
    vector<KeyPoint> keypoint1, keypoint2;
    detector.detect(input1, keypoint1);

    Mat output1;
    drawKeypoints(input1, keypoint1, output1);
    imshow("sift_result1.jpg", output1);
    imwrite("sift_result1.jpg", output1);

    Mat output2;
    SiftDescriptorExtractor extractor;
    Mat descriptor1, descriptor2;
    BruteForceMatcher<L2<float>> matcher;

    vector<DMatch> matches;
    Mat img_matches;
    detector.detect(input2, keypoint2);
    drawKeypoints(input2, keypoint2, output2);

    imshow("sift_result2.jpg", output2);
    imwrite("sift_result2.jpg", output2);

    extractor.compute(input1, keypoint1, descriptor1);
    extractor.compute(input2, keypoint2, descriptor2);

    matcher.match(descriptor1, descriptor2, matches);

    drawMatches(input1, keypoint1, input2, keypoint2, matches, img_matches);
    imshow("matches", img_matches);
    imwrite("matches.jpg", img_matches);
}

//surf进行特征点匹配
void SurfDemo(string fn1, string fn2)
{
    // TODO: Add your control notification handler code here
    Mat input1 = imread(fn1, 1);
    Mat input2 = imread(fn2, 1);
    SurfFeatureDetector detector(2500);
    vector<KeyPoint> keypoint1, keypoint2;
    detector.detect(input1, keypoint1);

    Mat output1;
    drawKeypoints(input1, keypoint1, output1, cv::Scalar::all(255), cv::DrawMatchesFlags::DRAW_RICH_KEYPOINTS);
    //drawKeypoints(input1,keypoint1,output1);
    imshow("sift_result1.jpg", output1);
    imwrite("sift_result1.jpg", output1);

    Mat output2;
    SurfDescriptorExtractor extractor;
    Mat descriptor1, descriptor2;
    BruteForceMatcher<L2<float>> matcher;

    vector<DMatch> matches;
    Mat img_matches;
    detector.detect(input2, keypoint2);
    drawKeypoints(input2, keypoint2, output2, cv::Scalar::all(255), cv::DrawMatchesFlags::DRAW_RICH_KEYPOINTS);

    imshow("sift_result2.jpg", output2);
    imwrite("sift_result2.jpg", output2);

    extractor.compute(input1, keypoint1, descriptor1);
    extractor.compute(input2, keypoint2, descriptor2);

    matcher.match(descriptor1, descriptor2, matches);

    drawMatches(input1, keypoint1, input2, keypoint2, matches, img_matches);
    imshow("matches", img_matches);
    imwrite("matches.jpg", img_matches);
}

//orb进行特征点匹配
void OrbDemo(string fn1, string fn2)
{
    // TODO: Add your control notification handler code here
    Mat obj = imread(fn1, 1);   //载入目标图像
    Mat scene = imread(fn2, 1); //载入场景图像
    if (obj.empty() || scene.empty())
    {
        cout << "Can't open the picture!\n";
        return;
    }
    vector<KeyPoint> obj_keypoints, scene_keypoints;
    Mat obj_descriptors, scene_descriptors;
    ORB detector;     //采用ORB算法提取特征点
    detector.detect(obj, obj_keypoints);
    detector.detect(scene, scene_keypoints);
    detector.compute(obj, obj_keypoints, obj_descriptors);
    detector.compute(scene, scene_keypoints, scene_descriptors);
    BFMatcher matcher(NORM_HAMMING, true); //汉明距离做为相似度度量
    vector<DMatch> matches;
    matcher.match(obj_descriptors, scene_descriptors, matches);
    Mat match_img;
    drawMatches(obj, obj_keypoints, scene, scene_keypoints, matches, match_img);
    imshow("滤除误匹配前", match_img);
}


//背景差分,读取当前摄像头的图像
void BackDiffTest()
{
    // TODO: Add your control notification handler code here
    //string videoFile = "F://program//Book//Chapter4//car.avi";
    //string videoFile = "F:\\program\\Book\\Chapter4\\car.avi";

    VideoCapture capture(0);
    //capture.open(videoFile);

    if (!capture.isOpened())
    {
        cout << "read video failure" << std::endl;
        return;
    }

    BackgroundSubtractorMOG2 mog;

    Mat foreground;
    Mat background;

    Mat frame;
    long frameNo = 0;
    while (capture.read(frame))
    {
        ++frameNo;
        //cout<<frameNo<<endl;
        // 运动前景检测，并更新背景
        mog(frame, foreground, 0.01);
        // 腐蚀
        erode(foreground, foreground, Mat());
        // 膨胀
        dilate(foreground, foreground, Mat());
        mog.getBackgroundImage(background);   // 返回当前背景图像
        imshow("foreground", foreground);
        imshow("background", background);
        imshow("frame", frame);
        if (waitKey(25) > 0)
        {
            break;
        }
    }
}

//混合高斯模型，读取视频文件，并提取背景
void MixedGaussianTest(string fn)
{
    IplImage* pFrameOr;  //当前帧
    IplImage* pFrame;  //当前帧
    IplImage* pFrame33;  //当前帧
    IplImage* pFrame333;   //当前帧

    CvCapture* pCaptureOr;
    CvCapture* pCapture;
    CvCapture* pCapture1;
    CvCapture* pCapture2;
    int nFrmNum;

    cvNamedWindow("AVIOriginal1", 0);
    cvResizeWindow("AVIOriginal1", 340, 250);
    cvMoveWindow("AVIOriginal1", 0, 0);

    cvNamedWindow("AVIOriginal2", 0);
    cvResizeWindow("AVIOriginal2", 330, 250);
    cvMoveWindow("AVIOriginal2", 345, 0);

    cvNamedWindow("AVIOriginal3", 0);
    cvResizeWindow("AVIOriginal3", 330, 250);
    cvMoveWindow("AVIOriginal3", 680, 0);

    pCapture = cvCaptureFromFile(fn.c_str());
    pCapture1 = cvCaptureFromFile(fn.c_str());
    pCapture2 = cvCaptureFromFile(fn.c_str());
    pFrame = cvQueryFrame(pCapture1);
    //pFrame33=cvQueryFrame( pCapture1 );
    //pFrame333=cvQueryFrame( pCapture1 );
    pFrame33 = cvCloneImage(pFrame);
    pFrame333 = cvCloneImage(pFrame);

    float alpha = 10;
    float beta = 15;
    float gamma = 11;

    float alphaR = 1;
    float betaR = 1.7;
    float gammaR = 1;

    IplImage* img = NULL;
    IplImage* img1 = NULL;

    IplImage* pFramenum1 = NULL;//第一帧图像，不参与循环
    IplImage* pFramenumImg1 = NULL;//第一帧灰度化后的图像，不参与循环
    IplImage* pFramenumFrImg1 = NULL;//当前帧与第一帧差分并阈值化后的图像
    CvMat* pFramenumMat1 = NULL;//第一帧矩阵，不参与循环
    CvMat* pFramenumFr1 = NULL;//当前帧与第一帧差分后的矩阵

    //  IplImage* pFrame = NULL;    //当前帧
    IplImage* pFrImg = NULL;    //当前帧灰度图
    CvMat* pFrameMat = NULL;
    CvMat* pFrMat = NULL;
    //      IplImage* pFrame33 = NULL;  //当前帧
    //      IplImage* pFrame333 = NULL;  //当前帧
    IplImage* pFrame3 = NULL;   //当前帧

    IplImage* pFrame1 = NULL;//落后当前帧三帧的落后帧 
    IplImage* pFrImg1 = NULL;   //差分后图像
    CvMat* pFrameMat1 = NULL;
    CvMat* pFrMat1 = NULL;

    IplImage* pFrame2 = NULL;//超过当前帧三帧的超前帧 
    IplImage* pFrImg2 = NULL;
    CvMat* pFrameMat2 = NULL;
    CvMat* pFrMat2 = NULL;

    CvMemStorage* storage = cvCreateMemStorage(0);                                     //创建64K的动态内存块
    CvSeq* contours = 0;

    CvMemStorage* storage2 = cvCreateMemStorage(0);                                     //创建64K的动态内存块
    CvSeq* contours2 = 0;

    int i, j;
    CvScalar s0, s1;

    CvSize size;                              //搜索时的邻域尺寸
    size.width = 3;
    size.height = 3;
    CvTermCriteria criteria;
    criteria.type = CV_TERMCRIT_ITER;
    criteria.epsilon = 0.1;  //结果的精确性

    nFrmNum = 0;
    while ((pFrame = cvQueryFrame(pCapture)) && (nFrmNum<250))
    {
        nFrmNum++;
        //      pFrameOr=cvCloneImage(pFrame);
        pFrame1 = cvQueryFrame(pCapture1);
        //如果是第一帧，需要申请内存，并初始化
        if (nFrmNum == 1)
        {
            pFramenum1 = cvCloneImage(pFrame);
            pFramenumImg1 = cvCreateImage(cvSize(pFrame->width, pFrame->height), IPL_DEPTH_8U, 1);
            pFramenumMat1 = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
            pFramenumFr1 = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
            cvCvtColor(pFramenum1, pFramenumImg1, CV_BGR2GRAY);
            cvConvert(pFramenumImg1, pFramenumMat1);

            pFrImg = cvCreateImage(cvSize(pFrame->width, pFrame->height), IPL_DEPTH_8U, 1);
            pFrMat = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
            pFrameMat = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);

            pFrImg1 = cvCreateImage(cvSize(pFrame->width, pFrame->height), IPL_DEPTH_8U, 1);
            pFrMat1 = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
            pFrameMat1 = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);

            pFrImg2 = cvCreateImage(cvSize(pFrame->width, pFrame->height), IPL_DEPTH_8U, 1);
            pFrMat2 = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
            pFrameMat2 = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);

            img = cvCreateImage(cvSize(pFrame->width, pFrame->height), IPL_DEPTH_8U, 1);

            //转化成单通道图像再处理
            cvCvtColor(pFrame, pFrImg, CV_BGR2GRAY);
            cvConvert(pFrImg, pFrameMat);
            cvConvert(pFrImg, pFrMat);
            for (i = 0; i<3; i++)
                pFrame1 = cvQueryFrame(pCapture1);
        }
        else  if (nFrmNum>7)
        {
            pFrame2 = cvQueryFrame(pCapture2);
            pFrame3 = cvCloneImage(pFrame);
            pFrame33 = cvCloneImage(pFrame);
            pFrame333 = cvCloneImage(pFrame);

            cvCvtColor(pFrame, pFrImg, CV_BGR2GRAY);
            cvConvert(pFrImg, pFrameMat);

            cvCvtColor(pFrame1, pFrImg1, CV_BGR2GRAY);
            cvConvert(pFrImg1, pFrameMat1);

            cvCvtColor(pFrame2, pFrImg2, CV_BGR2GRAY);
            cvConvert(pFrImg2, pFrameMat2);

            cvAbsDiff(pFrameMat, pFrameMat1, pFrMat1);//当前帧跟前面帧相减
            cvAbsDiff(pFrameMat, pFrameMat2, pFrMat2);//当前帧与后面帧相减
            cvAbsDiff(pFrameMat, pFramenumMat1, pFramenumFr1);//当前帧与第一帧相减

            //二值化前景图
            cvThreshold(pFrMat1, pFrImg1, 10, 255.0, CV_THRESH_BINARY);
            cvThreshold(pFrMat2, pFrImg2, 10, 255.0, CV_THRESH_BINARY);
            cvThreshold(pFramenumFr1, pFramenumImg1, 10, 255, CV_THRESH_BINARY);

            //膨胀化前景图
            cvDilate(pFrImg1, pFrImg1, NULL, 2);
            cvDilate(pFrImg2, pFrImg2, NULL, 2);

            //当前帧与前面帧相减后提取的轮廓线
            cvFindContours(pFrImg1, storage, &contours, sizeof(CvContour),                     //寻找初始化轮廓并放置于序列中
                CV_RETR_LIST, CV_LINK_RUNS);
            for (; contours; contours = contours->h_next)
            {
                if (contours->total<200)
                    continue;
                else  break;
            }
            cvDrawContours(pFrame333, contours, CV_RGB(255, 255, 0), CV_RGB(0, 0, 0), 0, 2, 8);

            //前差分图与后差分图相与，得到更准确的轮廓线
            cvAnd(pFrImg1, pFrImg2, pFrImg1, NULL);
            img1 = cvCloneImage(pFrImg);

            cvFindContours(pFrImg1, storage, &contours, sizeof(CvContour),                     //寻找初始化轮廓并放置于序列中
                CV_RETR_LIST, CV_LINK_RUNS);
            for (; contours; contours = contours->h_next)
            {
                if (contours->total<200)
                    continue;
                else  break;
            }

            CvPoint* point = new CvPoint[contours->total]; //分配length个轮廓点
            CvSeqReader reader;
            CvPoint pt = cvPoint(0, 0);                                                     //pt.x=0,pt.y=0

            cvStartReadSeq(contours, &reader);                                               //初始化序列读取过程
            for (i = 0; i < contours->total; i++)
            {
                CV_READ_SEQ_ELEM(pt, reader);           //将由reader指定的元素复制到pt指定内存中，若reader指向的当前块到块尾，则转到下一块       
                point[i] = pt;//将pt所存元素移到point数组中
            }

            criteria.max_iter = 5;                  //最大迭代次数
            cvSobel(pFrImg, pFrImg, 1, 1, 3);
            cvSnakeImage(pFrImg, point, contours->total, &alpha, &beta, &gamma, CV_VALUE, size, criteria, 0);

            for (i = 0; i<contours->total; i++)
            {
                j = (i + 1) % (contours->total);
                cvLine(pFrame33, point[i], point[j], CV_RGB(255, 255, 0), 2, 8, 0);
            }

            //图像颠倒，使其反转
            pFrImg->origin = 1;
            pFrImg1->origin = 1;
            pFrImg2->origin = 1;
            img->origin = 1;

            //显示图像
            if (nFrmNum<59 || (nFrmNum>62 && nFrmNum<101) || nFrmNum>103)
            {
                //              pFrame33=cvCloneImage(pFrame3);
                //              pFrame333=cvCloneImage(pFrame3);
                //              cvShowImage("AVIOriginal",pFrameOr);
                cvShowImage("AVIOriginal1", pFrame333);
                cvShowImage("AVIOriginal2", pFrame33);
                cvShowImage("AVIOriginal3", pFrame);
            }
            if (cvWaitKey(10)>0) continue;
        }
    }
    cvReleaseMemStorage(&storage);//释放内存块
    cvReleaseMemStorage(&storage2);//释放内存块

    //释放图像和矩阵
    cvReleaseImage(&pFrImg);
    cvReleaseImage(&pFrImg1);
    cvReleaseImage(&pFrImg2);

    cvReleaseMat(&pFrameMat);
    cvReleaseMat(&pFrMat);
}

int main(int argc, char* argv[])
{
    int mode = 1;
    switch (mode)
    {
    case 1: SiftDemo("33.jpg", "3333.jpg"); break;
    case 2: SurfDemo("33.jpg", "3333.jpg"); break;
    case 3: OrbDemo("33.jpg", "3333.jpg"); break;
    case 4: BackDiffTest(); break;
    case 5: MixedGaussianTest("cat.avi");
    }


    //此函数等待按键，按键盘任意键就返回
    waitKey();
    return 0;
}

图片

原图像

  • 这里写图片描述

  • 这里写图片描述

结果图

  • 这里写图片描述

  • 这里写图片描述

  • 这里写图片描述

littletomatodonkey
关注
专栏目录
【OpenCV】5th-识别背景和前景
sj的博客
11-27 1308
打开前置摄像头或本地视频，识别背景和前景#include <stdio.h> #include <cv.h> #include <cxcore.h> #include <highgui.h> #include <opencv2\core\core.hpp> #include <opencv2\highgui\highgui.hpp> #include <opencv2\opencv.
opencv——特征检测
朝闻雨的博客
09-25 277
绘制关键点的drawKeypoints()函数： void drawKeypoints( const Mat &amp;amp;amp;amp;amp;image,//输入图像 const vector&amp;amp;amp;amp;lt;KeyPoint&amp;amp;amp;amp;gt; &amp;amp;amp;amp;amp;keypoints,//根据源图像得到的特征点，它是一个输出参数 Mat &amp;a
OpenCV成长之路(9)：特征点检测与图像匹配
weixin_34163741的博客
01-03 1615
特征点又称兴趣点、关键点，它是在图像中突出且具有代表意义的一些点，通过这些点我们可以用来识别图像、进行图像配准、进行3D重建等。本文主要介绍OpenCV中几种定位与表示关键点的函数。 一、Harris角点 角点是图像中最基本的一种关键点，它是由图像中一些几何结构的关节点构成，很多都是线条之间产生的交点。Harris角点是一类比较经典的角点类型，它的基本原理是计算图像中每点与周围点变化率的平均值...
OpenCV4特征匹配
最新发布
qq_45445740的博客
08-20 1098
因为每个特征点都具有标志着唯一身份和特点的描述子，因此特征点匹配其实就是在两个图像中寻找具有相似描述子的两个特征点。，就是指将从影像中提取的特征作为共轭实体，而将所提特征属性或描述参数(实际上是特征的特征，也可以认为是影像的特征)作为匹配实体，通过计算匹配实体之间的相似性测度以实现共轭实体配准的影像匹配方法。它使用第一组中的每个特征的描述子，与第二组中的所有特征描述子进行匹配，计算它们之间的差距，然后将最接近的一个匹配返回。虽然Harris角点具有旋转不变的特征，但缩放后，原来的角点有可能就检测不到了。
python opencv —— 背景提取（MOG、KNN）、识别与检测（Haar Cascade）
weixin_30633949的博客
05-01 834
注意 opencv 的坐标轴，x 轴向右，和 width 对应，y 轴向下，和 height 对应； 1. MOG2 与 KNN MOG：Mixture of Gaussian import cv2 cap = cv2.VideoCapture('./data/video/768x576.avi') knn_sub = cv2.createBackg...
opencv 8 --背景减除 -- BackgroundSubtractorMOG2
热门推荐
wust小吴
05-21 1万+
在很多基础应用中背景检出都是一个非常重要的步骤。 例如顾客统计，使用一个静态摄像头来记录进入和离开房间的人数；或者是交通摄像头，需要提取交通工具的信息等。 在所有的这些例子中，首先要将人或车单独提取出来。 技术上来说，我们需要从静止的背景中提取移动的前景 如果你有一张背景(仅有背景不含前景)图像，比如没有顾客的房间，没有交通工具的道路等，那就好办了。我们只需要在新的图像中减去背景就可以得...
opencv K均值聚类分析,标准像背景识别
人工智能笔记
07-26 334
/* 本章内容 * K均值聚类 */ 输出结果： 2. 绘制聚类结果： 输出结果： 源码 //#include <QCoreApplication> #include <iostream> #include <opencv2/opencv.hpp> #include <opencv2/xfeatures2d.hpp> int main(int argc, char *argv[]) { /*...
python利用opencv基于模板匹配对喷码字符进行分割与识别
05-27
在本文中，我们将深入探讨如何使用Python和OpenCV库实现基于模板匹配的喷码字符分割与识别技术。这项技术在工业质量控制、自动化检测等领域有着广泛的应用，特别是对于那些需要精确识别流水线上产品上的喷码字符的...
opencvsharp-master.zip_OpenCVSharp匹配_OpenCvSharp_图片识别_标记识别
07-14
而特征匹配则通过计算图像的关键点和描述符来寻找相似性，这在识别复杂形状和物体时非常有用。 接下来是标记识别。标记识别通常用于增强现实、物体跟踪等场景，它涉及到识别预定义的图案或标志，如二维码、AR标签等...
opencv指纹识别FVS_opencv_指纹识别_VC++
04-14
首先，OpenCV是一个跨平台的计算机视觉库，它提供了大量的图像处理和计算机视觉算法，包括图像读取、处理、特征检测、对象识别等。在指纹识别系统中，OpenCV可以帮助我们完成图像预处理、特征提取以及匹配等多个关键...
使用OpenCV对图片进行特征点检测和匹配（C++）
anheku1562的博客
08-10 4569
背景 最近从不同网站下载了非常多的动漫壁纸，其中有一些内容相同，但是大小、背景颜色、色调、主人公的位置不同（例子如下）。正因为如此，基础的均方误差、直方图检测等方法很难识别出这些相似的图片。 思路 OpenCV中有很多用来对特征点进行检测和计算的函数，这些函数能够利用像素点及其周围的灰度检测其是否是图像中的特征点，并计算出它的信息，比如ORB、SIFT、SURF、AKANA。同...
opencv实现背景分离
01-04
使用opencv函数grabcut，实现前景和背景分离 使用opencv函数grabcut，实现前景和背景分离
动态目标追踪和前景背景提取（使用Python和opencv编程）
08-12
动态目标追踪和前景背景提取（使用Python和opencv编程）
TensorFlow + Opencv 实现简单的图像识别
10-21
使用TensorFlow搭建简单的BP神经网络的模型，一层输入层，一层隐藏，一层输出，最终实现简单的图像识别。
Opencv实现特征点提取和匹配
04-02
基于OpenCV的实现特征点提取和匹配的程序。
背景差法OpenCV实现程序代码
07-11
背景差法OpenCV实现程序代码 获取于互联网络
在OpenCV里使用特征匹配和单映射变换的代码详解
09-18
特征点匹配的目的是找到两幅图像中的相似点，这对于图像配准、对象识别和3D重建等应用至关重要。 单映射变换（Homography）是计算机视觉中一个基础概念，描述了不同视角下图像之间的对应关系。简而言之，单映射变换...
OpenCV视频分析背景提取与前景提取
小白学视觉
12-13 2516
点击上方“小白学视觉”，选择加"星标"或“置顶”重磅干货，第一时间送达基本思想OpenCV中支持的两种背景提取算法都是基于模型密度评估，然后在像素级对图像进行前景与背景分类的方法，它们具有...
【OpenCV】动态目标检测（背景/场景）
Taily老段的专栏
12-05 6461
Taily老段的微信公众号，欢迎交流学习 https://blog.csdn.net/taily_duan/article/details/81214815 // OpenCV3Contrib.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include &lt;opencv2/opencv.hpp&gt; //头文件 #include &lt...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

littletomatodonkey

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值