Reconstruct Mesh Using Poisson

SUMMARY

Reconstruct Mesh Using Poisson generates a smooth, watertight 3D mesh from a point cloud with normals using the Poisson surface reconstruction algorithm.

This Skill is useful in industrial, mobile, and humanoid robotics pipelines for creating high-quality object surfaces. For example, it can reconstruct precise meshes of parts for inspection or quality control in manufacturing, generate detailed environment models for mobile robot navigation, or create object surfaces for humanoid robot manipulation and grasp planning. The resulting mesh preserves fine geometric detail while providing a continuous surface.

Use this Skill when you want to convert a point cloud into a smooth, watertight mesh for perception, simulation, or analysis workflows.

The Skill

from telekinesis import vitreous

reconstructed_mesh = vitreous.reconstruct_mesh_using_poisson(
    point_cloud=point_cloud,
    octree_depth=8,
    octree_width=0,
    scale_factor=1.05,
)

API Reference

Performance Note

Current Data Limits: The system currently supports up to 1 million points per request (approximately 16MB of data). We're actively optimizing data transfer performance as part of our beta program, with improvements rolling out regularly to enhance processing speed.

Example

Raw Pointcloud

Unprocessed point cloud. Normals are computed internally if the point cloud does not have them.

Reconstructed Mesh

Reconstructed mesh. A higher depth leads to a mesh with more details.
Parameters: octree_depth = 8

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" / "industrial_part_7_normals.ply")
point_cloud = io.load_point_cloud(filepath=filepath)
logger.success(f"Loaded point cloud with {len(point_cloud.positions)} points")

# Execute operation
reconstructed_mesh = vitreous.reconstruct_mesh_using_poisson(
  point_cloud=point_cloud,
  octree_depth=8,
  octree_width=0,
  scale_factor=1.05,
)
logger.success(
  f"Reconstructed mesh from {len(point_cloud.positions)} points using Poisson"
)

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 reconstruct_mesh_using_poisson

The Explanation of the Code

The script begins by importing the necessary modules: vitreous for 3D operations, datatypes and io for data handling, pathlib for file 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 number of points is logged to confirm successful loading.

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

# Load point cloud
filepath = str(DATA_DIR / "point_clouds" / "industrial_part_7_normals.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 reconstruct_mesh_using_poisson Skill, which generates a smooth, watertight mesh from the input point cloud using Poisson surface reconstruction. This technique is especially useful in robotics and industrial 3D vision pipelines for creating high-quality meshes from scanned parts, enabling accurate surface analysis, inspection, or simulation. Parameters like octree_depth control mesh detail, while scale_factor adjusts the reconstruction to better fit the input cloud.

# Execute operation
reconstructed_mesh = vitreous.reconstruct_mesh_using_poisson(
  point_cloud=point_cloud,
  octree_depth=8,
  octree_width=0,
  scale_factor=1.05,
)
logger.success(
  f"Reconstructed mesh from {len(point_cloud.positions)} points using Poisson"
)

How to Tune the Parameters

The reconstruct_mesh_using_poisson Skill has three parameters that control the mesh reconstruction quality and detail:

octree_depth (default: 8):

• The depth of the octree used for spatial subdivision
• Increase (10-12) to create finer detail but uses more memory and computation time
• Decrease (6-8) to create coarser meshes but is faster
• Each level doubles the resolution
• Typical range: 6-12
• Use 6-8 for coarse meshes, 8-10 for balanced quality/speed, 10-12 for high detail

octree_width (default: 0):

• The width of the octree in voxels (0 = auto)
• 0: Automatically computed from point cloud bounds (recommended)
• Manual value: Defines the spatial extent (100-10000)
• Increase to expand the reconstruction volume
• Typical range: 0 (auto) or 100-10000
• Use 0 for automatic, or set manually if you need a specific volume size

scale_factor (default: 1.05):

• The scale factor for the reconstruction
• Increase (1.1-1.2) to expand the surface slightly beyond the points, helping close small holes
• Decrease (1.0-1.05) to contract the surface closer to points
• Typical range: 1.0-1.2
• Use 1.0-1.05 for tight fit, 1.05-1.1 for balanced, 1.1-1.2 for more expansion

TIP

Best practice: Start with default values. Increase octree_depth if you need more detail. Adjust scale_factor if the mesh doesn't close properly (increase) or extends too far beyond points (decrease). Keep octree_width=0 for automatic sizing unless you have specific requirements.

Note: Normals are computed internally if the point cloud does not have them. However, providing pre-computed normals typically produces better reconstruction quality.

Where to Use the Skill in a Pipeline

Poisson mesh reconstruction is commonly used in the following pipelines:

• High-quality surface generation
• Inspection and quality control
• Grasp planning with detailed geometry
• Simulation and visualization

A typical pipeline for high-quality mesh generation looks as follows:

# Example pipeline using Poisson mesh reconstruction (parameters omitted).

from telekinesis import vitreous

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

# 2. Preprocess: remove outliers and downsample
filtered_cloud = vitreous.filter_point_cloud_using_statistical_outlier_removal(...)
downsampled_cloud = vitreous.filter_point_cloud_using_voxel_downsampling(...)

# 3. Optional: Estimate normals (normals are computed internally if missing)
# Note: Providing normals typically produces better results, but the algorithm
# will compute them automatically if they are not present

# 4. Reconstruct mesh using Poisson
reconstructed_mesh = vitreous.reconstruct_mesh_using_poisson(
    point_cloud=downsampled_cloud,
    octree_depth=8,
    octree_width=0,
    scale_factor=1.05,
)

# 5. Optional: Use mesh for analysis, visualization, or collision checking

Related skills to build such a pipeline:

• filter_point_cloud_using_statistical_outlier_removal: clean input before reconstruction
• filter_point_cloud_using_voxel_downsampling: reduce point cloud density for faster processing
• reconstruct_mesh_using_convex_hull: alternative method for simple convex meshes
• cluster_point_cloud_using_dbscan: separate objects before generating individual meshes

Alternative Skills

Skill	vs. Reconstruct Mesh Using Poisson
reconstruct_mesh_using_convex_hull	Use convex hull when you need a simple, fast convex representation for collision detection. Use Poisson reconstruction when you need smooth, detailed meshes that preserve fine geometric features.

When Not to Use the Skill

Do not use reconstruct mesh using Poisson when:

• You need a simple convex representation (use reconstruct_mesh_using_convex_hull instead)
• The point cloud is very sparse (Poisson may not produce good results with insufficient points)
• You need fast computation (Poisson is computationally expensive, especially with high octree_depth)
• The point cloud has large holes or missing regions (Poisson may not close them effectively)

TIP

Note: Normals are computed internally if the point cloud does not have them. However, providing pre-computed normals typically produces better reconstruction quality, especially if you can estimate them with high accuracy.