arithmetic.hpp

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


    namespace Arithmetic
    {

      enum class PixelOverflow
      {
        Scale,
        Truncate
      };
      enum class PixelOverflow {…};

      enum class SqrtPixelScaling
      {
        AsIs,
        Yes
      };
      enum class SqrtPixelScaling {…};


      inline std::unique_ptr<Image> Add(const Image &image1, const Image &image2, PixelOverflow overflow)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          return CVB_CALL_CAPI(AddImages(image1.Handle(), image2.Handle(), overflow == PixelOverflow::Scale, resimg));
        });
      }
      inline std::unique_ptr<Image> Add(const Image &image1, const Image &image2, PixelOverflow overflow) {…}


      template <class RANGE>
      inline typename TypedRange<std::unique_ptr<Image>, double, RANGE>::type
      Add(const Image &image, const RANGE &values, PixelOverflow overflow)
      {
        auto valuesRange = MakeRangeAdapter<double>(values, image.PlanesCount());
 
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          /* Note: need to cast-away const of "values" parameter to match the C-API, the function does not modify it. */
          return CVB_CALL_CAPI(AddConstant(image.Handle(), const_cast<double *>(valuesRange.Data()),
                                           overflow == PixelOverflow::Scale, resimg));
        });
      }
      Add(const Image &image, const RANGE &values, PixelOverflow overflow) {…}


      inline std::unique_ptr<Image> Add(const Image &image, double value, PixelOverflow overflow)
      {
        return Add(image, std::vector<double>(image.PlanesCount(), value), overflow);
      }
      inline std::unique_ptr<Image> Add(const Image &image, double value, PixelOverflow overflow) {…}


      inline std::unique_ptr<Image> Multiply(const Image &image1, const Image &image2, PixelOverflow overflow)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          return CVB_CALL_CAPI(
              MultiplyImages(image1.Handle(), image2.Handle(), overflow == PixelOverflow::Scale, resimg));
        });
      }
      inline std::unique_ptr<Image> Multiply(const Image &image1, const Image &image2, PixelOverflow overflow) {…}


      template <class RANGE>
      inline typename TypedRange<std::unique_ptr<Image>, double, RANGE>::type
      Multiply(const Image &image, const RANGE &values, PixelOverflow overflow)
      {
        auto valuesRange = MakeRangeAdapter<double>(values, image.PlanesCount());
 
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          /* Note: need to cast-away const of "values" parameter to match the C-API, the function does not modify it. */
          return CVB_CALL_CAPI(MultiplyConstant(image.Handle(), const_cast<double *>(valuesRange.Data()),
                                                overflow == PixelOverflow::Scale, resimg));
        });
      }
      Multiply(const Image &image, const RANGE &values, PixelOverflow overflow) {…}


      inline std::unique_ptr<Image> Multiply(const Image &image, double value, PixelOverflow overflow)
      {
        return Multiply(image, std::vector<double>(image.PlanesCount(), value), overflow);
      }
      inline std::unique_ptr<Image> Multiply(const Image &image, double value, PixelOverflow overflow) {…}


      inline std::unique_ptr<Image> Subtract(const Image &image1, const Image &image2)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          /* Beware: in the C interface the order of input image arguments is swapped! */
          return CVB_CALL_CAPI(SubtractImages(image2.Handle(), image1.Handle(), resimg));
        });
      }
      inline std::unique_ptr<Image> Subtract(const Image &image1, const Image &image2) {…}


      template <class RANGE>
      inline typename TypedRange<std::unique_ptr<Image>, double, RANGE>::type Subtract(const Image &image,
                                                                                       const RANGE &values)
      {
        auto valuesRange = MakeRangeAdapter<double>(values, image.PlanesCount());
 
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          /* Note: need to cast-away const of "values" parameter to match the C-API, the function does not modify it. */
          return CVB_CALL_CAPI(SubtractConstant(image.Handle(), const_cast<double *>(valuesRange.Data()), resimg));
        });
      }
      inline typename TypedRange<std::unique_ptr<Image>, double, RANGE>::type Subtract(const Image &image, {…}


      inline std::unique_ptr<Image> Subtract(const Image &image, double value)
      {
        return Subtract(image, std::vector<double>(image.PlanesCount(), value));
      }
      inline std::unique_ptr<Image> Subtract(const Image &image, double value) {…}


      inline std::unique_ptr<Image> Divide(const Image &image1, const Image &image2, int upShift)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          /* Beware: in the C interface the order of input image arguments is swapped! */
          return CVB_CALL_CAPI(DivideImages(image2.Handle(), image1.Handle(), upShift, resimg));
        });
      }
      inline std::unique_ptr<Image> Divide(const Image &image1, const Image &image2, int upShift) {…}


      template <class RANGE>
      inline typename TypedRange<std::unique_ptr<Image>, double, RANGE>::type Divide(const Image &image,
                                                                                     const RANGE &values)
      {
        auto valuesRange = MakeRangeAdapter<double>(values, image.PlanesCount());
 
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          /* Note: need to cast-away const of "values" parameter to match the C-API, the function does not modify it. */
          return CVB_CALL_CAPI(DivideConstant(image.Handle(), const_cast<double *>(valuesRange.Data()), resimg));
        });
      }
      inline typename TypedRange<std::unique_ptr<Image>, double, RANGE>::type Divide(const Image &image, {…}


      inline std::unique_ptr<Image> Divide(const Image &image, double value)
      {
        return Divide(image, std::vector<double>(image.PlanesCount(), value));
      }
      inline std::unique_ptr<Image> Divide(const Image &image, double value) {…}


      inline std::unique_ptr<Image> Absolute(const Image &image)
      {
        return Internal::DoResCallObjectOut<Image>(
            [&](void *&resimg) { return CVB_CALL_CAPI(AbsoluteImage(image.Handle(), resimg)); });
      }
      inline std::unique_ptr<Image> Absolute(const Image &image) {…}


      inline std::unique_ptr<Image> SubtractAbs(const Image &image1, const Image &image2)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          /* Beware: in the C interface the order of input image arguments is swapped!
           * (with "absolute" the order actually does not matter, but let's be consistent with Subtract). */
          return CVB_CALL_CAPI(SubtractImagesAbsolute(image2.Handle(), image1.Handle(), resimg));
        });
      }
      inline std::unique_ptr<Image> SubtractAbs(const Image &image1, const Image &image2) {…}


      template <class RANGE>
      inline typename TypedRange<std::unique_ptr<Image>, double, RANGE>::type SubtractAbs(const Image &image,
                                                                                          const RANGE &values)
      {
        auto valuesRange = MakeRangeAdapter<double>(values, image.PlanesCount());
 
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          /* Note: need to cast-away const of "values" parameter to match the C-API, the function does not modify it. */
          return CVB_CALL_CAPI(
              SubtractConstantAbsolute(image.Handle(), const_cast<double *>(valuesRange.Data()), resimg));
        });
      }
      inline typename TypedRange<std::unique_ptr<Image>, double, RANGE>::type SubtractAbs(const Image &image, {…}


      inline std::unique_ptr<Image> SubtractAbs(const Image &image, double value)
      {
        return SubtractAbs(image, std::vector<double>(image.PlanesCount(), value));
      }
      inline std::unique_ptr<Image> SubtractAbs(const Image &image, double value) {…}


      inline std::unique_ptr<Image> Square(const Image &image, PixelOverflow overflow)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          return CVB_CALL_CAPI(SquareImage(image.Handle(), overflow == PixelOverflow::Scale, resimg));
        });
      }
      inline std::unique_ptr<Image> Square(const Image &image, PixelOverflow overflow) {…}


      inline std::unique_ptr<Image> Sqrt(const Image &image, SqrtPixelScaling scaling)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          return CVB_CALL_CAPI(SquareRootImage(image.Handle(), scaling == SqrtPixelScaling::Yes, resimg));
        });
      }
      inline std::unique_ptr<Image> Sqrt(const Image &image, SqrtPixelScaling scaling) {…}
 
    } /* namespace Arithmetic */
    namespace Arithmetic {…}
 
    using Arithmetic::PixelOverflow;
    using Arithmetic::SqrtPixelScaling;
 
    using Arithmetic::Absolute;
    using Arithmetic::Add;
    using Arithmetic::Divide;
    using Arithmetic::Multiply;
    using Arithmetic::Sqrt;
    using Arithmetic::Square;
    using Arithmetic::Subtract;
    using Arithmetic::SubtractAbs;
 
  } /* namespace Foundation */
  CVB_END_INLINE_NS
} /* namespace Cvb */
 
#endif