/**
 * CvBase implementation.
 *
 * See cvbase.hpp for details.
 *
 * @author vona
 **/

#include "cvbase.hpp"

#include <iomanip>

using namespace std;

/**
 * Format ITEMS as a string.
 *
 * ITEMS is a standard cout-style << sequence, e.g.
 *
 * std::string s = FMT(19<<std::hex<<" 0x"<<19<<" float "<<19.2);
 **/
#define FMT(ITEMS) \
  ((dynamic_cast<ostringstream &> (ostringstream()<<flush<<ITEMS)).str())

const char *CvBase::DEF_INPUT = "-1";
const int CvBase::DEF_CAM_W = 640, CvBase::DEF_CAM_H = 480;
const float CvBase::DEF_MAX_FPS = 10.0f;
const int CvBase::DEF_MIN_DELAY_MS = 5;
const char *CvBase::DEF_APPNAME = "cvbase";

CvBase::CvBase(const char *appname_) {

  cap = 0;
  saveImage = capImage = procImage = 0;
  maxFPS = DEF_MAX_FPS; minDelayMS = DEF_MIN_DELAY_MS;
  appname = appname_;

  frameN = -1;

  //cvGetTickFrequency() returns ticks per microsecond
  msPerTick = (1.0/1000.0)*(1.0/cvGetTickFrequency());

  paused = dbg = false;
}

CvBase::~CvBase() {
  cvDestroyAllWindows();
  if (saveImage != 0) cvReleaseImage(&saveImage);
  if (cap != 0) cvReleaseCapture(&cap);
}

int CvBase::init(int argc, char *argv[]) {

  cout<<"OpenCV "<<CV_VERSION
      <<" ("<<CV_MAJOR_VERSION<<"."
      <<CV_MINOR_VERSION<<"."
      <<CV_SUBMINOR_VERSION<<")"<<endl;

  int ate = 0;

  for (int i = 1; i < argc; i++)
    if ((string("-h") == argv[i]) || (string("-?") == argv[i]))
      { cmdHelp(); exit(0); }

  const char *input = (argc >= 2) ? argv[1] : DEF_INPUT; if (argc >= 2) ate++;
  int index = -2;
  if (!((istringstream(input)>>index).fail())) {

    //either no args or first arg parsed as an int; open a camera

    int w = DEF_CAM_W, h = DEF_CAM_H;
    if (argc >= 4) {
      if (!(istringstream(argv[2])>>w).fail()) {
        ate++;
        if (!(istringstream(argv[3])>>h).fail()) ate++;
      }
    }

    cap = cvCaptureFromCAM(index);
    if (!cap) { cerr<<"error opening camera "<<index<<endl; exit(-1); }

    int rw = cvSetCaptureProperty(cap, CV_CAP_PROP_FRAME_WIDTH, w);
    int rh = cvSetCaptureProperty(cap, CV_CAP_PROP_FRAME_HEIGHT, h);
    if (!rw || !rh) { cerr<<"W: error setting camera to "<<w<<"x"<<h<<endl; }

    cout<<"reading frames from "
        <<((index >= 0) ? FMT("camera "<<index) : "first available camera")
        <<endl;

  } else {

    //input specifier did not parse as an int, try to open it as a video file
    cap = cvCaptureFromFile(input);
    if (!cap) { cerr<<"error opening file \""<<input<<"\""<<endl; exit(-1); }

    cout<<"reading frames from file \""<<input<<"\""<<endl;
  }

  if (!cvNamedWindow(appname, CV_WINDOW_AUTOSIZE))
    { cerr<<"W: error opening window"<<endl; }

  cvMoveWindow(appname, 0, 0);

  return initExt(argc, argv, ate);
}

