Telekinesis Agentic Skill Library

Appearance

Filter Point Cloud Using Radius Outlier Removal ​

SUMMARY

Filter Point Cloud Using Radius Outlier Removal removes isolated or noisy points by checking if each point has a minimum number of neighbors within a specified radius.

This Skill is useful in industrial, mobile, and humanoid robotics pipelines for cleaning point cloud data before processing. For example, it can remove sensor noise from scanned objects on a factory line, clean LIDAR scans for mobile robot navigation, or filter out stray points for humanoid manipulation tasks. By eliminating outliers, downstream perception, clustering, and pose estimation become more accurate and reliable.

Use this Skill when you want to denoise point cloud data while preserving the main structure of the scene.

The Skill ​

python
from telekinesis import vitreous

filtered_point_cloud = vitreous.filter_point_cloud_using_radius_outlier_removal(
    point_cloud=point_cloud,
    num_points=5,
    neighborhood_radius=0.01,
)

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 ​

Note: The effect of radius-based outlier removal depends heavily on the density and scale of the input point cloud. The parameter values shown below (num_points and neighborhood_radius) are only examples, different datasets may require larger or smaller radii and neighbor counts to achieve similar results. Always tune the parameters according to the point spacing and physical size of your scene.

Raw Sensor Input

Unprocessed point cloud captured directly from the sensor. Contains sparse speckle noise and isolated outlier points.

Mild Outlier Removal

Light filtering that removes only the most isolated noisy points while preserving all valid structures.
Parameters: num_points = 50, neighborhood_radius = 50.

Moderate Outlier Removal

Balanced filtering that removes most sparse clutter and small isolated clusters while keeping overall structure intact.
Parameters: num_points = 75, neighborhood_radius = 35.

Aggressive Outlier Removal

Strong outlier removal that produces a very clean point cloud but may remove thin structures and surface-edge details.
Parameters: num_points = 75, neighborhood_radius = 25.

The Code ​

python
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" / "can_vertical_3_downsampled.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_radius_outlier_removal(
  point_cloud=point_cloud,
  num_points=5,
  neighborhood_radius=0.01,
)
logger.success("Filtered points using radius outlier removal")

The Explanation of the Code ​

The code starts by importing essential modules for point cloud processing, data handling, and optional logging, including vitreous, datatypes, io, pathlib, and loguru.

python
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 number of points is logged to ensure that the dataset is correctly loaded and ready for processing.

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

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

The main operation applies the filter_point_cloud_using_radius_outlier_removal Skill. This Skill removes isolated points that have fewer than a specified number of neighbors within a given radius. It is particularly useful in robotics pipelines for cleaning noisy point cloud data before downstream tasks such as segmentation, object detection, or motion planning.

python
# Execute operation
filtered_point_cloud = vitreous.filter_point_cloud_using_radius_outlier_removal(
  point_cloud=point_cloud,
  num_points=5,
  neighborhood_radius=0.01,
)
logger.success("Filtered points using radius outlier removal")

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:

bash
cd telekinesis-examples
python examples/vitreous_examples.py --example filter_point_cloud_using_radius_outlier_removal

How to Tune the Parameters ​

The filter_point_cloud_using_radius_outlier_removal Skill has two parameters that control the outlier removal:

num_points (required):

  • The minimum number of neighbors required within the radius for a point to be kept
  • Increase (5-20) to remove more points (stricter filtering), keeping only points in dense regions
  • Decrease (3-5) to keep more points but may retain some outliers
  • Typical range: 3-20
  • For dense point clouds, use 5-10
  • For sparse clouds, use 3-5
  • Set based on expected local point density

neighborhood_radius (required):

  • The search radius for finding neighbors around each point
  • Units: Uses the same units as your point cloud (e.g., if point cloud is in meters, radius is in meters; if in millimeters, radius is in millimeters)
  • Increase to consider a larger area, making the filter less sensitive to local density variations but may remove valid points in sparse regions
  • Decrease to make it more sensitive to local density but may miss outliers in sparse areas
  • Should be set to 2-3x the typical point spacing in your cloud
  • Typical range: 0.01-0.1 in point cloud units for small objects, 0.1-1.0 for larger scenes

TIP

Best practice: Start with neighborhood_radius set to 2-3x your point spacing, then adjust num_points based on your point cloud density. For dense clouds, use higher num_points. For sparse clouds, use lower num_points.

Where to Use the Skill in a Pipeline ​

Radius outlier removal is commonly used in the following pipelines:

  • Point cloud denoising
  • Preprocessing before segmentation
  • Noise removal for registration
  • Data cleaning for clustering

A typical pipeline for point cloud denoising looks as follows:

python
# Example pipeline using radius outlier removal (parameters omitted).

from telekinesis import vitreous

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

# 2. Optional: Downsample first to reduce computation
downsampled_cloud = vitreous.filter_point_cloud_using_voxel_downsampling(...)

# 3. Remove radius outliers
filtered_cloud = vitreous.filter_point_cloud_using_radius_outlier_removal(
    point_cloud=downsampled_cloud,
    num_points=5,
    neighborhood_radius=0.01,
)

# 4. Optional: Further cleaning with statistical outlier removal
cleaned_cloud = vitreous.filter_point_cloud_using_statistical_outlier_removal(...)

# 5. Process the cleaned point cloud
clusters = vitreous.cluster_point_cloud_using_dbscan(...)

Related skills to build such a pipeline:

  • filter_point_cloud_using_statistical_outlier_removal: alternative outlier removal method
  • filter_point_cloud_using_voxel_downsampling: reduce point cloud density before filtering
  • cluster_point_cloud_using_dbscan: process cleaned point clouds

Alternative Skills ​

Skillvs. Filter Point Cloud Using Radius Outlier Removal
filter_point_cloud_using_statistical_outlier_removalUse statistical outlier removal when you want to remove points based on distance distribution. Use radius outlier removal when you want to remove points with too few neighbors.

When Not to Use the Skill ​

Do not use filter point cloud using radius outlier removal when:

  • The point cloud is very sparse (the filter may remove too many valid points)
  • You need to preserve thin structures (radius filtering may remove points on thin edges)
  • Point density varies significantly (the filter may not work well with varying density)
  • You want distance-based outlier removal (use filter_point_cloud_using_statistical_outlier_removal instead)
  • The point cloud is already clean (no need for additional filtering)