perspective_camera_equipped_entity.h

Go to the documentation of this file.

 
#ifndef PERSPECTIVE_CAMERA_EQUIPPED_ENTITY_H
#define PERSPECTIVE_CAMERA_EQUIPPED_ENTITY_H
 
namespace argos {
   class CPerspectiveCameraEquippedEntity;
   class CEmbodiedEntity;
   struct SAnchor;
}
 
#include <argos3/core/simulator/entity/entity.h>
#include <argos3/core/simulator/physics_engine/physics_model.h>
#include <argos3/core/utility/math/vector3.h>
#include <argos3/core/utility/math/quaternion.h>
 
namespace argos {
 
   class CPerspectiveCameraEquippedEntity : public CEntity {
 
   public:
 
      ENABLE_VTABLE();
 
   public:
 
      CPerspectiveCameraEquippedEntity(CComposableEntity* pc_parent);
 
      CPerspectiveCameraEquippedEntity(CComposableEntity* pc_parent,
                                       const std::string& str_id,
                                       const CRadians& c_aperture,
                                       Real f_focal_length,
                                       Real f_range,
                                       SInt32 n_width,
                                       SInt32 n_height,
                                       SAnchor& s_anchor);
 
      virtual void Init(TConfigurationNode& t_tree);
 
      virtual void Enable();
 
      virtual void Disable();
 
      inline const CRadians& GetAperture() const {
         return m_cAperture;
      }
 
      inline void SetAperture(const CRadians& c_aperture) {
         m_cAperture = c_aperture;
      }
 
      inline Real GetFocalLength() const {
         return m_fFocalLength;
      }
 
      inline void SetFocalLength(Real f_focal_length) {
         m_fFocalLength = f_focal_length;
      }
 
      inline Real GetRange() const {
         return m_fRange;
      }
 
      inline void SetRange(Real f_range) {
         m_fRange = f_range;
      }
 
      inline const SAnchor& GetAnchor() const {
         return *m_psAnchor;
      }
 
      inline void SetAnchor(SAnchor& s_anchor) {
         m_psAnchor = &s_anchor;
      }
 
      inline SInt32 GetImagePxWidth() const {
         return m_nImagePxWidth;
      }
 
      inline SInt32 GetImagePxHeight() const {
         return m_nImagePxHeight;
      }
 
      inline void SetImagePxSize(SInt32 n_width,
                                 SInt32 n_height) {
         m_nImagePxWidth  = n_width;
         m_nImagePxHeight = n_height;
         Real fAspectRatio =
            static_cast<Real>(m_nImagePxWidth) /
            static_cast<Real>(m_nImagePxHeight);
         m_fImageMtHeight =
            2.0 * m_fFocalLength * Tan(m_cAperture) /
            Sqrt(1.0 + fAspectRatio * fAspectRatio);
         m_fImageMtWidth = m_fImageMtHeight * fAspectRatio;
      }
 
      inline Real GetImageMtWidth() const {
         return m_fImageMtWidth;
      }
 
      inline Real GetImageMtHeight() const {
         return m_fImageMtHeight;
      }
 
      virtual std::string GetTypeDescription() const {
         return "perspective_camera";
      }
 
   private:
 
      CRadians m_cAperture;
 
      Real m_fFocalLength;
 
      Real m_fRange;
 
      SInt32 m_nImagePxWidth;
 
      SInt32 m_nImagePxHeight;
 
      Real m_fImageMtWidth;
 
      Real m_fImageMtHeight;
 
      SAnchor* m_psAnchor;
 
   };
}
 
#endif