global.hpp

#pragma once
 
#include <array>
#include <functional>
#include <iterator>
#include <list>
#include <memory>
#include <mutex>
#include <vector>
 
#include "namespace.hpp"
 
#include "_cexports/c_core.h"
#include "_cexports/c_driver.h"
 
#ifdef _DEBUG
#  define CVB_FORCE_INLINE inline
#else  // _DEBUG
#  ifdef _MSC_VER
 
#    define CVB_FORCE_INLINE __forceinline
 
#  elif __GNUC__ && __cplusplus
 
#    define CVB_FORCE_INLINE inline __attribute__((always_inline))
 
#  else
 
#  endif
#endif  // _DEBUG
 
 
namespace Cvb
{
 
CVB_BEGIN_INLINE_NS
 
class IArray;
class DataType;
class DeviceFactory;
class ImagePlane;
class LinearAccessData;
class Vpat;
 
class Buffer;
using BufferPtr = std::shared_ptr<Buffer>;
 
class BufferBase;
using BufferBasePtr = std::shared_ptr<BufferBase>;
 
class PFNCBuffer;
using PFNCBufferPtr = std::shared_ptr<PFNCBuffer>;
 
class Plane;
using PlanePtr = std::shared_ptr<Plane>;
 
class PlaneEnumerator;
using PlaneEnumeratorPtr = std::shared_ptr<PlaneEnumerator>;
 
class Image;
using ImagePtr = std::shared_ptr<Image>;
 
class WrappedImage;
using WrappedImagePtr = std::shared_ptr<WrappedImage>;
 
class PanoramicMappedImage;
using PanoramicMappedImagePtr = std::shared_ptr<PanoramicMappedImage>;
 
class Device;
using DevicePtr = std::shared_ptr<Device>;
 
class Composite;
using CompositePtr = std::shared_ptr<Composite>;
 
class HandleOnly;
using HandleOnlyPtr = std::shared_ptr<HandleOnly>;
 
class CancellationToken;
using CancellationTokenPtr = std::shared_ptr<CancellationToken>;
 
class CancellationTokenSource;
using CancellationTokenSourcePtr = std::shared_ptr<CancellationTokenSource>;
 
const double CVB_M_PI = 3.14159265358979323846;
 
class ComponentsPointers3D;
 
template<class T>
class SparseComponentsPointers3D;
 
template<class T>
class DenseComponentsPointers3D;
 
enum class PixelDataType
{
  Undefined,
  UInt,
  Int,
  Float,
  ComplexPackedFloat
};
 
enum class ColorModel
{
  RGBGuess = CExports::CM_Guess_RGB,
  MonoGuess = CExports::CM_Guess_Mono,
  Unknown = CExports::CM_Unknown,
  Mono = CExports::CM_Mono,
 
#ifdef RGB
#undef RGB
#endif
  RGB = CExports::CM_RGB,
  YUV = CExports::CM_YUV,
  HSI = CExports::CM_HSI,
  YCbCr = CExports::CM_YCbCr,
  CieLUV = CExports::CM_LUV,
  CieLab = CExports::CM_Lab,
  HLS = CExports::CM_HLS,
  YCC = CExports::CM_YCC,
  HSV = CExports::CM_HSV,
  CieXYZ = CExports::CM_XYZ
};
 
 
enum class DeviceUpdateMode
{
  UpdateDeviceImage,
  NewDeviceImage
};
 
enum class PlaneNormalization
{
  Individual,
  Identical
};
 
enum class CoordinateSystemType
{
  PixelCoordinates,
 
  ImageCoordinates
};
 
enum class SubPixelMode
{
  ParabolicFast = CExports::TSubPixelMode::SP_Parabolic_Fast,
 
  ParabolicAccurate = CExports::TSubPixelMode::SP_Parabolic_Accurate,
 
  Gaussian = CExports::TSubPixelMode::SP_Gauss
};
 
 
enum class Neighborhood
{
  Use3x3 = 1,
 
  Use5x5 = 2,
 
  Use7x7 = 3,
 
  Use9x9 = 4
};
 
enum class MappingOption
{
  CopyPixels,
 
  LinkPixels
};
 
enum class WaitStatus
{
  Ok = CExports::CVDWS_Ok,
  Timeout = CExports::CVDWS_Timeout,
  Abort = CExports::CVDWS_Canceled
};
 
 
enum class PlaneRole
{
  Undefined = CExports::CVCPR_Undefined,
 
