polarization.hpp

#pragma once
 
#if defined _WIN32
 
#  include "../_cexports/c_polarization.h"
 
#  include "../global.hpp"
 
#  include "../image.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace Foundation
  {


    namespace Polarization
    {
      enum class ImageResolution
      {
        Half = 0,
        Full = 1
      };
      enum class ImageResolution {…};

      enum class PseudoColorMode
      {
        Hsv1 = CExports::CVPOL_PCM_HSV_1,
        Hsv2 = CExports::CVPOL_PCM_HSV_2,
        Degree = CExports::CVPOL_PCM_DEGREE_POL,
        AnglePolMono = CExports::CVPOL_PCM_ANGLE_POL_MONO,
        AngleRgb = CExports::CVPOL_PCM_ANGLE_POL_COL
      };
      enum class PseudoColorMode {…};

      enum class Pattern
      {
        Square_90_45_135_0 = CExports::CVPOL_PATTERN_90_45_135_0,
        Line_0_90_135 = CExports::CVPOL_PATTERN_LINE_0_90_135,
        BayerGreenBlue = CExports::CVPOL_PATTERN_BAYER_GREEN_BLUE,
        BayerBlueGreen = CExports::CVPOL_PATTERN_BAYER_BLUE_GREEN,
        BayerRedGreen = CExports::CVPOL_PATTERN_BAYER_RED_GREEN,
        BayerGreenRed = CExports::CVPOL_PATTERN_BAYER_GREEN_RED
      };
      enum class Pattern {…};

      inline std::unique_ptr<Image> ConvertToPlanes(const Image &rawImage, const Pattern pattern,
                                                    const ImageResolution resolution)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&handle) {
          return CVB_CALL_CAPI(
              CVPolConvertPatternImageToPlanes(rawImage.Handle(), static_cast<CExports::cvbval_t>(pattern),
                                               static_cast<CExports::CVPOL_RESOLUTION>(resolution), handle));
        });
      }
      inline std::unique_ptr<Image> ConvertToPlanes(const Image &rawImage, const Pattern pattern, {…}

      inline std::unique_ptr<Image> CalculateStokesImage(const Image &polarizationImage)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&handle) {
          return CVB_CALL_CAPI(CVPolCalculateStokesImage(polarizationImage.Handle(), handle));
        });
      }
      inline std::unique_ptr<Image> CalculateStokesImage(const Image &polarizationImage) {…}

      inline std::unique_ptr<Image> CalculateStokes0(const Image &polarizationImage)
      {
        return Internal::DoResCallObjectOut<Image>(
            [&](void *&handle) { return CVB_CALL_CAPI(CVPolCalculateStokes0(polarizationImage.Handle(), handle)); });
      }
      inline std::unique_ptr<Image> CalculateStokes0(const Image &polarizationImage) {…}

      inline std::unique_ptr<Image> CalculateStokes1(const Image &polarizationImage)
      {
        return Internal::DoResCallObjectOut<Image>(
            [&](void *&handle) { return CVB_CALL_CAPI(CVPolCalculateStokes1(polarizationImage.Handle(), handle)); });
      }
      inline std::unique_ptr<Image> CalculateStokes1(const Image &polarizationImage) {…}

      inline std::unique_ptr<Image> CalculateStokes2(const Image &polarizationImage)
      {
        return Internal::DoResCallObjectOut<Image>(
            [&](void *&handle) { return CVB_CALL_CAPI(CVPolCalculateStokes2(polarizationImage.Handle(), handle)); });
      }
      inline std::unique_ptr<Image> CalculateStokes2(const Image &polarizationImage) {…}

      inline std::unique_ptr<Image> CalculateMinReflectionImage(const Image &polarizationImage)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&handle) {
          return CVB_CALL_CAPI(CVPolCalculateMinReflectionImage(polarizationImage.Handle(), handle));
        });
      }
      inline std::unique_ptr<Image> CalculateMinReflectionImage(const Image &polarizationImage) {…}

      inline std::unique_ptr<Image> ColorizeStokesImage(const Image &stokesImage, const PseudoColorMode &colorMode)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&handle) {
          return CVB_CALL_CAPI(CVPolColorizePolarization(
              stokesImage.Handle(), static_cast<CExports::CVPOL_PSEUDO_COLOR_MODE>(colorMode), handle));
        });
      }
      inline std::unique_ptr<Image> ColorizeStokesImage(const Image &stokesImage, const PseudoColorMode &colorMode) {…}
    };  // namespace Polarization
    namespace Polarization {…}
 
    using Polarization::ImageResolution;
    using Polarization::Pattern;
    using Polarization::PseudoColorMode;
 
    using Polarization::CalculateMinReflectionImage;
    using Polarization::CalculateStokes0;
    using Polarization::CalculateStokes1;
    using Polarization::CalculateStokes2;
    using Polarization::CalculateStokesImage;
    using Polarization::ColorizeStokesImage;
    using Polarization::ConvertToPlanes;
 
  }  // namespace Foundation
 
  CVB_END_INLINE_NS
}  // namespace Cvb
 
#endif