OpenCV 学习总结

原野风霜324

已于 2023-07-08 17:29:30 修改

阅读量95

点赞数

分类专栏：机器视觉文章标签： opencv 计算机视觉 c++

于 2023-06-24 22:03:53 首次发布

本文链接：https://blog.csdn.net/liuxu324/article/details/131367167

版权

机器视觉专栏收录该内容

3 篇文章 0 订阅

订阅专栏

图片读取和保存

#include <iostream>
#include<opencv2/opencv.hpp>
using namespace std;
using namespace cv;

int main()
{
    // read & write pic
    Mat img;
    Mat img = imread("test.jpg");
    if (img.empty()) {
        cout << "img is empty" << endl;
        return -1;
    }
    imshow("test", img);
    
    waitKey(0);
    bool saved = imwrite("test_save.jpg", img);
    if (saved) {
        cout << "save ok" << endl;
    }

    return 0;
}

视频读取和保存

#include <iostream>
#include<opencv2/opencv.hpp>
using namespace std;
using namespace cv;

int main()
{
	// read & write video
    Mat img;

    VideoCapture video(0);// 0 - pc local camera
    if (!video.isOpened()) {
        cout << "video open error" << endl;
        return -1;
    }
    video >> img;
    if (img.empty()) {
        cout << "img empty" << endl;
        return -1;
    }

    double fps = 25.0;
    bool isColor = (img.type() == CV_8UC3);
    VideoWriter w1;
    #if 0//avi
    string filename = "test_save.avi";
    int encode_type = VideoWriter::fourcc('M','J','P','G');
    #else//mp4
    string filename = "test_save.mp4";
    int encode_type = VideoWriter::fourcc('M', 'P', '4', 'V');
    #endif
    w1.open(filename,encode_type,fps,img.size(),isColor);
    if (!w1.isOpened()) {
        cout << "w1 open error" << endl;
        return -1;
    }

    while (1){
        Mat frame;
        video >> frame;
        if (frame.empty()) {
            cout << "frame empty" << endl;
            break;
        }
        
        w1.write(frame);

        namedWindow("video_test", WINDOW_NORMAL);
        imshow("video_tset", frame);

        char c = waitKey(50);
        if (27 == c) {  //按ESC 退出
            cout << "ESC" << endl;
            break;
        }
    }

    video.release();
    w1.release();

    return 0;
}

多个视频文件连接

main

#include <iostream>
#include <opencv2/opencv.hpp>
#include "my_time.hpp"
#include "save_video.hpp"

using namespace std;
using namespace cv;

int main()
{
    VideoCapture video(0);// 0 - pc local camera
    if (!video.isOpened()) {
        cout << "=== video open error" << endl;
        return -1;
    }

    bool firstInFlg = true;
    static int index = 0;
    static uint64_t oldTime = 0;
    uint64_t curTime = 0, difTime = 0;
    MyTime myTime;
    SaveVidoe saveVidoe;
    JointVideo jointVideo;

    while (1){
        Mat frame;
        video >> frame;
        if (frame.empty()) {
            cout << "frame empty" << endl;
            break;
        }

        curTime = myTime.timeMs();
        if (firstInFlg)
        {
            firstInFlg = false;
            oldTime = curTime;

            index = 1;
            saveVidoe.onInit(index, frame);//默认1
        }
        if ((difTime = (curTime-oldTime)) > 10000) {
            cout << "=== difTime: " << difTime << endl;
            oldTime = curTime;
            
            saveVidoe.release(index);

            index++;
            index = (index > VIDEO_NUM_MAX) ? 1 : index;
            saveVidoe.onInit(index, frame);
        }
        saveVidoe.mySaveVideo(index, frame);

        namedWindow("video_test", WINDOW_NORMAL);
        imshow("video_tset", frame);

        char c = waitKey(50);
        if (27 == c) {  //按ESC 退出
            cout << "ESC" << endl;
            break;
        }
        else if ('s' == c)
        {
            cout << "=== joint video" << endl;
            cout << "=== index: " << index << endl;
            jointVideo.myJointVideo(index);
            break;
        }
    }

    video.release();

    return 0;
}

save_video.hpp

#pragma once

#include <iostream>
#include <string>
#include <opencv2/opencv.hpp>

using namespace std;
using namespace cv;

#define VIDEO_NUM_MAX (4)

class JointVideo
{
public:
    JointVideo() {};
    ~JointVideo() {};