  PixMono = CExports::CVCPR_PixMono,
  PixRGB_R = CExports::CVCPR_PixRGB_R,
  PixRGB_G = CExports::CVCPR_PixRGB_G,
  PixRGB_B = CExports::CVCPR_PixRGB_B,
  PixYUV_Y = CExports::CVCPR_PixYUV_Y,
  PixYUV_U = CExports::CVCPR_PixYUV_U,
  PixYUV_V = CExports::CVCPR_PixYUV_V,
  PixHSV_H = CExports::CVCPR_PixHSV_H,
  // Saturation channel value.
  PixHSV_S = CExports::CVCPR_PixHSV_S,
  PixHSV_V = CExports::CVCPR_PixHSV_V,
  PixLAB_L = CExports::CVCPR_PixLAB_L,
  PixLAB_A = CExports::CVCPR_PixLAB_A,
  PixLAB_B = CExports::CVCPR_PixLAB_B,
  PixConfidence = CExports::CVCPR_PixConfidence,
 
  CoordCartesian_X = CExports::CVCPR_CoordCartesian_X,
  CoordCartesian_Y = CExports::CVCPR_CoordCartesian_Y,
  CoordCartesian_Z = CExports::CVCPR_CoordCartesian_Z,
  CoordCartesian_W = CExports::CVCPR_CoordCartesian_W,
  CoordPolar_Rho = CExports::CVCPR_CoordPolar_Rho,
  CoordPolar_Phi = CExports::CVCPR_CoordPolar_Phi,
  CoordCylindrical_Rho = CExports::CVCPR_CoordCylindrical_Rho,
  CoordCylindrical_Phi = CExports::CVCPR_CoordCylindrical_Phi,
  CoordCylindrical_Z = CExports::CVCPR_CoordCylindrical_Z,
  CoordSpherical_Rho = CExports::CVCPR_CoordSpherical_Rho,
  CoordSpherical_Phi = CExports::CVCPR_CoordSpherical_Phi,
  CoordSpherical_Theta = CExports::CVCPR_CoordSpherical_Theta,
  Normal_X = CExports::CVCPR_Normal_X,
  Normal_Y = CExports::CVCPR_Normal_Y,
  Normal_Z = CExports::CVCPR_Normal_Z,
  PointPlanarity = CExports::CVCPR_Point_Planarity,
  PointVariation = CExports::CVCPR_Point_Variation,
  PointSphericity = CExports::CVCPR_Point_Sphericity,
  PointLinearity = CExports::CVCPR_Point_Linearity,
  PointCurvature = CExports::CVCPR_Point_Curvature,
 
  Custom = CExports::CVCPR_Custom
};
 
enum class PanoramaDirection
{
  Horizontal = CExports::PM_Horizontal,
  Vertical = CExports::PM_Vertical
};
 
enum class ConnectionState
{
  NotSupported,
  Connected,
  Disconnected
};
 
enum class CompositePurpose
{
  Custom = -1,
  Image = 0,
  ImageList,
  MultiAoi,
  RangeMap,
  PointCloud,
  ImageCube
};
 
enum class ConversionMode
{
    Automatic
};
 
namespace Internal
{
 
template <class T> class AsyncRef
{
public:
  AsyncRef() = default;
 
  std::shared_ptr<T> AtomicGet(std::function<std::shared_ptr<T>()> create = nullptr)
  {
    std::unique_lock<std::mutex> guard(mutex_);
    auto ref = weakRef_.lock();
    if (!ref && create)
    {
      ref = create();
      weakRef_ = ref;
    }
    return ref;
  }
 
  void Reset() noexcept { weakRef_.reset(); }
 
private:
  std::mutex mutex_;
 
  std::weak_ptr<T> weakRef_;
};
 
class HandlerCarrier
{
public:
  HandlerCarrier() noexcept = default;
  virtual ~HandlerCarrier() = default;
};
 
typedef std::shared_ptr<HandlerCarrier> HandlerCarrierPtr;
typedef std::weak_ptr<HandlerCarrier> HandlerCarrierWPtr;
 
class CarrierContainer;
 
}
 
 
class EventCookie
{
  friend Internal::CarrierContainer;
 
public:
 
