代码出处,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. [Matlab]技巧笔记

    1.将字符串作为Matlab命令执行 md = 'dir'; eval(md); 2.将字符串作为系统命令执行 md = 'dir'; system(md); 3.使显示图像的坐标轴使用相同的度量单位 ...

  2. x264源代码简单分析:宏块分析(Analysis)部分-帧内宏块(Intra)

    ===================================================== H.264源代码分析文章列表: [编码 - x264] x264源代码简单分析:概述 x26 ...

  3. 【IOS 开发】Objective-C Foundation 框架 -- 字符串 | 日期 | 对象复制 | NSArray | NSSet | NSDictionary | 谓词

    一. 字符串 API 1. NSString 用法简介 (1) NSString API 介绍 NSString 功能 : -- 创建字符串 : 使用 init 开头的实例方法, 也可以使用 Stri ...

  4. Cocos2D iOS之旅:如何写一个敲地鼠游戏(四):创建TexturePacker自动脚本

    大熊猫猪·侯佩原创或翻译作品.欢迎转载,转载请注明出处. 如果觉得写的不好请告诉我,如果觉得不错请多多支持点赞.谢谢! hopy ;) 免责申明:本博客提供的所有翻译文章原稿均来自互联网,仅供学习交流 ...

  5. path和classpath的区别

    path的作用 path是系统用来指定可执行文件的完整路径,即使不在path中设置JDK的路径也可执行JAVA文件,但必须把完整的路径写出来,如C:\Program Files\Java\jdk1.6 ...

  6. Uva - 512 - Spreadsheet Tracking

    Data in spreadsheets are stored in cells, which are organized in rows (r) and columns (c). Some oper ...

  7. Android进阶(二十八)上下文菜单ContextMenu使用案例

    上下文菜单ContextMenu使用案例 前言 回顾之前的应用程序,发现之前创建的选项菜单无法显示了.按照正常逻辑来说,左图中在"商品信息"一栏中应该存在选项菜单,用户可进行分享等 ...

  8. iOS中 Swift初级入门学习(三)

    // // main.swift // LessonSwift-03 // // Copyright (c) 2015年 韩俊强. All rights reserved. // import Fou ...

  9. Chapter 1 Securing Your Server and Network(13):配置端点安全性

    原文出处:http://blog.csdn.net/dba_huangzj/article/details/38489765,专题目录:http://blog.csdn.net/dba_huangzj ...

  10. (NO.00003)iOS游戏简单的机器人投射游戏成形记(十二)

    回到Xcode,新建Level1类,继承于CCNode. 打开Level1.m在初始化方法中添加如下方法: -(void)didLoadFromCCB{ [self initBasket]; [sel ...