astra_ros: Device.hpp Source File

Go to the documentation of this file.
 #ifndef _ASTRA_ROS_DEVICE_HPP_
 #define _ASTRA_ROS_DEVICE_HPP_
  
 #include <string>
 #include <memory>
 #include <iostream>
 #include <vector>
 #include <boost/optional.hpp>
  
 #include "Parameter.hpp"
  
 #include <astra/capi/astra.h>
  
 namespace astra_ros
 {
   class Device
   {
   public:
     typedef std::shared_ptr<Device> Ptr;
     typedef std::shared_ptr<const Device> ConstPtr;
  
     struct ImageStreamMode
     {
       boost::optional<std::uint32_t> width;
  
       boost::optional<std::uint32_t> height;
  
       boost::optional<astra_pixel_format_t> pixel_format;
  
       boost::optional<std::uint8_t> fps;
     };
  
     struct Frame
     {
       struct Color
       {
         std::uint32_t data_length;
  
         // The image data for the color stream (use metadata to understand the content).
         // This pointer is only valid until the next update().
         std::uint8_t *data;
  
         astra_image_metadata_t metadata;
       };
  
       struct Ir
       {
         float horizontal_fov;
         float vertical_fov;
  
         std::uint32_t data_length;
  
         // The image data for the IR stream (use metadata to understand the content).
         // This pointer is only valid until the next update().
         std::uint8_t *data;
  
         astra_image_metadata_t metadata;
       };
  
       struct Depth
       {
         float horizontal_fov;
         float vertical_fov;
  
         bool registered;
  
         std::uint32_t data_length;
  
         // The image data for the depth stream (use metadata to understand the content).
         // This pointer is only valid until the next update().
         std::int16_t *data;
  
         astra_image_metadata_t metadata;
       };
  
       struct Body
       {
         astra_floor_info_t *floor_info;
         astra_bodymask_t body_mask;
         astra_body_list_t body_list;
       };
  
       struct ColorizedBody
       {
         std::uint32_t data_length;
  
         // The pixel data for the colorized body stream.
         // This pointer is only valid until the next update().
         astra_rgba_pixel_t *data;
  
         astra_image_metadata_t metadata;
       };
  
       struct Hand
       {
  
       };
  
       struct MaskedColor
       {
         std::uint32_t data_length;
  
         // The pixel data for the masked color stream.
         // This pointer is only valid until the next update().
         astra_rgba_pixel_t *data;
  
         astra_image_metadata_t metadata;
       };
  
       struct Point
       {
         std::uint32_t data_length;
         astra_vector3f_t *data;
       };
  
       boost::optional<Color> color;
       
       boost::optional<Ir> ir;
  
       boost::optional<Depth> depth;
  
       boost::optional<Body> body;
  
       boost::optional<ColorizedBody> colorized_body;
  
       boost::optional<Hand> hand;
  
       boost::optional<MaskedColor> masked_color;
  
       boost::optional<Point> point;
     };
  
     struct Configuration
     {
       typedef std::function<void (const Frame &frame)> OnFrame;
  
       struct ColorStream
       {
         typedef Parameter<bool> Running;
         typedef Parameter<bool> Mirrored;
  
         typedef Parameter<ImageStreamMode> Mode;
  
         Running running;
  
         boost::optional<Mirrored> mirrored;
  
         boost::optional<Mode> mode;
       };
  
       struct IrStream
       {
         typedef Parameter<bool> Running;
         typedef Parameter<bool> Mirrored;
  
         typedef Parameter<ImageStreamMode> Mode;
  
         typedef Parameter<std::int32_t> Gain;
         typedef Parameter<std::int32_t> Exposure;
  
         Running running;
  
         boost::optional<Mirrored> mirrored;
  
         boost::optional<Mode> mode;
  
         boost::optional<Gain> gain;
         boost::optional<Exposure> exposure;
         
       };
  
       struct DepthStream
       {
         typedef Parameter<bool> Running;
         typedef Parameter<bool> Mirrored;
  
         typedef Parameter<ImageStreamMode> Mode;
  
         typedef Parameter<bool> Registration;
         typedef Parameter<int> D2CMode;
  
         Running running;
  
         boost::optional<Mirrored> mirrored;
  
         boost::optional<Mode> mode;
  
         boost::optional<Registration> registration;
  
         
         boost::optional<D2CMode> d2c_mode;
         
       };
  
       struct BodyStream
       {
         typedef Parameter<bool> Running;
         typedef Parameter<astra_body_orientation_t> BodyOrientation;
         typedef Parameter<astra_skeleton_optimization_t> SkeletonOptimization;
         typedef Parameter<astra_skeleton_profile_t> SkeletonProfile;
         typedef Parameter<astra_body_tracking_feature_flags_t> BodyFeatures;
  
         boost::optional<std::string> license;
  
         Running running;
  
         boost::optional<BodyOrientation> body_orientation;
         boost::optional<SkeletonOptimization> skeleton_optimization;
         boost::optional<SkeletonProfile> skeleton_profile;
         boost::optional<BodyFeatures> default_body_features;
       };
  
       struct ColorizedBodyStream
       {
         typedef Parameter<bool> Running;
         typedef Parameter<bool> Mirrored;
  
         Running running;
       };
  
       struct HandStream
       {
         typedef Parameter<bool> Running;
         Running running;
       };
  
       struct MaskedColorStream
       {
         typedef Parameter<bool> Running;
         typedef Parameter<bool> Mirrored;
  
         Running running;
       };
  
       struct PointStream
       {
         typedef Parameter<bool> Running;
         Running running;
       };
  
       boost::optional<std::string> uri;
       OnFrame on_frame;
  
  
       boost::optional<ColorStream> color_stream;
       
       boost::optional<IrStream> ir_stream;
  
       boost::optional<DepthStream> depth_stream;
       
       boost::optional<BodyStream> body_stream;
       
       boost::optional<ColorizedBodyStream> colorized_body_stream;
       
       boost::optional<HandStream> hand_stream;
       
       boost::optional<MaskedColorStream> masked_color_stream;
       
       boost::optional<PointStream> point_stream;
     };
  
     static Ptr open(const Configuration &configuration);
  
     void update();
  
     inline const Configuration &getConfiguration() const noexcept
     {
       return configuration_;
     }
  
     inline Configuration &getConfiguration() noexcept
     {
       return configuration_;
     }
  
     orbbec_camera_params getCameraParameters() const;
  
     boost::optional<std::string> getSerialNumber() const;
  
     boost::optional<std::uint32_t> getChipId() const;
  
     boost::optional<astra_usb_info_t> getColorUsbInfo() const;
     
     boost::optional<astra_usb_info_t> getDepthUsbInfo() const;
  
     boost::optional<astra_usb_info_t> getIrUsbInfo() const;
  
     boost::optional<std::vector<ImageStreamMode>> getColorImageStreamModes() const;
     
     boost::optional<std::vector<ImageStreamMode>> getDepthImageStreamModes() const;
  
     boost::optional<std::vector<ImageStreamMode>> getIrImageStreamModes() const;
  
   private:
     Device(const Configuration &configuration);
  
     bool onStreamStartedChange(astra_streamconnection_t stream, const bool &started, const bool &started_prev);
     bool onDepthRegistrationChange(astra_depthstream_t stream, const bool &registration, const bool &prev_registration);
     bool onDepthD2CModeChange(astra_depthstream_t stream, const int &d2c_mode, const bool &prev_d2c_mode);
     bool onBodyOrientationChange(astra_bodystream_t body_stream, const astra_body_orientation_t &orientation, const astra_skeleton_optimization_t &prev_orientation);
     bool onBodySkeletonOptimizationChange(astra_bodystream_t body_stream, const astra_skeleton_optimization_t &optimization, const astra_skeleton_optimization_t &prev_optimization);
     bool onBodySkeletonProfileChange(astra_bodystream_t body_stream, const astra_skeleton_profile_t &profile, const astra_skeleton_profile_t &prev_profile);
     bool onModeChange(astra_streamconnection_t stream, const ImageStreamMode &mode, const ImageStreamMode &prev_mode);
     bool onMirroredChange(astra_streamconnection_t stream, const bool &mirrored, const bool &prev_mirrored);
  
     std::vector<ImageStreamMode> getImageStreamModes(astra_streamconnection_t stream) const;
  
     Configuration configuration_;
  
     astra_streamsetconnection_t stream_set_;
     astra_reader_t reader_;
  
     boost::optional<astra_colorstream_t> color_stream_;
     boost::optional<astra_infraredstream_t> ir_stream_;
     boost::optional<astra_depthstream_t> depth_stream_;
     boost::optional<astra_bodystream_t> body_stream_;
     boost::optional<astra_colorizedbodystream_t> colorized_body_stream_;
     boost::optional<astra_handstream_t> hand_stream_;
     boost::optional<astra_maskedcolorstream_t> masked_color_stream_;
     boost::optional<astra_pointstream_t> point_stream_;
   };
 }
  
 std::ostream &operator <<(std::ostream &o, const astra_ros::Device::Configuration::ColorStream &value);
 std::ostream &operator <<(std::ostream &o, const astra_ros::Device::Configuration::IrStream &value);
 std::ostream &operator <<(std::ostream &o, const astra_ros::Device::Configuration::DepthStream &value);
 std::ostream &operator <<(std::ostream &o, const astra_ros::Device::Configuration::BodyStream &value);
 std::ostream &operator <<(std::ostream &o, const astra_ros::Device::Configuration::ColorizedBodyStream &value);
 std::ostream &operator <<(std::ostream &o, const astra_ros::Device::Configuration::MaskedColorStream &value);
 std::ostream &operator <<(std::ostream &o, const astra_ros::Device::Configuration &value);
  
 #endif