代码出处,opencv2 cookbook:

/*------------------------------------------------------------------------------------------*\
This file contains material supporting chapter 10 of the cookbook:
Computer Vision Programming using the OpenCV Library.
by Robert Laganiere, Packt Publishing, 2011. This program is free software; permission is hereby granted to use, copy, modify,
and distribute this source code, or portions thereof, for any purpose, without fee,
subject to the restriction that the copyright notice may not be removed
or altered from any source or altered source distribution.
The software is released on an as-is basis and without any warranties of any kind.
In particular, the software is not guaranteed to be fault-tolerant or free from failure.
The author disclaims all warranties with regard to this software, any use,
and any consequent failure, is purely the responsibility of the user. Copyright (C) 2010-2011 Robert Laganiere, www.laganiere.name
\*------------------------------------------------------------------------------------------*/ #if !defined VPROCESSOR
#define VPROCESSOR #include <iostream>
#include <iomanip>
#include <sstream>
#include <string>
#include <vector>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp> #include <iostream>
#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp> #pragma comment(lib,"opencv_core2410d.lib")
#pragma comment(lib,"opencv_highgui2410d.lib")
#pragma comment(lib,"opencv_imgproc2410d.lib") // The frame processor interface
class FrameProcessor { public:
// processing method
virtual void process(cv:: Mat &input, cv:: Mat &output)= 0;
}; class VideoProcessor { private: // the OpenCV video capture object
cv::VideoCapture capture;
// the callback function to be called
// for the processing of each frame
void (*process)(cv::Mat&, cv::Mat&);
// the pointer to the class implementing
// the FrameProcessor interface
FrameProcessor *frameProcessor;
// a bool to determine if the
// process callback will be called .是否使用回调函数的bool变量
bool callIt;
// Input display window name
std::string windowNameInput;
// Output display window name
std::string windowNameOutput;
// delay between each frame processing
int delay;
// number of processed frames
long fnumber;
// stop at this frame number
long frameToStop;
// to stop the processing
bool stop; // vector of image filename to be used as input
std::vector<std::string> images;
// image vector iterator
std::vector<std::string>::const_iterator itImg; // the OpenCV video writer object
cv::VideoWriter writer;
// output filename
std::string outputFile; // current index for output images
int currentIndex;
// number of digits in output image filename
int digits;
// extension of output images
std::string extension; // to get the next frame
// 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;
}
}
} // to write the output frame
// could be: video file or images
void writeNextFrame(cv::Mat& frame)
{ if (extension.length()) { // then we write images std::stringstream ss;
ss << outputFile << std::setfill('0') << std::setw(digits) << currentIndex++ << extension;
cv::imwrite(ss.str(),frame); }
else
{ // then write video file writer.write(frame);
}
} public: // Constructor setting the default values
VideoProcessor() : callIt(false), delay(-1),
fnumber(0), stop(false), digits(0), frameToStop(-1),
process(0), frameProcessor(0) {} // set the name of the video file
bool setInput(std::string filename) { fnumber= 0;
// In case a resource was already
// associated with the VideoCapture instance
capture.release();
images.clear(); // Open the video file
return capture.open(filename);
} // set the camera ID
bool setInput(int id)
{ fnumber= 0;
// In case a resource was already
// associated with the VideoCapture instance
capture.release();
images.clear(); // Open the video file
return capture.open(id);
} // set the vector of input images
bool setInput(const std::vector<std::string>& imgs)
{ fnumber= 0;
// In case a resource was already
// associated with the VideoCapture instance
capture.release(); // the input will be this vector of images
images= imgs;
itImg= images.begin(); return true;
} // set the output video file
// by default the same parameters than input video will be used
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(); // same as input char c[4];
// use same codec as input
if (codec==0) {
codec= getCodec(c);
} // Open output video
return writer.open(outputFile, // filename
codec, // codec to be used
framerate, // frame rate of the video
getFrameSize(), // frame size
isColor); // color video?
} // set the output as a series of image files
// extension must be ".jpg", ".bmp" ...
bool setOutput(const std::string &filename, // filename prefix
const std::string &ext, // image file extension
int numberOfDigits=3, // number of digits
int startIndex=0)
{ // start index // number of digits must be positive
if (numberOfDigits<0)
return false; // filenames and their common extension
outputFile= filename;
extension= ext; // number of digits in the file numbering scheme
digits= numberOfDigits;
// start numbering at this index
currentIndex= startIndex; return true;
} // set the callback function that will be called for each frame
void setFrameProcessor(void (*frameProcessingCallback)(cv::Mat&, cv::Mat&))
{ // invalidate frame processor class instance
frameProcessor= 0;
// this is the frame processor function that will be called
process= frameProcessingCallback;
callProcess();
} // set the instance of the class that implements the FrameProcessor interface
void setFrameProcessor(FrameProcessor* frameProcessorPtr)
{ // invalidate callback function
process= 0;
// this is the frame processor instance that will be called
frameProcessor= frameProcessorPtr;
callProcess();
} // stop streaming at this frame number
void stopAtFrameNo(long frame)
{ frameToStop= frame;
} // process callback to be called
void callProcess()
{ callIt= true;
} // do not call process callback
void dontCallProcess()
{ callIt= false;
} // to display the processed frames
void displayInput(std::string wn)
{ windowNameInput= wn;
cv::namedWindow(windowNameInput);
} // to display the processed frames
void displayOutput(std::string wn)
{ windowNameOutput= wn;
cv::namedWindow(windowNameOutput);
} // do not display the processed frames
void dontDisplay()
{ cv::destroyWindow(windowNameInput);
cv::destroyWindow(windowNameOutput);
windowNameInput.clear();
windowNameOutput.clear();
} // set a delay between each frame
// 0 means wait at each frame
// negative means no delay
void setDelay(int d)
{ delay= d;
} // a count is kept of the processed frames
long getNumberOfProcessedFrames()
{ return fnumber;
} // return the size of the video frame
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();
}
} // return the frame number of the next frame
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;
} // return the frame rate
double getFrameRate()
{ // undefined for vector of images
if (images.size()!=0) return 0; double r= capture.get(CV_CAP_PROP_FPS);
return r;
} // return the number of frames in video
long getTotalFrameCount()
{ // for vector of images
if (images.size()!=0) return images.size(); long t= capture.get(CV_CAP_PROP_FRAME_COUNT);
return t;
} // get the codec of input video
int getCodec(char codec[4])
{ // undefined for vector of images
if (images.size()!=0) return -1; union {
int value;
char code[4]; } returned; returned.value= static_cast<int>(capture.get(CV_CAP_PROP_FOURCC)); codec[0]= returned.code[0];
codec[1]= returned.code[1];
codec[2]= returned.code[2];
codec[3]= returned.code[3]; return returned.value;
} // go to this frame number
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);
}
} // Stop the processing
void stopIt()
{ stop= true;
} // Is the process stopped?
bool isStopped()
{ return stop;
} // Is a capture device opened?
bool isOpened()
{ return capture.isOpened() || !images.empty();
} // to grab (and process) the frames of the sequence
void run()
{ // current frame
cv::Mat frame;
// output frame
cv::Mat output; // if no capture device has been set
if (!isOpened())
return; stop= false; while (!isStopped())
{ // read next frame if any
if (!readNextFrame(frame))
break; // display input frame
if (windowNameInput.length()!=0)
cv::imshow(windowNameInput,frame); // calling the process function or method
if (callIt)
{ // process the frame
if (process)
process(frame, output);
else if (frameProcessor)
frameProcessor->process(frame,output);
// increment frame number
fnumber++; }
else
{ output= frame;
} // write output sequence
if (outputFile.length()!=0)
writeNextFrame(output); // display output frame
if (windowNameOutput.length()!=0)
cv::imshow(windowNameOutput,output); // introduce a delay
if (delay>=0 && cv::waitKey(delay)>=0)
stopIt(); // check if we should stop
if (frameToStop>=0 && getFrameNumber()==frameToStop)
stopIt();
}
}
}; #endif
/*------------------------------------------------------------------------------------------*\
This file contains material supporting chapter 10 of the cookbook:
Computer Vision Programming using the OpenCV Library.
by Robert Laganiere, Packt Publishing, 2011. This program is free software; permission is hereby granted to use, copy, modify,
and distribute this source code, or portions thereof, for any purpose, without fee,
subject to the restriction that the copyright notice may not be removed
or altered from any source or altered source distribution.
The software is released on an as-is basis and without any warranties of any kind.
In particular, the software is not guaranteed to be fault-tolerant or free from failure.
The author disclaims all warranties with regard to this software, any use,
and any consequent failure, is purely the responsibility of the user. Copyright (C) 2010-2011 Robert Laganiere, www.laganiere.name
\*------------------------------------------------------------------------------------------*/ #include "videoprocessor.h" void draw(cv::Mat& img, cv::Mat& out)
{ img.copyTo(out);
cv::circle(out, cv::Point(100,100),5,cv::Scalar(255,0,0),2);
} void canny(cv::Mat& img, cv::Mat& out) { // Convert to gray
cv::cvtColor(img,out,CV_BGR2GRAY);
// Compute Canny edges
cv::Canny(out,out,100,200);
// Invert the image
cv::threshold(out,out,128,255,cv::THRESH_BINARY_INV);
} int main()
{
// Open the video file
cv::VideoCapture capture("../bike.avi");
// check if video successfully opened
if (!capture.isOpened())
return 1; // Get the frame rate
double rate= capture.get(CV_CAP_PROP_FPS); bool stop(false);
cv::Mat frame; // current video frame
cv::namedWindow("Extracted Frame"); // Delay between each frame
// corresponds to video frame rate
int delay= 1000/rate; // for all frames in video
while (!stop) { // read next frame if any
if (!capture.read(frame))
break; cv::imshow("Extracted Frame",frame); // introduce a delay
// or press key to stop
if (cv::waitKey(delay)>=0)
stop= true;
} // Close the video file
capture.release(); cv::waitKey(); // Now using the VideoProcessor class // Create instance
VideoProcessor processor;
// Open video file
processor.setInput("../bike.avi");
// Declare a window to display the video
processor.displayInput("Input Video");
processor.displayOutput("Output Video");
// Play the video at the original frame rate
processor.setDelay(1000./processor.getFrameRate());
// Set the frame processor callback function
processor.setFrameProcessor(canny);
// Start the process
processor.run();
cv::waitKey(); // Second test
// Create instance
// VideoProcessor processor;
// Open video file
processor.setInput("../bike.avi"); // Get basic info about video file
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; // No processing
processor.dontCallProcess();
// Output filename
// processor.setOutput("../output/bikeOut",".jpg");
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; // Position the stream at frame 300
// processor.setFrameNumber(300);
// processor.stopAtFrameNo(120); // Declare a window to display the video
processor.displayInput("Current Frame");
processor.displayOutput("Output Frame"); // Play the video at the original frame rate
processor.setDelay(1000./processor.getFrameRate()); // Start the process
processor.run(); std::cout << processor.getFrameNumber() << std::endl;
std::cout << processor.getPositionMS() << std::endl; cv::waitKey();
}

