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