void CvBase::mainLoop() {

  double frameStartMS, startMS;
  int minFrameMS = 1000.0/maxFPS;

  cout<<setprecision(3);

  frameN = -1;
  for (;;) {
    
    frameStartMS = nowMS();

    if (!paused) {
      
      if (dbg) cout<<"-- capturing frame "<<frameN<<endl;
      startMS = nowMS();
      capImage = cvQueryFrame(cap);

      if (capImage != 0) {
        if (dbg) cout<<"captured "<<capImage->width<<"x"<<capImage->height<<
                   " frame ("<<(nowMS()-startMS)<<"ms)"<<endl;
        
        if (frameN == 0)
          cout<<"capture size "<<capImage->width<<"x"<<capImage->height
              <<", "<<capImage->nChannels<<" channels"
              <<", "<<((capImage->depth)&(~IPL_DEPTH_SIGN))<<" bits"
              <<", "<<(((capImage->depth)&IPL_DEPTH_SIGN)?"signed":"unsigned")
              <<endl;
        
        frameN++;
      } else { cerr<<"W: error capturing frame"<<endl; }

    } else if (dbg) cout<<"-- paused on frame "<<frameN<<endl;

    if (dbg) cout<<"processing..."<<endl;
    startMS = nowMS();
    procImage = process(capImage);
    if (dbg) cout<<"processed into "<<procImage->width<<"x"<<procImage->height
                 <<" image ("<<(nowMS()-startMS)<<"ms)"<<endl;
    
    if (cvGetWindowHandle(appname) == 0)
      { cout<<"main window closed, exiting"<<endl; break; }
    
    if (procImage != 0) { 
      
      //note: small race condition here; if user closes window now, it will be
      //reopened when we call cvShowImage()
      
      if (dbg) cout<<"displaying processed image"<<endl;
      startMS = nowMS();
      
      //note: if necessary, this call will deal with whatever bit depth or
      //number of channels the image may have (it will assume BGR order for 3
      //channel images)
      cvShowImage(appname, procImage);
      
      if (dbg) cout<<"displayed "<<procImage->width<<"x"<<procImage->height
                   <<" image ("<<(nowMS()-startMS)<<"ms)"<<endl;
    }
    
    if (dbg) cout<<"frame time "<<(nowMS() - frameStartMS)<<"ms"<<endl;
    
    int waitUntilMS = frameStartMS + minFrameMS;
    if (waitUntilMS < nowMS()) waitUntilMS = nowMS()+minDelayMS;

    if (dbg) cout<<"-- finished frame "<<(paused ? frameN : (frameN-1))
                 <<" ("<<(1000.0/(waitUntilMS-frameStartMS))<<" FPS)"<<endl;
   
    bool wasDbg = dbg;

    for (int w = waitUntilMS-nowMS(); w > 0; w = waitUntilMS-nowMS()) {

      if (dbg) cout<<"waiting "<<w<<"ms (or until keypress)"<<endl;

      int c = cvWaitKey(w);
      if (c < 0) break; //cvWaitKey timed out

      if (!handleKey(c)) { cout<<flush; return; }
    }

    cout<<flush;

    if (wasDbg) dbg = false;
  }
}

void CvBase::cmdHelp() {
  bool cio = camIndexOptional();
  cout<<appname<<" -?|-h -- display this help"<<endl;
  cout<<appname
      <<" "<<(cio?"[":"")<<"I [W H]"<<(cio?"]":"")<<" "<<cmdHelpExtParams()
      <<"-- use cv cam index I (def -1) [at WxH, def "
      <<DEF_CAM_W<<"x"<<DEF_CAM_H<<"]"<<endl;
  cout<<appname<<" path "<<cmdHelpExtParams()
      <<"-- read frames from video file at path"<<endl;
  cmdHelpExt();
}

void CvBase::guiHelp() {
  cout<<"h -- display this help"<<endl;
  cout<<"q,ESC -- quit"<<endl;
  cout<<"SPACE -- toggle run/pause"<<endl;
  cout<<"g -- debug next frame"<<endl;
  cout<<"c -- save last captured image"<<endl;
  cout<<"p -- save last processed image"<<endl;
  guiHelpExt();
}

bool CvBase::handleKey(int code) {

  switch (code) {
  case 'h': { guiHelp(); break; }
  case 27: case 'q': return false;
  case ' ': { paused = !paused; break; }
  case 'g': { dbg = true; break; }
  case 'c': {
    if (capImage == 0) { cerr<<"no capture image"<<endl; break; }
    string fn = FMT(appname<<"-c"<<frameN<<".png");
    cout<<"saving capture image to "<<fn<<endl;
    if (!save(fn.c_str(), capImage)) cerr<<"error saving image"<<endl;
    break;
  }
  case 'p': {
    if (procImage == 0) { cerr<<"no processed image"<<endl; break; }
    string fn = FMT(appname<<"-p"<<frameN<<".png");
    cout<<"saving processed image to "<<fn<<endl;
    if (!save(fn.c_str(), procImage)) cerr<<"error saving image"<<endl;
    break;
  }
  default: return handleKeyExt(code);
  }

  return true;
}

bool CvBase::save(const char *filename, IplImage *image) {

  //(re-)allocate saveImage if necessary, since cvSaveImage can handle only
  //8-bit 1 or 3 channel images (it also assumes BGR order in the latter case)
  if ((image->depth != IPL_DEPTH_8U) ||
      ((image->nChannels != 1) && (image->nChannels != 3))) {
    int w = image->width, h = image->height;
    int nc = (image->nChannels > 1) ? 3 : 1;
    if ((saveImage == 0) ||
        (saveImage->width != w) || (saveImage->height != h) ||
        (saveImage->nChannels != nc)) {
      if (saveImage != 0) cvReleaseImage(&saveImage);
      saveImage = cvCreateImage(cvSize(w, h), IPL_DEPTH_8U, nc);
    }
  }
  
  if (saveImage != 0) { cvConvertImage(image, saveImage); image = saveImage; }

  return cvSaveImage(filename, image);
}