  EventCookie() noexcept = default;
 
 
  operator bool() const noexcept { return !handlerCarrier_.expired(); }
 
private:
  EventCookie(const Internal::HandlerCarrierPtr &handlerCarrier) { handlerCarrier_ = handlerCarrier; }
 
  Internal::HandlerCarrierWPtr handlerCarrier_;
};
 
namespace Internal
{
 
typedef void(REL_CB)(void *handle);
 
}
 
template <class T, Internal::REL_CB CB> class SharedHandleGuard;
 
template <class T, Internal::REL_CB CB = nullptr> class HandleGuard
{
 
public:
  explicit HandleGuard(void *handle) noexcept : handle_(handle, CB)
  {
    static_assert(std::is_same<T, void>::value,
                  "CVB: HandleGuard need specialization, or type void with release callback!");
  }
 
  HandleGuard(void *handle, std::function<void(void *)> deleter) noexcept : handle_(handle, deleter) {}
 
  void *Handle() const noexcept { return handle_.get(); }
 
  void Reset(void *handle = nullptr) noexcept { handle_.reset(handle); }
 
  void *Release() noexcept { return handle_.release(); }
 
private:
  std::unique_ptr<void, std::function<void(void *)>> handle_;
 
  friend class SharedHandleGuard<T, CB>;
};
 
typedef HandleGuard<void, CVB_CALL_CAPI(ReleaseObjectVoid)> ReleaseObjectGuard;
 
template <class T, Internal::REL_CB CB = nullptr> class SharedHandleGuard
{
public:
  SharedHandleGuard(HandleGuard<T, CB> &&uniqueGuard) : shandle_(std::move(uniqueGuard.handle_)) {}
 
  SharedHandleGuard(const SharedHandleGuard &) = default;
  SharedHandleGuard &operator=(const SharedHandleGuard &) = default;
 
  void *Handle() const noexcept { return shandle_.get(); }
 
private:
  std::shared_ptr<void> shandle_;
};
 
typedef SharedHandleGuard<void, CVB_CALL_CAPI(ReleaseObjectVoid)> SharedReleaseObjectGuard;
 
// forward declaration needed for gcc
namespace Utilities
{
 
namespace SystemInfo
{
void ThrowLastError();
void ThrowLastError(int errorCode);
 
}
 
}
 
namespace Internal
{
 
template <class T> class CbCarrier : public HandlerCarrier
{
 
public:
  static std::shared_ptr<CbCarrier> Create(std::function<T> cb) { return std::make_shared<CbCarrier<T>>(cb); }
 
  CbCarrier(std::function<T> cb) noexcept : cb_(cb) {}
 
  std::function<T> CB() const noexcept { return cb_; }
 
private:
  std::function<T> cb_;
};
 
class CarrierContainer
{
public:
  CarrierContainer() noexcept {}
 
  CarrierContainer(CarrierContainer &&other) noexcept : carrierList_(std::move(other.carrierList_)) {}
 
  ~CarrierContainer() = default;
 
  EventCookie Register(const HandlerCarrierPtr &handlerBase) noexcept
  {
    std::unique_lock<std::mutex> guard(carrierListMutex_);
    carrierList_.push_back(handlerBase);
    return EventCookie(handlerBase);
  }
 
  void Unregister(EventCookie eventCookie) noexcept
  {
    std::unique_lock<std::mutex> guard(carrierListMutex_);
    auto handlerBase = eventCookie.handlerCarrier_.lock();
    if (!handlerBase)
      return;
 
    carrierList_.remove(handlerBase);
  }
 
  template <class T, class... Args> void Call(Args &&... args) const
  {
    std::list<HandlerCarrierPtr> eventHolderList;
    {
      std::unique_lock<std::mutex> guard(carrierListMutex_);
      eventHolderList.insert(eventHolderList.end(), carrierList_.begin(), carrierList_.end());
    }
    for (auto &holderBase : eventHolderList)
    {
      auto holder = std::dynamic_pointer_cast<CbCarrier<T>>(holderBase);
      holder->CB()(std::forward<Args>(args)...);
    }
  }
 
private:
  CarrierContainer &operator=(CarrierContainer &&other) noexcept = delete;
 
