Camera.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// $Id$
//
// Copyright 2008, 2009, 2010, 2011, 2012  Antonio Franchi and Paolo Stegagno
//
// This file is part of MIP.
//
// MIP is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// MIP 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with MIP. If not, see <http://www.gnu.org/licenses/>.
//
// Contact info: antonio.franchi@tuebingen.mpg.de stegagno@diag.uniroma1.it
//
// ----------------------------------------------------------------------------




/* TODO:
 Camera par must maintain (loading form a configuration file):
  - a Pose for the mounting parameters
  - size of frame
  - fps
  
  - a matrix for the intrinsic parameters or the following parameters:
   - focal length
   - field of view
   - skew
   - principal point coordinates
   - pixel ratio
  
  - color-space
  
 Camera class must provide (also using CameraVar class):
  - access to image
  - retrieving of new frame
  - recording of video stream
  - access to image as IplImage (backward compatibility - to be removed asap)
  - access to cv::Mat used to store the image
  - a Pose for the current pose of the camera (if estimated)
  
 TODO: check if we need CVD camera
*/
#ifndef __CAMERA_H_
#define __CAMERA_H_

#ifdef MIP_HOST_APPLE
#include <applePatch.h>
#endif


#include <assert.h>

#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/highgui/highgui.hpp"

#include <baselib.h>
#include <Resource.h>
#include <stdlib.h>

using namespace std;

namespace MipResources{
 
 
 /* @{ */
 
 

 class CameraOptions : public Options {
  public:
   DecimalOption  *fLength;  
   IntOption    *device;  
   IntOption    *frameH;  
   IntOption    *frameW;  
   BoolOption   *videoLoop; 
      StringOption  *codec;     

   CameraOptions();

   string getObjectName() const {
    return "CameraOptions";
   }
 };

 class CameraPar{
  //  Camera par must maintain (loading form a configuration file):
  //   - a Pose for the mounting parameters
  //   - size of frame
  //   - fps
  //   
  //   - a matrix for the intrinsic parameters or the following parameters:
  //    - focal length
  //    - field of view
  //    - skew
  //    - principal point coordinates
  //    - pixel ratio
  //   
  //   - color-space
  private:
   // Parameters for image
   Decimal width;     
   Decimal height;     
   Decimal fps;      
   
   // Intrinsic parameters, those should be collected in a matrix
   Pose3D  mountingPose;   
   Decimal focalLength;   
   Decimal skew;       
   Decimal fieldOfView;   
   Decimal principalPointX; 
   Decimal principalPointY; 
   Decimal pixelRatio;    
  public:
   CameraPar(Decimal f = 0, Decimal w = 0, Decimal h = 0,
        Decimal rate = 0, Pose3D mPose = Pose3D(), Decimal skew = 0,
        Decimal fov  = 0, Decimal pPX = 0, Decimal pPY = 0,
        Decimal pR = 0);
   
   void setFocLength(Decimal newF);

   void setFrameSize(Decimal W, Decimal H);

   Decimal focLength() const;
 };


 class CameraVar{
  //    Camera class must provide (also using CameraVar class):
  //   - access to image
  //   - retrieving of new frame
  //   - recording of video stream
  //   - access to image as IplImage (backward compatibility - to be removed asap)
  //   - access to cv::Mat used to store the image
  //   - a Pose for the current pose of the camera (if estimated)
  protected:
   MipBaselib::Time   *lastTime;   
   MipBaselib::Time   *initTime;   
   IplImage *_img;          
   Position3D  *_position;
   Orientation3D *_orientation;
  public:
   CameraVar();

   CameraVar(IplImage* i, Position3D initPos, Orientation3D initOri);

   IplImage* getImage();
   
   void setImage(IplImage* i);

   void setInitTime(MipBaselib::Time t);

   void setLastTime(MipBaselib::Time t);

   MipBaselib::Time getLastTime();

   MipBaselib::Time getInitTime();
   
   Position3D* position() {
    return _position;
   }
   
   Orientation3D* orientation() {
    return _orientation;
   }
   
   void setPosition(Position3D newPos) {
    _position = new Position3D(newPos);
   }
   
   void setOrientation(Orientation3D newOri) {
    _orientation = new Orientation3D(newOri);
   }

 };


 class Camera : public Resource{
  protected:
   CameraOptions _options;  
   CameraPar* _par;  
   CameraVar* _var;  
   CvCapture* _cap;  
   cv::VideoCapture _device; 
   cv::Mat _image;      
  public:
   Camera(){  cout << "Camera constructor." << endl;};
   
   ~Camera();

   Camera(int argc, const char* argv[]);

//   Camera(int device, Decimal fLength);

   virtual CameraVar* getVar(void){
    return _var;
   }

   virtual CameraPar* getPar(void){
    return _par;
   }

   virtual ResourcePlate getPlate() const;

   virtual bool getFrame(IplImage*& s, MipBaselib::Time& t);

   virtual bool getFrame(cv::Mat& s, Time& t);
   
   virtual bool recordLastFrame();

   virtual bool setResolution(double w, double h);

      virtual bool setCodec(char *c);

   virtual bool setFrameRate(double fr){}

   virtual bool setBrightness(double b){}

   virtual bool setContrast(double c){}

   virtual bool setSaturation(double s){}

   virtual bool setHue(double h){}

   virtual void videoLoop(){}

                        // Luca Ricci mod. //
                        virtual timeval getTimeStamp(){};
                        // *************** //
 };
}; // end of namespace


#endif

/* @} */