    int myJointVideo(int index)
    {
        string dstName = "save_video_nto1.mp4";
        char filename[32] = { 0 };
        char filename_bak[32] = { 0 };
        char filename_1[32] = { 0 };
        char filename_2[32] = { 0 };
        
        for (int i = 1; i < VIDEO_NUM_MAX+1; i++)
        {
            memset(filename, 0, sizeof(filename));
            snprintf(filename, sizeof(filename), "save_video_%d.mp4", i);
            memset(filename_bak, 0, sizeof(filename_bak));
            snprintf(filename_bak, sizeof(filename_bak), "save_video_%d_bak.mp4", i);
            int ret = rename(filename, filename_bak);
            if (ret)
            {
                cout << "rename err: " << i << " == cur index:" << index << endl;
            }
        }

        for (int i = 1; i < VIDEO_NUM_MAX; i++)
        {
            memset(filename_1, 0, sizeof(filename_1));
            memset(filename_2, 0, sizeof(filename_2));
            if (1 == i)
            {
                snprintf(filename_1, sizeof(filename_1), "save_video_%d_bak.mp4", i);
                snprintf(filename_2, sizeof(filename_2), "save_video_%d_bak.mp4", i+1);
            }
            else
            {
                snprintf(filename_1, sizeof(filename_1), "save_video_nto1_bak.mp4");
                snprintf(filename_2, sizeof(filename_2), "save_video_%d_bak.mp4", i + 1);
            }
            VideoCapture firstVideo(filename_1);
            VideoCapture secondVideo(filename_2);
            if (!firstVideo.isOpened() || !secondVideo.isOpened())
            {
                cout << "=== could not open the input video." << endl;
                return -1;
            }

            double totalFrameOne = firstVideo.get(CAP_PROP_FRAME_COUNT);
            cout << "totalFrameOne : " << totalFrameOne << endl;
            double frameRateOne = firstVideo.get(CAP_PROP_FPS);   //acquire the frame rate
            cout << "frameRateOne : " << frameRateOne << endl;

            Size firstSize = Size((int)firstVideo.get(CAP_PROP_FRAME_WIDTH), (int)firstVideo.get(CAP_PROP_FRAME_HEIGHT));   //acquire input size 
            int codec = static_cast<int>(firstVideo.get(CAP_PROP_FOURCC));  //get codec type- int form
            VideoWriter dstVideo(dstName, codec, 30, firstSize, true);   //open the output
            if (!dstVideo.isOpened())
            {
                cout << "=== could not open the output video for write." << endl;
                return -1;
            }

            Mat srcOneFrame, srcTwoFrame;
            if (!firstVideo.read(srcOneFrame) || !secondVideo.read(srcTwoFrame))
            {
                cout << "=== Read Frame failed." << endl;
                return -1;
            }
            for (;;)
            {
                firstVideo >> srcOneFrame;   //read
                dstVideo.write(srcOneFrame);  //save
                if (srcOneFrame.empty())  //check if at end
                {
                    secondVideo >> srcTwoFrame;
                    dstVideo.write(srcTwoFrame);
                    if (srcTwoFrame.empty())
                    {
                        cout << "=== joint ok. cur i: " << i << endl;
                        break;
                    }
                }
            }
            firstVideo.release();
            secondVideo.release();
            dstVideo.release();

            int ret = rename("save_video_nto1.mp4", "save_video_nto1_bak.mp4");
            if (ret)
            {
                cout << "rename err: save_video_nto1_bak" << endl;
            }
        }
    };

private:

};

class SaveVidoe
{
public:
    SaveVidoe() {};
    ~SaveVidoe() {};

;   void onInit(int index, Mat& img)
    {
        string filename_1 = "save_video_1.mp4";
        string filename_2 = "save_video_2.mp4";
        string filename_3 = "save_video_3.mp4";
        string filename_4 = "save_video_4.mp4";
        int encode_type = VideoWriter::fourcc('M', 'P', '4', 'V');
        int fps = 30;

        switch (index)
        {
            case 1:
                this->vw_1.open(filename_1, encode_type, fps, img.size(), true);
                if (!vw_1.isOpened()) {
                    cout << "=== vw_1 open error" << endl;
                    return ;
                }
                break;
            case 2:
                this->vw_2.open(filename_2, encode_type, fps, img.size(), true);
                if (!vw_2.isOpened()) {
                    cout << "=== vw_2 open error" << endl;
                    return;
                }
                break;
            case 3:
                this->vw_3.open(filename_3, encode_type, fps, img.size(), true);
                if (!vw_3.isOpened()) {
                    cout << "=== vw_3 open error" << endl;
                    return;
                }
                break;
            case 4:
                this->vw_4.open(filename_4, encode_type, fps, img.size(), true);
                if (!vw_4.isOpened()) {
                    cout << "=== vw_4 open error" << endl;
                    return;
                }
                break;
            default:
                break;
        }
    };

    void release(int index) 
    {
        switch (index)
        {
            case 1:
                this->vw_1.release();
                break;
            case 2:
                this->vw_2.release();
                break; 
            case 3:
                this->vw_3.release();
                break;
            case 4:
                this->vw_4.release();
                break;
            default:
                break;
        }
    };

    int mySaveVideo(int index, Mat& frame)
    {
        switch(index)
        {
            case 1:
                this->vw_1.write(frame);
                break;
            case 2:
                this->vw_2.write(frame);
                break;
            case 3:
                this->vw_3.write(frame);
                break;
            case 4:
                this->vw_4.write(frame);
                break;
            default:
                cout << "=== index error" << endl;
                break;
        }
        return 0;
    };

private:
    VideoWriter vw_1;
    VideoWriter vw_2;
    VideoWriter vw_3;
    VideoWriter vw_4;
};

my_time.hpp

#pragma once

#include <iostream>
#include <sys/timeb.h>

class MyTime
{
public:
	MyTime() {};
	~MyTime() {};

	uint64_t timeMs(void);

private:

};

uint64_t MyTime::timeMs(void) 
{
	timeb now;
	ftime(&now);
	return now.time * 1000 + now.millitm;
}