  mutable std::mutex carrierListMutex_;
  std::list<HandlerCarrierPtr> carrierList_;
};
 
template <class OBJ, class RES, class... ARGS>
inline std::unique_ptr<OBJ> DoCallObjectOut(std::function<RES(void *&handle)> call, ARGS &&... args)
{
  void *handle = nullptr;
  auto code = CExports::MakeErrorCode(call(handle));
  if (code < 0)
  {
    Utilities::SystemInfo::ThrowLastError(code);
  }
  return OBJ::FromHandle(HandleGuard<OBJ>(handle), std::forward<ARGS>(args)...);
}
 
template <class OBJ, class... ARGS>
inline std::unique_ptr<OBJ> DoBoolCallObjectOut(std::function<CExports::cvbbool_t(void *&handle)> call, ARGS &&... args)
{
  return DoCallObjectOut<OBJ, CExports::cvbbool_t, ARGS...>(call, std::forward<ARGS>(args)...);
}
 
template <class OBJ, class... ARGS>
inline std::unique_ptr<OBJ> DoResCallObjectOut(std::function<CExports::cvbres_t(void *&handle)> call, ARGS &&... args)
{
  return DoCallObjectOut<OBJ, CExports::cvbres_t, ARGS...>(call, std::forward<ARGS>(args)...);
}
 
template <class OBJ> inline std::unique_ptr<OBJ> DoHandleCallObjectOut(void *result)
{
  return DoCallObjectOut<OBJ, void *>([=](void *&handle) { return (handle = result); });
}
 
template <class OBJ, class RES, class... ARGS>
inline std::shared_ptr<OBJ> DoCallShareOut(std::function<RES(void *&handle)> call, ARGS &&... args)
{
  void *handle = nullptr;
  auto code = CExports::MakeErrorCode(call(handle));
  if (code < 0)
  {
    Utilities::SystemInfo::ThrowLastError(code);
  } 
  return OBJ::template FromHandle<OBJ>(typename OBJ::GuardType(handle), std::forward<ARGS>(args)...);
}
 
template <class OBJ, class... ARGS>
inline std::shared_ptr<OBJ> DoBoolCallShareOut(std::function<CExports::cvbbool_t(void *&handle)> call, ARGS &&... args)
{
  return DoCallShareOut<OBJ, CExports::cvbbool_t, ARGS...>(call, std::forward<ARGS>(args)...);
}
 
template <class OBJ, class... ARGS>
inline std::shared_ptr<OBJ> DoResCallShareOut(std::function<CExports::cvbres_t(void *&handle)> call, ARGS &&... args)
{
  return DoCallShareOut<OBJ, CExports::cvbres_t, ARGS...>(call, std::forward<ARGS>(args)...);
}
 
template <class T, class RES> inline T DoCallValueOut(std::function<RES(T &handle)> call)
{
  T value;
  auto code = CExports::MakeErrorCode(call(value));
  if (code < 0)
  {
    Utilities::SystemInfo::ThrowLastError(code);
  }
  return value;
}
 
template <class T> inline T DoBoolCallValueOut(std::function<CExports::cvbbool_t(T &handle)> call)
{
  return DoCallValueOut<T, CExports::cvbbool_t>(call);
}
 
template <class T> inline T DoResCallValueOut(std::function<CExports::cvbres_t(T &value)> call)
{
  return DoCallValueOut<T, CExports::cvbres_t>(call);
}
 
template <class RES> inline void DoCall(std::function<RES()> call)
{
  auto code = CExports::MakeErrorCode(call());
  if (code < 0)
    Utilities::SystemInfo::ThrowLastError(code);
}
 
inline void DoBoolCall(std::function<CExports::cvbbool_t()> call)
{
  DoCall<CExports::cvbbool_t>(call);
}
 
inline void DoResCall(std::function<CExports::cvbres_t()> call)
{
  DoCall<CExports::cvbres_t>(call);
}
 
class SmartBool final
{
public:
  SmartBool() noexcept = default;
  SmartBool(bool val) noexcept : cVal_(val ? 1 : 0) {}
 
#if defined _WIN32
  SmartBool(CExports::cvbbool_t val) noexcept : cVal_(val) {}
#endif
 
  operator bool() const noexcept { return ((cVal_) ? true : false); }
 
