test_images.hpp

#pragma once
 
#if defined _WIN32
 
#  include "../_cexports/c_foundation.h"
 
#  include "../global.hpp"
#  include "../image.hpp"
#  include "../exception.hpp"
#  include "../size_2d.hpp"
 
#  include "transform_2d.hpp"
 
#  include <memory>
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  namespace Foundation
  {


    namespace TestImages
    {

      enum class TestImageDataType
      {
        Unsigned8,
        Unsigned16,
        Signed16,
        Signed32,
        Float32
      };
      enum class TestImageDataType {…};
 
      namespace Private
      {
        /* Decompose the enumerated test image data types into the set of parameters
         * required by the original C-function. */
        inline void DecomposeTestImageDataType(TestImageDataType dt, int &bitsPerPixel, bool &isSigned, bool &isFloat)
        {
          switch (dt)
          {
            case TestImageDataType::Float32:
              bitsPerPixel = 32;
              isSigned     = true;
              isFloat      = true;
              break;
            case TestImageDataType::Signed16:
              bitsPerPixel = 16;
              isSigned     = true;
              isFloat      = false;
              break;
            case TestImageDataType::Signed32:
              bitsPerPixel = 32;
              isSigned     = true;
              isFloat      = false;
              break;
            case TestImageDataType::Unsigned16:
              bitsPerPixel = 16;
              isSigned     = true;
              isFloat      = false;
              break;
            case TestImageDataType::Unsigned8:
              bitsPerPixel = 8;
              isSigned     = false;
              isFloat      = false;
              break;
            default:
              throw std::invalid_argument("unknown test image data type requested");
          }
        }
      } /* namespace Private */


      inline std::unique_ptr<Image> CreateJaehneImage(Size2D<int> size, int numPlanes, TestImageDataType dataType)
      {
        int bitsPerPixel;
        bool isSigned, isFloat;
        Private::DecomposeTestImageDataType(dataType, bitsPerPixel, isSigned, isFloat);
 
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          return CVB_CALL_CAPI(
              CreateFilterTestImage(size.Width(), size.Height(), numPlanes, bitsPerPixel, isSigned, isFloat, resimg));
        });
      }
      inline std::unique_ptr<Image> CreateJaehneImage(Size2D<int> size, int numPlanes, TestImageDataType dataType) {…}


      inline std::unique_ptr<Image> CreateRampImage(Size2D<int> size, int numPlanes, TestImageDataType dataType,
                                                    Axis axis, double offset = 0.0, double slope = 1.0)
      {
        if (axis == Axis::NoAxis)
        {
          throw std::invalid_argument("creating the test image needs at least one axis selected");
        }
 
        bool axisHorizontal = axis == Axis::X || axis == Axis::Both;
        bool axisVertical   = axis == Axis::Y || axis == Axis::Both;
 
        int bitsPerPixel;
        bool isSigned, isFloat;
        Private::DecomposeTestImageDataType(dataType, bitsPerPixel, isSigned, isFloat);
 
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          return CVB_CALL_CAPI(CreateGreyRamp(size.Width(), size.Height(), numPlanes, bitsPerPixel, isSigned, isFloat,
                                              offset, slope, axisHorizontal, axisVertical, resimg));
        });
      }
      inline std::unique_ptr<Image> CreateRampImage(Size2D<int> size, int numPlanes, TestImageDataType dataType, {…}
 
    } /* namespace TestImages */
    namespace TestImages {…}
 
    using TestImages::TestImageDataType;
 
    using TestImages::CreateJaehneImage;
    using TestImages::CreateRampImage;
 
  } /* namespace Foundation */
  CVB_END_INLINE_NS
} /* namespace Cvb */
 
#endif