Every depth camera driver that ships an RGBD point cloud pays for it twice: once in CPU, to align each depth pixel into the color frame, and once in bandwidth, because the published point carries an RGB value alongside x, y and z. If your application reads geometry only — picking, volume, clearance, height maps — you can publish straight from the depth image with no RGB alignment, halve every message and drop the alignment from the CPU budget. This guide walks the parameter change, the depth_image_proc nodelet that replaces the built-in publisher, the byte math that tells you what you save, and the cases where the alignment still earns its keep.
What the RGBD pipeline costs you
The default chain runs depth computation, a depth-to-color alignment, then a publisher that stamps each aligned pixel with an RGB value and sends one PointCloud2 whose points carry x, y, z and rgb together. On the driver this pattern usually targets, the topic name announces it: /camera/depth/color/points. The alignment stage is the same one covered in depth to color alignment without losing depth precision, and it runs on every frame whether or not anyone reads the color.
Three costs follow. The alignment is a per-pixel remap at full frame rate, often the largest consumer-side load in the pipeline. The message doubles: a textured point travels as 32 bytes against 16 for geometry alone. And the coupling bites when color disappears: with the color sensor disabled and the texture stream left at its default, the built-in publisher stops outright, so the geometry vanishes with it. Geometry-only applications pay all three costs for data they discard on arrival, and the point cloud frame rate slower than depth symptom usually traces straight back to this pairing work.
Size the message for an 848 × 480 depth frame at 30 Hz
The inputs, and where each comes from: 848 × 480 px at 30 Hz is a common stereo depth mode; 32 bytes per XYZRGB point and 16 bytes per XYZ point are the two PointCloud2 layouts the drivers publish; a 1 Gbit/s link moves 125 MB/s before protocol overhead (1,000 Mbit/s ÷ 8). Assume every pixel valid — the worst case. An invalid pixel removes the same bytes from both layouts, so the 2:1 ratio survives any scene.
The rule: bytes per cloud equals pixels times bytes per point, and bandwidth equals bytes per cloud times frame rate.
Points per frame: 848 × 480 = 407,040.
- XYZRGB: 407,040 × 32 B = 13,025,280 B, about 13.0 MB per cloud. At 30 Hz: 13,025,280 × 30 = 390,758,400 B/s, about 391 MB/s or 3.13 Gbit/s.
- XYZ: 407,040 × 16 B = 6,512,640 B, about 6.5 MB per cloud. At 30 Hz: 6,512,640 × 30 = 195,379,200 B/s, about 195 MB/s or 1.56 Gbit/s.
The decision turns on one threshold: 125 MB/s on a GigE link, with the depth and infrared image streams riding the same wire. The depth image alone adds 407,040 × 2 B × 30 Hz = 24.4 MB/s at this size, and each 8-bit infrared stream adds 12.2 MB/s. On the host there is no wire to saturate: the XYZ cloud halves every copy and the change is pure gain. Across GigE the full-rate XYZ cloud still does not fit, so cap it at 10 Hz: 6,512,640 × 10 = 65.1 MB/s, and the whole stream (65.1 + 24.4 + 12.2 = 101.7 MB/s) fits with about 18% headroom — where the RGBD cloud fits at no usable rate. Full rate off-host wants 2.5GbE: 232 MB/s of streams sits comfortably inside its 312 MB/s.
When geometry alone is enough
Cut the alignment when every consumer reads geometry: grasp poses and bin picking, parcel volume and cubing, height maps and flatness checks (2.5D height map to 3D point cloud), distance and bend-angle measurement (measuring from depth point clouds in Python), obstacle maps for mobile platforms, clearance checks around fixtures.
Keep it when a consumer reads rgb: appearance-based segmentation or defect calls made on the cloud, texture-assisted registration when calibrating two depth cameras for combined clouds, operator views used for debugging, models trained on RGBD input. Artifacts are a reason to drop it too: color fringing at depth edges in an RGBD cloud is the alignment's calibration error, not depth noise (stereo camera RGB calibration), and a geometry-only cloud removes it by construction.
Publish the XYZ cloud from the depth stream
- Audit the consumers first. Run rostopic info on the current cloud topic to list subscribers, then check each for reads of the rgb field. Anything that needs color moves to its own stream before you touch the main one.
- Try the driver's parameters before adding nodes. On the driver this pattern targets, two settle it: set pointcloud_texture_stream to a non-color stream value and enable_color to false. The cloud keeps its topic and arrives untextured. If your build instead stops publishing without a color frame, that behavior lives in the publisher itself — take the nodelet route below.
- Leave the depth and infrared streams enabled. Stereo depth is computed from the infrared pair, so infrared is geometry, not color; only the RGB sensor is expendable. Leave any built-in cloud switch off as well: on one driver it is called enable_pointcloud, off by default for performance and deprecated in favor of exactly this external route.
- Load depth_image_proc/point_cloud_xyz into the running nodelet manager (my_manager below stands in for its name). Its documented inputs are image_rect and camera_info, and it publishes points in its own namespace. The to= names are placeholders too; take the real ones from rostopic list on your driver.
<node pkg="nodelet" type="nodelet" name="depth_point_cloud_xyz"
args="load depth_image_proc/point_cloud_xyz my_manager"
respawn="true">
<remap from="image_rect" to="camera/depth/image_rect"/>
<remap from="camera_info" to="camera/depth/camera_info"/>
</node>
- Feed it the rectified depth image in a metric encoding. The nodelet deprojects with the pinhole model from camera_info and converts the two standard depth encodings (the exact encodings are in the FAQ), but it applies no distortion model, so a raw image warps the cloud.
- Repoint consumers to the new points topic, or remap the nodelet's output onto the old topic name if nothing reads rgb. Put the remap in the launch files so it survives the next redeploy.
Verify before you cut over
Two commands cover most of it, run with the pipeline live:
rostopic hz /depth_point_cloud_xyz/points
rostopic echo --noarr /depth_point_cloud_xyz/points
The first reports the publish rate, which should match the depth frame rate — 30 Hz in the example above. The second shows the layout: a point_step of 16 with exactly three fields, x, y and z, each float32 (datatype 7). An RGBD cloud reports 32 and a fourth rgb field. Multiply the message width by its height for the valid-point count; a number far below 407,040 at this resolution points to exposure or projector trouble, not to the pipeline change. Then compare CPU against the old configuration — if the load barely moved, a filter or subscriber is still doing the work, and the pointcloud filter that slows the depth camera FPS guide helps you find it. If this cloud feeds collision monitoring or a stop function, re-time that whole chain at the new rates and topic names before production.
Per-point intensity without the alignment
Some jobs want shading without color, and stereo geometry gives it to you free: the depth map is computed in the reference infrared camera's frame, so the infrared intensity image lines up pixel for pixel and there is no cross-sensor alignment to pay for. The fusion is covered in point cloud with RGB and IR intensity, and the stream formats behind it in 16-bit depth and 8-bit infrared streams on one depth camera. Treat infrared intensity as monochrome shading — it moves with the projector pattern and the ambient light, so it separates by illumination, not appearance. When true color matters only occasionally, record depth and color side by side and align offline instead; the registration procedure is in how to register RGB and depth images for a colored point cloud.
Mistakes that drag the color pipeline back
- CameraInfo from the wrong camera. Deprojection needs the depth camera's own intrinsics; point the nodelet at the color camera's calibration and every point lands displaced, the trap behind aligned depth point cloud intrinsics.
- Unrectified depth. The nodelet has no distortion model, so anything but the rectified image warps the cloud toward the edges.
- Stale subscribers. Clients still bound to /camera/depth/color/points receive nothing and look like a dead camera; audit subscriptions the way the pointcloud-stops-publishing diagnosis does.
- Frame mix-ups. The cloud carries the depth optical frame id; transform it before merging sensors or drawing overlays, as in transforming depth point clouds between optical and camera frame.
- Over-pruned streams. Disabling infrared or the projector to save bandwidth removes geometry, not color; drop the RGB sensor and leave the rest alone.
Depth cameras for geometry-only cells
Any sensor that publishes a depth image plus intrinsics plugs into this route, so the choice follows the workspace rather than the pipeline. For close-range cells a compact ToF sensing camera such as the MV-DT01WMU suits the short standoffs. Where surface detail drives the measurement, a projected structured-light 3D camera such as the MV-DPS200P-02 resolves it. For swept-line profiling of larger parts, the MV-DLS300P-04 laser galvanometer stereo camera steers its line across the target; mount that one outside the operator's eye line and respect the laser class on its label. All three feed the same depth-image route described above, and geometry-only clouds are what volume and palletizing cells run in production.
- Type
- Depth / ToF camera
- Type
- Stereo / structured light
- Type
- Stereo / structured light
Where to go next
Shortlist hardware in the 3D sensors category or the camera finder, then settle the rest of the chain — mounting, triggering, the controller that carries the streams — in the configurator. To keep an offline copy of a capture for checks like the math above, the XYZ and PNG export guide shows the format. The 3D topic page collects the rest of the depth-camera material, and the contact page reaches the applications team for a second opinion on a specific cell.
Questions
Does skipping the alignment change the point positions?
No. The XYZ cloud is deprojected from the same depth image with the same depth intrinsics, so every point lands where the RGBD cloud put it. Alignment never improved geometry: it only looked up a color value per point, adding the color camera's extrinsics to the math. Accuracy, calibration and density are untouched; you lose only the rgb field and the CPU cost of filling it.
Why is a textured point 32 bytes and not 24?
Twelve bytes carry x, y and z as float32 and four carry the packed RGB value; the rest is padding that keeps each point on a 32-byte boundary, which some SIMD and GPU code expects. The XYZ layout pads the same way to 16 bytes. That padding is why the saving is exactly half, and why point_step reads 16 or 32 rather than 12 or 16.
Which depth encodings does the XYZ nodelet convert?
The two standard ones: 32-bit float maps with depth in metres and 16-bit unsigned integer maps with depth in millimetres, both rectified. The nodelet reads the pinhole model from camera_info and applies no distortion model, so a raw image produces a warped cloud rather than an error. An unsupported encoding makes the nodelet drop the frame with an encoding message, which shows up as a points topic that exists but never publishes.
Will viewers still render a cloud without rgb?
Yes. A PointCloud2 display draws x, y and z regardless of the rgb field; without it the cloud renders in a single flat color or by axis or distance, per the display's style setting. Choosing RGB coloring on an XYZ cloud shows nothing useful. If operators read the scene by color, publish a separate low-rate RGBD cloud for them instead of re-enabling alignment on the main pipeline.
Can I disable the infrared streams along with color?
Not if you want depth. A stereo depth camera computes its map from the rectified infrared pair, so the infrared streams stay on; the projector should stay on too unless the scene has enough natural texture — test by watching the valid-point count, not by trusting a dark-looking preview. Only the RGB sensor is expendable, which is exactly the stream this route removes.


