CameraParam.hh

/*
$Id: CameraParam.hh,v 2.20 2006/07/31 13:47:40 streckel Exp $
*/
/* 
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 __CameraParameter_inc__
#define __CameraParameter_inc__
#include <bias_config.h>
#include <Base/Common/BIASpragmaStart.hh>
#include <Geometry/ProjectionParametersIO.hh>

#include <vector>
#include <string>
#include <Base/Debug/Error.hh>
#ifdef BIAS_HAVE_XML2
#  include <Base/Common/XMLIO.hh>
#endif

#include <Base/Math/Vector2.hh>
#include <Base/Geometry/KMatrix.hh>

#define CAMERA_PARAMETER_CURRENT_XML_VERSION 2.0

namespace BIAS{


  class BIASImage_EXPORT CameraParam{

    //    static std::string CameraModelName[];
    // static std::string LensModelName[];

  public:
    CameraParam();
    CameraParam(const CameraParam &cp);
    /** @brief pass K and image dims to construct a simple parameter file */
    CameraParam(const KMatrix& K, const int w, const int h);
#ifdef BIAS_HAVE_XML2
    CameraParam(const std::string &filename);
    //    CameraParam(XMLIO &myXML, xmlNodePtr &cameraNode);
#endif //BIAS_HAVE_XML2

    ~CameraParam();

    // @brief default initialization, ends up with _INVALID_ object
    void Init();
    void Init(const CameraParam &cp);

    void InitPerspective(const std::string CamModel, const int CamID, 
                         const std::string LensModel,
                         const int imgWidth, const int imgHeight, 
                         const double principalX, const double principalY, 
                         const double focallength,
                         const double aspectratio,
                         const double k1, const double k2, 
                         const double k3, const double k4,
                         const std::vector<double> &IlluCorrX, 
                         const std::vector<double> &IlluCorrY);
    void InitSpherical(const std::string CamModel, const int CamID, 
                       const std::string LensModel,
                       const int imgWidth, const int imgHeight, 
                       const double principalX, const double principalY, 
                       const double radius,
                       const std::vector<double> &AngleCorrX,
                       const std::vector<double> &AngleCorrY,
                       const std::vector<double> &IlluCorrX, 
                       const std::vector<double> &IlluCorrY);

#ifdef BIAS_HAVE_XML2
    // @brief initialization with camera data file
    int Init(const std::string &filename);
    // @brief initialization with camera node from pre-parsed data file
    int Init(XMLIO &myXML, xmlNodePtr &cameraNode);
#endif //BIAS_HAVE_

     /** @brief Set to 'true', if camera has a zoom lens.
         @author streckel 06/2004*/
     void SetZoomCamera(const bool zoomCam);

     /** @brief True, if camera has a zoom lens.
         @author streckel 06/2004*/
     bool IsZoomCamera() const;

     /** @brief Set the current camera zoom, the focal length will be 
         calculated.
         @author buck */
     void SetZoom(const double abszoom);

     /** @brief Set the current camera focal length, the zoom will be 
         calculated.
         @author buck */
     void SetFocalLength(const double f);

     /** @brief Set the zoom and focal length of a zoom camera to the 
         default settings.
         @author streckel 06/2004*/
     void SetUnzoomed();

     /** @brief Set the current camera zoom, the focal length will be 
         calculated.
         @author buck */
     double GetZoom() const;

     /** @brief Get the current camera focal length.
         @author buck */
     double GetFocalLength() const;

    /** @brief Set CCD cell-size in meter. 
        AspectRatio is CS_Y/CS_X
        @author streckel */
    void SetCellSize(const double CellSizeX, const double AspectRatio);

    double GetCellSizeX() {return cd_.cellSizeX_;}
    double GetCellSizeY() {return cd_.cellSizeY_;}

    /** @brief Set principal point in pixels relative to top left corner
        @author streckel */
    void SetPrincipal(const double x, const double y);

    /** @brief Set downsampling factor  - 
        all get functions will return transformed values

        E.g. if your image size(width and height) is half the original
        and the field of view did stay the same, then set factor to 2. <br>
        CAUTION: The Set-functions still require the original values
        @author streckel */
    void SetDownsampling(const double factor);

        double GetDownsamplingFactor();

    /** @brief get camera image width.
        @author buck */
    unsigned int GetWidth() const; 
    /** @brief get camera image height.
        @author buck */
    unsigned int GetHeight() const;

    inline double GetAspectratio() const {
      return cd_.aspectratio_;
    }

    /** set size of image seperatly */
    void SetSize(unsigned int w,unsigned int h) {
      cd_.width_ =w; cd_.height_ = h; }

    /** @brief get principal point, x  in pixels relative to top left corner
        @author buck */
    double GetPrincipalX() const; 
    /** @brief get principal point, y  in pixels relative to top left corner
        @author buck */
    double GetPrincipalY() const; 

    /* @brief Get the Cameras KMatrix corresponding to the current 
       zoom setting
       @author streckel */
    BIAS::KMatrix GetKMatrix() const;

    inline int GetCamID() const {
      return cd_.CamID_;
    }

    inline double GetRadius() const{
      if (IsSpherical()) {
        return cd_. radius_/downsamplingFactor_+0.000000001;
      } else {
        return -1;
      }
    }

    inline double SetRadius(double r) {
      if (!IsSpherical()) {
        BIASERR("Can notset radius for perspective camera");
        return -1;
      }
      cd_.radius_ = r;
      // should reinit now
      return 0;
    }


    inline void GetDefaultUndistortion(double& f,
                                       double& kc1, double& kc2,
                                       double& kc3, double& kc4) const 
    {
      f   = cd_.focallengthDef_/downsamplingFactor_+0.000000001;
      kc1 = cd_.kc1Def_;
      kc2 = cd_.kc2Def_;
      kc3 = cd_.kc3Def_;
      kc4 = cd_.kc4Def_;
    }

    inline void GetZoomUndistortion(std::vector<CPDiscreteParam>& vp) const {
      std::vector<CPDiscreteParam>::const_iterator it;
      vp.clear();
      vp.reserve(cd_.knownparams_vect_.size());
      for (it=cd_.knownparams_vect_.begin();
           it!=cd_.knownparams_vect_.end();it++) {
        CPDiscreteParam cpp=*it;
        cpp.focallength = cpp.focallength/downsamplingFactor_+0.000000001;
        vp.push_back(cpp);
      }
    }

    inline double GetAspectRatio() const {
      return cd_.aspectratio_;
    }

    inline  bool IsSpherical() const { return cd_.LensIsSpherical_;}

    inline  bool IsPerspective() const {return !cd_.LensIsSpherical_;}  

    inline std::vector<double> GetAngleCorrX() const {
      return cd_.AngleCorrX_;
    }
    inline std::vector<double> GetAngleCorrY() const {
      return cd_.AngleCorrY_;
    }
    inline std::vector<double> GetIlluCorrX() const {
      return cd_.IlluCorrX_;
    }
    inline std::vector<double> GetIlluCorrY() const {
      return cd_.IlluCorrY_;
    }

