astra_ros/Device_8hpp_source.html

#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