point_cloud_fusion_cuda.hpp

Go to the documentation of this file.

// Copyright Institute for Automotive Engineering (ika), RWTH Aachen University
// SPDX-License-Identifier: Apache-2.0
 
#pragma once
 
#ifdef ENABLE_CUDA
 
#include <cstddef>
#include <cstdint>
#include <vector>
 
namespace point_cloud_fusion {
namespace cuda {
 
struct CudaFieldCopy {
  int src_offset;
  int dst_offset;
  int size;
};
 
// Metadata struct for device consumption
struct CloudMetadata {
  int num_points;       // Actual number of points in this cloud
  int num_samples;      // Number of samples to take (for strided sampling)
  float stride;         // Stride for uniform sampling (>= 1.0)
  int apply_transform;  // bool as int for alignment
  float rotation[9];
  float translation[3];
  int pad;  // alignment padding
};
 
class CudaTransformContext {
 public:
  CudaTransformContext();
  ~CudaTransformContext();
 
  // Disable copy/move
  CudaTransformContext(const CudaTransformContext&) = delete;
  CudaTransformContext& operator=(const CudaTransformContext&) = delete;
 
  bool resetBatch(size_t total_max_points,
                  size_t max_single_cloud_points,
                  size_t input_point_step,
                  size_t output_point_step,
                  int src_x_offset,
                  int src_y_offset,
                  int src_z_offset,
                  int dst_x_offset,
                  int dst_y_offset,
                  int dst_z_offset,
                  const std::vector<CudaFieldCopy>& copy_plan,
                  float x_min,
                  float x_max,
                  float y_min,
                  float y_max,
                  float z_min,
                  float z_max,
                  bool range_enable);
 
  bool addCloud(const uint8_t* input_data,
                size_t num_points,
                const float* rotation_matrix_host,
                const float* translation_host,
                bool apply_transform,
                size_t slot_index,
                int desired_points = 0);
 
  bool getBatchOutput(std::vector<uint8_t>& output_data, size_t& valid_count);
 
 private:
  bool ensureInputCapacity(size_t num_points);
  bool ensureOutputCapacity(size_t total_max_points, size_t point_step);
  void cleanup();
 
  // Device memory
  uint8_t* d_input_points_;
  uint8_t* d_accumulated_buffer_;
  unsigned int* d_global_count_;  // Atomic counter for total output
  void* d_cloud_metadata_;        // Device buffer for CloudMetadata
  void* d_copy_plan_;             // Device buffer for CudaFieldCopy
 
  // Host pinned memory
  unsigned int* h_global_count_pinned_;
  void* h_cloud_metadata_pinned_;  // Host pinned buffer for CloudMetadata
 
  // CUDA resources
  void* stream_;  // cudaStream_t
 
  size_t input_capacity_;
  size_t output_capacity_;
  size_t current_input_point_step_;
  size_t current_output_point_step_;
  size_t slot_size_points_;   // fixed slot size in points (padding per cloud)
  size_t num_slots_;          // number of slots (usually number of input clouds)
  size_t metadata_capacity_;  // number of slots we can store metadata for
  size_t copy_plan_capacity_;
 
  int current_src_x_offset_;
  int current_src_y_offset_;
  int current_src_z_offset_;
  int current_dst_x_offset_;
  int current_dst_y_offset_;
  int current_dst_z_offset_;
  float current_x_min_;
  float current_x_max_;
  float current_y_min_;
  float current_y_max_;
  float current_z_min_;
  float current_z_max_;
  bool current_range_enable_;
  int num_copy_ops_;
 
  // We keep a host vector of metadata to fill before upload
  std::vector<CloudMetadata> host_metadata_;
 
  // Stored input pointers for batch upload
  struct InputCloudInfo {
    const uint8_t* data;
    size_t size_bytes;
    size_t slot_index;
  };
  std::vector<InputCloudInfo> pending_inputs_;
};
 
}  // namespace cuda
}  // namespace point_cloud_fusion
 
#endif  // ENABLE_CUDA