OpenCV处理视频序列的类的更多相关文章

  1. Atitit Java OpenCV 捕获视频

    Atitit Java  OpenCV 捕获视频 ,打开一段视频或默认的摄像头 有两种方法,一种是在定义类的时候,一种是用open()方法. 一. 读取视频序列 OpenCV提供了一个简便易用的框架以 ...

  2. [AI开发]零代码分析视频结构化类应用结构设计

    视频结构化类应用涉及到的技术栈比较多,而且每种技术入门门槛都较高,比如视频接入存储.编解码.深度学习推理.rtmp流媒体等等.每个环节的水都非常深,单独拿出来可以写好几篇文章,如果没有个几年经验基本很 ...

  3. OpenCV的视频读取

    现在找一个能拍摄视频的设备真是太容易了.结果大家都用视频来代替以前的序列图像.视频可能由两种形式得到,一个是像网络摄像头那样实时视频流,或者由其他设备产生的压缩编码后的视频文件.幸运的是,OpenCV ...

  4. OpenCV读写视频文件解析

    OpenCV读写视频文件解析 一.视频读写类 视频处理的是运动图像,而不是静止图像.视频资源可以是一个专用摄像机.网络摄像头.视频文件或图像文件序列. 在 OpenCV 中,VideoCapture ...

  5. 【计算机视觉】OpenCV读取视频获取时间戳等信息(PS:经测试并不是时间戳,与FFMPEG时间戳不一样)

    OpenCV中通过VideoCaptrue类对视频进行读取操作以及调用摄像头,下面是该类的API. 1.VideoCapture类的构造函数: C++: VideoCapture::VideoCapt ...

  6. 使用opencv显示视频的方法

    下面对使用opencv显示视频做一个简单的记录.当然,网上这方面的资料已经数不胜数了,我只是将其简单记录,总结一下. 在opencv中显示视频主要有: (1)从本地读取视频和调用摄像头读取视频 (2) ...

  7. FFmpeg YUV视频序列编码为视频

    上一篇已经写了如何配置好开发环境,这次就先小试牛刀,来个视频的编码.搞视频处理的朋友肯定比较熟悉YUV视频序列,很多测试库提供的视频数据都是YUV视频序列,我们这里就用用YUV视频序列来做视频.关于Y ...

  8. java 实现视频转换通用工具类:视频截图-Ffmpeg(四)

    java 实现视频转换通用工具类:获取视频元数据信息(一) java 实现视频转换通用工具类:视频相互转换-总方法及Mencoder(二) java 实现视频转换通用工具类:视频相互转换-Ffmpeg ...

  9. java 实现视频转换通用工具类:视频相互转换-Ffmpeg(三)

    java 实现视频转换通用工具类:获取视频元数据信息(一) java 实现视频转换通用工具类:视频相互转换-总方法及Mencoder(二) 这节主要是ffmpeg的相关方法封装,在实际调用中主要使用f ...

