cameraIntrinsicsPinhole.h

Go to the documentation of this file.

#ifndef DLR_COMPUTERVISION_CAMERAINTRINSICSPINHOLE_H
#define DLR_COMPUTERVISION_CAMERAINTRINSICSPINHOLE_H

#include <iostream>
#include <dlrComputerVision/cameraIntrinsics.h>
#include <dlrGeometry/ray3D.h>
#include <dlrNumeric/array2D.h>
#include <dlrNumeric/vector2D.h>


namespace dlr {

  namespace computerVision {

    class CameraIntrinsicsPinhole : public CameraIntrinsics {
    public:

      CameraIntrinsicsPinhole();

      
      CameraIntrinsicsPinhole(size_t numPixelsX,
                              size_t numPixelsY,
                              double focalLength,
                              double pixelSizeX,
                              double pixelSizeY,
                              double centerU,
                              double centerV);


      virtual
      ~CameraIntrinsicsPinhole() {}


      double
      getCenterU() const {return m_centerU;}
          

      double
      getCenterV() const {return m_centerV;}
          

      double
      getFocalLength() const {return m_focalLength;}
          

      double
      getKx() const {return m_kX;}
          

      double
      getKy() const {return m_kY;}
          

      size_t
      getNumPixelsX() const {return m_numPixelsX;}
          

      size_t
      getNumPixelsY() const {return m_numPixelsY;}
          

      double
      getPixelSizeX() const {return m_focalLength / m_kX;}
          

      double
      getPixelSizeY() const {return m_focalLength / m_kY;}
          

      dlr::numeric::Array2D<double>
      getProjectionMatrix() const;

      
      virtual dlr::numeric::Vector2D
      project(const dlr::numeric::Vector3D& point) const;


      std::istream&
      readFromStream(std::istream& inputStream);


      virtual dlr::geometry::Ray3D
      reverseProject(const dlr::numeric::Vector2D& pixelPosition,
                     bool normalize = true) const;


      std::ostream&
      writeToStream(std::ostream& outputStream) const;

      
    protected:

      double m_centerU;
      double m_centerV;
      double m_focalLength;
      double m_kX;
      double m_kY;
      size_t m_numPixelsX;
      size_t m_numPixelsY;

    };


    inline std::ostream&
    operator<<(std::ostream& stream,
               const CameraIntrinsicsPinhole& intrinsics)
    {
      return intrinsics.writeToStream(stream);
    }


    inline std::istream&
    operator>>(std::istream& stream,
               CameraIntrinsicsPinhole& intrinsics)
    {
      return intrinsics.readFromStream(stream);
    }

    
  } // namespace computerVision
  
} // namespace dlr


/* ============ Definitions of inline & template functions ============ */


#include <cmath>

namespace dlr {

  namespace computerVision {
    

  } // namespace computerVision
  
} // namespace dlr

#endif /* #ifndef DLR_COMPUTERVISION_CAMERAINTRINSICSPINHOLE_H */