lut.hpp

#pragma once
 
#if defined _WIN32
 
#  include "../_cexports/c_foundation.h"
 
#  include "../global.hpp"
#  include "../image.hpp"
#  include "../exception.hpp"
 
#  include <iterator>
#  include <vector>
#  include <algorithm>
#  include <memory>
#  include <cstdint>
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  namespace Foundation
  {


    namespace Lut
    {

      enum class LutInterpolation
      {
        Constant,
        Linear,
        Cubic
      };
      enum class LutInterpolation {…};


      struct LutLevel
      {
        double Level;
        double Value;
      };
      struct LutLevel {…};


      template <class RANGE>
      inline typename TypedRange<std::unique_ptr<Image>, int, RANGE>::type ApplyLut(const ImagePlane &plane,
                                                                                    const RANGE &values)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          return CVB_CALL_CAPI(
              ApplyLUT8Bit(plane.Parent().Handle(), plane.Plane(),
                           reinterpret_cast<CExports::cvbval_t *>(MakeRangeAdapter<int>(values, 256).Data()), resimg));
        });
      }
      inline typename TypedRange<std::unique_ptr<Image>, int, RANGE>::type ApplyLut(const ImagePlane &plane, {…}


      template <class RANGE>
      inline typename TypedRange<std::unique_ptr<Image>, std::uint8_t, RANGE>::type ApplyLut(const ImagePlane &plane,
                                                                                             const RANGE &values)
      /*template <class ByteRange, class = Private::IsTypedRange<ByteRange, uint8_t>, class = void>
      inline std::unique_ptr<Image> ApplyLut (const ImagePlane & plane, const ByteRange &values)*/
      {
        std::vector<int> values_int;
        std::copy(std::begin(values), std::end(values), std::back_inserter(values_int));
        return ApplyLut(plane, values_int);
      }
      inline typename TypedRange<std::unique_ptr<Image>, std::uint8_t, RANGE>::type ApplyLut(const ImagePlane &plane, {…}


      template <class RANGE>
      inline typename TypedRange<std::unique_ptr<Image>, LutLevel, RANGE>::type
      ApplyLut(const ImagePlane &plane, const RANGE &levels, LutInterpolation interpolation)
      /*template <class LutLevelRange, class = Private::IsTypedRange<LutLevelRange, LutLevel>>
      inline std::unique_ptr<Image> ApplyLut (const ImagePlane & plane, const LutLevelRange &levels, LutInterpolation
      interpolation) */
      {
        std::vector<double> levelData, valueData;
        for (auto &&lutLevel : levels)
        {
          levelData.push_back(lutLevel.Level);
          valueData.push_back(lutLevel.Value);
        }
 
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          switch (interpolation)
          {
            case LutInterpolation::Constant:
              return CVB_CALL_CAPI(ApplyLUTGeneric(
                  plane.Parent().Handle(), plane.Plane(), static_cast<CExports::cvbval_t>(levelData.size()),
                  const_cast<double *>(levelData.data()), const_cast<double *>(valueData.data()), resimg));
            case LutInterpolation::Linear:
              return CVB_CALL_CAPI(ApplyLUTLinear(
                  plane.Parent().Handle(), plane.Plane(), static_cast<CExports::cvbval_t>(levelData.size()),
                  const_cast<double *>(levelData.data()), const_cast<double *>(valueData.data()), resimg));
            case LutInterpolation::Cubic:
              return CVB_CALL_CAPI(ApplyLUTCubic(
                  plane.Parent().Handle(), plane.Plane(), static_cast<CExports::cvbval_t>(levelData.size()),
                  const_cast<double *>(levelData.data()), const_cast<double *>(valueData.data()), resimg));
            default:
              throw std::invalid_argument("unknown LUT interpolation mode");
          }
        });
      }
      ApplyLut(const ImagePlane &plane, const RANGE &levels, LutInterpolation interpolation) {…}
 
    } /* namespace Lut */
    namespace Lut {…}
 
    using Lut::LutInterpolation;
    using Lut::LutLevel;
 
    using Lut::ApplyLut;
 
  } /* namespace Foundation */
  CVB_END_INLINE_NS
} /* namespace Cvb */
 
#endif