data_type.hpp

#pragma once

#include <limits>
#include <type_traits>
#include <utility>


#include <cmath>



#include "_cexports/c_img.h"

#include "global.hpp"
#include "exception.hpp"

namespace Cvb
{

CVB_BEGIN_INLINE_NS




class DataType final
{
  public:


    static DataType FromNativeDescriptor(int dataTypeDescriptor) noexcept
    {
      return DataType(dataTypeDescriptor);
    }


    static DataType Int8BppUnsigned() noexcept
    {
      return DataType(8);
    }


    static DataType Int8BppSigned() noexcept
    {
      return DataType(8 | CExports::DT_Signed);
    }


    static DataType Int10BppUnsigned() noexcept
    {
      return DataType(10);
    }


    static DataType Int12BppUnsigned() noexcept
    {
      return DataType(12);
    }


    static DataType Int16BppUnsigned() noexcept
    {
      return DataType(16);
    }


    static DataType Int16BppSigned() noexcept
    {
      return DataType(16 | CExports::DT_Signed);
    }


    static DataType Int32BppUnsigned() noexcept
    {
      return DataType(32);
    }


    static DataType Int32BppSigned() noexcept
    {
      return DataType(32 | CExports::DT_Signed);
    }


    static DataType Int64BppUnsigned() noexcept
    {
      return DataType(64);
    }


    static DataType Int64BppSigned() noexcept
    {
      return DataType(64 | CExports::DT_Signed);
    }


    static DataType Float32Bpp() noexcept
    {
      return DataType(32 | CExports::DT_Float | CExports::DT_Signed);
    }


    static DataType Float64Bpp() noexcept
    {
      return DataType(64 | CExports::DT_Float | CExports::DT_Signed);
    }




    template<typename T>
    static DataType FromNativeType() noexcept
    {
      static_assert(std::is_integral<T>::value || std::is_floating_point<T>::value,
                    "CVB: Unsupported image plane data type!");
      static_assert((1 << 8) == CExports::DT_Signed,
                    "CVB: DT_Signed does not match!");
      static_assert((1 << 9) == CExports::DT_Float,
                    "CVB: DT_Float does not match!");


      CExports::cvbdatatype_t nativeDescriptor = sizeof(T) * 8 // bit size
        | std::is_signed<T>::value << 8 // set signed bit if signed int or float
        | std::is_floating_point<T>::value << 9; // set float bit if float

      return DataType(nativeDescriptor);
    }


    template <template<class> class T, class ACTION, class... CTORARGS>
    auto CallWithInstanceOf(ACTION action, CTORARGS... args) const -> decltype(action(T<int>{std::forward<CTORARGS>(args)...}))
    {
      if(this->IsUnsignedInteger())
      {
        switch(this->BytesPerPixel())
        {
          case 1:
          {
            T<std::uint8_t> t{std::forward<CTORARGS>(args)...};
            return action(t);
          }
          case 2:
          {
            T<std::uint16_t> t{std::forward<CTORARGS>(args)...};
            return action(t);
          }
          case 4:
          {
            T<std::uint32_t> t{std::forward<CTORARGS>(args)...};
            return action(t);
          }
          case 8:
          {
            T<std::uint64_t> t{std::forward<CTORARGS>(args)...};
            return action(t);
          }
          default:
          {
            break;
          }
        }
      }
      else if(this->IsSignedInteger())
      {
        switch (this->BytesPerPixel())
        {
          case 1:
          {
            T<std::int8_t> t{std::forward<CTORARGS>(args)...};
            return action(t);
          }
          case 2:
          {
            T<std::int16_t> t{std::forward<CTORARGS>(args)...};
            return action(t);
          }
          case 4:
          {
            T<std::int32_t> t{std::forward<CTORARGS>(args)...};
            return action(t);
          }
          case 8:
          {
            T<std::int64_t> t{std::forward<CTORARGS>(args)...};
            return action(t);
          }
          default:
          {
            break;
          }
        }
      }
      else if(this->IsFloat())
      {
        switch (this->BytesPerPixel())
        {
          case 4:
          {
            T<float> t{std::forward<CTORARGS>(args)...};
            return action(t);
          }
          case 8:
          {
            T<double> t{std::forward<CTORARGS>(args)...};
            return action(t);
          }
          default:
          {
            break;
          }
        }
      }

      throw std::runtime_error("Could not match native data type");
    }


