1. Verifying Coordinate Valdiity

Point cloud data frequently contains sensor artifacts, resulting in coordinates populated with NaN or Inf values. PCL provides a dedicated utility to safely verify whether a point contains mathematically valid coordinates before processing. The pcl::isFinite() function evaluates all three spatial axes and returns a boolean indicating data integrity.

#include <pcl/point_types.h>
#include <pcl/common/common.h>
#include <iostream>
#include <limits>

int main() {
    pcl::PointXYZ clean_vertex;
    clean_vertex.x = 0.0f;
    clean_vertex.y = 0.0f;
    clean_vertex.z = 0.0f;
    std::cout << "Finite check: " << std::boolalpha << pcl::isFinite(clean_vertex) << '\n';

    pcl::PointXYZ corrupted_vertex;
    corrupted_vertex.x = std::numeric_limits<float>::quiet_NaN();
    corrupted_vertex.y = 0.0f;
    corrupted_vertex.z = 5.0f;
    std::cout << "Finite check: " << std::boolalpha << pcl::isFinite(corrupted_vertex) << '\n';
    return 0;
}

2. Duplicating Homogeneous Point Clouds

When working with identical point structures, deep copying preserves both spatial data and metadata. PCL's copyPointCloud template handles memory allocation and field mapping automatically, eliminating the need for manual iteration. Smart pointers are recommended to manage cloud lifecycles efficiently.

#include <pcl/point_cloud.h>
#include <pcl/point_types.h>
#include <pcl/io/io.h>

// Initialize source with a single measurement
pcl::PointCloud<pcl::PointXYZ>::Ptr origin_data(new pcl::PointCloud<pcl::PointXYZ>);
pcl::PointXYZ sample_pt{1.0f, 2.0f, 3.0f};
origin_data->push_back(sample_pt);

// Allocate destination and perform deep copy
pcl::PointCloud<pcl::PointXYZ>::Ptr cloned_data(new pcl::PointCloud<pcl::PointXYZ>);
pcl::copyPointCloud(*origin_data, *cloned_data);

// Access copied element via direct indexing
auto retrieved = cloned_data->points.front();
std::cout << "Cloned coordinates: " << retrieved.x << " " << retrieved.y << " " << retrieved.z << '\n';

3. Converting Between Heterogeneous Point Types

Cross-type duplication is common when pipelines require enriched data structures (e.g., adding surface normals). PCL maps overlapping fields automatically, while unassigned fields in the target type are zero-initialized. Attempting to copy a basic point cloud into a pure pcl::Normal container will fail due to incmopatible memory layouts; the target must inherit spatial coordinates.

#include <pcl/point_cloud.h>
#include <pcl/point_types.h>
#include <pcl/io/io.h>

pcl::PointCloud<pcl::PointXYZ>::Ptr spatial_only(new pcl::PointCloud<pcl::PointXYZ>);
spatial_only->push_back(pcl::PointXYZ{4.5f, 8.2f, 1.9f});

// Target includes geometry and normal vectors
pcl::PointCloud<pcl::PointNormal>::Ptr enriched_data(new pcl::PointCloud<pcl::PointNormal>);
pcl::copyPointCloud(*spatial_only, *enriched_data);

const auto& mapped_element = enriched_data->at(0);
std::cout << "Transferred XYZ: " << mapped_element.x << " " << mapped_element.y << " " << mapped_element.z << '\n';
std::cout << "Default normal[0]: " << mapped_element.normal_x << '\n';
std::cout << "Default normal[2]: " << mapped_element.normal[2] << '\n';

4. Extracting Spatial Bounds and Handling NaN Values

Computing the minimum and maximum extents of a cloud is essential for voxelization and visualization. The official pcl::getMinMax3D function internally filters non-finite values, ensuring accurate bounding boxes. A naive manual iteration that skips validity checks will produce incorrect bounds if the dataset contains sensor dropouts represented as NaN.

#include <pcl/point_cloud.h>
#include <pcl/common/common.h>

pcl::PointXYZ min_corner, max_corner;
pcl::getMinMax3D(*raw_cloud, min_corner, max_corner);

std::cout << "Upper bound: (" << max_corner.x << ", " << max_corner.y << ", " << max_corner.z << ")\n";
std::cout << "Lower bound: (" << min_corner.x << ", " << min_corner.y << ", " << min_corner.z << ")\n";

// Naive alternative that ignores invalid data
float unfiltered_min = std::numeric_limits<float>::max();
float unfiltered_max = -std::numeric_limits<float>::max();
for (const auto& pt : raw_cloud->points) {
    unfiltered_min = std::min(unfiltered_min, pt.x);
    unfiltered_max = std::max(unfiltered_max, pt.x);
}
// Result diverges if raw_cloud contains NaN values, as comparisons propagate invalid states.

5. Managing Structured (Organized) Clouds

Unorganized clouds store points in a linear buffer, while organized clouds maintain a 2D grid topology matching the sensor's capture matrix (width × height). Setting width and height enables image-style coordinate access using (row, column) indexing. This layout is mandatory for depth-image-based algorithms and stereo matching routines.

#include <pcl/point_cloud.h>
#include <pcl/point_types.h>

using Vertex = pcl::PointXYZ;
using StructuredCloud = pcl::PointCloud<Vertex>;

StructuredCloud::Ptr depth_grid(new StructuredCloud);
depth_grid->width = 640;
depth_grid->height = 480;
depth_grid->is_dense = true;
depth_grid->resize(depth_grid->width * depth_grid->height);

// Initialize with default coordinates
std::cout << "Top-left pixel: " << (*depth_grid)(0, 0) << '\n';

// Assign a specific measurement using matrix notation
Vertex calibrated_point{0.5f, 0.3f, 1.2f};
(*depth_grid)(120, 340) = calibrated_point;

std::cout << "Updated pixel: " << (*depth_grid)(120, 340) << '\n';