《OpenCV2 计算机视觉编程手册》视频处理一

本文主要结合《OpenCV2 计算机视觉编程手册》第10章的内容，学习OpenCV 处理视频图像的一般方法，包括读入，处理，写出。

1.头文件

#ifndef HEAD_H_
#define HEAD_H_

#include <iostream>
#include <iomanip>// 控制输出格式
#include <sstream>// 文件流控制
#include <string>
#include <vector>

#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>

#endif // HEAD_H_

2. VideoProcessor头文件

#ifndef VPROCESSOR_H_
#define VPROCESSOR_H_

#include "head.h"

void canny(cv::Mat& img, cv::Mat& out)
{
cv::cvtColor(img, out, CV_BGR2GRAY);                      // 灰度转换
cv::Canny(out, out, 100, 200);                            // Canny边缘检测
cv::threshold(out, out, 128, 255, cv::THRESH_BINARY_INV); // 二值图像反转, 小于128设置为255, 否则为0;即边缘为黑色
}

// 抽象类FrameProcessor中纯虚函数process必须在子类(其继承类)中重新定义。
// http://blog.csdn.net/hackbuteer1/article/details/7558868 // 帧处理器接口
class FrameProcessor
{
public:
// 处理方法,定义为纯虚函数, 让其子类实现具体的接口
virtual void process(cv:: Mat &input, cv:: Mat &output)= 0;
};

