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
 
}