blob.hpp

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


    namespace Blob
    {

      enum class BlobRangeFilter
      {
        Size,
        Width,
        Height
      };
      enum class BlobRangeFilter {…};


      enum class BlobBorderFilter : std::uint32_t
      {
        None = 0,
        Right = 1,
        Top = 2,
        Left = 4,
        Bottom = 8,
        All = 15
      };
      enum class BlobBorderFilter : std::uint32_t {…};
 
      inline BlobBorderFilter operator|(BlobBorderFilter a, BlobBorderFilter b)
      {
        return static_cast<BlobBorderFilter>(static_cast<std::uint32_t>(a) | static_cast<std::uint32_t>(b));
      }
 
      class BlobResult;
      class BlobFilter;
 
      inline std::vector<BlobResult> BinarizeAndSearchBlobs(const ImagePlane &plane,
                                                            ValueRange<int> binarizationThreshold);
      inline std::vector<BlobResult> BinarizeAndSearchBlobs(const ImagePlane &plane,
                                                            ValueRange<int> binarizationThreshold, Rect<int> aoi);
      inline std::vector<BlobResult>
      BinarizeAndSearchBlobs(const ImagePlane &plane, ValueRange<int> binarizationThreshold, const BlobFilter &filter);
      inline std::vector<BlobResult> BinarizeAndSearchBlobs(const ImagePlane &plane,
                                                            ValueRange<int> binarizationThreshold, Rect<int> aoi,
                                                            const BlobFilter &filter);
      inline std::vector<BlobResult> SearchBlobs(const Image &binarizedImage);
      inline std::vector<BlobResult> SearchBlobs(const Image &binarizedImage, Rect<int> aoi);
      inline std::vector<BlobResult> SearchBlobs(const Image &binarizedImage, const BlobFilter &filter);
      inline std::vector<BlobResult> SearchBlobs(const Image &binarizedImage, Rect<int> aoi, const BlobFilter &filter);
 
      namespace Internal
      {
 
        class BlobAnalyzer final
        {
          friend class BlobResult;
          friend class BlobFilter;
 
          friend std::vector<BlobResult> Blob::BinarizeAndSearchBlobs(const ImagePlane &plane,
                                                                      ValueRange<int> binarizationThreshold);
          friend std::vector<BlobResult>
          Blob::BinarizeAndSearchBlobs(const ImagePlane &plane, ValueRange<int> binarizationThreshold, Rect<int> aoi);
          friend std::vector<BlobResult> Blob::BinarizeAndSearchBlobs(const ImagePlane &plane,
                                                                      ValueRange<int> binarizationThreshold,
                                                                      const BlobFilter &filter);
          friend std::vector<BlobResult> Blob::BinarizeAndSearchBlobs(const ImagePlane &plane,
                                                                      ValueRange<int> binarizationThreshold,
                                                                      Rect<int> aoi, const BlobFilter &filter);
          friend std::vector<BlobResult> Blob::SearchBlobs(const Image &binarizedImage);
          friend std::vector<BlobResult> Blob::SearchBlobs(const Image &binarizedImage, Rect<int> aoi);
          friend std::vector<BlobResult> Blob::SearchBlobs(const Image &binarizedImage, const BlobFilter &filter);
          friend std::vector<BlobResult> Blob::SearchBlobs(const Image &binarizedImage, Rect<int> aoi,
                                                           const BlobFilter &filter);
 
        private:
          explicit BlobAnalyzer(const ImagePlane &plane)
              : handle_(
                    CExports::FBlobCreate(plane_.Parent().Handle(), static_cast<CExports::cvbdim_t>(plane_.Plane())))
              , plane_(plane)
          {
            if (!handle_.Handle())
              Utilities::SystemInfo::ThrowLastError();
          }
 
          void *Handle() const noexcept
          {
            return handle_.Handle();
          }
 
          void SetAOI(Rect<int> aoi)
          {
            auto result = CVB_CALL_CAPI(FBlobSetArea(
                Handle(), static_cast<CExports::cvbdim_t>(plane_.Plane()), static_cast<CExports::cvbdim_t>(aoi.Left()),
                static_cast<CExports::cvbdim_t>(aoi.Top()), static_cast<CExports::cvbdim_t>(aoi.Right()),
                static_cast<CExports::cvbdim_t>(aoi.Bottom())));
            if (result < 0)
              Utilities::SystemInfo::ThrowLastError(result);
          }
 
          void SetSkipBinarzation(bool skip)
          {
            auto result = CVB_CALL_CAPI(FBlobSetSkipBinarization(Handle(), skip ? 1 : 0));
            if (result < 0)
              Utilities::SystemInfo::ThrowLastError(result);
          }
 
          void SetBorderFilter(BlobBorderFilter borderFilter)
          {
            auto result =
                CVB_CALL_CAPI(FBlobSetObjectTouchBorder(Handle(), static_cast<CExports::cvbval_t>(borderFilter)));
            if (result < 0)
              Utilities::SystemInfo::ThrowLastError(result);
          }
 
          void SetSizeFilter(ValueRange<int> sizeFilter)
          {
            auto result = CVB_CALL_CAPI(FBlobSetLimitArea(Handle(), static_cast<CExports::cvbval_t>(sizeFilter.Min()),
                                                          static_cast<CExports::cvbval_t>(sizeFilter.Max())));
            if (result < 0)
              Utilities::SystemInfo::ThrowLastError(result);
          }
 
          void SetWidthFilter(ValueRange<int> widthFilter)
          {
            auto result = CVB_CALL_CAPI(FBlobSetLimitWidth(Handle(), static_cast<CExports::cvbval_t>(widthFilter.Min()),
                                                           static_cast<CExports::cvbval_t>(widthFilter.Max())));
            if (result < 0)
              Utilities::SystemInfo::ThrowLastError(result);
          }
 
          void SetHeightFilter(ValueRange<int> heightFilter)
          {
            auto result =
                CVB_CALL_CAPI(FBlobSetLimitHeight(Handle(), static_cast<CExports::cvbval_t>(heightFilter.Min()),
                                                  static_cast<CExports::cvbval_t>(heightFilter.Max())));
            if (result < 0)
              Utilities::SystemInfo::ThrowLastError(result);
          }
 
          void SetBinarizationRange(ValueRange<int> binarizationRange)
          {
            auto result = CVB_CALL_CAPI(
                FBlobSetObjectFeatureRange(Handle(), static_cast<CExports::cvbval_t>(binarizationRange.Min()),
                                           static_cast<CExports::cvbval_t>(binarizationRange.Max())));
            if (result < 0)
              Utilities::SystemInfo::ThrowLastError(result);
          }
 
          std::vector<BlobResult> Run();
 
          const ImagePlane &plane_;
 
          ReleaseObjectGuard handle_;
        };
 
      }  // namespace Internal


      class BlobResult final
      {
        friend class Internal::BlobAnalyzer;
 
      public:
        BlobResult() noexcept
            : boundingBox_(Rect<int>())
        {
        }


        double X() const noexcept
        {
          return center_.X();
        }
        double X() const noexcept {…}


        double Y() const noexcept
        {
          return center_.Y();
        }
        double Y() const noexcept {…}


        Point2D<double> Center() const noexcept
        {
          return center_;
        }
        Point2D<double> Center() const noexcept {…}


        double Size() const noexcept
        {
          return size_;
        }
        double Size() const noexcept {…}


        Rect<int> BoundingBox() const noexcept
        {
          return boundingBox_;
        }
        Rect<int> BoundingBox() const noexcept {…}


        double MinimumMoment() const noexcept
        {
          return minimumMoment_;
        }
        double MinimumMoment() const noexcept {…}


        double MaximumMoment() const noexcept
        {
          return maximumMoment_;
        }
        double MaximumMoment() const noexcept {…}


        double MomentRatio() const noexcept
        {
          return momentRatio_;
        }
        double MomentRatio() const noexcept {…}


        Angle MomentAngle() const noexcept
        {
          return momentAngle_;
        }
        Angle MomentAngle() const noexcept {…}


        std::vector<Point2D<int>> MinimumMomentPoints() const
        {
          return minimummomentPoints_;
        }
        std::vector<Point2D<int>> MinimumMomentPoints() const {…}
 
      private:
        BlobResult(const Internal::BlobAnalyzer &analyzer, int index) noexcept
        {
          // for speed reasons (this ctor will be called potentially very
          // often...) there will be no consistency checks here...
          double x = 0.0;
          double y = 0.0;
          CVB_CALL_CAPI(FBlobGetCenterEx(analyzer.Handle(), index, x, y));
          center_ = Point2D<double>(x, y);
 
          CExports::cvbval_t size = 0;
          CVB_CALL_CAPI(FBlobGetSize(analyzer.Handle(), index, size));
          size_ = static_cast<double>(size);
 
          CExports::cvbdim_t left   = 0;
          CExports::cvbdim_t top    = 0;
          CExports::cvbdim_t width  = 0;
          CExports::cvbdim_t height = 0;
          CVB_CALL_CAPI(FBlobGetBoundingBoxEx(analyzer.Handle(), index, left, top, width, height));
          boundingBox_ = Rect<int>(Point2D<int>(static_cast<int>(left), static_cast<int>(top)),
                                   Size2D<int>(static_cast<int>(width), static_cast<int>(height)));
 
          double angleRad = 0.0;
          CVB_CALL_CAPI(
              FBlobGetMoments(analyzer.Handle(), index, minimumMoment_, maximumMoment_, momentRatio_, angleRad));
          momentAngle_ = Angle::FromRadians(angleRad);
 
          CExports::cvbval_t x0 = 0;
          CExports::cvbval_t y0 = 0;
          CExports::cvbval_t x1 = 0;
          CExports::cvbval_t y1 = 0;
          CVB_CALL_CAPI(FBlobGetMinMomentPointsEx(analyzer.Handle(), index, x0, y0, x1, y1));
          minimummomentPoints_ = {Point2D<int>(static_cast<int>(x0), static_cast<int>(y0)),
                                  Point2D<int>(static_cast<int>(x1), static_cast<int>(y1))};
        }
 
        Point2D<double> center_;
        double size_ = 0.0;
        Rect<int> boundingBox_;
        double minimumMoment_ = 0.0;
        double maximumMoment_ = 0.0;
        double momentRatio_   = 0.0;
        Angle momentAngle_;
        std::vector<Point2D<int>> minimummomentPoints_;
      };
      class BlobResult final {…};
 
      inline std::vector<BlobResult> Internal::BlobAnalyzer::Run()
      {
        auto resutlExec = CExports::FBlobExec(Handle());
        if (resutlExec < 0)
          Utilities::SystemInfo::ThrowLastError(resutlExec);
 
        CExports::cvbval_t numBlobs = 0;
        auto resultNumBlobs         = CExports::FBlobGetNumBlobs(Handle(), numBlobs);
        if (resutlExec < 0)
          Utilities::SystemInfo::ThrowLastError(resultNumBlobs);
 
        std::vector<BlobResult> results(static_cast<std::size_t>(numBlobs));
        for (int i = 0; i < static_cast<int>(numBlobs); ++i)
          results[i] = BlobResult(*this, i);
 
        return results;
      }


      class BlobFilter final
      {
        friend std::vector<BlobResult> BinarizeAndSearchBlobs(const ImagePlane &plane,
                                                              ValueRange<int> binarizationThreshold,
                                                              const BlobFilter &filter);
        friend std::vector<BlobResult> BinarizeAndSearchBlobs(const ImagePlane &plane,
                                                              ValueRange<int> binarizationThreshold, Rect<int> aoi,
                                                              const BlobFilter &filter);
        friend std::vector<BlobResult> SearchBlobs(const Image &binarizedImage, const BlobFilter &filter);
        friend std::vector<BlobResult> SearchBlobs(const Image &binarizedImage, Rect<int> aoi,
                                                   const BlobFilter &filter);
 
      public:

        BlobFilter() = default;


        Cvb::Foundation::Blob::BlobBorderFilter BorderFilter() const noexcept
        {
          return borderFilter_;
        }
        Cvb::Foundation::Blob::BlobBorderFilter BorderFilter() const noexcept {…}


        void SetBorderFilter(Cvb::Foundation::Blob::BlobBorderFilter borderFilter) noexcept
        {
          borderFilter_ = borderFilter;
        }
        void SetBorderFilter(Cvb::Foundation::Blob::BlobBorderFilter borderFilter) noexcept {…}


        bool ContainsRangeFilter(BlobRangeFilter rangeFilter) const noexcept
        {
          return rangeFilters_.find(rangeFilter) != rangeFilters_.end();
        }
        bool ContainsRangeFilter(BlobRangeFilter rangeFilter) const noexcept {…}


        ValueRange<int> &operator[](BlobRangeFilter rangeFilter)
        {
          return rangeFilters_[rangeFilter];
        }
        ValueRange<int> &operator[](BlobRangeFilter rangeFilter) {…}
 
      private:
        void Apply(Internal::BlobAnalyzer &analyzer) const
        {
          if (borderFilter_ != Cvb::Foundation::Blob::BlobBorderFilter::None)
            analyzer.SetBorderFilter(borderFilter_);
          if (ContainsRangeFilter(BlobRangeFilter::Size))
            analyzer.SetSizeFilter(rangeFilters_[BlobRangeFilter::Size]);
          if (ContainsRangeFilter(BlobRangeFilter::Width))
            analyzer.SetWidthFilter(rangeFilters_[BlobRangeFilter::Width]);
          if (ContainsRangeFilter(BlobRangeFilter::Height))
            analyzer.SetHeightFilter(rangeFilters_[BlobRangeFilter::Height]);
        }
 
        Cvb::Foundation::Blob::BlobBorderFilter borderFilter_ = Cvb::Foundation::Blob::BlobBorderFilter::None;
        mutable std::map<BlobRangeFilter, ValueRange<int>> rangeFilters_;
      };
      class BlobFilter final {…};


      inline std::vector<BlobResult> BinarizeAndSearchBlobs(const ImagePlane &plane,
                                                            ValueRange<int> binarizationThreshold)
      {
        Internal::BlobAnalyzer analyzer(plane);
        analyzer.SetBinarizationRange(binarizationThreshold);
        return analyzer.Run();
      }
      inline std::vector<BlobResult> BinarizeAndSearchBlobs(const ImagePlane &plane, {…}


      inline std::vector<BlobResult> BinarizeAndSearchBlobs(const ImagePlane &plane,
                                                            ValueRange<int> binarizationThreshold, Rect<int> aoi)
      {
        Internal::BlobAnalyzer analyzer(plane);
        analyzer.SetBinarizationRange(binarizationThreshold);
        analyzer.SetAOI(aoi);
        return analyzer.Run();
      }
      inline std::vector<BlobResult> BinarizeAndSearchBlobs(const ImagePlane &plane, {…}


      inline std::vector<BlobResult>
      BinarizeAndSearchBlobs(const ImagePlane &plane, ValueRange<int> binarizationThreshold, const BlobFilter &filter)
      {
        Internal::BlobAnalyzer analyzer(plane);
        analyzer.SetBinarizationRange(binarizationThreshold);
        filter.Apply(analyzer);
        return analyzer.Run();
      }
      BinarizeAndSearchBlobs(const ImagePlane &plane, ValueRange<int> binarizationThreshold, const BlobFilter &filter) {…}


      inline std::vector<BlobResult> BinarizeAndSearchBlobs(const ImagePlane &plane,
                                                            ValueRange<int> binarizationThreshold, Rect<int> aoi,
                                                            const BlobFilter &filter)
      {
        Internal::BlobAnalyzer analyzer(plane);
        analyzer.SetBinarizationRange(binarizationThreshold);
        analyzer.SetAOI(aoi);
        filter.Apply(analyzer);
        return analyzer.Run();
      }
      inline std::vector<BlobResult> BinarizeAndSearchBlobs(const ImagePlane &plane, {…}


      inline std::vector<BlobResult> SearchBlobs(const Image &binarizedImage)
      {
        Internal::BlobAnalyzer analyzer(binarizedImage.Plane(0));
        analyzer.SetSkipBinarzation(true);
        return analyzer.Run();
      }
      inline std::vector<BlobResult> SearchBlobs(const Image &binarizedImage) {…}


      inline std::vector<BlobResult> SearchBlobs(const Image &binarizedImage, Rect<int> aoi)
      {
        Internal::BlobAnalyzer analyzer(binarizedImage.Plane(0));
        analyzer.SetSkipBinarzation(true);
        analyzer.SetAOI(aoi);
        return analyzer.Run();
      }
      inline std::vector<BlobResult> SearchBlobs(const Image &binarizedImage, Rect<int> aoi) {…}


      inline std::vector<BlobResult> SearchBlobs(const Image &binarizedImage, const BlobFilter &filter)
      {
        Internal::BlobAnalyzer analyzer(binarizedImage.Plane(0));
        analyzer.SetSkipBinarzation(true);
        filter.Apply(analyzer);
        return analyzer.Run();
      }
      inline std::vector<BlobResult> SearchBlobs(const Image &binarizedImage, const BlobFilter &filter) {…}


      inline std::vector<BlobResult> SearchBlobs(const Image &binarizedImage, Rect<int> aoi, const BlobFilter &filter)
      {
        Internal::BlobAnalyzer analyzer(binarizedImage.Plane(0));
        analyzer.SetSkipBinarzation(true);
        analyzer.SetAOI(aoi);
        filter.Apply(analyzer);
        return analyzer.Run();
      }
      inline std::vector<BlobResult> SearchBlobs(const Image &binarizedImage, Rect<int> aoi, const BlobFilter &filter) {…}
 
    }  // namespace Blob
    namespace Blob {…}
 
    using Blob::BinarizeAndSearchBlobs;
    using Blob::BlobBorderFilter;
    using Blob::BlobFilter;
    using Blob::BlobRangeFilter;
    using Blob::BlobResult;
    using Blob::SearchBlobs;
 
  }  // namespace Foundation
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb
 
#endif