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

}