moments.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 "../rect.hpp"
 
#include <memory>
 
namespace Cvb
{
CVB_BEGIN_INLINE_NS
 
 
namespace Foundation { namespace Moments { class ImageMoments; } }
 
template <>
inline HandleGuard<Foundation::Moments::ImageMoments>::HandleGuard(void * handle) noexcept
  : HandleGuard<Foundation::Moments::ImageMoments>(handle, [](void* h) { CVB_CALL_CAPI(ReleaseObject(h)); })
{
}
 
 
namespace Foundation
{
 
 
namespace Moments
{
 
enum class MomentsCalculation
{
  FavorNone = CExports::MC_FavorNone,
  FavorSpeed = CExports::MC_FavorSpeed,
  FavorAccuracy = CExports::MC_FavorAccuracy
};
 
 
enum class MomentsOrder
{
  Order0 = 0,
  Order1 = 1,
  Order2 = 2,
  Order3 = 3
};
 
enum class MomentsNormalization
{
  Unnormalized,
  Normalized
};
 
 
struct HuMoments
{
double M1;
 
double M2;
 
double M3;
 
double M4;
 
double M5;
 
double M6;
 
double M7;
}; /* HuMoments */
 
 
class ImageMoments
{
public:
 
  ImageMoments (const ImagePlane & imagePlane, Rect<int> aoi, MomentsCalculation preference = MomentsCalculation::FavorNone)
    : handle_(nullptr),
      calculationPreference_ (preference),
      lastOffset_ (aoi.Location ())
  {
    auto h = CVB_CALL_CAPI(CreateImageMoments(static_cast<CExports::TMomentsCalculation>(preference)));
    if (!h)
    {
      Utilities::SystemInfo::ThrowLastError ();
    }
    handle_.Reset(h);
 
    CVB_CALL_CAPI_CHECKED (CalculateMoments(imagePlane.Parent().Handle(), imagePlane.Plane(),
                                            aoi.Left(), aoi.Top(), aoi.Right(), aoi.Bottom(), h));
  }
 
 
  ImageMoments (const ImagePlane & imagePlane, MomentsCalculation preference = MomentsCalculation::FavorNone)
    : ImageMoments (imagePlane, imagePlane.Parent ().Bounds (), preference)
  { }
 
  ImageMoments (ImageMoments&&) noexcept = default;
 
  ImageMoments& operator=(ImageMoments&&) noexcept = default;
 
public:
 
  static std::unique_ptr<ImageMoments> Calculate (const ImagePlane & imagePlane, Rect<int> aoi, MomentsCalculation preference = MomentsCalculation::FavorNone)
  {
    return std::unique_ptr<ImageMoments>(new ImageMoments(imagePlane, aoi, preference));
  }
 
 
  static std::unique_ptr<ImageMoments> Calculate (const ImagePlane & imagePlane, MomentsCalculation preference = MomentsCalculation::FavorNone)
  {
    return std::unique_ptr<ImageMoments>(new ImageMoments(imagePlane, preference));
  }
 
 
  MomentsCalculation CalculationPreference () const noexcept
  {
    return calculationPreference_;
  }
 
 
  void * Handle() const noexcept
  {
    return handle_.Handle();
  }
 
 
 
 
  double SpatialMoment (MomentsOrder xOrder, MomentsOrder yOrder, MomentsNormalization normalization, Point2D<int> offset)
  {
    double moment;
    CVB_CALL_CAPI_CHECKED (GetSpatialImageMoment(Handle(), static_cast<int>(xOrder), static_cast<int>(yOrder),
                                                 offset.X(), offset.Y(), normalization == MomentsNormalization::Normalized, moment));
    return moment;
  }
 
 
  double SpatialMoment (MomentsOrder xOrder, MomentsOrder yOrder, MomentsNormalization normalization)
  {
    return SpatialMoment (xOrder, yOrder, normalization, lastOffset_);
  }
 
 
  double CentralMoment (MomentsOrder xOrder, MomentsOrder yOrder, MomentsNormalization normalization)
  {
    double moment;
    CVB_CALL_CAPI_CHECKED (GetCentralImageMoment(Handle(), static_cast<int>(xOrder), static_cast<int>(yOrder),
                                                 normalization == MomentsNormalization::Normalized, moment));
    return moment;
  }
 
 
  HuMoments HuMoments ()
  {
    double m1, m2, m3, m4, m5, m6, m7;
    CVB_CALL_CAPI_CHECKED (GetHuImageMoments(Handle(), m1, m2, m3, m4, m5, m6, m7));
    typedef struct HuMoments HuMomentsType;
    return HuMomentsType{m1, m2, m3, m4, m5, m6, m7};
  }
 
private:
  HandleGuard<ImageMoments> handle_;
  MomentsCalculation calculationPreference_;
  Point2D<int> lastOffset_;
}; /* ImageMoments */
 
typedef std::shared_ptr<ImageMoments> ImageMomentsPtr;
 
} /* namespace Moments */
 
using Moments::MomentsCalculation;
using Moments::MomentsOrder;
using Moments::MomentsNormalization;
 
using Moments::HuMoments;
using Moments::ImageMoments;
using Moments::ImageMomentsPtr;
 
} /* namespace Foundation */
CVB_END_INLINE_NS
} /* namespace Cvb */
 
#endif