kitti.hpp

Go to the documentation of this file.

#pragma once
 
#include <array>
#include <cstdint>  // For fixed-width integers
#include <cstring>  // For memcpy
#include <iosfwd>  // Forward declare std::istream
#include <map>
#include <memory>  // unique_ptr
#include <optional>
#include <string>
#include <vector>
 
#include <cpp-toolbox/container/string.hpp>  // For string utilities like ends_with
#include <cpp-toolbox/cpp-toolbox_export.hpp>
#include <cpp-toolbox/file/file.hpp>  // Assuming MemoryMappedFile is here
#include <cpp-toolbox/file/memory_mapped_file.hpp>
#include <cpp-toolbox/io/formats/base.hpp>  // base_file_format_t, base_file_data_t
#include <cpp-toolbox/logger/thread_logger.hpp>
#include <cpp-toolbox/macro.hpp>  // For platform checks if needed directly
#include <cpp-toolbox/types/point.hpp>  // point_cloud_t (inherits base_file_data_t)
 
namespace toolbox::io
{
 
// Forward declare the concrete data type we'll work with
using toolbox::types::point_cloud_t;
using toolbox::types::point_t;
 
class CPP_TOOLBOX_EXPORT kitti_format_t final : public base_file_format_t
{
public:
  explicit kitti_format_t() = default;
 
  ~kitti_format_t() override = default;
 
  // 禁用复制，继承移动操作/Disable copy, inherit move operations
  kitti_format_t(const kitti_format_t&) = delete;
  kitti_format_t& operator=(const kitti_format_t&) = delete;
  // kitti_format_t(kitti_format_t&&) = default; // 继承的足够了/Inherited is
  // fine kitti_format_t& operator=(kitti_format_t&&) = default; //
  // 继承的足够了/Inherited is fine
 
  [[nodiscard]] auto can_read(const std::string& path) const -> bool override;
 
  [[nodiscard]] auto get_supported_extensions() const
      -> std::vector<std::string> override;
 
  auto read(const std::string& path, std::unique_ptr<base_file_data_t>& data)
      -> bool override;
 
  [[nodiscard]] auto write(const std::string& path,
                           const std::unique_ptr<base_file_data_t>& data,
                           bool binary) const -> bool override;
 
private:
  // --- Internal Helper Functions ---
 
  template<typename T>
  bool write_internal(const std::string& path,
                      const point_cloud_t<T>& cloud,
                      bool binary) const;
 
  template<typename T>
  static bool read_binary_data(const std::string& path,
                               point_cloud_t<T>& cloud);
 
};  // class pcd_format_t
 
template<typename T>
CPP_TOOLBOX_EXPORT std::unique_ptr<toolbox::types::point_cloud_t<T>>
read_kitti_bin(const std::string& path);
 
template<typename T>
CPP_TOOLBOX_EXPORT bool write_kitti_bin(
    const std::string& path, const toolbox::types::point_cloud_t<T>& cloud);
 
}  // namespace toolbox::io
 
#include <cpp-toolbox/io/formats/detail/kitti_impl.hpp>