pcd.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;  // Assuming point_t is also in types namespace
 
class CPP_TOOLBOX_EXPORT pcd_format_t final : public base_file_format_t
{
private:
  // --- Internal Helper Structs/Enums ---
 
  struct pcd_header_t
  {
    std::string version; 
    std::vector<std::string> fields; 
    std::vector<char>
        types; 
    std::vector<size_t> sizes; 
    std::vector<size_t> counts; 
    size_t width =
        0; 
    size_t height =
        0; 
    std::array<double, 7> viewpoint {
        0,
        0,
        0,
        1,
        0,
        0,
        0};
    size_t points = 0; 
    enum class data_type_t : uint8_t
    {
      ASCII, 
      BINARY, 
      BINARY_COMPRESSED, 
      UNKNOWN 
    } data_type = data_type_t::UNKNOWN; 
    size_t point_step = 0; 
    size_t header_length = 0; 
    std::map<std::string, size_t> m_field_indices;
 
    struct field_info_t
    {
      char type; 
      size_t size; 
      size_t count; 
      size_t offset; 
    };
 
    bool parse_line(const std::string& line);
 
    void calculate_point_step_and_indices();
 
    [[nodiscard]] std::optional<field_info_t> get_field_info(
        const std::string& field_name) const;
 
    [[nodiscard]] bool validate(size_t file_size_bytes) const;
  };
 
public:
  explicit pcd_format_t() = default;
 
  ~pcd_format_t() override = default;
 
  // 禁用复制，继承移动操作/Disable copy, inherit move operations
  pcd_format_t(const pcd_format_t&) = delete;
  pcd_format_t& operator=(const pcd_format_t&) = delete;
  // pcd_format_t(pcd_format_t&&) = default; // 继承的足够了/Inherited is fine
  // pcd_format_t& operator=(pcd_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;
 
  static bool parse_header_stream(std::istream& stream,
                                  pcd_header_t& header,
                                  size_t& header_end_pos);
 
  template<typename T>
  static bool read_ascii_data(std::istream& stream,
                              const pcd_header_t& header,
                              point_cloud_t<T>& cloud);
 
  template<typename T>
  static bool read_binary_data(const std::string& path,
                               const pcd_header_t& header,
                               point_cloud_t<T>& cloud);
 
  template<typename PointStorageT>
  static bool parse_ascii_point_line(const std::string& line,
                                     const pcd_header_t& header,
                                     point_t<PointStorageT>& point,
                                     point_t<PointStorageT>* normal = nullptr,
                                     point_t<PointStorageT>* color = nullptr);
 
  template<typename DestT, typename PCDT>
  static bool read_binary_field_value(const unsigned char* point_ptr,
                                      size_t offset,
                                      DestT& out_val);
 
};  // class pcd_format_t
 
template<typename T>
CPP_TOOLBOX_EXPORT std::unique_ptr<toolbox::types::point_cloud_t<T>> read_pcd(
    const std::string& path);
 
template<typename T>
CPP_TOOLBOX_EXPORT bool write_pcd(const std::string& path,
                                  const toolbox::types::point_cloud_t<T>& cloud,
                                  bool binary);
 
}  // namespace toolbox::io
 
#include <cpp-toolbox/io/formats/detail/pcd_impl.hpp>