Filter Point Cloud Using Uniform Downsampling

SUMMARY

Filter Point Cloud Using Uniform Downsampling reduces point cloud density by selecting every kᵗʰ point from the original cloud, effectively shrinking the dataset while maintaining a roughly uniform distribution.

This Skill is useful in industrial, mobile, and humanoid robotics pipelines for speeding up processing of large point clouds. For instance, it can simplify scans of factory floors for quick inspection, downsample LIDAR data for mobile robot navigation, or reduce high-density point clouds when a humanoid robot processes an environment. Uniform downsampling helps improve computational efficiency while preserving overall geometry.

Use this Skill when you want to quickly reduce point cloud size without introducing bias, especially in pre-processing for registration, clustering, or pose estimation.

The Skill

from telekinesis import vitreous

filtered_point_cloud = vitreous.filter_point_cloud_using_uniform_downsampling(
    point_cloud=point_cloud,
    step_size=10,
)

API Reference

Data Transfer Notice

There is no longer a fixed limit of 1 million points per request. However, very large datasets may result in slower data transfer and processing times. We are continuously optimizing performance as part of our beta program, with ongoing improvements to enhance speed and reliability.

Example

Raw Sensor Input

Unprocessed point cloud captured directly from the sensor. Shows full resolution, natural noise, and uneven sampling density.

Moderate Downsampling

Light reduction that keeps the global structure while making further processing significantly lighter. Note that dense areas are still dense relative to sparse ones.
Parameters: step_size = 5.

Aggressive Downsampling

Aggressive thinning for fast previewing or early-stage pipeline testing
Parameters: step_size = 20

The Code

from telekinesis import vitreous
from datatypes import datatypes, io
import pathlib

# Optional for logging
from loguru import logger

DATA_DIR = pathlib.Path("path/to/telekinesis-data")

# Load point cloud
filepath = str(DATA_DIR / "point_clouds" / "zivid_welding_scene.ply")
point_cloud = io.load_point_cloud(filepath=filepath)
logger.success(f"Loaded point cloud with {len(point_cloud.positions)} points")

# Execute operation
filtered_point_cloud = vitreous.filter_point_cloud_using_uniform_downsampling(
  point_cloud=point_cloud,
  step_size=10,
)
logger.success("Filtered points using uniform downsampling")

The Explanation of the Code

The example starts by importing the required modules, including vitreous for point cloud operations, datatypes and io for data handling, pathlib for path management, and loguru for optional logging.

from telekinesis import vitreous
from datatypes import datatypes, io
import pathlib

# Optional for logging
from loguru import logger

Next, a point cloud is loaded from a .ply file, and the total number of points is logged to verify successful loading.

DATA_DIR = pathlib.Path("path/to/telekinesis-data")

# Load point cloud
filepath = str(DATA_DIR / "point_clouds" / "zivid_welding_scene.ply")
point_cloud = io.load_point_cloud(filepath=filepath)
logger.success(f"Loaded point cloud with {len(point_cloud.positions)} points")

The main operation uses the filter_point_cloud_using_uniform_downsampling Skill. This Skill reduces the density of the point cloud by selecting every k-th point, where k is defined by the step_size parameter. Uniform downsampling creates a smaller, more manageable dataset while maintaining the overall shape of the scene, which is useful in robotics pipelines for faster processing, collision checking, or when preparing data for segmentation and registration tasks.

# Execute operation
filtered_point_cloud = vitreous.filter_point_cloud_using_uniform_downsampling(
  point_cloud=point_cloud,
  step_size=10,
)
logger.success("Filtered points using uniform downsampling")

Running the Example

Runnable examples are available in the Telekinesis examples repository. Follow the README in that repository to set up the environment. Once set up, you can run this specific example with:

cd telekinesis-examples
python examples/vitreous_examples.py --example filter_point_cloud_using_uniform_downsampling

How to Tune the Parameters

The filter_point_cloud_using_uniform_downsampling Skill has one parameter that controls the downsampling:

step_size (required):

• The interval for selecting points (selects every Nth point)
• Increase (20-100) to reduce the number of points more aggressively, creating a sparser point cloud
• Decrease (2-5) to keep more points, preserving more detail
• The output will have approximately (original_count / step_size) points
• Typical range: 2-100
• Use 2-5 for light downsampling, 5-20 for moderate, 20-100 for aggressive
• Must be >= 1

TIP

Best practice: Start with a moderate step_size (5-10) and adjust based on your needs. Use smaller values to preserve detail, larger values for faster processing.

Where to Use the Skill in a Pipeline

Uniform downsampling is commonly used in the following pipelines:

• Fast preprocessing
• Quick preview generation
• Reducing computation time
• Early-stage pipeline testing

A typical pipeline for fast preprocessing looks as follows:

# Example pipeline using uniform downsampling (parameters omitted).

from telekinesis import vitreous

# 1. Load point cloud
point_cloud = vitreous.load_point_cloud(...)

# 2. Uniform downsampling for faster processing
downsampled_cloud = vitreous.filter_point_cloud_using_uniform_downsampling(
    point_cloud=point_cloud,
    step_size=10,
)

# 3. Process the downsampled point cloud
clusters = vitreous.cluster_point_cloud_using_dbscan(...)

Related skills to build such a pipeline:

• filter_point_cloud_using_voxel_downsampling: alternative downsampling method that creates uniform spatial distribution
• cluster_point_cloud_using_dbscan: process downsampled point clouds
• register_point_clouds_using_point_to_point_icp: register downsampled point clouds

Alternative Skills

Skill	vs. Filter Point Cloud Using Uniform Downsampling
filter_point_cloud_using_voxel_downsampling	Use voxel downsampling when you want uniform spatial distribution (points replaced by voxel centroids). Use uniform downsampling when you want to simply select every Nth point.

When Not to Use the Skill

Do not use filter point cloud using uniform downsampling when:

• You need uniform spatial distribution (use filter_point_cloud_using_voxel_downsampling instead)
• Point order matters (uniform downsampling depends on point order)
• You need to preserve fine details (downsampling reduces detail)
• The point cloud is already sparse (no need for additional downsampling)
• You need precise geometric representation (downsampling may lose important points)