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
 
}