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;
    }
  }  // namespace Foundation
 
  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));
        }


        explicit ImageMoments(const ImagePlane &imagePlane, MomentsCalculation preference = MomentsCalculation::FavorNone)
            : ImageMoments(imagePlane, imagePlane.Parent().Bounds(), preference)
        {
        }

        ImageMoments(ImageMoments &&) noexcept = default;

        ImageMoments &operator=(ImageMoments &&) noexcept = default;
 
        ~ImageMoments() = default;
        ImageMoments()                                = delete;
        ImageMoments(const ImageMoments &)            = delete;
        ImageMoments &operator=(const ImageMoments &) = delete;


        static std::unique_ptr<ImageMoments> Calculate(const ImagePlane &imagePlane, Rect<int> aoi,
                                                       MomentsCalculation preference = MomentsCalculation::FavorNone)
        {
          return std::make_unique<ImageMoments>(imagePlane, aoi, preference);
        }


        static std::unique_ptr<ImageMoments> Calculate(const ImagePlane &imagePlane,
                                                       MomentsCalculation preference = MomentsCalculation::FavorNone)
        {
          return std::make_unique<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 = 0;
          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 = 0;
          CVB_CALL_CAPI_CHECKED(GetCentralImageMoment(Handle(), static_cast<int>(xOrder), static_cast<int>(yOrder),
                                                      normalization == MomentsNormalization::Normalized, moment));
          return moment;
        }


        HuMoments HuMoments()
        {
          double m1 = 0, m2 = 0, m3 = 0, m4 = 0, m5 = 0, m6 = 0, m7 = 0;
          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::MomentsNormalization;
    using Moments::MomentsOrder;
 
    using Moments::HuMoments;
    using Moments::ImageMoments;
    using Moments::ImageMomentsPtr;
 
  } /* namespace Foundation */
  CVB_END_INLINE_NS
} /* namespace Cvb */
 
#endif