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
};
 
 
struct LutLevel
{
  double Level;
  double Value;
};
 
 
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));
  });
}
 
 
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);
}
 
 
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");
    }
  });
}
 
} /* namespace Lut */
 
using Lut::LutInterpolation;
using Lut::LutLevel;
 
using Lut::ApplyLut;
 
} /* namespace Foundation */
CVB_END_INLINE_NS
} /* namespace Cvb */
 
#endif