analysis.hpp

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


    namespace Analysis
    {


      inline void LocalEigenValuesAndVectors(const ImagePlane &plane, Filter::FixedFilterSize derivatorSize,
                                             Filter::FixedFilterSize blurSize, std::unique_ptr<Image> &lambda1,
                                             std::unique_ptr<Image> &lambda2, std::unique_ptr<Image> &eigenValue1x,
                                             std::unique_ptr<Image> &eigenValue1y, std::unique_ptr<Image> &eigenValue2x,
                                             std::unique_ptr<Image> &eigenValue2y)
      {
        CExports::IMG hl1 = nullptr;
        CExports::IMG hl2 = nullptr;
        CExports::IMG hev1x = nullptr;
        CExports::IMG hev1y = nullptr;
        CExports::IMG hev2x = nullptr;
        CExports::IMG hev2y = nullptr;
        CVB_CALL_CAPI_CHECKED(LocalEigenValuesAndVectors(
            plane.Parent().Handle(), plane.Plane(), static_cast<CExports::TFilterMask>(derivatorSize),
            static_cast<CExports::TFilterMask>(blurSize), hl1, hl2, hev1x, hev1y, hev2x, hev2y));
 
        HandleGuard<Image> gl1(hl1);
        HandleGuard<Image> gl2(hl2);
        HandleGuard<Image> gev1x(hev1x);
        HandleGuard<Image> gev1y(hev1y);
        HandleGuard<Image> gev2x(hev2x);
        HandleGuard<Image> gev2y(hev2y);
 
        auto l1   = Image::FromHandle(std::move(gl1));
        auto l2   = Image::FromHandle(std::move(gl2));
        auto ev1x = Image::FromHandle(std::move(gev1x));
        auto ev1y = Image::FromHandle(std::move(gev1y));
        auto ev2x = Image::FromHandle(std::move(gev2x));
        auto ev2y = Image::FromHandle(std::move(gev2y));
 
        lambda1      = std::move(l1);
        lambda2      = std::move(l2);
        eigenValue1x = std::move(ev1x);
        eigenValue1y = std::move(ev1y);
        eigenValue2x = std::move(ev2x);
        eigenValue2y = std::move(ev2y);
      }


      inline std::unique_ptr<Image> LocalMinEigenValues(const ImagePlane &plane, Filter::FixedFilterSize derivatorSize,
                                                        Filter::FixedFilterSize blurSize)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          return CVB_CALL_CAPI(LocalMinEigenValues(plane.Parent().Handle(), plane.Plane(),
                                                   static_cast<CExports::TFilterMask>(derivatorSize),
                                                   static_cast<CExports::TFilterMask>(blurSize), resimg));
        });
      }


      inline double WangQuality(const ImagePlane &plane1, const ImagePlane &plane2)
      {
        double quality = 0;
        CVB_CALL_CAPI_CHECKED(WangImageQuality(plane1.Parent().Handle(), plane1.Plane(), plane2.Parent().Handle(),
                                               plane2.Plane(), quality));
        return quality;
      }
 
    } /* namespace Analysis */
 
    using Analysis::LocalEigenValuesAndVectors;
    using Analysis::LocalMinEigenValues;
    using Analysis::WangQuality;
 
  } /* namespace Foundation */
  CVB_END_INLINE_NS
} /* namespace Cvb */
 
#endif