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 BlobBorderFilter : std::uint32_t
{
  None = 0,
  Right = 1,
  Top = 2,
  Left = 4,
  Bottom = 8,
  All = 15
};
 
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_;
};
 
}
 
 
class BlobResult final
{
  friend class Internal::BlobAnalyzer;
 
  public:
 
    BlobResult() noexcept
      : boundingBox_(Rect<int>())
    {}
 
 
 
    double X() const noexcept
    {
      return center_.X();
    }
 
 
    double Y() const noexcept
    {
      return center_.Y();
    }
 
 
    Point2D<double> Center() const noexcept
    {
      return center_;
    }
 
 
    double Size() const noexcept
    {
      return size_;
    }
 
 
    Rect<int> BoundingBox() const noexcept
    {
      return boundingBox_;
    }
 
 
    double MinimumMoment() const noexcept
    {
      return minimumMoment_;
    }
 
 
    double MaximumMoment() const noexcept
    {
      return maximumMoment_;
    }
 
 
    double MomentRatio() const noexcept
    {
      return momentRatio_;
    }
 
 
    Angle MomentAngle() const noexcept
    {
      return momentAngle_;
    }
 
 
    std::vector<Point2D<int>> MinimumMomentPoints() const
    {
      return minimummomentPoints_;
    }
 
  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_;
 
};
 
 
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_;
    }
 
 
    void SetBorderFilter(Cvb::Foundation::Blob::BlobBorderFilter borderFilter) noexcept
    {
      borderFilter_ = borderFilter;
    }
 
 
    bool ContainsRangeFilter(BlobRangeFilter rangeFilter) const noexcept
    {
      return rangeFilters_.find(rangeFilter) != rangeFilters_.end();
    }
 
 
 
 
    ValueRange<int>& operator[](BlobRangeFilter rangeFilter)
    {
      return rangeFilters_[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_;
};
 
 
 
 
 
 
 
 
 
 
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, 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, ValueRange<int> binarizationThreshold, const BlobFilter & filter)
{
  Internal::BlobAnalyzer analyzer(plane);
  analyzer.SetBinarizationRange(binarizationThreshold);
  filter.Apply(analyzer);
  return analyzer.Run();
}
 
 
 
 
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> SearchBlobs(const Image & binarizedImage)
{
  Internal::BlobAnalyzer analyzer(binarizedImage.Plane(0));
  analyzer.SetSkipBinarzation(true);
  return analyzer.Run();
}
 
 
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, 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, Rect<int> aoi, const BlobFilter & filter)
{
  Internal::BlobAnalyzer analyzer(binarizedImage.Plane(0));
  analyzer.SetSkipBinarzation(true);
  analyzer.SetAOI(aoi);
  filter.Apply(analyzer);
  return analyzer.Run();
}
 
 
}
 
using Blob::BlobRangeFilter;
using Blob::BlobBorderFilter;
using Blob::BlobResult;
using Blob::BlobFilter;
using Blob::BinarizeAndSearchBlobs;
using Blob::SearchBlobs;
 
 
 
 
}
 
 
 
 
CVB_END_INLINE_NS
 
}
 
#endif