VideoManager.h

#pragma once

#include <iostream>
#include <iomanip>
#include <sstream>
#include <string>
#include <vector>
#include <opencv\cv.h>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/video/video.hpp>
#include <opencv2/video/background_segm.hpp>
#include "VolumeData.h"
#include "saliency.h"

using namespace cv;


/*------------------------------------------------------------------------------------------*\
   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
\*------------------------------------------------------------------------------------------*/

class FrameProcessor {

  public:
    // processing method
    virtual void process(cv:: Mat &input, cv:: Mat &output)= 0;
};


class VideoManager
{
private:

      // the OpenCV video capture object
      cv::VideoCapture capture;
      bool toggleSaliencyDetect;
      // 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 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;

      bool readNextFrame(cv::Mat& frame);
      void writeNextFrame(cv::Mat& frame);

      VolumeData volume;

      //static const int MAX_FRAMES = 100;
      int maxFrames;
      int startFrame;
      int fps;

public:
    
    VideoManager() : callIt(false), delay(-1), 
    fnumber(0), stop(false), digits(0), frameToStop(-1), 
    process(0), frameProcessor(0) {}
    ~VideoManager(void);


    bool setInput(std::string filename, bool performSaliencyDetect, int skippedFrames, int startFr, int maxFr);
    

    bool setInput(int id, bool performSaliencyDetect, int skippedFrames, int startFr, int maxFr);

    bool setInput(const std::vector<std::string>& imgs, bool performSaliencyDetect, int skippedFrames, int startFr, int maxFr);
    bool setOutput(const std::string &filename, int codec=0, double framerate=0.0, bool isColor=true);
    bool setOutput(const std::string &filename, const std::string &ext, int numberOfDigits=3, int startIndex=0);
    void setFrameProcessor(void (*frameProcessingCallback)(cv::Mat&, cv::Mat&));
    void setFrameProcessor(FrameProcessor* frameProcessorPtr);
    void stopAtFrameNo(long frame);
    void callProcess();
    void dontCallProcess();
    void displayInput(std::string wn);
    void displayOutput(std::string wn);
    void dontDisplay();
    void setDelay(int d);
    long getNumberOfProcessedFrames();
    cv::Size getFrameSize();
    long getFrameNumber();
    double getPositionMS();
    double getFrameRate();
    long getTotalFrameCount();
    int getCodec(char codec[4]);
    bool setFrameNumber(long pos);
    bool setPositionMS(double pos);
    bool setRelativePosition(double pos);
    void stopIt();
    bool isStopped();
    bool isOpened();
    void run(VolumeData& vol);
};