avt_vimba_camera.h

Go to the documentation of this file.

#ifndef AVT_VIMBA_CAMERA_H
#define AVT_VIMBA_CAMERA_H

#include <VimbaCPP/Include/VimbaCPP.h>

#include <avt_vimba_camera/AvtVimbaCameraConfig.h>
#include <avt_vimba_camera/frame_observer.h>
#include <avt_vimba_camera/avt_vimba_api.h>

#include <diagnostic_updater/diagnostic_updater.h>
#include <diagnostic_updater/publisher.h>

#include <boost/function.hpp>
#include <boost/thread.hpp>

#include <string>

using AVT::VmbAPI::VimbaSystem;
using AVT::VmbAPI::CameraPtr;
using AVT::VmbAPI::FramePtr;
using AVT::VmbAPI::IFrameObserverPtr;

namespace avt_vimba_camera {

enum FrameStartTriggerMode {
  Freerun,
  FixedRate,
  Software,
  SyncIn1,
  SyncIn2,
  SyncIn3,
  SyncIn4
};

enum CameraState {
  OPENING,
  IDLE,
  CAMERA_NOT_FOUND,
  FORMAT_ERROR,
  ERROR,
  OK
};

class AvtVimbaCamera {
 public:
  AvtVimbaCamera();
  AvtVimbaCamera(std::string name);
  void start(std::string ip_str, std::string guid_str, bool debug_prints = true);
  void stop();
  double getTimestamp(void);
  bool resetTimestamp(void);
  double getDeviceTemp(void);

  CameraPtr getCameraPtr(void) {
    return vimba_camera_ptr_;
  }

  int getWidth();
  int getHeight();
  int getMaxWidth();
  int getMaxHeight();

  // Pass callback function pointer
  typedef boost::function<void (const FramePtr)> frameCallbackFunc;
  void setCallback(frameCallbackFunc callback = &avt_vimba_camera::AvtVimbaCamera::defaultFrameCallback) {
    userFrameCallback = callback;
  }

  typedef avt_vimba_camera::AvtVimbaCameraConfig Config;
  void updateConfig(Config& config);
  void startImaging(void);
  void stopImaging(void);
  bool isOpened(void) { return opened_; }

 private:
  Config config_;

  AvtVimbaApi api_;
  // IFrame Observer
  SP_DECL(FrameObserver) frame_obs_ptr_;
  // The currently streaming camera
  CameraPtr vimba_camera_ptr_;
  // Current frame
  FramePtr vimba_frame_ptr_;
  // The max width
  VmbInt64_t vimba_camera_max_width_;
  // The max height
  VmbInt64_t vimba_camera_max_height_;

  // Mutex
  boost::mutex config_mutex_;

  bool opened_;
  bool streaming_;
  bool on_init_;
  bool show_debug_prints_;
  std::string name_;

  diagnostic_updater::Updater updater_;
  CameraState camera_state_;
  std::string diagnostic_msg_;

  // ROS params
  int num_frames_;
  std::string guid_;
  std::string frame_id_;
  std::string trigger_source_;
  int trigger_source_int_;

  CameraPtr openCamera(std::string id_str);

  frameCallbackFunc userFrameCallback;
  void frameCallback(const FramePtr vimba_frame_ptr);
  void defaultFrameCallback(const FramePtr vimba_frame_ptr) {
    std::cout << "[AvtVimbaCamera] No frame callback provided." << std::endl;
  }

  template<typename T>
  bool setFeatureValue(const std::string& feature_str, const T& val);
  template<typename T>
  bool getFeatureValue(const std::string& feature_str, T& val);
  bool getFeatureValue(const std::string& feature_str, std::string& val);
  bool runCommand(const std::string& command_str);
  std::string interfaceToString(VmbInterfaceType interfaceType);
  std::string accessModeToString(VmbAccessModeType modeType);
  int getTriggerModeInt(std::string mode_str);
  void printAllCameraFeatures(const CameraPtr& camera);

  void updateAcquisitionConfig(Config& config);
  void updateExposureConfig(Config& config);
  void updateGainConfig(Config& config);
  void updateWhiteBalanceConfig(Config& config);
  void updateImageModeConfig(Config& config);
  void updateROIConfig(Config& config);
  void updateBandwidthConfig(Config& config);
  void updatePixelFormatConfig(Config& config);
  void updatePtpModeConfig(Config& config);
  void updateGPIOConfig(Config& config);
  void updateIrisConfig(Config& config);

  void getCurrentState(diagnostic_updater::DiagnosticStatusWrapper &stat);

};
}
#endif