VideoSource_DiskZessPMD.cpp

/* 
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003-2009    (see file CONTACT for details)
  Multimediale Systeme der Informationsverarbeitung
  Institut fuer Informatik
  Christian-Albrechts-Universitaet Kiel


BIAS 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.

BIAS 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 BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
#ifndef  WIN32
#include <unistd.h>
#else
#include <Base/Common/W32Compat.hh>
#endif //WIN32

#include <string>
#include <sstream>
#include <iostream>

#include "VideoSource_DiskZessPMD.hh"
#include <Base/Image/ImageIO.hh>
#include <Image/Camera.hh>

#include <Base/Common/BIASpragma.hh>
#include <Base/Common/FileHandling.hh>

using namespace BIAS;
using namespace std;


BIAS::VideoSource_DiskZessPMD::VideoSource_DiskZessPMD() : VideoSource_Disk()
{
  GenerateNewUIDs_=true;
}

BIAS::VideoSource_DiskZessPMD::~VideoSource_DiskZessPMD()
{
}

int BIAS::VideoSource_DiskZessPMD::OpenDevice()
{
  BIASERR("use OpenDevice(const vector<string> &FileNames)");
  BIASABORT;
  return -1;
}

int BIAS::VideoSource_DiskZessPMD::OpenDevice(const vector<string> &FileNames)
{  
  Camera<unsigned char> img;
  BIASDOUT(D_VSO_DISK,"FileNames[0] : "<<FileNames[0]);
  if (ImageIO::Load(FileNames[0], img)!=0) {
    BIASERR("unable to read "<<FileNames[0]);
    return -1;
  }
  Width_ = img.GetWidth();
  Height_ = img.GetHeight();
  ColorChannels_ = img.GetChannelCount();
  ColorMode_ = img.GetColorModel();
  BytesPerPixel_ = img.GetDepth();

  FileNames_.clear();
  for (vector<string>::const_iterator i = FileNames.begin(); 
       i != FileNames.end();i++){
    FileNames_.push_back(*i);
  }

  CompleteInitialized_ = true;
  ActiveFrame_ = 0;

  return 0;
}


int BIAS::VideoSource_DiskZessPMD::GrabSingle(Camera<unsigned char> &image)
{
  BIASDOUT(D_VSO_DISK,"VideoSource_DiskPMD::GrabSingle()");

  if (!Active_) {
    BIASERR("VideoSource_Disk::GrabSingle(): VideoSource Object not active, use PreGrab()");
    return -1;
  }
  
  if (Grabbing_) {
    BIASERR("VideoSource_Disk::GrabSingle(): VideoSource Object is already grabbing()");
    return -1;
  }
  
  // Add Metadata to the Camera via Projection Object
  if (FileNames_.size() == 0) {
    if (ActiveFrame_ == FileNames_.size()){
      BIASERR("VideoSource_DISK: End of input. SetLoop(true) or Rewind()");
      return -1;
    }
  } else {
    if (ActiveFrame_ == FileNames_.size()) {
      BIASERR("VideoSource_DISK: End of input. SetLoop(true) or Rewind()");
      return -1;
    }

    ImageIO::Load(FileNames_[ActiveFrame_],image);
    ImageIO::Load(FileNames_[ActiveFrame_+1],DepthImg_);
    ImageIO::Load(FileNames_[ActiveFrame_+2],ModCoeffImg_);
  }
  Grabbing_ = true;
 
  image.SetUID(BIAS::UUID::GenerateUUID());
  DepthImg_.SetUID(image.GetUID());
  ModCoeffImg_.SetUID(image.GetUID());
  
  // set time to _now_
  if (FrameCounterAsTimeStamp_) image.SetTime(ActiveFrame_,0);
  else {
    timeval tv;
    gettimeofday(&tv, NULL);
    image.SetTime(tv.tv_sec,tv.tv_usec);
  }
  if(ActiveFrame_<FileNames_.size()-1){
    BIASDOUT(D_VSO_DISK,"GrabSingle() "<<ActiveFrame_<<"  "<<
             FileNames_[ActiveFrame_]);
    ActiveFrame_+=3;
  }
  else if (Loop_) {
    ActiveFrame_=0;
    BIASDOUT(D_VSO_DISK,"GrabSingle() restarting with first file");
  } 
  else ActiveFrame_+=3;

  Grabbing_ = false;
  BIASDOUT(D_VSO_DISK,"leaving GrabSingle()");
  // check time and sleep while enough time elapsed
  double secPerFrame=1.0/FramesPerSecond_;
  
  //struct timeval now;         -- displaced by TimeMeasure
  //double secs=0.0;            --         -"-
  //while (secs<=secPerFrame) { --         -"-
  if(KeepFPS_) {
    timer_.Stop();
    while (timer_.GetRealTime()<=(1E06*secPerFrame)) {
      timer_.Start();
#ifdef   WIN32
      Sleep(1);        //go sleeping for 1 msec
#else  //not WIN32
      usleep(1000);     //go sleeping for 1 msec
#endif //WIN32
      timer_.Stop();
      
    }
    timer_.Reset();
    timer_.Start();
  }
  //lastTime_=now;   -- displaced by TimeMeasure

  return 0;
}