    template <class T>
    bool Matches() const noexcept
    {
      static_assert(std::is_integral<T>::value || std::is_floating_point<T>::value,
                    "CVB: T must be integer or floating point");

      // floats use specialization below
      return this->BytesPerPixel() == sizeof(T)
        && this->IsFloat() == std::is_floating_point<T>::value
        && this->IsSigned() == std::is_signed<T>::value;
    }


    int NativeDescriptor() const noexcept
    {
      return dataTypeDescriptor_;
    }


    int BitsPerPixel() const noexcept
    {
      return dataTypeDescriptor_ & 0xFF;
    }


    int BytesPerPixel() const noexcept
    {
      // remember: 0x7 is equivalent to % 8
      return BitsPerPixel() / 8 + (((BitsPerPixel() & 0x7) != 0) ? 1 : 0);
    }


    bool IsFloat() const noexcept
    {
      // as defined in iCVCImg.h...
      return (dataTypeDescriptor_ & CExports::DT_Float) != 0;
    }


    bool IsSignedInteger() const noexcept
    {
      return (dataTypeDescriptor_ & CExports::DT_Signed) != 0 && !IsFloat();
    }


    bool IsUnsignedInteger() const noexcept
    {
      return (dataTypeDescriptor_ & 0xB00) == 0;
    }


    bool IsSigned() const noexcept
    {
      return (dataTypeDescriptor_ & CExports::DT_Signed) != 0;
    }


    bool HasOverlayBit() const noexcept
    {
      return (dataTypeDescriptor_ & CExports::DT_Overlay) != 0;
    }


    bool IsComplexPacked() const noexcept
    {
      return (dataTypeDescriptor_ & CExports::DT_ComplexPacked) != 0;
    }


    double MinVal() const noexcept
    {
      if (IsFloat())
      {
#ifdef min
#undef min
#endif
        if (BytesPerPixel() == 4)
          return static_cast<double>(std::numeric_limits<float>::lowest());
        else if (BytesPerPixel() == 8)
          return std::numeric_limits<double>::lowest();
        else
          return std::numeric_limits<double>::quiet_NaN();
      }
      else
      {
        CExports::cvbval_t min = 0;
        CExports::cvbval_t max = 0;
        CVB_CALL_CAPI(GetDatatypeMinMaxVal(static_cast<CExports::cvbdatatype_t>(dataTypeDescriptor_), min, max));
        return static_cast<double>(min);
      }
    }


    double MaxVal() const noexcept
    {
#ifdef max
#undef max
#endif
      if (IsFloat())
      {
        if (BytesPerPixel() == 4)
          return static_cast<double>(std::numeric_limits<float>::max());
        else if (BytesPerPixel() == 8)
          return std::numeric_limits<double>::max();
        else
          return std::numeric_limits<double>::quiet_NaN();
      }
      else
      {
        CExports::cvbval_t min = 0;
        CExports::cvbval_t max = 0;
        CVB_CALL_CAPI(GetDatatypeMinMaxVal(static_cast<CExports::cvbdatatype_t>(dataTypeDescriptor_), min, max));
        return static_cast<double>(max);
      }

    }


    PixelDataType NumericType() const  noexcept
    {

      if ((IsComplexPacked()) && (IsFloat()))
        return PixelDataType::ComplexPackedFloat;
      else if (IsFloat())
        return PixelDataType::Float;
      else if (IsSignedInteger())
        return PixelDataType::Int;
      else if (IsUnsignedInteger())
        return PixelDataType::UInt;
      else
        return PixelDataType::Undefined;

    }



    double UndefinedVal() const noexcept
    {

      if (IsSignedInteger() || IsUnsignedInteger())
        return round((MaxVal() - MinVal()) / 2.0);
      else
        return 0.0;

    }


    bool operator==(const DataType& dataType) const noexcept
    {
      if (IsFloat() && dataType.IsFloat())
        return BitsPerPixel() == dataType.BitsPerPixel(); // skip signed bit if float or double
      return dataTypeDescriptor_ == dataType.dataTypeDescriptor_;
    }


    bool operator!=(const DataType& dataType) const noexcept
    {
      return !(*this == dataType);
    }



  private:

    DataType(CExports::cvbdatatype_t dataTypeDescriptor) noexcept
      : dataTypeDescriptor_(dataTypeDescriptor)
    {
    }


    int dataTypeDescriptor_;
};


CVB_END_INLINE_NS

}