VideoManager.hpp

Go to the documentation of this file.

/*
*
* VU Visualization 2
*
* Author: Dominik Bauer, Pascal Plank
* SS 2016
* All rights reserved.
*
*/

#ifndef VIDEOMANAGER
#define VIDEOMANAGER

#include <iostream>
#include <iomanip>
#include <sstream>
#include <string>
#include <vector>
#include <vector>
#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>

// Enums for filtertypes
enum spatialFilterType { 
    LAPLACIAN, 
    GAUSSIAN
};

enum temporalFilterType { 
    IIR, 
    IDEAL 
};



class VideoManager {

public:
    explicit VideoManager();

    bool setInput(const std::string &fileName);

    // For saving the video to a special location
    bool setOutput(const std::string &filename, int codec = 0, double framerate = 0.0, bool isColor = true);
    void writeOutput();

    bool isOpened();
    bool isStopped();
    int getCodec(char codec[4]);
    cv::Size getFrameSize();
    double getFrameRate();
    bool getNextFrame(cv::Mat& frame);
    bool jumpTo(long index);
    double getCurrentFrame();
    double getNumberOfFrames();

    // Magnification functions
    void motionMagnification();
    void colorMagnification();
    void setSpatialFilter(spatialFilterType type);
    void setTemporalFilter(temporalFilterType type);
    void setLevels(int lvls);

    // Magnification setter: Color and Motion
    void setAlpha(float amplification);
    void setLowCutoff(float low);
    void setHighCutoff(float high);
    void setFrequencyCutoffs(float low, float high);
    
    // Magnification setter: motion
    void setMotionCutOffWavelength(float lambda);
    void setExaggerationFactor(float factor);
    void setChromAttenuation(float attenuation);

    void setMask(float x1, float y1, float x2, float y2, bool masked);
private:
    //std::vector<cv::Mat> dispFrames;
    //std::vector<cv::Mat> frames;

    //cv::VideoCapture capture;
    cv::VideoWriter writer;
    cv::VideoWriter tempWriter;
    
    double rate;
    long fnumber;       // number of processed frames
    long length;        // total number of frames
    long curPos;        // current playing position

    // Flags
    bool modify;        // indicates a modification of the current video
    bool stopped;       // true if playing video has been stopped

    // frame control
    
    
    
    void writeNextFrame(cv::Mat& frame);
    int curIndex;                           // current index for the output images

    // set the temp video file which will be modified (default: same parameters as input)
    bool createTemp(double framerate = 0.0, bool isColor = true);
    
    std::string tempFile;
    std::vector<std::string> tempFileList;  // list of all created temp-files
    std::string outputFile;
    std::string extension;  
    int digits;                             // number of digits in the output image filename

    // Pyramids and filtering
    bool buildGaussianPyramid(const cv::Mat &img, const int levels, std::vector<cv::Mat> &pyramid);
    bool buildLaplacianPyramid(const cv::Mat &img, const int levels, std::vector<cv::Mat> &pyramid);
    void reconImgFromLaplacianPyramid(const std::vector<cv::Mat> &pyramid, const int levels, cv::Mat &dst);
    void VideoManager::attenuate(cv::Mat &src, cv::Mat &dst);
    void upsamplingFromGaussianPyramid(const cv::Mat &src, const int levels, cv::Mat &dst);
    bool spatialFilter(const cv::Mat &src, std::vector<cv::Mat> &pyramid);
    void temporalFilter(const cv::Mat &src, cv::Mat &dst);
    int levels;     // numbers of image pyramid levels
    int curLevel;
    spatialFilterType spatialType;
    temporalFilterType temporalType;
    void temporalIIRFilter(const cv::Mat &src, cv::Mat &dst);
    void temporalIdealFilter(const cv::Mat &src, cv::Mat &dst);
    void createIdealBandpassFilter(cv::Mat &filter, double fl, double fh, double rate);
    // low pass filters for IIR
    std::vector<cv::Mat> lowpass1;
    std::vector<cv::Mat> lowpass2;
    float delta;
    void amplify(const cv::Mat &src, cv::Mat &dst);

    // Variables for color and motion magnification
    float fl;       // low cut-off
    float fh;       // high cut-off
    float lambda;                           // representative wavelength lambda
    float alpha;    // amplification factor

    // Variables for motion magnifications
    float lambda_c;                         // cut-off wavelength
    float exaggeration_factor;
    float chromAttenuation;

    void concat(const std::vector<cv::Mat> &frames, cv::Mat &dst);
    void deConcat(const cv::Mat &src, const cv::Size &frameSize, std::vector<cv::Mat> &frames);

    bool useMask;
    cv::Mat mask;
};

#endif