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);
    }
    WhiteBalanceFactors(double red, double green, double blue) {…}


    double Red() const noexcept
    {
      return static_cast<double>(red_) / ConversionFactor;
    }
    double Red() const noexcept {…}


    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);
    }
    void SetRed(double red) {…}


    double Green() const noexcept
    {
      return static_cast<double>(green_) / ConversionFactor;
    }
    double Green() const noexcept {…}


    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);
    }
    void SetGreen(double green) {…}


    double Blue() const noexcept
    {
      return static_cast<double>(blue_) / ConversionFactor;
    }
    double Blue() const noexcept {…}


    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);
    }
    void SetBlue(double blue) {…}


    static WhiteBalanceFactors Identity() noexcept
    {
      return WhiteBalanceFactors(1.0, 1.0, 1.0);
    }
    static WhiteBalanceFactors Identity() noexcept {…}
 
  private:
    int red_   = 1;
    int green_ = 1;
    int blue_  = 1;
 
    static constexpr double MaxFactor        = 16.0;
    static constexpr double ConversionFactor = 256.0;
  };
  class WhiteBalanceFactors final {…};


  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 WhiteBalanceFactors CalculateWhiteBalanceFactors(const Image &image, Area2D aoi) {…}


  inline void ApplyWhiteBalanceFactors(const Image &image, WhiteBalanceFactors factors)
  {
    if (!CVB_CALL_CAPI(ApplyWhiteBalance(image.Handle(), factors.Red(), factors.Green(), factors.Blue())))
      Utilities::SystemInfo::ThrowLastError();
  }
  inline void ApplyWhiteBalanceFactors(const Image &image, WhiteBalanceFactors factors) {…}
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb