finder.hpp

#pragma once

#include "../_cexports/c_dnc_find.h"
#include "../string.hpp"
#include "../dense_point_cloud.hpp"
#include "dnc.hpp"
#include "search_parameters.hpp"
#include "search_result.hpp"
#include "teach_parameters.hpp"

namespace Cvb
{

CVB_BEGIN_INLINE_NS

template <>
inline HandleGuard<Dnc::Finder>::HandleGuard(void* handle) noexcept
  : HandleGuard<Dnc::Finder>(handle, [](void* handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
{
}

namespace Dnc
{


class Finder final
{
  private:

    struct PrivateTag {};

  public:

    Finder(HandleGuard<Finder>&& guard, PrivateTag) noexcept
      : handle_(std::move(guard))
    {
    }


    static std::unique_ptr<Finder> Load(const String& fileName)
    {
      return Internal::DoResCallObjectOut<Finder>([&](void*& handle)
        {
          return CVB_CALL_CAPI(CVDNCCreateFromFileTyped(fileName.c_str(), handle));
        });
    }


    static std::unique_ptr<Finder> FromHandle(HandleGuard<Finder>&& guard)
    {
      if (!guard.Handle())
        throw std::runtime_error("handle must not be null");

      return std::make_unique<Finder>(std::move(guard), PrivateTag{});
    }


    void* Handle() const noexcept
    {
      return handle_.Handle();
    }


    std::vector<SearchResult> Find(const  DensePointCloud& pointCloud, const SearchParameters& parameters)
    {
      CVB_CALL_CAPI_CHECKED(CVDNCSetSearchParams(Handle(), *reinterpret_cast<const CExports::CVDNCSearchParams*>(&parameters)));

      CExports::CVDNCRESULTS resultsHandle = nullptr;
      CVB_CALL_CAPI_CHECKED(CVDNCFind(Handle(), pointCloud.Handle(), resultsHandle));
      ReleaseObjectGuard guard(resultsHandle);

      auto numResults = CExports::CVDNCGetNumResults(resultsHandle);
      std::vector<SearchResult> results(numResults);

      for (auto& result : results)
      {
        int index = static_cast<int>(std::distance(&results.front(), &result));
        CVB_CALL_CAPI_CHECKED(CVDNCGetResult(resultsHandle, index, *reinterpret_cast<CExports::CVDNCResult*>(&result)));
      }

      return results;
    }
    

    void Save(const String& fileName)
    {
      CVB_CALL_CAPI_CHECKED(CVDNCSaveClassifierTyped(Handle(), fileName.c_str()));
    }


    std::tuple<TeachParameters, double, double> GetTeachParameters()
    {
      double resolution = 0.0;
      double fringe = 0.0;
      TeachParameters teachParams;
      Internal::DoResCall([this, &teachParams , &resolution, &fringe]() {
        
        return CVB_CALL_CAPI(CVDNCGetTeachParams(
          Handle(), 
          resolution, 
          fringe, 
          *reinterpret_cast<CExports::CVDNCTeachParams*>(&teachParams)));
        });
      return std::make_tuple(teachParams, resolution, fringe);
    }

  private:

    HandleGuard<Finder> handle_;
};

}

CVB_END_INLINE_NS

}