match_3d.hpp

#pragma once

#include "../_cexports/c_match_3d.h"

#include "../affine_matrix_3d.hpp"
#include "../global.hpp"
#include "../point_cloud.hpp"

namespace Cvb
{

CVB_BEGIN_INLINE_NS


namespace Match3D
{

class MatchingParameters;
class MatchingResult;

inline MatchingResult
MatchDownSampledPointClouds(const PointCloud &model, const PointCloud &scene, const MatchingParameters &parameters);

class MatchingParameters final
{
  friend MatchingResult
  MatchDownsampledPointClouds(const PointCloud &model, const PointCloud &scene, const MatchingParameters &parameters);

public:

  MatchingParameters(std::size_t maxModelPoints, std::size_t maxScenePoints) noexcept
  {
    SetMaxModelPoints(maxModelPoints);
    SetMaxScenePoints(maxScenePoints);
  }


  MatchingParameters(std::size_t maxModelPoints,
                     std::size_t maxScenePoints,
                     int maxIterations,
                     double maxDistanceStdDev,
                     double deltaThresholdRMS) noexcept
  {
    SetMaxModelPoints(maxModelPoints);
    SetMaxScenePoints(maxScenePoints);
    SetMaxIterations(maxIterations);
    SetMaxDistanceStdDev(maxDistanceStdDev);
    SetDeltaThresholdRMS(deltaThresholdRMS);
  }


  std::size_t MaxModelPoints() const noexcept { return static_cast<std::size_t>(maxModelPoints_); }


  void SetMaxModelPoints(std::size_t maxModelPoints) noexcept
  {
    maxModelPoints_ = static_cast<std::int64_t>(maxModelPoints);
  }


  std::size_t MaxScenePoints() const noexcept { return static_cast<std::size_t>(maxScenePoints_); }


  void SetMaxScenePoints(std::size_t maxScenePoints) noexcept
  {
    maxScenePoints_ = static_cast<std::int64_t>(maxScenePoints);
  }


  int MaxIterations() const noexcept { return static_cast<int>(params_.MaxIterations); }


  void SetMaxIterations(int maxIterations) noexcept
  {
    params_.MaxIterations = static_cast<CExports::cvbval_t>(maxIterations);
  }


  double MaxDistanceStdDev() const noexcept { return params_.MaxDistanceStdDev; }


  void SetMaxDistanceStdDev(double maxDistanceStdDev) noexcept { params_.MaxDistanceStdDev = maxDistanceStdDev; }


  double DeltaThresholdRMS() const noexcept { return params_.DeltaRmsThreshold; }


  void SetDeltaThresholdRMS(double deltaThresholdRMS) noexcept { params_.DeltaRmsThreshold = deltaThresholdRMS; }

private:
  std::int64_t maxModelPoints_;
  std::int64_t maxScenePoints_;

  CExports::CVM3DMatchParameters params_ = CExports::CVM3DDefaultParameters;
};

class MatchingResult final
{
  friend MatchingResult
  MatchDownsampledPointClouds(const PointCloud &model, const PointCloud &scene, const MatchingParameters &parameters);

public:

  double DistanceRMS() const noexcept { return rmsDistance_; }


  AffineMatrix3D Transformation() const noexcept { return transformation_; }


  int NumIterations() const noexcept { return numIterations_; }

private:
  MatchingResult() noexcept = default;

  double rmsDistance_;
  CExports::cvbval_t numIterations_;
  AffineMatrix3D transformation_;
};


inline MatchingResult
MatchDownsampledPointClouds(const PointCloud &model, const PointCloud &scene, const MatchingParameters &parameters)
{
  MatchingResult result;
  Internal::DoResCall([&]() {
    return CVB_CALL_CAPI(
        CVM3DMatchDownsampledPointClouds(model.Handle(),
                                         parameters.maxModelPoints_,
                                         scene.Handle(),
                                         parameters.maxScenePoints_,
                                         parameters.params_,
                                         result.rmsDistance_,
                                         result.numIterations_,
                                         *reinterpret_cast<CExports::CVC3DTransformation *>(&result.transformation_)));
  });
  return result;
}


inline double DistanceRMS(const PointCloud &model, const PointCloud &scene)
{
  return Internal::DoResCallValueOut<double>([&](double &value) {
    return CVB_CALL_CAPI(CVM3DRmsDistanceOfPointClouds(model.Handle(), scene.Handle(), value));
  });
}

}

CVB_END_INLINE_NS

}