class VideoProcessor
{
private:
cv::VideoCapture capture;           // OpenCV视频采集对象(object)
void (*process)(cv::Mat&, cv::Mat&);// 每帧处理的回调函数, 函数指针调用
FrameProcessor *frameProcessor;     // 基类(含纯虚函数的抽象类)FrameProcessor接口指针, 指向子类的实现
bool callIt;                        // 启动回调函数与否的bool判断, true:调用, false:不调用
std::string windowNameInput;        // 输入显示窗口名字
std::string windowNameOutput;       // 输出显示窗口名字
int delay;                          // 帧间处理延迟
long fnumber;                       // 已处理帧总数
long frameToStop;                   // 在该帧停止
bool stop;                          // 停止处理标志位!

std::vector<std::string> images;               // 输入的图像集或者图像向量(vector容器)
std::vector<std::string>::const_iterator itImg;// 图像集的迭代器

cv::VideoWriter writer;             // OpenCV视频写出对象
std::string outputFile;             // 输出视频文件名字
int currentIndex;                   // 输出图像集的当前索引
int digits;                         // 输出图像文件名字的数字
std::string extension;              // 输出图像集的扩展名

// Getting the next frame which could be: video file; camera; vector of images
bool readNextFrame(cv::Mat& frame)
{
if (images.size()==0)
return capture.read(frame);
else
{
if (itImg != images.end())
{
frame= cv::imread(*itImg);
itImg++;
return frame.data != 0;
}
else
{
return false;
}
}
}

// Writing the output frame which could be: video file or images
void writeNextFrame(cv::Mat& frame)
{
if (extension.length())
{ // 输出图像文件
std::stringstream ss;
ss << outputFile << std::setfill('0') << std::setw(digits) << currentIndex++ << extension;
cv::imwrite(ss.str(),frame);
}
else
{ // 输出视频文件
writer.write(frame);
}
}

public:
// 构造函数
VideoProcessor() : callIt(false), delay(-1),
fnumber(0), stop(false), digits(0), frameToStop(-1),
process(0), frameProcessor(0) {}

// 设置视频文件的名字
bool setInput(std::string filename)
{
fnumber= 0;
// In case a resource was already
// associated with the VideoCapture instance
capture.release();            // 释放之前打开过的资源
images.clear();               // 释放之前打开过的资源
return capture.open(filename);// 打开视频文件
}

// 设置相机ID
bool setInput(int id)
{
fnumber= 0;
// In case a resource was already
// associated with the VideoCapture instance
capture.release();
images.clear();
// 打开视频文件
return capture.open(id);
}

// 设置输入的图像集
bool setInput(const std::vector<std::string>& imgs)
{
fnumber= 0;
// In case a resource was already
// associated with the VideoCapture instance
capture.release();//释放之前打开过的资源

// 输入的是图像集
images= imgs;
itImg= images.begin();
return true;
}

// 设置输出视频文件, 默认参数和输入的一样
bool setOutput(const std::string &filename, int codec=0, double framerate=0.0, bool isColor=true)
{
outputFile= filename;
extension.clear();

if (framerate==0.0)
framerate= getFrameRate(); // 与输入相同

char c[4];                     // 使用和输入相同的编码格式
if (codec==0)
{
codec= getCodec(c);
}

// 打开输出视频
return writer.open(outputFile, // 文件名
codec,                     // 使用的解码格式
framerate,                 // 帧率
getFrameSize(),            // 帧大小
isColor);                  // 是否为彩色视频
}

// 设置输出是图像集, 后缀必须是".jpg", ".bmp" ...
bool setOutput(const std::string &filename, // 文件名前缀
const std::string &ext,                 // 图像文件后缀
int numberOfDigits=3,                   // 数字位数
int startIndex=0)                       // 开始索引000
{
if (numberOfDigits<0)                   // 数字位数必须是正数
return false;

outputFile = filename;                  // 文件名
extension  = ext;                       // 公共后缀名

digits       = numberOfDigits;          // 文件名中的数字位数
currentIndex = startIndex;              // 开始索引

return true;
}

// 设置每一帧的回调函数
void setFrameProcessor(void (*frameProcessingCallback)(cv::Mat&, cv::Mat&))
{
// invalidate frame processor class instance 使FrameProcessor实例无效化
frameProcessor = 0;
process = frameProcessingCallback;
callProcess();
}

// 设置FrameProcessor接口实例
void setFrameProcessor(FrameProcessor* frameProcessorPtr)
{
// invalidate callback function 使回调函数无效化
process = 0;
frameProcessor= frameProcessorPtr;
callProcess();
}

// 在frame帧停止
void stopAtFrameNo(long frame)
{
frameToStop= frame;
}

// 处理回调函数
void callProcess()
{
callIt= true;
}

// 不调用回调函数
void dontCallProcess()
{
callIt= false;
}

// 显示输入的图像帧
void displayInput(std::string wn)
{
windowNameInput= wn;
cv::namedWindow(windowNameInput);
}

// 显示处理的图像帧
void displayOutput(std::string wn)
{
windowNameOutput= wn;
cv::namedWindow(windowNameOutput);
}

// 不显示处理的图像帧
void dontDisplay()
{
cv::destroyWindow(windowNameInput);
cv::destroyWindow(windowNameOutput);
windowNameInput.clear();
windowNameOutput.clear();
}

// 设置帧间延迟时间
// 0 means wait at each frame
// negative means no delay
void setDelay(int d)
{
delay= d;
}

// 处理帧的总数
long getNumberOfProcessedFrames()
{
return fnumber;
}

// 返回视频帧的大小
cv::Size getFrameSize()
{
if (images.size()==0)
{
// get size of from the capture device
int w= static_cast<int>(capture.get(CV_CAP_PROP_FRAME_WIDTH));
int h= static_cast<int>(capture.get(CV_CAP_PROP_FRAME_HEIGHT));

return cv::Size(w,h);
}
else
{ // if input is vector of images
cv::Mat tmp= cv::imread(images[0]);
if (!tmp.data) return cv::Size(0,0);
else return tmp.size();
}
}

// 返回下一帧的帧数
long getFrameNumber()
{
if (images.size()==0)
{
// get info of from the capture device
long f= static_cast<long>(capture.get(CV_CAP_PROP_POS_FRAMES));
return f;
}
else
{ // if input is vector of images
return static_cast<long>(itImg-images.begin());
}
}

// return the position in ms
double getPositionMS()
{
// undefined for vector of images
if (images.size()!=0) return 0.0;

double t= capture.get(CV_CAP_PROP_POS_MSEC);
return t;
}

// 返回帧率
double getFrameRate()
{
// undefined for vector of images
if (images.size()!=0) return 0;

double r= capture.get(CV_CAP_PROP_FPS);
return r;
}

// 返回视频中图像的总数
long getTotalFrameCount()
{
// for vector of images
if (images.size()!=0) return images.size();

long t= capture.get(CV_CAP_PROP_FRAME_COUNT);
return t;
}

// 获取输入视频的编解码器
int getCodec(char codec[4])
{
// 未制定的图像集
if (images.size()!=0) return -1;

union
{// 4-char编码的数据结果
int value;
char code[4];
} returned;
// 获取编码
returned.value= static_cast<int>(capture.get(CV_CAP_PROP_FOURCC));
// 获得4字符
codec[0]= returned.code[0];
codec[1]= returned.code[1];
codec[2]= returned.code[2];
codec[3]= returned.code[3];
// 返回对应的整数
return returned.value;
}

// 设置帧位置
bool setFrameNumber(long pos)
{
// for vector of images
if (images.size()!=0)
{
// move to position in vector
itImg= images.begin() + pos;
// is it a valid position?
if (pos < images.size())
return true;
else
return false;

}
else
{ // if input is a capture device
return capture.set(CV_CAP_PROP_POS_FRAMES, pos);
}
}

// go to this position
bool setPositionMS(double pos)
{
// not defined in vector of images
if (images.size()!=0)
return false;
else
return capture.set(CV_CAP_PROP_POS_MSEC, pos);
}

// go to this position expressed in fraction of total film length
bool setRelativePosition(double pos)
{
// for vector of images
if (images.size()!=0)
{
// move to position in vector
long posI= static_cast<long>(pos*images.size()+0.5);
itImg= images.begin() + posI;
// is it a valid position?
if (posI < images.size())
return true;
else
return false;
}
else
{ // if input is a capture device
return capture.set(CV_CAP_PROP_POS_AVI_RATIO, pos);
}
}

// 停止运行
void stopIt()
{
stop= true;
}
// 是否已停止运行?
bool isStopped()
{
return stop;
}

// 判断是否是视频捕获设备或图像集
bool isOpened()
{
return capture.isOpened() || !images.empty();
}

// 获取并处理图像
void run()
{
cv::Mat frame;  // 当前帧
cv::Mat output; // 输出帧

// if no capture device has been set
if (!isOpened())
return;

stop= false;
while (!isStopped())
{
// 读取下一帧
if (!readNextFrame(frame))
break;

// 显示输出帧
if (windowNameInput.length()!=0)
cv::imshow(windowNameInput,frame);

// 调用帧处理回调函数或FrameProcessor实例
if (callIt)
{
// 处理当前帧
if (process)             // 如果是回调函数
process(frame, output);
else if (frameProcessor) //如果是FrameProcessor实例
frameProcessor->process(frame,output);
// 增加帧数
fnumber++;

}
else
{
output= frame;
}

// 写出输出图像序列
if (outputFile.length()!=0)
writeNextFrame(output);

// 显示输出帧
if (windowNameOutput.length()!=0)
cv::imshow(windowNameOutput,output);

// 引入帧间延迟
if (delay>=0 && cv::waitKey(delay)>=0)
stopIt();

// 检查是否需要停止运行
if (frameToStop>=0 && getFrameNumber()==frameToStop)
stopIt();
}
}
};

