white_balance.hpp

#pragma once
 
#include "global.hpp"
 
#include "image.hpp"
 
namespace Cvb
{
 
CVB_BEGIN_INLINE_NS
 
 
 
 
class WhiteBalanceFactors final
{
  public:
 
 
    WhiteBalanceFactors(double red, double green, double blue)
    {
      SetRed(red);
      SetGreen(green);
      SetBlue(blue);
    }
 
 
    double Red() const noexcept
    {
      return static_cast<double>(red_) / ConversionFactor;
    }
 
 
    void SetRed(double red)
    {
      if ((red < 0.0) || (red > MaxFactor))
        throw std::invalid_argument("argument out of range for red factor");
 
      red_ = static_cast<int>(red * ConversionFactor);
    }
 
 
    double Green() const noexcept
    {
      return static_cast<double>(green_) / ConversionFactor;
    }
 
 
    void SetGreen(double green)
    {
      if ((green < 0.0) || (green > MaxFactor))
        throw std::invalid_argument("argument out of range for green factor");
 
      green_ = static_cast<int>(green *ConversionFactor);
    }
 
 
    double Blue() const noexcept
    {
      return static_cast<double>(blue_) / ConversionFactor;
    }
 
 
 
    void SetBlue(double blue)
    {
      if ((blue < 0.0) || (blue > MaxFactor))
        throw std::invalid_argument("argument out of range for blue factor");
 
      blue_ = static_cast<int>(blue * ConversionFactor);
    }
 
 
    static WhiteBalanceFactors Identity() noexcept
    {
      return WhiteBalanceFactors(1.0, 1.0, 1.0);
    }
 
  private:
 
    int red_ = 1;
    int green_ = 1;
    int blue_ = 1;
 
    static constexpr double MaxFactor = 16.0;
    static constexpr double ConversionFactor = 256.0;
 
};
 
 
 
inline WhiteBalanceFactors CalculateWhiteBalanceFactors(const Image & image, Area2D aoi)
{
  double red = std::numeric_limits<double>::quiet_NaN(), green = std::numeric_limits<double>::quiet_NaN(), blue = std::numeric_limits<double>::quiet_NaN();
  if (!CVB_CALL_CAPI(CalculateWhiteBalance(image.Handle(),
    *reinterpret_cast<CExports::TArea*>(&aoi),
    red,
    green,
    blue)))
    Utilities::SystemInfo::ThrowLastError();
 
  return WhiteBalanceFactors(red, green, blue);
}
 
 
 
inline void ApplyWhiteBalanceFactors(const Image & image, WhiteBalanceFactors factors)
{
  if (!CVB_CALL_CAPI(ApplyWhiteBalance(image.Handle(), factors.Red(), factors.Green(), factors.Blue())))
    Utilities::SystemInfo::ThrowLastError();
}
 
 
 
CVB_END_INLINE_NS
 
}