bayer_conversion.hpp

#pragma once
 
#include "../_cexports/c_bayer_to_rgb.h"
 
#include "../global.hpp"
#include "../image.hpp"
#include "../exception.hpp"
#include "../wrapped_image.hpp"
#include "../white_balance.hpp"
#include "../rect.hpp"
#include "../size_2d.hpp"
#include "../area_2d.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  namespace Foundation
  {


    namespace BayerConversion
    {

      enum class RGBConversion
      {
        Linear = CExports::RGB_INTERPOLATE,
        NearestNeighbor = CExports::RGB_NEIGHBOUR,
        HalfResolution = CExports::RGB_HALF
      };
      enum class RGBConversion {…};


      enum class BayerPattern
      {
        GreenBlue = CExports::PM_GREENBLUE,
        BlueGreen = CExports::PM_BLUEGREEN,
        RedGreen = CExports::PM_REDGREEN,
        GreenRed = CExports::PM_GREENRED
      };
      enum class BayerPattern {…};

      enum class GammaCorrection
      {
        Gamma100 = CExports::GAMMA_100,
        Gamma045 = CExports::GAMMA_045,
        Gamma060 = CExports::GAMMA_060
      };
      enum class GammaCorrection {…};


      inline std::unique_ptr<Image> CreateDestinationImage(int width, int height, RGBConversion mode)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          /* The dummy image is only asked for its size... so we do not need actual image data. */
          auto dummy = WrappedImage::FromGrey8Pixels(reinterpret_cast<void *>(42), width, height);
          return CVB_CALL_CAPI(
              etCreateOutputImage(dummy->Handle(), resimg, static_cast<CExports::B2RGB_InterpolationMode>(mode)));
        });
      }
      inline std::unique_ptr<Image> CreateDestinationImage(int width, int height, RGBConversion mode) {…}


      inline std::unique_ptr<Image> CreateDestinationImage(Size2D<int> size, RGBConversion mode)
      {
        return CreateDestinationImage(size.Width(), size.Height(), mode);
      }
      inline std::unique_ptr<Image> CreateDestinationImage(Size2D<int> size, RGBConversion mode) {…}


      inline void BayerToRGB(const Image &imageSrc, Image &imageDst, BayerPattern pattern, RGBConversion conversion,
                             GammaCorrection gamma            = GammaCorrection::Gamma100,
                             WhiteBalanceFactors whiteBalance = WhiteBalanceFactors::Identity())
      {
        /* Note: the binary compatibility between WhiteBalanceFactors and WB is guaranteed, therefore the cast below is
         * legal. */
        CExports::IMG dstHandle = imageDst.Handle();
        CVB_CALL_CAPI_CHECKED(
            etBayerToRGB(imageSrc.Handle(), dstHandle, static_cast<CExports::B2RGB_PixelMode>(pattern),
                         static_cast<CExports::B2RGB_InterpolationMode>(conversion),
                         static_cast<CExports::B2RGB_Gamma>(gamma), reinterpret_cast<CExports::WB &>(whiteBalance)));
        imageDst.RaisePixelContentChanged();
      }
      inline void BayerToRGB(const Image &imageSrc, Image &imageDst, BayerPattern pattern, RGBConversion conversion, {…}


      inline std::unique_ptr<Image> BayerToRGB(const Image &image, BayerPattern pattern, RGBConversion conversion,
                                               GammaCorrection gamma            = GammaCorrection::Gamma100,
                                               WhiteBalanceFactors whiteBalance = WhiteBalanceFactors::Identity())
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          /* Note: the binary compatibility between WhiteBalanceFactors and WB is guaranteed, therefore the cast below
           * is legal. */
          return CVB_CALL_CAPI(etBayerToRGB(image.Handle(), resimg, static_cast<CExports::B2RGB_PixelMode>(pattern),
                                            static_cast<CExports::B2RGB_InterpolationMode>(conversion),
                                            static_cast<CExports::B2RGB_Gamma>(gamma),
                                            reinterpret_cast<CExports::WB &>(whiteBalance)));
        });
      }
      inline std::unique_ptr<Image> BayerToRGB(const Image &image, BayerPattern pattern, RGBConversion conversion, {…}


      inline std::unique_ptr<Image> BayerToMono(const Image &image, BayerPattern pattern, RGBConversion conversion,
                                                GammaCorrection gamma            = GammaCorrection::Gamma100,
                                                WhiteBalanceFactors whiteBalance = WhiteBalanceFactors::Identity())
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          /* Note: the binary compatibility between WhiteBalanceFactors and WB is guaranteed, therefore the cast below
           * is legal. */
          return CVB_CALL_CAPI(etBayerToMono(image.Handle(), resimg, static_cast<CExports::B2RGB_PixelMode>(pattern),
                                             static_cast<CExports::B2RGB_InterpolationMode>(conversion),
                                             static_cast<CExports::B2RGB_Gamma>(gamma),
                                             reinterpret_cast<CExports::WB &>(whiteBalance)));
        });
      }
      inline std::unique_ptr<Image> BayerToMono(const Image &image, BayerPattern pattern, RGBConversion conversion, {…}


      inline std::unique_ptr<Image> RGBToBayer(const Image &image, BayerPattern pattern)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          return CVB_CALL_CAPI(etRGBToBayer(image.Handle(), resimg, static_cast<CExports::B2RGB_PixelMode>(pattern)));
        });
      }
      inline std::unique_ptr<Image> RGBToBayer(const Image &image, BayerPattern pattern) {…}


      inline WhiteBalanceFactors GetWhiteBalance(const Image &image, BayerPattern pattern, Area2D aoi)
      {
        WhiteBalanceFactors wb(0, 0, 0);
        /* Note: the binary compatibility between Area2D and TArea is guaranteed, therefore the cast below is legal. */
        CVB_CALL_CAPI_CHECKED(etWhiteBalance(image.Handle(), static_cast<CExports::B2RGB_PixelMode>(pattern),
                                             CExports::WB_SET, reinterpret_cast<CExports::TArea &>(aoi),
                                             reinterpret_cast<CExports::WB &>(wb)));
        return wb;
      }
      inline WhiteBalanceFactors GetWhiteBalance(const Image &image, BayerPattern pattern, Area2D aoi) {…}


      inline WhiteBalanceFactors GetWhiteBalance(const Image &image, BayerPattern pattern)
      {
        return GetWhiteBalance(image, pattern, Area2D(static_cast<Rect<double>>(image.Bounds())));
      }
      inline WhiteBalanceFactors GetWhiteBalance(const Image &image, BayerPattern pattern) {…}
 
    } /* namespace BayerConversion */
    namespace BayerConversion {…}
 
    using BayerConversion::BayerPattern;
    using BayerConversion::GammaCorrection;
    using BayerConversion::RGBConversion;
 
    using BayerConversion::BayerToMono;
    using BayerConversion::BayerToRGB;
    using BayerConversion::CreateDestinationImage;
    using BayerConversion::GetWhiteBalance;
    using BayerConversion::RGBToBayer;
 
  } /* namespace Foundation */
  CVB_END_INLINE_NS
} /* namespace Cvb */