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> Load(const String &fileName) {…}


      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{});
      }
      static std::unique_ptr<Finder> FromHandle(HandleGuard<Finder> &&guard) {…}


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


      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;
      }
      std::vector<SearchResult> Find(const DensePointCloud &pointCloud, const SearchParameters &parameters) {…}


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


      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);
      }
      std::tuple<TeachParameters, double, double> GetTeachParameters() {…}
 
    private:
      HandleGuard<Finder> handle_;
    };
    class Finder final {…};
 
  }  // namespace Dnc
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb