Hey there! Let's tackle your two related questions step by step—first, how to read structured point clouds while keeping that critical image-to-point-cloud width/height link, and second, how to fix that cloud->height = 1 issue with ZED's PCD files.

First: What's a Structured (Ordered) Point Cloud? #

First, let's get clear on the basics: A structured point cloud maps directly to your camera's image pixels. That means cloud->height matches your image's height, cloud->width matches the image's width, and the point at index y * width + x corresponds exactly to the pixel at (x,y) in your camera feed.

The problem with ZED's exported PCDs turning into height=1 is that PCL defaults to saving/reading unstructured (unordered) point clouds when there are invalid points (like pixels with no depth data). Those invalid points get stripped out, and the remaining points get dumped into a flat list—losing the original pixel-to-point mapping.

Fixing the ZED PCD height=1 Issue (Two Methods) #

Method 1: Export Structured Point Clouds Directly from ZED SDK (Best Practice) #

If you still have access to the camera or the raw capture, skip using PCL's default save functions. Use the ZED SDK's built-in methods to export ordered point clouds—this preserves the width/height metadata automatically, even with invalid points (they'll just be marked as NaN instead of being removed).

Here's a quick C++ example:

sl::Camera zed;
sl::InitParameters init_params;
// Initialize your camera with your desired resolution (e.g., 1280x720)
init_params.camera_resolution = sl::RESOLUTION::HD720;

// Open the camera (handle errors appropriately!)
auto open_status = zed.open(init_params);
if (open_status != sl::ERROR_CODE::SUCCESS) {
    // Handle error
}

sl::Mat point_cloud;
// Retrieve the structured point cloud (XYZRGBA format here)
zed.retrieveMeasure(point_cloud, sl::MEASURE::XYZRGBA);

// Save directly using ZED's API—this keeps width/height intact!
point_cloud.write("zed_structured_cloud.pcd");

zed.close();

When you read this PCD back with PCL, cloud->height will be 720, cloud->width will be 1280, and the invalid points will be present as NaN values—no more flat list!

Method 2: Manually Reconstruct the Structured Cloud (For Existing PCDs) #

If you only have the unstructured PCD file (with height=1), you can rebuild the pixel-to-point mapping as long as you know the original camera resolution (e.g., HD720 = 1280x720, HD1080 = 1920x1080). You'll also need the corresponding depth image from the ZED capture (since that tells you which pixels had valid depth data).

Here's how to do it in C++:

#include <pcl/io/pcd_io.h>
#include <pcl/point_types.h>
#include <opencv2/opencv.hpp>
#include <limits>

int main() {
    // Define your original ZED resolution (adjust to your capture settings)
    const int TARGET_WIDTH = 1280;
    const int TARGET_HEIGHT = 720;

    // Read the unordered point cloud
    pcl::PointCloud<pcl::PointXYZRGBA>::Ptr unordered_cloud(new pcl::PointCloud<pcl::PointXYZRGBA>);
    if (pcl::io::loadPCDFile<pcl::PointXYZRGBA>("zed_unstructured_cloud.pcd", *unordered_cloud) == -1) {
        // Handle loading error
        return -1;
    }

    // Create a new structured point cloud container
    pcl::PointCloud<pcl::PointXYZRGBA>::Ptr structured_cloud(new pcl::PointCloud<pcl::PointXYZRGBA>);
    structured_cloud->width = TARGET_WIDTH;
    structured_cloud->height = TARGET_HEIGHT;
    structured_cloud->is_dense = false; // Important: tells PCL we have invalid points
    structured_cloud->points.resize(TARGET_WIDTH * TARGET_HEIGHT);

    // Load the corresponding depth image from ZED (saved as 16-bit PNG usually)
    cv::Mat depth_img = cv::imread("zed_depth_image.png", cv::IMREAD_UNCHANGED);
    if (depth_img.empty()) {
        // Handle depth image load error
        return -1;
    }

    // Map unordered points back to their original pixel positions
    size_t unordered_point_idx = 0;
    for (int y = 0; y < TARGET_HEIGHT; y++) {
        for (int x = 0; x < TARGET_WIDTH; x++) {
            // ZED marks invalid depth pixels as 0
            if (depth_img.at<unsigned short>(y, x) != 0) {
                // Assign the valid point from the unordered cloud
                structured_cloud->points[y * TARGET_WIDTH + x] = unordered_cloud->points[unordered_point_idx];
                unordered_point_idx++;
            } else {
                // Mark invalid points with NaN
                structured_cloud->points[y * TARGET_WIDTH + x].x = std::numeric_limits<float>::quiet_NaN();
                structured_cloud->points[y * TARGET_WIDTH + x].y = std::numeric_limits<float>::quiet_NaN();
                structured_cloud->points[y * TARGET_WIDTH + x].z = std::numeric_limits<float>::quiet_NaN();
            }
        }
    }

    // Save the restored structured cloud (or use it directly)
    pcl::io::savePCDFileASCII("zed_restructured_cloud.pcd", *structured_cloud);
    return 0;
}

After running this, your structured_cloud will have the correct height and width matching your ZED's image resolution, with points aligned to their original pixel positions.

General Tips for Working with Structured Point Clouds #

• Always check the PCD file header: A structured cloud will have HEIGHT set to your image height, not 1. Here's what a valid structured PCD header looks like:

VERSION .7
FIELDS x y z rgb
SIZE 4 4 4 4
TYPE F F F F
COUNT 1 1 1 1
WIDTH 1280
HEIGHT 720
VIEWPOINT 0 0 0 1 0 0 0
POINTS 921600
DATA ascii

• Set is_dense = false when creating structured clouds—this tells PCL not to discard invalid points, which preserves the structure.

内容的提问来源于stack exchange，提问作者kartik paigwar