  CExports::cvbbool_t *Ptr() noexcept { return &cVal_; }
 
private:
  CExports::cvbbool_t cVal_ = 0;
};
 
}
 
template <class T>
using IsNumeric =
    std::integral_constant<bool,
                           std::is_same<double, T>::value || std::is_same<float, T>::value ||
                               std::is_same<std::int64_t, T>::value || std::is_same<std::int32_t, T>::value ||
                               std::is_same<std::int16_t, T>::value || std::is_same<std::int8_t, T>::value>;
 
template <class T> using EnableIfNumeric = std::enable_if<IsNumeric<T>::value>;
 
template <class T> using EnableIfArithmetic = std::enable_if<std::is_arithmetic<T>::value>;
 
template <class T, class... ARGS> struct AllOfType;
 
template <class T, class ARG> struct AllOfType<T, ARG>
{
  static constexpr bool Value =
      std::is_same<typename std::remove_const<typename std::remove_reference<T>::type>::type, ARG>::value ||
      std::is_base_of<typename std::remove_const<typename std::remove_reference<T>::type>::type, ARG>::value;
};
 
template <class T, class ARG, class... ARGS> struct AllOfType<T, ARG, ARGS...>
{
  static constexpr bool Value =
      (std::is_same<typename std::remove_const<typename std::remove_reference<T>::type>::type, ARG>::value ||
       std::is_base_of<typename std::remove_const<typename std::remove_reference<T>::type>::type, ARG>::value) &&
      AllOfType<T, ARGS...>::Value;
};
 
template <typename RET, typename TYPE, class RANGE>
using TypedRange = std::enable_if<std::is_same<TYPE,
                                               typename std::remove_const<typename std::remove_reference<decltype(
                                                   *std::begin(std::declval<RANGE &>()))>::type>::type>::value,
                                  RET>;
 
template <class RET, class TYPE, class... ARGS>
using VarArgRange = typename std::enable_if<AllOfType<TYPE, ARGS...>::Value, RET>;
 
template <class TYPE, class RANGE> class RangeAdapter
{
public:
  /* The constructor only stores the reference and compile-time-checks the value type.
    * All operations are performed only when needed. */
  RangeAdapter(const RANGE &range) : inputRef_(range)
  {
    static_assert(
        std::is_same<typename std::remove_const<
                         typename std::remove_reference<decltype(*std::begin(std::declval<RANGE &>()))>::type>::type,
                     TYPE>::value,
        "Unexpected range value type");
  }
 
  /* Returns pointer to the range values in a contiguous memory block. */
  TYPE *Data() const
  {
    /* TODO: should we actively check for empty container here? */
    return const_cast<TYPE *>(Data(inputRef_.get()));
  }
 
  /* Returns size of the range. */
  std::size_t Size() const { return std::distance(std::begin(inputRef_.get()), std::end(inputRef_.get())); }
 
private:
  /* Actual input-range dependent workers for the contiguous data query. */
  template <size_t N> const TYPE *Data(const TYPE (&carray)[N]) const { return carray; }
 
  template <size_t N> const TYPE *Data(const std::array<TYPE, N> &stdarray) const { return stdarray.data(); }
 
  const TYPE *Data(const std::vector<TYPE> &stdvec) const { return stdvec.data(); }
 
  template <class LIST> const TYPE *Data(const LIST &list) const
  {
    if (convertedRange_.empty())
    {
      convertedRange_.assign(std::begin(list), std::end(list));
    }
    return convertedRange_.data();
  }
 
private:
  const std::reference_wrapper<const RANGE> inputRef_;
  mutable std::vector<TYPE> convertedRange_;
};
 
template <class TYPE, class RANGE>
RangeAdapter<TYPE, RANGE> MakeRangeAdapter(const RANGE &range, std::size_t minSize = 1)
{
  RangeAdapter<TYPE, RANGE> rangeAdapter(range);
  if (minSize != 0 && rangeAdapter.Size() < minSize)
    throw std::runtime_error("insufficient number of input range values");
  return rangeAdapter;
}
 
template <class...>
struct DispatchableTypeList
{
};
 
template <class DT, class... DTS>
struct DispatchableTypeList<DT, DTS...>
{
  using DefaultType = DT;
};
 
template <class PLANE_T>
struct PlaneTraits;
 
CVB_END_INLINE_NS
 
}