descriptors.hpp

Go to the documentation of this file.

#pragma once
 
#include <cpp-toolbox/pcl/descriptors/base_descriptor_extractor.hpp>
#include <cpp-toolbox/pcl/descriptors/fpfh_extractor.hpp>
#include <cpp-toolbox/pcl/descriptors/pfh_extractor.hpp>
#include <cpp-toolbox/pcl/descriptors/shot_extractor.hpp>
#include <cpp-toolbox/pcl/descriptors/vfh_extractor.hpp>
#include <cpp-toolbox/pcl/descriptors/3dsc_extractor.hpp>
#include <cpp-toolbox/pcl/descriptors/cvfh_extractor.hpp>
#include <cpp-toolbox/pcl/descriptors/rops_extractor.hpp>
 
namespace toolbox::pcl
{
 
template<typename Signature>
std::vector<std::pair<size_t, size_t>> match_descriptors(
    const std::vector<Signature>& source_descriptors,
    const std::vector<Signature>& target_descriptors,
    typename Signature::data_type max_distance)
{
    std::vector<std::pair<size_t, size_t>> matches;
    
    for (size_t i = 0; i < source_descriptors.size(); ++i) {
        typename Signature::data_type min_dist = std::numeric_limits<typename Signature::data_type>::max();
        size_t best_match = 0;
        
        for (size_t j = 0; j < target_descriptors.size(); ++j) {
            auto dist = source_descriptors[i].distance(target_descriptors[j]);
            if (dist < min_dist) {
                min_dist = dist;
                best_match = j;
            }
        }
        
        if (min_dist < max_distance) {
            matches.emplace_back(i, best_match);
        }
    }
    
    return matches;
}
 
template<typename Signature>
std::vector<std::pair<size_t, size_t>> match_descriptors_ratio_test(
    const std::vector<Signature>& source_descriptors,
    const std::vector<Signature>& target_descriptors,
    float ratio_threshold = 0.8f)
{
    std::vector<std::pair<size_t, size_t>> matches;
    
    for (size_t i = 0; i < source_descriptors.size(); ++i) {
        typename Signature::data_type best_dist = std::numeric_limits<typename Signature::data_type>::max();
        typename Signature::data_type second_best_dist = std::numeric_limits<typename Signature::data_type>::max();
        size_t best_match = 0;
        
        // 找到最佳和次佳匹配 / Find best and second-best matches
        for (size_t j = 0; j < target_descriptors.size(); ++j) {
            auto dist = source_descriptors[i].distance(target_descriptors[j]);
            if (dist < best_dist) {
                second_best_dist = best_dist;
                best_dist = dist;
                best_match = j;
            } else if (dist < second_best_dist) {
                second_best_dist = dist;
            }
        }
        
        // 应用比率测试 / Apply ratio test
        if (best_dist < ratio_threshold * second_best_dist) {
            matches.emplace_back(i, best_match);
        }
    }
    
    return matches;
}
 
template<typename Signature>
Signature compute_descriptor_centroid(const std::vector<Signature>& descriptors) {
    if (descriptors.empty()) {
        return Signature{};
    }
    
    // 这里需要根据具体的Signature类型实现 / Implementation depends on specific Signature type
    // 示例实现适用于具有histogram成员的签名 / Example implementation for signatures with histogram member
    Signature centroid = descriptors[0];
    
    // 具体实现依赖于描述子类型 / Specific implementation depends on descriptor type
    // 通常需要对所有维度求平均 / Usually need to average all dimensions
    
    return centroid;
}
 
template<typename Signature>
std::pair<float, float> evaluate_descriptor_matching(
    const std::vector<Signature>& descriptors1,
    const std::vector<Signature>& descriptors2,
    const std::vector<std::pair<size_t, size_t>>& ground_truth_matches,
    typename Signature::data_type max_distance)
{
    auto predicted_matches = match_descriptors(descriptors1, descriptors2, max_distance);
    
    // 转换为set以便快速查找 / Convert to set for fast lookup
    std::set<std::pair<size_t, size_t>> gt_set(
        ground_truth_matches.begin(), ground_truth_matches.end());
    
    int true_positives = 0;
    for (const auto& match : predicted_matches) {
        if (gt_set.count(match) > 0) {
            true_positives++;
        }
    }
    
    float precision = predicted_matches.empty() ? 0.0f : 
        static_cast<float>(true_positives) / predicted_matches.size();
    float recall = ground_truth_matches.empty() ? 0.0f : 
        static_cast<float>(true_positives) / ground_truth_matches.size();
    
    return {precision, recall};
}
 
 
}  // namespace toolbox::pcl