#endif // VPROCESSOR_H_

3. 主函数

#include "head.h"
#include "videoprocessor.h"

int main()
{
//----Zero Test----
cv::VideoCapture capture("../bike.avi"); // 打开视频/摄像头0
if (!capture.isOpened())
return 1;
double rate= capture.get(CV_CAP_PROP_FPS);// 获取帧率
bool stop(false);
cv::Mat frame;                            // 当前帧
cv::namedWindow("Extracted Frame");
int delay= 1000/rate;                     // 延迟的毫秒
//int delay = 1000;
// 处理视频所有帧
while (!stop)
{
// read next frame if any
if (!capture.read(frame))
break;
cv::imshow("Extracted Frame",frame);
if (cv::waitKey(delay)>=0)            // 延迟等待直到cv::waitKey(delay)<0
stop= true;
}
capture.release();                       // 因为capture自动调用析构函数，所以capture.release不是必须的!
cv::waitKey();

//----First Test----
VideoProcessor processor;                           // 创建VideoProcessor类实例 processor
processor.setInput("../bike.avi");                  // 打开视频文件bike.avi
processor.displayInput("Input Video");              // 声明输入视频显示窗口
processor.displayOutput("Output Video");            // 声明输出视频显示窗口
processor.setDelay(1000./processor.getFrameRate()); // 设置播放视频为原始输入视频帧率
processor.setFrameProcessor(canny);                 // 设置帧处理器的回调函数--canny
processor.run();                                    // 开始处理视频文件
cv::waitKey();                                      // 等待按键响应

//----Second test----
processor.setInput("../bike.avi");                            // 重新设置打开视频
cv::Size size= processor.getFrameSize();                      // 获取视频文件的基本信息
std::cout << size.width << " " << size.height << std::endl;   // 视频图像的宽度(列)和高度(行)
std::cout << processor.getFrameRate() << std::endl;           // 视频的帧率
std::cout << processor.getTotalFrameCount() << std::endl;     // 视频总的帧数
std::cout << processor.getFrameNumber() << std::endl;         // 视频帧的编号
std::cout << processor.getPositionMS() << std::endl;          // 视频帧的位置(ms)
processor.dontCallProcess();                                   // 不处理打开视频文件
// 输出.jpg视频图像到output文件夹, 图像名字为bikeOut000.jpg~bikeOut118.jpg
processor.setOutput("../output/bikeOut",".jpg");
processor.run();
cv::waitKey();
// 输出bike.avi视频到output文件夹,编解码器为:XVID, 基于MPEG-4视频标准的开源解码库
char codec[4];                                                 // 编解码器标识
processor.setOutput("../output/bike.avi",processor.getCodec(codec),processor.getFrameRate());
std::cout << "Codec: " << codec[0] << codec[1] << codec[2] << codec[3] << std::endl;
processor.run();
cv::waitKey();

//----Three test----
processor.setInput("../bike.avi");
processor.displayInput("Input Video");              // 声明输入视频显示窗口
processor.displayOutput("Output Video");            // 声明输出视频显示窗口
processor.setFrameNumber(80);                       // 设置帧的位置
processor.stopAtFrameNo(120);                       // 停止的帧位置
processor.setDelay(1000./processor.getFrameRate());
processor.run();
cv::waitKey();

return 0;
}

Canny边缘检测



视频写出结果(包含文件和视频)



制定开始帧和结束帧位置