#ifdef BIAS_HAVE_XML2
    /** @brief Write all data to a camera data parameter file )
        @param Filename Name of the XML-camera-data-file, 
        document tag will be to be "Camera"
        @author streckel 06/2004 */
    int WriteCameraData(const std::string& Filename) const;
    /** @brief Add a camera sub-tree-structure to an allready created 
        XML-tree and write the data from (*this) into the tree - 
        called from the rig parameter class.
        @param myXML points to the XML-Tree
        @param cameraDataNode points to a "CameraData"-node to append the 
        "Camera"-node
        @author streckel 06/2004 */
    //int AddCameraDataToRig(XMLIO &myXML, xmlNodePtr &cameraDataNode) const;

    /** @brief Read a camera data parameter file and store the data in (*this)
        @param Filename Name of the XML-camera-data-file, 
        document tag has to be "Camera"
        @author streckel 06/2004 */
    int ReadCameraData(const std::string& Filename);
    /** @brief Read a camera data form a precreated XML-tree and store 
        the data in (*this)  - called from the rig parameter class.
        @param myXML points to the XML-Tree
        @param rigNode points to a "Camera"-node to evaluate
        @author streckel 06/2004 */
    //int ReadCameraData(XMLIO &myXML, xmlNodePtr &cameraNode);
#endif //BIAS_HAVE_XML2

    // Settings for specific cameras
    void SetData_EVID31_147094();
    void SetData_OMNITECH_ORIFL_190_3(); 

    /** @brief read jpeg EXIF header and set camera parameter 
        @return 0 on success 
        @author koeser 07/2005 */
    int ReadFromEXIF(const std::string& filename);

    void DebugOut() const;   

    const CameraData GetCameraData() const {
      return cd_;
    }

    void SetCameraData(const CameraData &cd) {
      cd_ = cd;
    }

  protected:    
    CameraData cd_;

    //0.5 means upsample, 2 means half size, 4 one forth ....
    double downsamplingFactor_;
    
    // calibration settings for the current zoom setting of a zoom camera
    // zoom and focallengthZoom are dependend:
    // if zoom is set, focallengthZoom will be calculated and vice versa
    // focal length is stored in pixel
    double zoom_;
    double focallengthZoom_;
    
    double InterpolateFocalLength_(); // w/ given abszoom
    double InterpolateAbsZoom_(); // w/ given focal length

// #ifdef BIAS_HAVE_XML2
//     int ReadCameraDataV0_8(XMLIO &myXML, xmlNodePtr &cameraNode);
//     int ReadCameraDataV1_0(XMLIO &myXML, xmlNodePtr &cameraNode);
//     int AddCameraDataToXMLTree(XMLIO &myXML, xmlNodePtr &rootNode) const;
// #endif //BIAS_HAVE_XML2

  };

}

#include <Base/Common/BIASpragmaEnd.hh>
#endif