point.hpp

Go to the documentation of this file.

#pragma once
 
#include <cmath>
#include <iostream>
#include <limits>
#include <memory>
#include <ostream>
#include <random>
#include <stdexcept>
#include <vector>
 
#include <cpp-toolbox/cpp-toolbox_export.hpp>
#include <cpp-toolbox/io/formats/base.hpp>
 
namespace toolbox::types
{
 
template<typename T>
struct CPP_TOOLBOX_EXPORT point_t
{
  using value_type = T;  
  
  T x;  
  T y;  
  T z;  
 
  // 定义析构函数(五法则/零法则) / Define destructor (Rule of Five/Zero)
  ~point_t() = default;
 
  point_t(T x_coord, T y_coord, T z_coord);
 
  point_t();
 
  point_t(const point_t& other) = default;  
  point_t(point_t&& other) noexcept =
      default;  
 
  point_t& operator=(const point_t& other) =
      default;  
  point_t& operator=(point_t&& other) noexcept =
      default;  
 
  point_t& operator+=(const point_t& other);
 
  point_t& operator-=(const point_t& other);
 
  point_t& operator*=(const T& scalar);
 
  point_t& operator/=(const T& scalar);
 
  [[nodiscard]] auto dot(const point_t& other) const -> T;
 
  [[nodiscard]] auto cross(const point_t& other) const -> point_t;
 
  [[nodiscard]] auto norm() const -> double;
 
  [[nodiscard]] auto normalize() const -> point_t<double>;
 
  [[nodiscard]] auto p_norm(const double& p_value) const -> double;
 
  [[nodiscard]] auto p_normalize(const double& p_value) const
      -> point_t<double>;
 
  [[nodiscard]] auto distance(const point_t& other) const -> double;
 
  [[nodiscard]] auto distance_p(const point_t& other,
                                const double& p_value) const -> double;
 
  // 定义比较运算符 / Define comparison operators
  bool operator==(const point_t& other) const;
 
  bool operator!=(const point_t& other) const;
 
  // 为测试目的添加基本的operator< / Add a basic operator< for testing purposes
  // 注意：这提供了一个任意但一致的排序 / Note: This provides an arbitrary but
  // consistent ordering.
  bool operator<(const point_t& other) const;
 
  [[nodiscard]] static auto min_value() -> point_t;
 
  [[nodiscard]] static auto max_value() -> point_t;
};
 
// 静态成员的特化(保持内联定义) / Specializations for static members (keep
// inline definitions here)
template<>
[[nodiscard]] inline auto point_t<int>::min_value() -> point_t<int>
{
  return {std::numeric_limits<int>::min(),
          std::numeric_limits<int>::min(),
          std::numeric_limits<int>::min()};
}
 
template<>
[[nodiscard]] inline auto point_t<int>::max_value() -> point_t<int>
{
  return {std::numeric_limits<int>::max(),
          std::numeric_limits<int>::max(),
          std::numeric_limits<int>::max()};
}
 
template<>
[[nodiscard]] inline auto point_t<float>::min_value() -> point_t<float>
{
  return {std::numeric_limits<float>::lowest(),
          std::numeric_limits<float>::lowest(),
          std::numeric_limits<float>::lowest()};
}
 
template<>
[[nodiscard]] inline auto point_t<float>::max_value() -> point_t<float>
{
  return {std::numeric_limits<float>::max(),
          std::numeric_limits<float>::max(),
          std::numeric_limits<float>::max()};
}
 
template<typename T>
auto operator<<(std::ostream& output_stream, const point_t<T>& pt)
    -> std::ostream&;
 
template<typename T>
class CPP_TOOLBOX_EXPORT point_cloud_t : public ::toolbox::io::base_file_data_t
{
public:
  std::vector<point_t<T>> points;  
  std::vector<point_t<T>> normals;  
  std::vector<point_t<T>> colors;  
  T intensity;  
 
  ~point_cloud_t() = default;
 
  point_cloud_t();
 
  point_cloud_t(const point_cloud_t& other);
  point_cloud_t(point_cloud_t&& other) noexcept;
  point_cloud_t& operator=(const point_cloud_t& other);
  point_cloud_t& operator=(point_cloud_t&& other) noexcept;
 
  [[nodiscard]] auto size() const -> std::size_t;
 
  [[nodiscard]] auto empty() const -> bool;
 
  void clear();
 
  void reserve(const std::size_t& required_size);
 
  [[nodiscard]] auto operator+(const point_cloud_t& other) const
      -> point_cloud_t;
 
  [[nodiscard]] auto operator+(const point_t<T>& point) const -> point_cloud_t;
 
  [[nodiscard]] auto operator+(point_t<T>&& point) const -> point_cloud_t;
 
  [[nodiscard]] auto operator+(point_cloud_t&& other) const -> point_cloud_t;
 
  point_cloud_t& operator+=(const point_t<T>& point);
 
  point_cloud_t& operator+=(point_t<T>&& point);
 
  point_cloud_t& operator+=(const point_cloud_t& other);
 
  point_cloud_t& operator+=(point_cloud_t&& other);
};
 
}  // namespace toolbox::types
 
// 包含实现文件 / Include the implementation file
#include "cpp-toolbox/types/impl/point_impl.hpp"