semantic_kitti_pair_dataset.hpp

Go to the documentation of this file.

#pragma once
 
#include <cpp-toolbox/io/dataset/dataset.hpp>
#include <cpp-toolbox/io/dataset/kitti_types.hpp>
#include <cpp-toolbox/io/dataloader/semantic_kitti_dataset.hpp>
 
#include <memory>
#include <string>
#include <optional>
 
namespace toolbox::io {
 
template<typename DataType = float>
class semantic_kitti_pair_dataset_t : 
    public dataset_t<semantic_kitti_pair_dataset_t<DataType>, 
                     semantic_kitti_frame_pair_t<DataType>> {
public:
    using pair_type = semantic_kitti_frame_pair_t<DataType>;
    using base_type = dataset_t<semantic_kitti_pair_dataset_t<DataType>, pair_type>;
    
    explicit semantic_kitti_pair_dataset_t(const std::string& sequence_path, 
                                          std::size_t skip = 1);
    
    void set_skip(std::size_t skip) { 
        skip_ = skip;
        // Clear cache as pairs have changed
        pair_cache_.clear();
    }
    
    [[nodiscard]] std::size_t get_skip() const { return skip_; }
    
    void set_cache_size(std::size_t size) {
        max_cache_size_ = size;
        base_dataset_.set_cache_size(size * 2); // Cache more frames
        // Trim cache if needed
        while (pair_cache_.size() > max_cache_size_) {
            pair_cache_.erase(pair_cache_.begin());
        }
    }
    
    void enable_motion_filter(bool enable) {
        filter_by_motion_ = enable;
    }
    
    void set_motion_thresholds(DataType min_translation, DataType min_rotation) {
        min_translation_ = min_translation;
        min_rotation_ = min_rotation;
    }
    
    // ==================== Dataset Interface ====================
    
    [[nodiscard]] std::size_t size_impl() const {
        const auto num_frames = base_dataset_.size();
        return (num_frames > skip_) ? (num_frames - skip_) : 0;
    }
    
    [[nodiscard]] std::optional<pair_type> at_impl(std::size_t index) const;
    
    // ==================== Additional Functionality ====================
    
    [[nodiscard]] const semantic_kitti_dataset_t<DataType>& 
    get_base_dataset() const { return base_dataset_; }
    
    [[nodiscard]] std::size_t get_source_frame_index(std::size_t pair_index) const {
        return pair_index;
    }
    
    [[nodiscard]] std::size_t get_target_frame_index(std::size_t pair_index) const {
        return pair_index + skip_;
    }
    
    void clear_cache() const {
        pair_cache_.clear();
        base_dataset_.clear_cache();
    }
    
    [[nodiscard]] std::vector<std::size_t> get_pairs_with_labels(
        const std::vector<uint16_t>& require_labels,
        std::size_t min_points = 100) const;
    
    [[nodiscard]] std::map<std::string, DataType> compute_motion_statistics() const;
 
private:
    bool meets_motion_criteria(
        const Eigen::Matrix<DataType, 4, 4>& relative_transform) const;
    
    // ==================== Member Variables ====================
    
    mutable semantic_kitti_dataset_t<DataType> base_dataset_;
    
    std::size_t skip_;
    
    mutable std::map<std::size_t, pair_type> pair_cache_;
    
    std::size_t max_cache_size_ = 30;
    
    bool filter_by_motion_ = false;
    DataType min_translation_ = 0.1;  // meters
    DataType min_rotation_ = 0.01;    // radians
};
 
} // namespace toolbox::io
 
// Include implementation
#include <cpp-toolbox/io/dataloader/impl/semantic_kitti_pair_dataset_impl.hpp>