随机推荐

  1. SpriteKit给游戏弹跳角色添加一个高度标示器

    这是一个类似于跳跃涂鸦的小游戏,主角不断吃能量球得到跳跃能量向更高的地方跳跃,如果图中碰到黑洞就挂了- 在游戏调试过程中如果能实时知道主角的高度就好了,这将有助于程序猿动态的判断游戏胜败逻辑. 你可以 ...

  2. socket系列之什么是socket

    1.什么是socket Socket是应用层与TCP/IP协议族通信的中间抽象层,它是一组接口,应用层通过调用这些接口实现发送和接收数据.一般这种抽象层由操作系统提供或者由JVM自己实现.使用sock ...

  3. Microsoft Dynamics CRM2011 更换Logo

    之前操作过但没做过记录,这里记录下以防以后有需要时记不起来还有迹可循 IE收藏栏的图标,在网站根目录下的的/favicon.ico CRM网页中的Logo,替换/_imgs/crmmastheadlo ...

  4. java的四种引用类型

    java的引用分为四个等级:4种级别由高到低依次为:强引用.软引用.弱引用和虚引用. ⑴强引用(StrongReference) 强引用是使用最普遍的引用.如果一个对象具有强引用,那垃圾回收器绝不会回 ...

  5. 让 Google Test 出错时断点

    Google Test 缺省是出错退出. 如果最后的出错行在系统库中,那就没什么帮助. 如果是调试运行,直接退出根本就不知道哪里出错了. 后来添加了一个运行参数: --gtest_break_on_f ...

  6. SSH深度历险(九) Struts2+DWZ+Uploadify实现多文件(文件和图片等等)上传

    在gxpt_uas系统中,要实现文件(文件和图片等等,可以灵活配置)的批量上传至mongodb,在学习这个过程中,学习了mongodb,并实现了批量上传的功能,实现思路:在DWZ的基础上参考官方的实例 ...

  7. Java数据类型及类型转换

    http://blog.csdn.net/pipisorry/article/details/51290064 java浮点数保留n位小数 import java.text.DecimalFormat ...

  8. 中国电信中兴F460光猫破解及路由级联设置

    http://blog.csdn.net/pipisorry/article/details/50636541 中国电信中兴F460光猫破解,获取超级密码,修改配置. 之前家里的宽带升级了,换成了光纤 ...

  9. 编译Android 4.4.2源码

    在之前的文章中,和大家分享了在天朝下下载android 4.4.2源码的过程(详见下载android4.4.2源码全过程(附已下载的源码)),现在写下编译的笔记. 虽然在android doc中,有提 ...

  10. x264 编码器选项分析 (x264 Codec Strong and Weak Points) 2

    文章目录: x264 编码器选项分析 (x264 Codec Strong and Weak Points) 1 x264 编码器选项分析 (x264 Codec Strong and Weak Po ...