ueye_cam_driver.hpp

Go to the documentation of this file.

/*******************************************************************************
* DO NOT MODIFY - AUTO-GENERATED
*
*
* DISCLAMER:
*
* This project was created within an academic research setting, and thus should
* be considered as EXPERIMENTAL code. There may be bugs and deficiencies in the
* code, so please adjust expectations accordingly. With that said, we are
* intrinsically motivated to ensure its correctness (and often its performance).
* Please use the corresponding web repository tool (e.g. github/bitbucket/etc.)
* to file bugs, suggestions, pull requests; we will do our best to address them
* in a timely manner.
*
*
* SOFTWARE LICENSE AGREEMENT (BSD LICENSE):
*
* Copyright (c) 2013-2016, Anqi Xu and contributors
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
*  * Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
*  * Redistributions in binary form must reproduce the above
*    copyright notice, this list of conditions and the following
*    disclaimer in the documentation and/or other materials provided
*    with the distribution.
*  * Neither the name of the School of Computer Science, McGill University,
*    nor the names of its contributors may be used to endorse or promote
*    products derived from this software without specific prior written
*    permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*******************************************************************************/

#ifndef UEYE_CAM_DRIVER_HPP_
#define UEYE_CAM_DRIVER_HPP_


#include <ueye.h>
#include <string>
#include <thread>
#include <functional>
#include "logging_macros.hpp"


namespace ueye_cam {


#define CAP(val, min, max) \
  if (val < min) { \
    val = min; \
  } else if (val > max) { \
    val = max; \
  }

#define IS_SUBSAMPLING_2X (IS_SUBSAMPLING_2X_VERTICAL | IS_SUBSAMPLING_2X_HORIZONTAL)
#define IS_SUBSAMPLING_4X (IS_SUBSAMPLING_4X_VERTICAL | IS_SUBSAMPLING_4X_HORIZONTAL)
#define IS_SUBSAMPLING_8X (IS_SUBSAMPLING_8X_VERTICAL | IS_SUBSAMPLING_8X_HORIZONTAL)
#define IS_SUBSAMPLING_16X (IS_SUBSAMPLING_16X_VERTICAL | IS_SUBSAMPLING_16X_HORIZONTAL)

#define IS_BINNING_2X (IS_BINNING_2X_VERTICAL | IS_BINNING_2X_HORIZONTAL)
#define IS_BINNING_4X (IS_BINNING_4X_VERTICAL | IS_BINNING_4X_HORIZONTAL)
#define IS_BINNING_8X (IS_BINNING_8X_VERTICAL | IS_BINNING_8X_HORIZONTAL)
#define IS_BINNING_16X (IS_BINNING_16X_VERTICAL | IS_BINNING_16X_HORIZONTAL)


class UEyeCamDriver {
public:
  constexpr static int ANY_CAMERA = 0;


  UEyeCamDriver(int cam_ID = ANY_CAMERA, std::string cam_name = "camera");

  virtual ~UEyeCamDriver();

  virtual INT connectCam(int new_cam_ID = -1);

  virtual INT disconnectCam();

  INT loadCamConfig(std::string filename, bool ignore_load_failure = true);

  INT setColorMode(std::string& mode, bool reallocate_buffer = true);

  INT setResolution(INT& image_width, INT& image_height, INT& image_left,
      INT& image_top, bool reallocate_buffer = true);

  INT setSubsampling(int& rate, bool reallocate_buffer = true);

  INT setBinning(int& rate, bool reallocate_buffer = true);

  INT setSensorScaling(double& rate, bool reallocate_buffer = true);

  INT setGain(bool& auto_gain, INT& master_gain_prc, INT& red_gain_prc,
      INT& green_gain_prc, INT& blue_gain_prc, bool& gain_boost);

  INT setExposure(bool& auto_exposure, double& exposure_ms);

  INT setWhiteBalance(bool& auto_white_balance, INT& red_offset, INT& blue_offset);

  INT setFrameRate(bool& auto_frame_rate, double& frame_rate_hz);

  INT setPixelClockRate(INT& clock_rate_mhz);

  INT setFlashParams(INT& delay_us, UINT& duration_us);

  INT setFreeRunMode();

  INT setExtTriggerMode();

  INT setStandbyMode();

  INT setMirrorUpsideDown(bool flip_horizontal);

  INT setMirrorLeftRight(bool flip_vertical);

  const char* processNextFrame(INT timeout_ms);

  inline bool isConnected() { return (cam_handle_ != (HIDS) 0); }

  inline bool freeRunModeActive() {
    return ((cam_handle_ != (HIDS) 0) &&
        (is_SetExternalTrigger(cam_handle_, IS_GET_EXTERNALTRIGGER) == IS_SET_TRIGGER_OFF) &&
        (is_CaptureVideo(cam_handle_, IS_GET_LIVE) == TRUE));
  }

  inline bool extTriggerModeActive() {
    return ((cam_handle_ != (HIDS) 0) &&
        (is_SetExternalTrigger(cam_handle_, IS_GET_EXTERNALTRIGGER) == IS_SET_TRIGGER_HI_LO) &&
        (is_CaptureVideo(cam_handle_, IS_GET_LIVE) == TRUE));
  }

  inline bool isCapturing() {
    return ((cam_handle_ != (HIDS) 0) &&
        (is_CaptureVideo(cam_handle_, IS_GET_LIVE) == TRUE));
  }

  const static char* err2str(INT error);

  const static char* colormode2str(INT mode);

  const static std::string colormode2img_enc(INT mode);

  const static INT colormode2bpp(INT mode);

  const static bool isSupportedColorMode(INT mode);

  const static INT name2colormode(const std::string& name);
  const static std::string colormode2name(INT mode);

  const static std::function<void*(void*, void*, size_t)> getUnpackCopyFunc(INT color_mode);
  static void* unpackRGB10(void* dst, void* src, size_t num);
  static void* unpack10u(void* dst, void* src, size_t num);
  static void* unpack12u(void* dst, void* src, size_t num);

  bool getTimestamp(UEYETIME *timestamp);

  bool getClockTick(uint64_t *tick);


protected:
  virtual INT syncCamConfig(std::string dft_mode_str = "mono8");


  virtual void handleTimeout() {};


  INT reallocateCamBuffer();

  const static std::map<std::string, INT> COLOR_DICTIONARY;

  HIDS cam_handle_;
  SENSORINFO cam_sensor_info_;
  char* cam_buffer_;
  int cam_buffer_id_;
  INT cam_buffer_pitch_;
  unsigned int cam_buffer_size_;
  std::string cam_name_;
  int cam_id_;
  IS_RECT cam_aoi_;
  unsigned int cam_subsampling_rate_;
  unsigned int cam_binning_rate_;
  double cam_sensor_scaling_rate_;
  INT color_mode_;
  INT bits_per_pixel_;
};


} // namespace ueye_cam


#endif /* UEYE_CAM_DRIVER_HPP_ */