filter.hpp

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


    namespace Filter
    {


      enum class FixedFilterSize
      {
        Kernel3x3 = CExports::FM_3x3,
        Kernel5x5 = CExports::FM_5x5,
        Kernel7x7 = CExports::FM_7x7
      };

      enum class FilterOrientation
      {
        Horizontal,
        Vertical
      };

      enum class EdgeFilter
      {
        Scharr = CExports::CE_Scharr,
        Sobel = CExports::CE_Sobel,
        Sobel2nd = CExports::CE_Sobel2nd
      };

      enum class RobertsDirection
      {
        Up,
        Down
      };


      inline std::unique_ptr<Image> Canny(const ImagePlane &imagePlane, Filter::EdgeFilter edgeFilter,
                                          int lowerThreshold, int upperThreshold)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          return CVB_CALL_CAPI(FilterCanny(imagePlane.Parent().Handle(), imagePlane.Plane(),
                                           static_cast<CExports::TCannyEdgeFilter>(edgeFilter), lowerThreshold,
                                           upperThreshold, resimg));
        });
      }


      inline std::unique_ptr<Image> Laplace(const Image &image, Filter::FixedFilterSize size)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          return CVB_CALL_CAPI(FilterLaplace(image.Handle(), static_cast<CExports::TFilterMask>(size), resimg));
        });
      }


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


      inline std::unique_ptr<Image> LowPass(const Image &image, Filter::FixedFilterSize size)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          return CVB_CALL_CAPI(FilterLoPass(image.Handle(), static_cast<CExports::TFilterMask>(size), resimg));
        });
      }


      inline std::unique_ptr<Image> HighPass(const Image &image, Filter::FixedFilterSize size)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          return CVB_CALL_CAPI(FilterHiPass(image.Handle(), static_cast<CExports::TFilterMask>(size), resimg));
        });
      }


      inline std::unique_ptr<Image> Gauss(const Image &image, Filter::FixedFilterSize size)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          return CVB_CALL_CAPI(FilterGauss(image.Handle(), static_cast<CExports::TFilterMask>(size), resimg));
        });
      }


      inline std::unique_ptr<Image> BoxMean(const Image &image, Size2D<int> maskSize, Point2D<int> maskOffset)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          return CVB_CALL_CAPI(FilterBoxMean(image.Handle(), maskSize.Width(), maskSize.Height(), maskOffset.X(),
                                             maskOffset.Y(), resimg));
        });
      }


      inline std::unique_ptr<Image> BoxMean(const Image &image, Size2D<int> maskSize)
      {
        return BoxMean(image, maskSize, Point2D<int>(maskSize.Width() / 2, maskSize.Height() / 2));
      }


      inline std::unique_ptr<Image> BoxMin(const Image &image, Size2D<int> maskSize, Point2D<int> maskOffset)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          return CVB_CALL_CAPI(FilterBoxMin(image.Handle(), maskSize.Width(), maskSize.Height(), maskOffset.X(),
                                            maskOffset.Y(), resimg));
        });
      }


      inline std::unique_ptr<Image> BoxMin(const Image &image, Size2D<int> maskSize)
      {
        return BoxMin(image, maskSize, Point2D<int>(maskSize.Width() / 2, maskSize.Height() / 2));
      }


      inline std::unique_ptr<Image> BoxMax(const Image &image, Size2D<int> maskSize, Point2D<int> maskOffset)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          return CVB_CALL_CAPI(FilterBoxMax(image.Handle(), maskSize.Width(), maskSize.Height(), maskOffset.X(),
                                            maskOffset.Y(), resimg));
        });
      }


      inline std::unique_ptr<Image> BoxMax(const Image &image, Size2D<int> maskSize)
      {
        return BoxMax(image, maskSize, Point2D<int>(maskSize.Width() / 2, maskSize.Height() / 2));
      }


      inline std::unique_ptr<Image> BoxMedian(const Image &image, Size2D<int> maskSize, Point2D<int> maskOffset)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          return CVB_CALL_CAPI(FilterBoxMedian(image.Handle(), maskSize.Width(), maskSize.Height(), maskOffset.X(),
                                               maskOffset.Y(), resimg));
        });
      }


      inline std::unique_ptr<Image> BoxMedian(const Image &image, Size2D<int> maskSize)
      {
        return BoxMedian(image, maskSize, Point2D<int>(maskSize.Width() / 2, maskSize.Height() / 2));
      }


      inline std::unique_ptr<Image> ColorMedian(const Image &image, Filter::FixedFilterSize maskType)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          return CVB_CALL_CAPI(FilterMedianColor(image.Handle(), static_cast<CExports::TFilterMask>(maskType), resimg));
        });
      }


      inline std::unique_ptr<Image> Wiener(const Image &image, Size2D<int> maskSize, Point2D<int> maskOffset,
                                           double noiseThreshold = 0.0)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          return CVB_CALL_CAPI(FilterWiener(image.Handle(), maskSize.Width(), maskSize.Height(), maskOffset.X(),
                                            maskOffset.Y(), noiseThreshold, resimg));
        });
      }


      inline std::unique_ptr<Image> Wiener(const Image &image, Size2D<int> maskSize, double noiseThreshold = 0.0)
      {
        return Wiener(image, maskSize, Point2D<int>(maskSize.Width() / 2, maskSize.Height() / 2), noiseThreshold);
      }


      inline std::unique_ptr<Image> Prewitt(const Image &image, Filter::FilterOrientation orientation)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          if (orientation == FilterOrientation::Horizontal)
          {
            return CVB_CALL_CAPI(FilterPrewittHorizontal(image.Handle(), resimg));
          }
          else if (orientation == FilterOrientation::Vertical)
          {
            return CVB_CALL_CAPI(FilterPrewittVertical(image.Handle(), resimg));
          }
          else
          {
            throw std::invalid_argument("unknown filter orientation requested");
          }
        });
      }


      inline std::unique_ptr<Image> Scharr(const Image &image, Filter::FilterOrientation orientation)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          if (orientation == FilterOrientation::Horizontal)
          {
            return CVB_CALL_CAPI(FilterScharrHorizontal(image.Handle(), resimg));
          }
          else if (orientation == FilterOrientation::Vertical)
          {
            return CVB_CALL_CAPI(FilterScharrVertical(image.Handle(), resimg));
          }
          else
          {
            throw std::invalid_argument("unknown filter orientation requested");
          }
        });
      }


      inline std::unique_ptr<Image> Sobel(const Image &image, Filter::FilterOrientation orientation,
                                          Filter::FixedFilterSize maskSize)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          if (orientation == FilterOrientation::Horizontal)
          {
            return CVB_CALL_CAPI(
                FilterSobelHorizontal(image.Handle(), static_cast<CExports::TFilterMask>(maskSize), resimg));
          }
          else if (orientation == FilterOrientation::Vertical)
          {
            return CVB_CALL_CAPI(
                FilterSobelVertical(image.Handle(), static_cast<CExports::TFilterMask>(maskSize), resimg));
          }
          else
          {
            throw std::invalid_argument("unknown filter orientation requested");
          }
        });
      }


      inline std::unique_ptr<Image> Sobel2nd(const Image &image, Filter::FilterOrientation orientation,
                                             Filter::FixedFilterSize maskSize)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          if (orientation == FilterOrientation::Horizontal)
          {
            return CVB_CALL_CAPI(
                FilterSobelHorizontal2ndOrder(image.Handle(), static_cast<CExports::TFilterMask>(maskSize), resimg));
          }
          else if (orientation == FilterOrientation::Vertical)
          {
            return CVB_CALL_CAPI(
                FilterSobelVertical2ndOrder(image.Handle(), static_cast<CExports::TFilterMask>(maskSize), resimg));
          }
          else
          {
            throw std::invalid_argument("unknown filter orientation requested");
          }
        });
      }


      inline std::unique_ptr<Image> Sobel2ndCross(const Image &image, Filter::FixedFilterSize maskSize)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          return CVB_CALL_CAPI(FilterSobelCross(image.Handle(), static_cast<CExports::TFilterMask>(maskSize), resimg));
        });
      }


      inline std::unique_ptr<Image> Roberts(const Image &image, Filter::RobertsDirection direction)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          if (direction == RobertsDirection::Down)
          {
            return CVB_CALL_CAPI(FilterRobertsDown(image.Handle(), resimg));
          }
          else if (direction == RobertsDirection::Up)
          {
            return CVB_CALL_CAPI(FilterRobertsUp(image.Handle(), resimg));
          }
          else
          {
            throw std::invalid_argument("unknown filter direction requested");
          }
        });
      }
 
    } /* namespace Filter */
 
    using Filter::EdgeFilter;
    using Filter::FilterOrientation;
    using Filter::FixedFilterSize;
    using Filter::RobertsDirection;
 
    using Filter::BoxMax;
    using Filter::BoxMean;
    using Filter::BoxMedian;
    using Filter::BoxMin;
    using Filter::Canny;
    using Filter::ColorMedian;
    using Filter::Gauss;
    using Filter::HighPass;
    using Filter::Laplace;
    using Filter::LowPass;
    using Filter::Prewitt;
    using Filter::Roberts;
    using Filter::Scharr;
    using Filter::Sharpen;
    using Filter::Sobel;
    using Filter::Sobel2nd;
    using Filter::Sobel2ndCross;
    using Filter::Wiener;
 
  } /* namespace Foundation */
  CVB_END_INLINE_NS
} /* namespace Cvb */
 
#endif