Skip to content
Permalink
Branch: master
Find file Copy path
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
280 lines (216 sloc) 7.32 KB
// Yet anther C++ implementation of EVM, based on OpenCV and Qt.
// Copyright (C) 2014 Joseph Pan <cs.wzpan@gmail.com>
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// 02110-1301 USA
//
#ifndef VIDEOPROCESSOR_H
#define VIDEOPROCESSOR_H
#include <iostream>
#include <iomanip>
#include <sstream>
#include <string>
#include <vector>
#include <QObject>
#include <QDateTime>
#include <vector>
#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>
#include "SpatialFilter.h"
enum spatialFilterType {LAPLACIAN, GAUSSIAN};
enum temporalFilterType {IIR, IDEAL};
class VideoProcessor : public QObject {
Q_OBJECT
friend class MagnifyDialog;
public:
explicit VideoProcessor(QObject *parent = 0);
// Is the player playing?
bool isStop();
// Is the video modified?
bool isModified();
// Is the player opened?
bool isOpened();
// set a delay between each frame
// 0 means wait at each frame
// negative means no delay
void setDelay(int d);
// a count is kept of the processed frames
long getNumberOfProcessedFrames();
// get the current playing progress
long getNumberOfPlayedFrames();
// get the video capture
cv::VideoCapture getCapture();
// return the size of the video frame
cv::Size getFrameSize();
// return the frame number of the next frame
long getFrameNumber();
// return the position in milliseconds
double getPositionMS();
// return the frame rate
double getFrameRate();
// return the number of frames in video
long getLength();
// return the video length in milliseconds
double getLengthMS();
// get the codec of input video
int getCodec(char codec[4]);
// get temp file lists
void getTempFile(std::string &);
// get current temp file
void getCurTempFile(std::string &);
// go to this position expressed in fraction of total film length
bool setRelativePosition(double pos);
// set the name of the video file
bool setInput(const std::string &fileName);
// 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);
// 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
// set spatial filter
void setSpatialFilter(spatialFilterType type);
// set temporal filter
void setTemporalFilter(temporalFilterType type);
// play the frames of the sequence
void playIt();
// pause the frames of the sequence
void pauseIt();
// Stop playing
void stopIt();
// display the prev frame of the sequence
void prevFrame();
// display the next frame of the sequence
void nextFrame();
// Jump to a position
bool jumpTo(long index);
// Jump to a position in milliseconds
bool jumpToMS(double pos);
// close the video
void close();
// motion magnification
void motionMagnify();
// color magnification
void colorMagnify();
// write the processed result
void writeOutput();
private slots:
void revertVideo();
signals:
void showFrame(cv::Mat frame);
void revert();
void sleep(int msecs);
void updateBtn();
void updateProgressBar();
void reload(const std::string &);
void updateProcessProgress(const std::string &message, int percent);
void closeProgressDialog();
private:
// the OpenCV video capture object
cv::VideoCapture capture;
// delay between each frame processing
int delay;
// video frame rate
double rate;
// number of processed frames
long fnumber;
// total number of frames
long length;
// to stop the player
bool stop;
// is the video modified
bool modify;
// the current playing pos
long curPos;
// current index for output images
int curIndex;
// current level of pyramid
int curLevel;
// number of digits in output image filename
int digits;
// extension of output images
std::string extension;
// spatial filter type
spatialFilterType spatialType;
// temporal filter type
temporalFilterType temporalType;
// level numbers of image pyramid
int levels;
// amplification factor
float alpha;
// cut-off wave length
float lambda_c;
// low cut-off
float fl;
// high cut-off
float fh;
// chromAttenuation
float chromAttenuation;
// delta
float delta;
// extraggon factor
float exaggeration_factor;
// lambda
float lambda;
// the OpenCV video writer object
cv::VideoWriter writer;
cv::VideoWriter tempWriter;
// output filename
std::string outputFile;
// temp filename
std::string tempFile;
// all temp files queue
std::vector<std::string> tempFileList;
// low pass filters for IIR
std::vector<cv::Mat> lowpass1;
std::vector<cv::Mat> lowpass2;
// recalculate the number of frames in video
// normally doesn't need it unless getLength()
// can't return a valid value
void calculateLength();
// get the next frame if any
bool getNextFrame(cv::Mat& frame);
// to write the output frame
void writeNextFrame(cv::Mat& frame);
// set the temp video file
// by default the same parameters to the input video
bool createTemp(double framerate=0.0, bool isColor=true);
// spatial filtering
bool spatialFilter(const cv::Mat &src, std::vector<cv::Mat> &pyramid);
// temporal filtering
void temporalFilter(const cv::Mat &src,
cv::Mat &dst);
// temporal IIR filtering
void temporalIIRFilter(const cv::Mat &src,
cv::Mat &dst);
// temporal ideal bandpass filtering
void temporalIdealFilter(const cv::Mat &src,
cv::Mat &dst);
// amplify motion
void amplify(const cv::Mat &src, cv::Mat &dst);
// attenuate I, Q channels
void attenuate(cv::Mat &src, cv::Mat &dst);
// concat images into a large Mat
void concat(const std::vector<cv::Mat> &frames, cv::Mat &dst);
// de-concat the concatnate image into frames
void deConcat(const cv::Mat &src, const cv::Size &frameSize, std::vector<cv::Mat> &frames);
// create an ideal bandpass processor
void createIdealBandpassFilter(cv::Mat &filter, double fl, double fh, double rate);
};
#endif // VIDEOPROCESSOR_H
You can’t perform that action at this time.