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
  {

    enum class CorrespondenceType
    {
      ClassicICP = CExports::CVM3DCT_ClassicICP,

      ConsensusICP = CExports::CVM3DCT_ConsensusICP
    };
    enum class CorrespondenceType {…};
 
    class MatchingParameters;
    class MatchingResult;
 
    inline MatchingResult IcpMatch(const PointCloud &scene, const PointCloud &model,
                                   const MatchingParameters &parameters);

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

      MatchingParameters() noexcept {}


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


      MatchingParameters(std::size_t maxScenePoints, std::size_t maxModelPoints, int maxIterations, double tolerance,
                         double minImprovement, double correspondenceThreshold, double convergenceRadius, bool prealign,
                         CorrespondenceType correspondenceMethod) noexcept
      {
        SetMaxModelPoints(maxModelPoints);
        SetMaxScenePoints(maxScenePoints);
 
        params_.major = static_cast<Cvb::CExports::cvbint32_t>(0);
        params_.minor = static_cast<Cvb::CExports::cvbint32_t>(1);
        SetMaxIterations(maxIterations);
        SetTolerance(tolerance);
        SetMinImprovement(minImprovement);
        SetCorrespondenceThreshold(correspondenceThreshold);
        SetConvergenceRadius(convergenceRadius);
        SetPrealign(prealign);
        SetCorrespondenceMethod(correspondenceMethod);
      }
      MatchingParameters(std::size_t maxScenePoints, std::size_t maxModelPoints, int maxIterations, double tolerance, {…}


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


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


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


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


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


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


      double Tolerance() const noexcept
      {
        return params_.Tolerance;
      }
      double Tolerance() const noexcept {…}


      void SetTolerance(double value) noexcept
      {
        params_.Tolerance = value;
      }
      void SetTolerance(double value) noexcept {…}


      double MinImprovement() const noexcept
      {
        return params_.MinImprovement;
      }
      double MinImprovement() const noexcept {…}


      void SetMinImprovement(double value) noexcept
      {
        params_.MinImprovement = value;
      }
      void SetMinImprovement(double value) noexcept {…}


      double CorrespondenceThreshold() const noexcept
      {
        return params_.CorrespondenceThreshold;
      }
      double CorrespondenceThreshold() const noexcept {…}


      void SetCorrespondenceThreshold(double value) noexcept
      {
        params_.CorrespondenceThreshold = value;
      }
      void SetCorrespondenceThreshold(double value) noexcept {…}


      double ConvergenceRadius() const noexcept
      {
        return params_.ConvergenceRadius;
      }
      double ConvergenceRadius() const noexcept {…}


      void SetConvergenceRadius(double value) noexcept
      {
        params_.ConvergenceRadius = value;
      }
      void SetConvergenceRadius(double value) noexcept {…}


      bool Prealign() const noexcept
      {
        return static_cast<bool>(params_.Prealign);
      }
      bool Prealign() const noexcept {…}


      void SetPrealign(bool value) noexcept
      {
        params_.Prealign = static_cast<Cvb::CExports::cvbbool_t>(value);
      }
      void SetPrealign(bool value) noexcept {…}


      CorrespondenceType CorrespondenceMethod() const noexcept
      {
        return static_cast<CorrespondenceType>(params_.CorrespondenceMethod);
      }
      CorrespondenceType CorrespondenceMethod() const noexcept {…}


      void SetCorrespondenceMethod(CorrespondenceType value) noexcept
      {
        params_.CorrespondenceMethod = static_cast<Cvb::CExports::CVM3DCorrespondenceType>(value);
      }
      void SetCorrespondenceMethod(CorrespondenceType value) noexcept {…}
 
    private:
      std::int64_t maxModelPoints_ = 0;
      std::int64_t maxScenePoints_ = 0;
 
      CExports::CVM3DMatchParameters params_ = CExports::CVM3DDefaultParameters;
    };
    class MatchingParameters final {…};

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

      double DistanceRMS() const noexcept
      {
        return rmsDistance_;
      }
      double DistanceRMS() const noexcept {…}


      AffineMatrix3D Transformation() const noexcept
      {
        return transformation_;
      }
      AffineMatrix3D Transformation() const noexcept {…}


      int NumIterations() const noexcept
      {
        return numIterations_;
      }
      int NumIterations() const noexcept {…}
 
    private:
      MatchingResult() noexcept = default;
 
      double rmsDistance_               = std::numeric_limits<double>::quiet_NaN();
      CExports::cvbval_t numIterations_ = 0;
      AffineMatrix3D transformation_;
    };
    class MatchingResult final {…};


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


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