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 CompressedPFNCBuffer;
  using CompressedPFNCBufferPtr = std::shared_ptr<CompressedPFNCBuffer>;
 
  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>;
 
  class PixelFormatConverter;
  using PixelFormatConverterPtr = std::shared_ptr<PixelFormatConverter>;
 
  const double CVB_M_PI = 3.14159265358979323846;
 
  class ComponentsPointers3D;
 
  template <class T>
  class SparseComponentsPointers3D;
 
  template <class T>
  class DenseComponentsPointers3D;

  enum class CompressedBufferType
  {
    Unknown  = CExports::CVCCT_Unknown,
    JPEG     = CExports::CVCCT_JPEG,
    JPEG2000 = CExports::CVCCT_JPEG2000,
  };

  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 RotationMap
  {
    By90Degrees = CExports::VPATROT_90,

    By180Degrees = CExports::VPATROT_180,

    By270Degrees = CExports::VPATROT_270
  };

  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,
    PixRGB_RGB = CExports::CVCPR_PixRGB_RGB,

    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;
      HandlerCarrier(const HandlerCarrier &other) noexcept            = default;
      HandlerCarrier &operator=(const HandlerCarrier &other) noexcept = default;
      HandlerCarrier(HandlerCarrier &&other) noexcept                 = default;
      HandlerCarrier &operator=(HandlerCarrier &&other) noexcept      = default;
      virtual ~HandlerCarrier()                                       = default;
    };
 
    typedef std::shared_ptr<HandlerCarrier> HandlerCarrierPtr;
    typedef std::weak_ptr<HandlerCarrier> HandlerCarrierWPtr;
 
    class CarrierContainer;
 
  }  // namespace Internal


  class EventCookie
  {
    friend Internal::CarrierContainer;
 
  public:

    EventCookie() noexcept = default;


    explicit operator bool() const noexcept
    {
      return !handlerCarrier_.expired();
    }
 
  private:
    explicit EventCookie(const Internal::HandlerCarrierPtr &handlerCarrier) noexcept
        : 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:
    explicit SharedHandleGuard(HandleGuard<T, CB> &&uniqueGuard)
        : shandle_(std::move(uniqueGuard.handle_))
    {
    }
 
    SharedHandleGuard(const SharedHandleGuard &other) noexcept       = default;
    SharedHandleGuard &operator=(const SharedHandleGuard &) noexcept = default;
    SharedHandleGuard(SharedHandleGuard &&other) noexcept            = default;
    SharedHandleGuard &operator=(SharedHandleGuard &&other) noexcept = default;
    ~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 SystemInfo
 
  }  // namespace Utilities
 
  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);
      }
 
      explicit 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(const CarrierContainer &other)            = delete;
      CarrierContainer &operator=(const CarrierContainer &other) = delete;
      CarrierContainer(CarrierContainer &&other) noexcept
      {
        try
        {
          carrierList_ = std::move(other.carrierList_);
        }
        catch (...)
        {
          // does not realy throw - catch required for static anlysis
        }
      }
      CarrierContainer &operator=(CarrierContainer &&other) = delete;
      ~CarrierContainer()                                   = default;
 
      EventCookie Register(const HandlerCarrierPtr &handlerBase)
      {
        std::unique_lock<std::mutex> guard(carrierListMutex_);
        carrierList_.push_back(handlerBase);
        return EventCookie{handlerBase};
      }
 
      void Unregister(EventCookie eventCookie) noexcept
      {
 
        auto handlerBase = eventCookie.handlerCarrier_.lock();
        if (!handlerBase)
          return;
 
        std::unique_lock<std::mutex> guard(carrierListMutex_);
        carrierList_.remove(handlerBase);
      }
 
      template <class T, class... Args>
      void Call(Args &&...args) const
      {
        std::list<HandlerCarrierPtr> carrierList;
        {
          std::unique_lock<std::mutex> guard(carrierListMutex_);
          carrierList.insert(carrierList.end(), carrierList_.begin(), carrierList_.end());
        }
        for (auto &carrier : carrierList)
        {
          auto holder = std::dynamic_pointer_cast<CbCarrier<T>>(carrier);
          holder->CB()(std::forward<Args>(args)...);
        }
      }
 
    private:
      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);
    }
  }  // namespace Internal
 
  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. */
    explicit 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
    {
      return const_cast<TYPE *>(Data(inputRef_.get()));  // NOLINT(cppcoreguidelines-pro-type-const-cast)
    }
 
    /* 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;
    }  // NOLINT(cppcoreguidelines-avoid-c-arrays)
 
    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
 
}  // namespace Cvb