Camera.hh

/*
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 __BIASCAMERA_HH__
#define __BIASCAMERA_HH__
#include "bias_config.h"

#include <Base/Image/Image.hh>
#include <Geometry/PMatrix.hh>
#include <Geometry/Projection.hh>
#include <Base/Geometry/KMatrix.hh>
#include <Geometry/RMatrix.hh>
#include <Base/Math/Vector3.hh>
#include <Base/Image/MetaData.hh>

//#ifdef BIAS_DAIMLERCHRYSLER
#include "DCData.hh"
//#endif

#define D_CAM_DCPTU       0x0001
#define D_CAM_DCINERT     0x0002
#define D_CAMERA_METADATA 0x0004
#define D_CAM_IO          0x0008

namespace BIAS {
  /** @class Camera
      @ingroup g_image
      @brief extends the Image by MetaData support (e.g. PMatrix,
      sensor data, etc.)

      This class Camera extends Image with
      - accurate timestamps
      - P-matrix support
      - C, R, K matrix support (camera center, -rotation, -calibration)
      - anything usefull representing a camera

      After reading a file with such meta data (call it MYDATA) you can call
      Camera::IsMYDATAValid() to find out if there is MYDATA in your camera
      object. If so, call Camera::GetMYDATA().
      Remark: In old image files written by BIAS, invalid meta data has been
      attached as zero entries, e.g. PMatrix=0,0,0,0,0,0,0,0,0,0,0,0 means
      that there was no PMatrix available.

      To add/update meta information data to your camera, call
      Camera::AddMYDATA(mydataobject) to attach it to the camera object.
      Before writing the camera, you must call
      Camera::UpdateMetaData() to tell the Camera to convert the current
      data into the BIAS::MetaData format, which is then written.

      See ImageIO for the file types where such meta data information can be
      stored and read, maybe mip or pgm/ppm.
  */
  template <class StorageType>
  class BIASImage_EXPORT Camera : public Image<StorageType>
  {
  public:
    Camera();
    explicit Camera(const ImageBase& img);
    Camera(const Camera<StorageType> &src);
    virtual ~Camera();

    /** virtual covariant copy constructor which produces the same type of
        object as the template object (Image, Camera, ...).
        Must be implemented in all derived classes and since some people do
        work with ImageBase objects, it is also implemented there.
        The caller is responsible to delete the clone.
        @author koeser 06/2006 */
    virtual Camera<StorageType>* Clone() const
    { return new Camera<StorageType>(*this); }

    /** @brief After ImageIO::Load() operated on AppData_, this method fills
        P_, Timestamp, DC_*, ...
        @param bUse2x64bitTS: use 2x(long long uint) timestamps (else 2xint)
    */
    int ParseMetaData(bool bUse2x64bitTS=true);

    /** @brief copy P_ and co. back to MetaData before
        useful before ImageIO::Write() or ImageIO::ExportImage
    */
    int UpdateMetaData();

    inline int SetP(const PMatrix& matP) { PValid_=true; P_=matP; return 0;};

    inline const BIAS::PMatrix& GetP() const { return P_; } ;

   inline int SetProj(const Projection& Proj) { ProjValid_=true;
    Proj_=Proj; return 0;};

    inline const BIAS::Projection& GetProj() const { return Proj_; } ;


    inline void SetASCIIString(const std::string& ASCIIString)
    {
      ASCIIString_=ASCIIString; ASCIIValid_=true;
    }

    inline std::string GetASCIIString()
    {
      return ASCIIString_;
    }


     /// @brief Set time and ensure correct format (seconds and useconds after 'sec')
    inline void SetTime(unsigned long long int sec, unsigned long long int usec)
    {
      TimeSec_   = sec + usec/1000000;
      TimeUSec_  = usec%TimeSec_;
      TimeValid_ = true;
    }

    /// @brief set time from double (in seconds and useconds after full seconds)
    inline void SetTime(double sec)
    {
        TimeValid_ = true;
        TimeSec_     = static_cast<int> (sec);
        TimeUSec_  = static_cast<int> (rint((sec-(double)TimeSec_)*1000000.0));
    }

    inline void GetTime(unsigned long long int &sec, unsigned long long int &usec)
    {
        sec  = TimeSec_;
        usec = TimeUSec_;
    }

    inline double GetTime() const
    {
      return double(TimeSec_) + double(TimeUSec_)/1000000.0;
    }


    inline void SetOrientation(const float ori[3])
    { Orientation_[0] = ori[0]; Orientation_[1] = ori[1];
    Orientation_[2] = ori[2]; OrientationValid_=true;};

    inline void SetOrientation(const BIAS::Vector3<double> &ori) {
      Orientation_[0] = float(ori[0]); Orientation_[1] = float(ori[1]);
      Orientation_[2] = float(ori[2]); OrientationValid_=true;
    }

    inline void GetOrientation(float &o0,float &o1,float &o2) const {
      o0 = Orientation_[0]; o1 = Orientation_[1]; o2 = Orientation_[2];}

    inline void GetOrientation(BIAS::Vector3<double> &ori) const {
      ori[0] = Orientation_[0]; ori[1] = Orientation_[1];
      ori[2] = Orientation_[2];}

    inline void SetC(const Vector3<double>& C) { _C = C; CValid_ = true;};
    inline const Vector3<double>& GetC() const { return _C; };

    inline void SetR(const RMatrix& R) { _R = R; RValid_ =true; };
    inline const RMatrix& GetR() const { return _R; };

    inline void SetK(const KMatrix& K) { _K = K; KValid_=true;};
    inline const KMatrix& GetK() const { return _K; };

    inline void Setf(const double& focal) {_f = focal; fValid_=true;};
    inline const double Getf() const { return _f; };

//#ifdef BIAS_DAIMLERCHRYSLER
    inline void SetPTU(DC_ptu& p) { ptu = p; ptuValid_ = true;};
    inline const DC_ptu& GetPTU() const { return ptu; };

    inline void SetInertial(DC_inertial& i) {
      inertial = i; inertialValid_=true; };
    inline const DC_inertial& GetInertial() const { return inertial; };

    inline void SetGPS(DC_GPS& g) {gps = g; gpsValid_=true;};
    inline const DC_GPS& GetGPS() const { return gps; };
//#endif

    Camera<StorageType>& operator=(const Camera<StorageType> &src);

    /// @brief see whats in the camera, for debug
    void PrintAppData(std::ostream &os) ;

    /** @brief Is field of data valid or unknown ? if false,
        the return value of the Get...()-function is undefined */
    inline bool IsTimeValid() const { return TimeValid_;}
    /** @brief Is field of data valid or unknown ? if false,
        the return value of the Get...()-function is undefined */
    inline bool IsOrientationValid() const { return OrientationValid_;}
    /** @brief Is field of data valid or unknown ? if false,
        the return value of the Get...()-function is undefined */
    inline bool IsPValid() const { return PValid_;}
    /** @brief Is field of data valid or unknown ? if false,
        the return value of the Get...()-function is undefined */
    inline bool IsKValid() const { return KValid_;}
    /** @brief Is field of data valid or unknown ? if false,
        the return value of the Get...()-function is undefined */
    inline bool IsRValid() const { return RValid_;}
    /** @brief Is field of data valid or unknown ? if false,
        the return value of the Get...()-function is undefined */
    inline bool IsCValid() const { return CValid_;}
    /** @brief Is field of data valid or unknown ? if false,
        the return value of the Get...()-function is undefined */
    inline bool IsPointValid() const { return PointValid_;}
    /** @brief Is field of data valid or unknown ? if false,
        the return value of the Get...()-function is undefined */
    inline bool IsfValid() const { return fValid_;}

    inline bool IsProjValid() const { return ProjValid_;}

    BIAS::UUID const GetReferenceUUID() const {return RefUUID_;};
    void SetReferenceUUID(const BIAS::UUID &uid) {RefUUID_ = uid;};

//#ifdef BIAS_DAIMLERCHRYSLER
    inline bool IsptuValid() { return ptuValid_;}
    inline bool IsinertialValid() { return inertialValid_;}
    inline bool IsgpsValid() { return gpsValid_;}
//#endif

  protected:
    /// @brief called by constructors to init all fields
    void Init_();

    /// ASCII multifunctional string
    std::string ASCIIString_;
    /// is correspondig field of data valid or unknown ?
    bool ASCIIValid_;

    /// time stamp in seconds
    //long int TimeSec_;
    unsigned long long int TimeSec_;
    /// time stamp in microseconds
    // long int TimeUSec_;
    unsigned long long int TimeUSec_;
    /// is correspondig field of data valid or unknown ?
    bool TimeValid_;

    /// orientation data from sensor ?
    float Orientation_[3];
    /// is correspondig field of data valid or unknown ?
    bool OrientationValid_;

    /// pmatrix, maybe non-metric
    PMatrix P_;
    /// is correspondig field of data valid or unknown ?
    bool PValid_;

    // new projection, will replace P_ soon
    Projection Proj_;
    bool ProjValid_;

    /// camera calibration with internals
    KMatrix _K;
    /// is correspondig field of data valid or unknown ?
    bool KValid_;

    /// camera orientation
    RMatrix _R;
    /// is correspondig field of data valid or unknown ?
    bool RValid_;

    /// camera center in wcs
    Vector3<double> _C;
    /// is correspondig field of data valid or unknown ?
    bool CValid_;

    /// a point, it is up to you what you put in
    HomgPoint2D _Point;
    /// is correspondig field of data valid or unknown ?
    bool PointValid_;

    /// focal length in m
    double _f;
    /// is correspondig field of data valid or unknown ?
    bool fValid_;

    // the uuid of a related image. E.g.:if this is a depth map, this
    // can reference the corresponding image.
    BIAS::UUID RefUUID_;

//#ifdef BIAS_DAIMLERCHRYSLER
    // car sensor data from DC
    DC_ptu ptu;
    /// is correspondig field of data valid or unknown ?
    bool ptuValid_;

    DC_inertial inertial;
    /// is correspondig field of data valid or unknown ?
    bool inertialValid_;

    DC_GPS gps;
    /// is correspondig field of data valid or unknown ?
    bool gpsValid_;
//#endif

  };
}
#endif