vpCameraParameters.h

/****************************************************************************
 *
 * ViSP, open source Visual Servoing Platform software.
 * Copyright (C) 2005 - 2019 by Inria. All rights reserved.
 *
 * This software 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 2 of the License, or
 * (at your option) any later version.
 * See the file LICENSE.txt at the root directory of this source
 * distribution for additional information about the GNU GPL.
 *
 * For using ViSP with software that can not be combined with the GNU
 * GPL, please contact Inria about acquiring a ViSP Professional
 * Edition License.
 *
 * See http://visp.inria.fr for more information.
 *
 * This software was developed at:
 * Inria Rennes - Bretagne Atlantique
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * France
 *
 * If you have questions regarding the use of this file, please contact
 * Inria at visp@inria.fr
 *
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 * Description:
 * Camera intrinsic parameters.
 *
 * Authors:
 * Eric Marchand
 * Anthony Saunier
 *
 *****************************************************************************/
 
#ifndef vpCameraParameters_H
#define vpCameraParameters_H
 
#include <vector>
 
#include <visp3/core/vpColVector.h>
#include <visp3/core/vpConfig.h>
#include <visp3/core/vpDebug.h>
#include <visp3/core/vpMatrix.h>
 
class VISP_EXPORT vpCameraParameters
{
  friend class vpMeterPixelConversion;
  friend class vpPixelMeterConversion;
 
public:
  typedef enum {
    perspectiveProjWithoutDistortion, 
    perspectiveProjWithDistortion,    
    ProjWithKannalaBrandtDistortion   
  } vpCameraParametersProjType;
 
  // generic functions
  vpCameraParameters();
  vpCameraParameters(const vpCameraParameters &c);
  vpCameraParameters(double px, double py, double u0, double v0);
  vpCameraParameters(double px, double py, double u0, double v0, double kud, double kdu);
  vpCameraParameters(double px, double py, double u0, double v0, const std::vector<double> &distortion_coefficients);
 
  vpCameraParameters &operator=(const vpCameraParameters &c);
  bool operator==(const vpCameraParameters &c) const;
  bool operator!=(const vpCameraParameters &c) const;
  virtual ~vpCameraParameters();
 
  void init();
  void init(const vpCameraParameters &c);
  void initFromCalibrationMatrix(const vpMatrix &_K);
  void initFromFov(const unsigned int &w, const unsigned int &h, const double &hfov, const double &vfov);
  void initPersProjWithoutDistortion(double px, double py, double u0, double v0);
  void initPersProjWithDistortion(double px, double py, double u0, double v0, double kud, double kdu);
  void initProjWithKannalaBrandtDistortion(double px, double py, double u0, double v0,
                                           const std::vector<double> &distortion_coefficients);
 
  inline bool isFovComputed() const { return isFov; }
 
  void computeFov(const unsigned int &w, const unsigned int &h);
 
  inline double getHorizontalFovAngle() const
  {
    if (!isFov) {
      vpTRACE("Warning: The FOV is not computed, getHorizontalFovAngle() "
              "won't be significant.");
    }
    return m_hFovAngle;
  }
 
  inline double getVerticalFovAngle() const
  {
    if (!isFov) {
      vpTRACE("Warning: The FOV is not computed, getVerticalFovAngle() won't "
              "be significant.");
    }
    return m_vFovAngle;
  }
 
  inline std::vector<vpColVector> getFovNormals() const
  {
    if (!isFov) {
      vpTRACE("Warning: The FOV is not computed, getFovNormals() won't be "
              "significant.");
    }
    return fovNormals;
  }
 
  inline double get_px() const { return px; }
  inline double get_px_inverse() const { return inv_px; }
  inline double get_py_inverse() const { return inv_py; }
  inline double get_py() const { return py; }
  inline double get_u0() const { return u0; }
  inline double get_v0() const { return v0; }
  inline double get_kud() const { return kud; }
  inline double get_kdu() const { return kdu; }
  inline std::vector<double> getKannalaBrandtDistortionCoefficients() const { return m_dist_coefs; }
 
  inline vpCameraParametersProjType get_projModel() const { return projModel; }
 
  vpMatrix get_K() const;
  vpMatrix get_K_inverse() const;
 
  void printParameters();
  friend VISP_EXPORT std::ostream &operator<<(std::ostream &os, const vpCameraParameters &cam);
 
private:
  static const double DEFAULT_U0_PARAMETER;
  static const double DEFAULT_V0_PARAMETER;
  static const double DEFAULT_PX_PARAMETER;
  static const double DEFAULT_PY_PARAMETER;
  static const double DEFAULT_KUD_PARAMETER;
  static const double DEFAULT_KDU_PARAMETER;
  static const vpCameraParametersProjType DEFAULT_PROJ_TYPE;
 
  double px, py;                    
  double u0, v0;                    
  double kud;                       
  double kdu;                       
  std::vector<double> m_dist_coefs; 
 
  unsigned int width;                  
  unsigned int height;                 
  bool isFov;                          
  double m_hFovAngle;                  
  double m_vFovAngle;                  
  std::vector<vpColVector> fovNormals; 
 
  double inv_px, inv_py;
 
  vpCameraParametersProjType projModel; 
};
 
#endif