You asked the camera for 60 fps color and 90 fps depth, and the pointcloud publishes at 30. This guide is for anyone running a stereo or time-of-flight depth camera into a pointcloud on a small compute device, typically through ROS. Two independent limits are at work: the pointcloud can only pair frames that both arrive, so it runs at the rate of its slower input stream, and converting depth pixels to 3D points costs CPU that a compact edge module may not have. You will measure what each stream actually delivers, apply one rule, and fix the stream settings and the compute load in the right order until the cloud reaches the rate you need.
The cloud runs at its slowest input
A textured pointcloud is built from frame pairs: one depth image and one color image, registered to each other. The driver pairs each depth frame with the color frame closest in time, and a cloud can only be published when both frames of a pair have arrived. The output rate is therefore:
Two decisions follow. A depth stream set above the color stream buys nothing: with 60 fps color, 90 fps depth still gives a 60 fps ceiling. And because every depth pixel becomes one 3D point, the compute cost of each frame is fixed by the depth mode alone; color settings change nothing there.
This pairing is not point-set registration. No algorithm is aligning clouds here; the driver stamps two frames and publishes the pair. Fusing many clouds into one model later is point-set registration, a separate and much heavier computation.
Step 1: measure what each stream actually delivers
Never argue with a configured number when you can measure the real one:
rostopic hz /camera/color/image_raw
rostopic hz /camera/depth/image_rect_raw
Let each run about ten seconds and read the average. Then compare:
| Measurement | Meaning | Action |
|---|---|---|
| Color reads below its configured rate (60 set, about 30 read) | Stream-side cap | Fix cause 1, then cause 2 |
| Both streams at their configured rates, cloud below the lower of the two | Compute-side cap | Fix cause 3 |
| A stream or the cloud reads zero | Different failure | Not slow but stopped: diagnose the pipeline load |
Cause 1: auto-exposure priority caps the color stream
With auto-exposure priority enabled, the color sensor is allowed to slow its own frame rate so the exposure can run longer. On this class of camera the color stream commonly falls to half its configured rate: you set 60 fps and the topic delivers about 30. The cloud, obeying the min-rate rule, publishes 30. This is the same mechanism behind auto-exposure priority dropping your frame rate to half.
Keep auto exposure on; turn only the priority off, in the launch file parameters:
/camera/rgb_camera/enable_auto_exposure: true
/camera/rgb_camera/auto_exposure_priority: false
The trade is physical: at a constant 60 fps the longest exposure is one frame period, about 16.7 ms, so dim scenes lose brightness. Recover it with gain or lighting, and query the exposure limits in microseconds before you clamp anything by hand.
Cause 2: the infrared streams share the same link
A stereo depth camera publishes two infrared image streams alongside depth and color, all over the same cable. If nothing in your pipeline reads them, they are pure overhead that can push color or depth below its configured rate. Disable both at launch:
enable_infra1:=false enable_infra2:=false
If you do need an infrared image, for texture or ambient checks, set infra_fps to the same rate as the depth stream so the published streams stay in step.
Cause 3: projection cost on the compute device
Turning depth pixels into points is per-point arithmetic: multiply the pixel coordinates by the intrinsics, divide by depth, write three floats. Do that for 307,200 points (640 × 480) sixty times a second and a small embedded module runs out of core before it runs out of camera. The signature is specific: both stream topics hold their configured rates, the cloud topic sags below the lower of the two, and one CPU core sits near 100 percent during capture.
Fixes, in order of value:
- Crop the depth ROI in 2D before the pointcloud reaches your code. Half the pixels, half the projection work.
- Lower the depth mode resolution: the same trade, coarser.
- Lower the target rate and run the depth camera at low fps to cut CPU load when the application allows it.
If the maker's viewer reaches your target rate but your pipeline does not, the camera and link are fine; the gap is per-frame work in your code, the same gap covered for capture time slower in the API than in the viewer and for a pointcloud filter slowing the camera fps.
Worked example: 90 fps depth, 60 fps color, a 30 fps cloud
Inputs, each with its source:
- Color stream configured: 60 fps (your launch file).
- Depth stream configured: 90 fps (your launch file).
- Pointcloud measured: 30 fps (your symptom).
- Depth mode: 640 × 480, a common VGA mode on this camera class, so 307,200 points per frame.
- Compute: a compact embedded vision module.
Rule in words: the cloud runs at the slower of its two input streams, and costs one deprojection per depth pixel.
The arithmetic:
- Ceiling if both streams delivered: min(60, 90) = 60 fps. Measured 30, so something sits below the camera's promise.
- With auto-exposure priority on, the color topic reads about 30 fps. Cloud = min(30, 90) = 30 fps, which matches the symptom exactly. The 90 fps depth stream contributed nothing.
- Set auto_exposure_priority: false and disable the two infrared streams. Color returns to 60 fps, so the ceiling is min(60, 90) = 60 fps. Cap depth at 60 fps too: the same ceiling, with depth traffic dropping from 90 to 60 frames per second, a third less.
- Compute check. Points per second wanted at 60 fps: 307,200 × 60 = 18,432,000, about 18.4 million. Points per second the module has already demonstrated: 307,200 × 30 = 9,216,000, about 9.2 million. Wanted 18.4 million, available 9.2 million.
- Match the load to the budget: crop to 640 × 240 = 153,600 points, and at 60 fps that is 153,600 × 60 = 9,216,000 points per second, exactly the load the module already sustains.
Decision. The target is 60 fps. If, with both streams measured at 60, the cloud still tops out near 30, compute is the cap: halve the depth pixels by crop or a lower mode and re-measure. If the application needs all 307,200 points per frame at 60 fps, this module will not deliver it at any stream setting: keep 30 fps, or move projection off the module.
When the min-rate rule does not apply
- Depth-only cloud: with no color texture there is no pair to wait for, and the ceiling is the depth stream's own rate, capped only by compute and link. Disabling the color stream entirely is the cheapest rate increase when texture is not needed.
- Aligned depth: when you align depth to color, the aligned output is published on the color cadence by construction, so raising the depth rate alone changes nothing there either; aligned depth streams follow the color timing.
- A color stream that stays below its configured rate with priority off and the infrared streams disabled is a separate problem: see color stream fps lower than configured on a depth camera.
If the rate is a specification: sensors that register on the device
A research pipeline tolerates a re-measure loop; a machine station with a cycle-time commitment does not. Factory 3D sensors pair and project on the device and ship XYZ over the link, so the cloud leaves the sensor at the sensor's own output cadence, whatever your controller is doing:
- Type
- Stereo / structured light
- Type
- Stereo / structured light
- Type
- Depth / ToF camera
A projected structured-light camera such as the MV-DPS200P-02 computes depth on board from its own pattern; a laser galvanometer stereo camera such as the MV-DLS300P-04 does the same with a scanned line, and a ToF sensing camera such as the MV-DT01WMU measures range per pixel. None of them asks your controller to deproject a frame.
Line-scan 2.5D systems take a fourth route: the MV-HLVS-16K100-L60 scans a 600 mm line at a 120 kHz sampling rate and outputs height maps, and 2.5D height map to 3D point cloud covers that conversion.
- Type
- 2.5D inspection
Laser profilers and stereo 3D cameras
170 models · from $699.00Checklist before you change hardware
- Measure all three topics, color, depth and cloud, ten seconds each, and write the numbers down.
- Color below configured? Set auto_exposure_priority: false and re-measure the color topic.
- Disable the unused infrared streams: enable_infra1:=false, enable_infra2:=false. Keep them only if something reads them, then set infra_fps to the depth rate.
- Cap depth at the color rate: 60/60 gives the same cloud ceiling as 90/60 with a third less depth traffic.
- Streams at target but cloud low? Crop the depth ROI to half the pixels and re-measure; halve again if the cloud is still short.
- Full frame needed at a rate the module cannot sustain? Keep the lower rate, or move to a sensor that registers on the device.
Run your own numbers through the camera finder or start at the camera step of the system configurator. The 3D topic page collects more depth-pipeline fixes, and if a station must hold a cloud rate you cannot reach in software, bring the measured stream and cloud rates to the contact page and we will size the sensor side.
Questions
Why does raising the depth stream to 90 fps not raise the pointcloud?
Because the cloud pairs each depth frame with a color frame and can only publish when both have arrived: cloud fps = min(color fps, depth fps). With 60 fps color, a 90 fps depth stream gives the same 60 fps ceiling as a 60 fps depth stream while sending a third more depth frames across the link. Set both streams to your target rate; depth above the color rate is wasted bandwidth.
Is it safe to disable both infrared streams?
Yes, if nothing downstream reads them. enable_infra1:=false and enable_infra2:=false stop the infrared images crossing the link; the depth stream keeps computing and publishing. Keep them only when you inspect infrared texture or run a stereo check, and then set infra_fps to the depth rate so the published streams stay in step.
How do I tell a CPU cap from a camera problem?
Measure the raw streams and compare them against each other, not against the configured values. If color and depth each hold their configured rate while the cloud topic sags below the lower of the two, the camera and link are fine and your compute is the cap; one core near 100 percent during capture confirms it. If a stream itself reads low, the cap is stream-side: fix auto-exposure priority and the infrared streams first.
What depth resolution keeps a 60 fps cloud on a small edge module?
Derive it from what the module already sustains: sustainable points per second = measured cloud fps × depth pixels. A module holding 30 fps at 640 × 480 sustains about 9.2 million points per second; at 60 fps that budget allows 153,600 pixels per frame, so crop to 640 × 240 or pick a lower mode. Re-measure after each change; the number that governs the cap is points per second, not resolution alone.
Does turning off auto-exposure priority hurt the color image?
It can, in dim light. With priority off the sensor holds a constant frame rate, so exposure is bounded by the frame period: at 60 fps the longest exposure is about 16.7 ms. If the color image darkens, recover brightness with gain or added light rather than re-enabling priority, and query the exposure limits in microseconds before you clamp anything by hand.
Does a pointcloud without color run at the depth rate?
Yes. A depth-only cloud has no color frame to wait for, so the min-rate rule drops out: the ceiling becomes the depth stream's own rate — 90 fps in the example setup — limited by compute and link alone. When texture is not needed, disabling the color stream entirely is the cheapest cloud-rate increase available, and it also removes the color frames from the link.



