threshold.hpp

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


    namespace Threshold
    {

      enum class StaticThresholding
      {
        LessThan = CExports::TH_Less,
        LessThanOrEqual = CExports::TH_LessOrEqual,
        Equal = CExports::TH_Equal,
        GreaterOrEqual = CExports::TH_GreaterOrEqual,
        Greater = CExports::TH_Greater
      };
      enum class StaticThresholding {…};

      enum class DynamicThresholdNorm
      {
        Mean = CExports::DTN_Mean,
        MinMax = CExports::DTN_MinMax
      };
      enum class DynamicThresholdNorm {…};


      inline std::unique_ptr<Image> StaticThreshold(const Image &image, const Image &thresholds,
                                                    StaticThresholding comparison)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          return CVB_CALL_CAPI(CreateImageThresholdImage(
              image.Handle(), thresholds.Handle(), static_cast<CExports::TThresholdComparison>(comparison), resimg));
        });
      }
      inline std::unique_ptr<Image> StaticThreshold(const Image &image, const Image &thresholds, {…}


      template <class RANGE>
      inline typename TypedRange<std::unique_ptr<Image>, double, RANGE>::type
      StaticThreshold(const Image &image, const RANGE &values, StaticThresholding comparison)
      {
        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(CreateConstantThresholdImage(image.Handle(), const_cast<double *>(valuesRange.Data()),
                                                            static_cast<CExports::TThresholdComparison>(comparison),
                                                            resimg));
        });
      }
      StaticThreshold(const Image &image, const RANGE &values, StaticThresholding comparison) {…}


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


      inline std::unique_ptr<Image> DynamicThreshold(const Image &image, int windowSize, int threshold,
                                                     DynamicThresholdNorm norm = DynamicThresholdNorm::Mean)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          return CVB_CALL_CAPI(CreateDynamicThresholdImageEx(
              image.Handle(), static_cast<CExports::TDynamicThresholdNorm>(norm), windowSize, threshold, resimg));
        });
      }
      inline std::unique_ptr<Image> DynamicThreshold(const Image &image, int windowSize, int threshold, {…}


      template <class RANGE>
      inline typename TypedRange<std::unique_ptr<Image>, double, RANGE>::type
      StaticTransparentThreshold(const Image &image, const RANGE &thresholds, StaticThresholding comparison,
                                 const RANGE &values)
      {
        auto planesCount     = static_cast<std::size_t>(image.PlanesCount());
        auto thresholdsRange = MakeRangeAdapter<double>(thresholds, planesCount);
        auto valuesRange     = MakeRangeAdapter<double>(values, 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(CreateTransparentThresholdImage(
              image.Handle(), const_cast<double *>(thresholdsRange.Data()), const_cast<double *>(valuesRange.Data()),
              static_cast<CExports::TThresholdComparison>(comparison), resimg));
        });
      }
      StaticTransparentThreshold(const Image &image, const RANGE &thresholds, StaticThresholding comparison, {…}


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


      template <class RANGE>
      inline typename TypedRange<std::unique_ptr<Image>, double, RANGE>::type
      StaticTransparentThreshold(const Image &image, const RANGE &thresholds, StaticThresholding comparison)
      {
        return StaticTransparentThreshold(image, thresholds, comparison, thresholds);
      }
      StaticTransparentThreshold(const Image &image, const RANGE &thresholds, StaticThresholding comparison) {…}


      inline std::unique_ptr<Image> StaticTransparentThreshold(const Image &image, double threshold,
                                                               StaticThresholding comparison)
      {
        return StaticTransparentThreshold(image, std::vector<double>(image.PlanesCount(), threshold), comparison);
      }
      inline std::unique_ptr<Image> StaticTransparentThreshold(const Image &image, double threshold, {…}


      inline void RangeThresholdToDst(const ImagePlane &plane, ValueRange<int> range, Image &imageDst, Rect<int> aoi)
      {
        CExports::TDRect tmpRect = {static_cast<double>(aoi.Left()), static_cast<double>(aoi.Top()),
                                    static_cast<double>(aoi.Right()), static_cast<double>(aoi.Bottom())};
        if (CVB_CALL_CAPI(FBlobBinariseImage(plane.Parent().Handle(), &tmpRect, plane.Plane(), range.Min(), range.Max(),
                                             imageDst.Handle()))
            < 0)
          Utilities::SystemInfo::ThrowLastError();
        imageDst.RaisePixelContentChanged();
      }
      inline void RangeThresholdToDst(const ImagePlane &plane, ValueRange<int> range, Image &imageDst, Rect<int> aoi) {…}


      inline void RangeThresholdToDst(const ImagePlane &plane, ValueRange<int> range, Image &imageDst)
      {
        RangeThresholdToDst(plane, range, imageDst, plane.Parent().Bounds());
      }
      inline void RangeThresholdToDst(const ImagePlane &plane, ValueRange<int> range, Image &imageDst) {…}


      inline std::unique_ptr<Image> RangeThreshold(const ImagePlane &plane, ValueRange<int> range, Rect<int> aoi)
      {
        auto result = Image::Create(aoi.Size());
        RangeThresholdToDst(plane, range, *result, aoi);
        return result;
      }
      inline std::unique_ptr<Image> RangeThreshold(const ImagePlane &plane, ValueRange<int> range, Rect<int> aoi) {…}


      inline std::unique_ptr<Image> RangeThreshold(const ImagePlane &plane, ValueRange<int> range)
      {
        auto result = Image::Create(plane.Parent().Size());
        RangeThresholdToDst(plane, range, *result);
        return result;
      }
      inline std::unique_ptr<Image> RangeThreshold(const ImagePlane &plane, ValueRange<int> range) {…}
 
    } /* namespace Threshold */
    namespace Threshold {…}
 
    using Threshold::DynamicThresholdNorm;
    using Threshold::StaticThresholding;
 
    using Threshold::DynamicThreshold;
    using Threshold::StaticThreshold;
    using Threshold::StaticTransparentThreshold;
 
    using Threshold::RangeThreshold;
    using Threshold::RangeThresholdToDst;
 
  } /* namespace Foundation */
  CVB_END_INLINE_NS
} /* namespace Cvb */
 
#endif