Telekinesis Agentic Skill Library

https://docs.telekinesis.ai/
Admin
The Telekinesis Agentic Skill Library is a unified ecosystem for generalized robotic intelligence,...
Tokens:406,102
Snippets:3,718
Trust Score:6.3
Update:4 months ago
Show doc for...
Tokens:
Raw
### Run Example from Repository

Source: https://docs.telekinesis.ai/public/images/vitreous/cluster_point_cloud_using_dbscan.html

Command to execute a specific example script from the Telekinesis examples repository after environment setup.

```bash
cd telekinesis-examples
python examples/vitreous_examples.py --example cluster_point_cloud_using_dbscan
```

--------------------------------

### Run Example Script

Source: https://docs.telekinesis.ai/public/images/vitreous/apply_transform_to_point_cloud.html

Command to execute the apply_transform_to_point_cloud example from the Telekinesis examples repository after environment setup.

```bash
cd telekinesis-examples
python examples/vitreous_examples.py --example apply_transform_to_point_cloud
```

--------------------------------

### Full Example: Setup and Use Kinematics Solver

Source: https://docs.telekinesis.ai/skills/synapse/setup-kinematics-solver.html

This script demonstrates how to pre-initialize an IK solver for the Synapse SDK, then use it to solve an inverse kinematics problem. It shows how to get supported solvers, set a specific solver, and then perform an IK solve using the cached solver.

```python
"""
Pre-initialize an IK solver for the Synapse SDK.

``setup-kinematics-solver`` initializes an IK solver by name and caches
it on the robot, so subsequent ``inverse_kinematics`` calls skip the
solver-construction cost. 

Supported solver names: ``"clik"``, ``"multi_start_clik"``, ``"tracik"``.

Universal Robots (UR10e) is used here purely for illustration. It supports all robots.

Usage:
    python setup-kinematics-solver.py
"""

from loguru import logger

from telekinesis.synapse.robots.manipulators import universal_robots


def main():
    """Pre-initialize the multi_start_clik solver, then solve IK with it."""

    # Create the robot (no connect required — IK runs on the kinematic model)
    robot = universal_robots.UniversalRobotsUR10E()

    # Get all supported kinematics solvers
    solvers = robot.supported_kinematics_solvers
    logger.info(f"Supported solvers: {solvers}")

    # Pre-load the desired solver so the first inverse_kinematics call is fast
    robot.setup-kinematics-solver(solver="multi_start_clik")

    # Check active kinematic solver
    active_kinematics_solver = robot.active_kinematics_solver
    logger.info(f"Active kinematics solver: {active_kinematics_solver}")

    # Solve IK using the cached solver (no need to pass ``solver=`` again)
    target_pose = [0.5, 0.2, 0.3, 180.0, 0.0, 0.0]
    try:
        q = robot.inverse_kinematics(target_pose=target_pose)
        logger.success(f"IK solution: {q}")
    except (RuntimeError, TypeError, ValueError) as e:
        logger.error(f"IK failed: {type(e).__name__}: {e}")


if __name__ == "__main__":
    main()

```

--------------------------------

### Run Medulla Webcam Quickstart Example

Source: https://docs.telekinesis.ai/getting-started/examples

This script provides a minimal example to capture a single frame from a webcam using the Medulla module.

```bash
python examples/medulla/webcam/quickstart.py
```

--------------------------------

### Run Quickstart Script

Source: https://docs.telekinesis.ai/getting-started/quickstart.html

Executes the Python script to start the Telekinesis AI quickstart simulation.

```bash
python quickstart.py
```

--------------------------------

### Example Pipeline Setup

Source: https://docs.telekinesis.ai/public/images/vitreous/register_point_clouds_using_fast_global_registration.html

Basic import statements for setting up a pipeline that uses fast global registration. This snippet shows the necessary imports before defining parameters and executing the registration.

```python
# Example pipeline using fast global registration (parameters omitted).

from telekinesis import vitreous
import numpy as np
```

--------------------------------

### Running Create Torus Mesh Example

Source: https://docs.telekinesis.ai/public/images/vitreous/create_torus_mesh.html

Command to execute the create_torus_mesh example from the Telekinesis examples repository after environment setup.

```bash
cd telekinesis-examples
python examples/vitreous_examples.py --example create_torus_mesh
```

--------------------------------

### Runnable Example Command

Source: https://docs.telekinesis.ai/skills/cornea/segment_image_using_local_threshold.html

Command to run the local threshold segmentation example from the Telekinesis examples repository after environment setup.

```bash
cd telekinesis-examples
python examples/cornea_examples.py --example segment_image_using_local_threshold
```

--------------------------------

### Run White Balance Example

Source: https://docs.telekinesis.ai/skills/pupil/enhance_image_using_white_balance.html

Command to execute the white balance example from the Telekinesis examples repository after environment setup.

```bash
cd telekinesis-examples
python examples/pupil_examples.py --example enhance_image_using_white_balance
```

--------------------------------

### Running the Example Script

Source: https://docs.telekinesis.ai/public/images/vitreous/add_point_clouds.html

This command demonstrates how to execute the Add Point Clouds example from the Telekinesis examples repository after setting up the environment. It uses a command-line argument to specify the example to run.

```bash
cd telekinesis-examples
python examples/vitreous_examples.py --example add_point_clouds
```

--------------------------------

### Runnable Example Command

Source: https://docs.telekinesis.ai/skills/cornea/segment_image_using_hsv.html

Command to run the segment_image_using_hsv example from the Telekinesis examples repository after environment setup. This allows testing the skill in a practical scenario.

```bash
cd telekinesis-examples
python examples/cornea_examples.py --example segment_image_using_hsv
```

--------------------------------

### Run Example from Telekinesis Repository

Source: https://docs.telekinesis.ai/skills/cornea/segment_image_using_focus_region.html

Executes the segment_image_using_focus_region example. Requires the Telekinesis examples repository to be set up.

```bash
cd telekinesis-examples
python examples/cornea_examples.py --example segment_image_using_focus_region
```

--------------------------------

### Run Example

Source: https://docs.telekinesis.ai/skills/cornea/segment_image_using_otsu_threshold.html

Command to run the Otsu threshold segmentation example from the Telekinesis examples repository.

```bash
cd telekinesis-examples
python examples/cornea_examples.py --example segment_image_using_otsu_threshold

```

--------------------------------

### Full Example: Get and Inspect Model

Source: https://docs.telekinesis.ai/skills/synapse/get-model.html

Demonstrates how to create a robot instance, retrieve its kinematic model, and log key attributes like configuration dimensions and joint counts. No connection to the physical robot is required.

```python
"""
Read the Pinocchio kinematic model for the Synapse SDK.

``get-model`` returns the standard ``pinocchio.Model`` object built from
the robot's URDF. 

Universal Robots (UR10e) is used here purely for illustration. It supports all robots.

Usage:
    python get-model.py
"""

from loguru import logger

from telekinesis.synapse.robots.manipulators import universal_robots


def main():
    """Read the Pinocchio kinematic model and log a few summary fields."""

    # Create the robot (no connect required — runs on the kinematic model)
    robot = universal_robots.UniversalRobotsUR10E()

    # Read the Pinocchio kinematic model
    model = robot.get-model()
    logger.success(f"Model: {model}")
    logger.info(f"Model name: {model.name}")
    logger.info(f"nq (configuration dim): {model.nq}")
    logger.info(f"nv (velocity dim): {model.nv}")
    logger.info(f"Number of joints: {model.njoints}")
    logger.info(f"Number of frames: {model.nframes}")


if __name__ == "__main__":
    main()
```

--------------------------------

### Example: Start, Use, and Stop a Freedrive Session

Source: https://docs.telekinesis.ai/skills/synapse/freedrive-mode.html

This script enables freedrive on all axes for 10 seconds, allowing manual interaction, and then exits cleanly. It requires the robot's IP address as an argument.

```python
"""
Freedrive mode example for the Synapse SDK.

``start_freedrive_mode`` puts the robot into hand-guiding mode — the operator
can physically push the arm and it complies. ``free_axes`` is a 6-element
mask ``[x, y, z, rx, ry, rz]`` where ``1`` means the axis is free and ``0``
means it is locked. ``stop_freedrive_mode`` returns the controller to normal
motion control.

Currently supported only for Universal Robots (UR10e).

Usage:
    python freedrive_mode.py --ip <ROBOT_IP>
"""

import argparse
import time
from loguru import logger

from telekinesis.synapse.robots.manipulators import universal_robots


def main(robot_ip: str):
    """Enter freedrive for 10 seconds, then exit."""

    # Create robot instance
    robot = universal_robots.UniversalRobotsUR10E()

    # Connect to the robot
    robot.connect(ip=robot_ip)

    # Enter freedrive with all axes free
    free_axes = [1, 1, 1, 1, 1, 1]
    logger.info(f"Starting freedrive - free axes: {free_axes}")
    robot.start_freedrive_mode(free_axes=free_axes)

    # Hold freedrive open for hand-guiding
    time.sleep(10)

    # Exit freedrive
    robot.stop_freedrive_mode()
    logger.success("Freedrive mode stopped.")

    # Disconnect
    robot.disconnect()


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="UR robot freedrive mode example")
    parser.add_argument("--ip", type=str, required=True, help="IP address of the UR robot")
    args = parser.parse_args()

    main(args.ip)

```

--------------------------------

### Example Pipeline Initialization

Source: https://docs.telekinesis.ai/skills/vitreous/register_point_clouds_using_fast_global_registration.html

Provides a basic Python setup for using the vitreous module and numpy for point cloud registration tasks. This snippet is a starting point for building a registration pipeline.

```python
# Example pipeline using fast global registration (parameters omitted).

from telekinesis import vitreous
import numpy as np

```

--------------------------------

### Run Example from Repository

Source: https://docs.telekinesis.ai/public/images/vitreous/register_point_clouds_using_point_to_point_icp.html

Demonstrates how to execute the point cloud registration example by navigating to the telekinesis-examples directory and running the specified Python script with the appropriate argument.

```bash
cd telekinesis-examples
python examples/vitreous_examples.py --example register_point_clouds_using_point_to_point_icp
```

--------------------------------

### Install Additional Dependencies for Examples

Source: https://docs.telekinesis.ai/skills/medulla/installation.html

Install extra dependencies required to run the examples provided with the Telekinesis AI SDK. This is a separate step from the base Medulla installation.

```bash
pip install telekinesis-ai[examples]
```

--------------------------------

### Run Example from Repository

Source: https://docs.telekinesis.ai/skills/cornea/segment_image_using_threshold.html

Demonstrates how to run the segment_image_using_threshold example from the Telekinesis examples repository. Ensure the environment is set up according to the repository's README.

```bash
cd telekinesis-examples
python examples/cornea_examples.py --example segment_image_using_threshold
```

--------------------------------

### Install Dependencies for Telekinesis Examples

Source: https://docs.telekinesis.ai/getting-started/examples

Install the required Python packages for running the Telekinesis examples. Ensure you have the correct conda environment activated.

```bash
conda activate telekinesis
pip install rerun-sdk==0.31.2 pycocotools scipy
```

--------------------------------

### Run the Scale Point Cloud Example

Source: https://docs.telekinesis.ai/getting-started/examples

This command executes the example demonstrating how to scale a point cloud by a given factor.

```bash
python examples/vitreous_examples.py --example scale_point_cloud
```

--------------------------------

### Run Detect Contours Example

Source: https://docs.telekinesis.ai/skills/retina/detect_contours.html

Command to run the detect_contours example from the Telekinesis examples repository after environment setup.

```bash
cd telekinesis-examples
python examples/retina_examples.py --example detect_contours
```

--------------------------------

### Run Subtract Point Clouds Example

Source: https://docs.telekinesis.ai/public/images/vitreous/subtract_point_clouds.html

Command to run the subtract_point_clouds example from the Telekinesis examples repository after setup.

```bash
cd telekinesis-examples
python examples/vitreous_examples.py --example subtract_point_clouds
```

--------------------------------

### Run Voxel Downsampling Example

Source: https://docs.telekinesis.ai/public/images/vitreous/filter_point_cloud_using_voxel_downsampling.html

Command to execute the filter_point_cloud_using_voxel_downsampling example from the Telekinesis examples repository after environment setup.

```bash
cd telekinesis-examples
python examples/vitreous_examples.py --example filter_point_cloud_using_voxel_downsampling
```

--------------------------------

### Run Example from Repository

Source: https://docs.telekinesis.ai/public/images/vitreous/register_point_clouds_using_point_to_plane_icp.html

Executes the point cloud registration example by navigating to the telekinesis-examples directory and running the specified Python script. Ensure the environment is set up according to the repository's README.

```bash
cd telekinesis-examples
python examples/vitreous_examples.py --example register_point_clouds_using_point_to_plane_icp
```

--------------------------------

### Run Example from Repository

Source: https://docs.telekinesis.ai/public/images/vitreous/register_point_clouds_using_cuboid_translation_sampler_icp.html

Executes the point cloud registration example by navigating to the telekinesis-examples directory and running the specified Python script. Ensure the environment is set up according to the repository's README.

```bash
cd telekinesis-examples
python examples/vitreous_examples.py --example register_point_clouds_using_cuboid_translation_sampler_icp
```

--------------------------------

### Full Example: Get Target TCP Speed with Synapse SDK

Source: https://docs.telekinesis.ai/skills/synapse/get-target-tcp-speed.html

This script reads the target TCP velocity from a Universal Robot UR10e. It can connect to a live robot or read from an offline cache. Ensure the Synapse SDK and necessary robot drivers are installed.

```python
"""
Read target (commanded) TCP velocity example for the Synapse SDK.

Returns the target/commanded TCP twist
``[vx, vy, vz (m/s), ωx, ωy, ωz (deg/s)]``. With ``--ip``, reads live
hardware state. Without ``--ip``, reads from the internal commanded cache
(no connection made) and logs a warning.

Illustrated using Universal Robots (UR10e), supported on all robots.

Usage:
    python get_target_tcp_speed.py [--ip <ROBOT_IP>]
"""

import argparse
from loguru import logger

from telekinesis.synapse.robots.manipulators import universal_robots


def main(ip: str | None = None):
    """Log the current target TCP velocity [m/s, deg/s]."""

    robot = universal_robots.UniversalRobotsUR10E()

    if ip is not None:
        robot.connect(ip=ip)
    else:
        logger.warning(
            "No --ip provided; reading offline commanded-cache state, "
            "not live hardware readings."
        )

    try:
        logger.success(f"target_tcp_speed [m/s, deg/s]: {robot.get_target_tcp_speed()}")
    finally:
        if ip is not None:
            robot.disconnect()


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Read target TCP velocity Synapse example")
    parser.add_argument("--ip", type=str, default=None, help="UR robot IP address (optional)")
    args = parser.parse_args()

    main(ip=args.ip)

```

--------------------------------

### Run Project Pixel to Camera Point Example

Source: https://docs.telekinesis.ai/skills/pupil/project_pixel_to_camera_point.html

Provides instructions on how to run a specific example script for the `project_pixel_to_camera_point` skill from the Telekinesis examples repository. This requires setting up the environment and navigating to the correct directory.

```bash
cd telekinesis-examples
python examples/pupil_examples.py --example project_pixel_to_camera_point
```

--------------------------------

### Run Example Script

Source: https://docs.telekinesis.ai/public/images/vitreous/register_point_clouds_using_rotation_sampler_icp.html

Executes the point cloud registration example from the Telekinesis examples repository. Ensure the environment is set up according to the repository's README.

```bash
cd telekinesis-examples
python examples/vitreous_examples.py --example register_point_clouds_using_rotation_sampler_icp
```

--------------------------------

### Run Example from Repository

Source: https://docs.telekinesis.ai/public/images/vitreous/filter_point_cloud_using_plane_splitting.html

This command shows how to execute the `filter_point_cloud_using_plane_splitting` example from the Telekinesis examples repository. Ensure you have cloned the repository and set up the environment as per the README.

```bash
cd telekinesis-examples
python examples/vitreous_examples.py --example filter_point_cloud_using_plane_splitting
```

--------------------------------

### Run Detect Objects Example

Source: https://docs.telekinesis.ai/skills/retina/detect_objects_using_qwen.html

Command to execute the `detect_objects_using_qwen` example from the Telekinesis examples repository after setting up the environment.

```bash
cd telekinesis-examples
python examples/retina_examples.py --example detect_objects_using_qwen
```

--------------------------------

### Run Estimate Principal Axes Example

Source: https://docs.telekinesis.ai/public/images/vitreous/estimate_principal_axes.html

Command to run the estimate_principal_axes example from the Telekinesis examples repository. Requires prior setup of the repository environment.

```bash
cd telekinesis-examples
python examples/vitreous_examples.py --example estimate_principal_axes
```

--------------------------------

### Run Example from Telekinesis Repository

Source: https://docs.telekinesis.ai/skills/cornea/segment_image_using_laplacian_threshold.html

This command demonstrates how to run the segment_image_using_laplacian_threshold example from the Telekinesis examples repository after setting up the environment.

```bash
cd telekinesis-examples
python examples/cornea_examples.py --example segment_image_using_laplacian_threshold
```

--------------------------------

### Install BabyROS Middleware

Source: https://docs.telekinesis.ai/

Install the BabyROS middleware using pip. This is a prerequisite for using the publisher and subscriber examples.

```bash
pip install babyros
```

--------------------------------

### Run Filter Point Cloud Using Mask Example

Source: https://docs.telekinesis.ai/public/images/vitreous/filter_point_cloud_using_mask.html

Command to run the filter_point_cloud_using_mask example from the telekinesis-examples repository after setup.

```bash
cd telekinesis-examples
python examples/vitreous_examples.py --example filter_point_cloud_using_mask
```

--------------------------------

### Run Pad Image Example

Source: https://docs.telekinesis.ai/skills/pupil/pad_image.html

Provides instructions on how to run the pad_image example from the Telekinesis examples repository after setting up the environment.

```bash
cd telekinesis-examples
python examples/pupil_examples.py --example pad_image
```

--------------------------------

### Run Example from Telekinesis Repository

Source: https://docs.telekinesis.ai/skills/pupil/filter_image_using_morphological_blackhat.html

Provides instructions on how to run the example code from the Telekinesis examples repository after setting up the environment. This allows for practical testing and demonstration of the skill.

```bash
cd telekinesis-examples
python examples/pupil_examples.py --example filter_image_using_morphological_blackhat
```

--------------------------------

### Clone Telekinesis Examples Repository

Source: https://docs.telekinesis.ai/getting-started/examples

Clone the telekinesis-examples repository and its submodules. This command ensures you get the latest commit and necessary data for running examples.

```bash
git clone --depth 1 --recurse-submodules --shallow-submodules \
  https://github.com/telekinesis-ai/telekinesis-examples.git

cd telekinesis-examples
```

--------------------------------

### Get Target Joint Velocities (Python)

Source: https://docs.telekinesis.ai/skills/synapse/get-target-joint-velocities.html

Example of how to get the target joint velocities using the Synapse SDK. This snippet demonstrates the basic usage of the `get_target_joint_velocities` function.

```python
qd_target = robot.get_target_joint_velocities()
```

--------------------------------

### Full Synapse Example: Get Timestamp

Source: https://docs.telekinesis.ai/skills/synapse/get-timestamp.html

A complete Python script demonstrating how to get the timestamp of the most recent state update. It supports connecting to a robot via IP or reading from an offline cache.

```python
"""
Read state timestamp example for the Synapse SDK.

Returns the timestamp of the most recent state update [s since epoch].
With ``--ip``, reads live hardware state. Without ``--ip``, reads from the
internal commanded cache (no connection made) and logs a warning.

Illustrated using Universal Robots (UR10e), supported on all robots.

Usage:
    python get_timestamp.py [--ip <ROBOT_IP>]
"""

import argparse
from loguru import logger

from telekinesis.synapse.robots.manipulators import universal_robots


def main(ip: str | None = None):
    """Log the timestamp of the most recent state update [s]."""

    robot = universal_robots.UniversalRobotsUR10E()

    if ip is not None:
        robot.connect(ip=ip)
    else:
        logger.warning(
            "No --ip provided; reading offline commanded-cache state, "
            "not live hardware readings."
        )

    try:
        logger.success(f"timestamp [s]: {robot.get_timestamp()}")
    finally:
        if ip is not None:
            robot.disconnect()


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Read state timestamp Synapse example")
    parser.add_argument("--ip", type=str, default=None, help="UR robot IP address (optional)")
    args = parser.parse_args()

    main(ip=args.ip)

```

--------------------------------

### Run Scale Point Cloud Example

Source: https://docs.telekinesis.ai/skills/vitreous/scale_point_cloud.html

Command to run the scale_point_cloud example from the Telekinesis examples repository after setting up the environment.

```bash
cd telekinesis-examples
python examples/vitreous_examples.py --example scale_point_cloud
```

--------------------------------

### Runnable Example Command

Source: https://docs.telekinesis.ai/skills/cornea/segment_image_using_flood_fill.html

This command demonstrates how to run the flood fill segmentation example from the Telekinesis examples repository after setting up the environment.

```bash
cd telekinesis-examples
python examples/cornea_examples.py --example segment_image_using_flood_fill

```

--------------------------------

### Get Cartesian Pose Example

Source: https://docs.telekinesis.ai/skills/synapse/get-cartesian-pose.html

This snippet demonstrates how to get the current TCP pose using the Synapse SDK. It can read live hardware state if an IP address is provided, otherwise it reads from an offline cache.

```python
pose = robot.get_cartesian_pose()
```

--------------------------------

### Load Image and Detect Objects with QWEN

Source: https://docs.telekinesis.ai/skills/retina/detect_objects_using_qwen.html

This example shows how to load an image from a file path and then use the `detect_objects_using_qwen` Skill to detect objects based on a natural language prompt. It includes optional logging for better traceability.

```python
from telekinesis import retina
from datatypes import io
import pathlib

# Optional for logging
from loguru import logger

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

# Load image
filepath = str(DATA_DIR / "images" / "warehouse_1.jpg")
image = io.load_image(filepath=filepath)
logger.success(f"Loaded image from {filepath}")

# Detect objects using QWEN
annotations = retina.detect_objects_using_qwen(
        image=image,
        prompt="person ."
    )

# Access results
annotations = annotations.to_list()
logger.success(
    f"Applied QWEN object detection on the given image. Detected {len(annotations)} objects."
)
```

--------------------------------

### Get Robot Status

Source: https://docs.telekinesis.ai/skills/synapse/get-robot-status.html

Retrieve the robot's current status. This is a basic example showing how to call the function.

```python
status = robot.get_robot_status()
```

--------------------------------

### Full RealSense Point Cloud Example

Source: https://docs.telekinesis.ai/skills/medulla/stream-pointcloud.html

Streams a continuous colour-mapped point cloud from a RealSense camera for 10 seconds. Ensure Rerun is installed and run from a terminal.

```python
import time
from loguru import logger

import rerun as rr

from telekinesis.medulla.cameras import realsense


def main():
    camera = realsense.RealSense(name="my_realsense_camera")
    try:
        rr.init("RealSense_Pointcloud_Video_Example", spawn=True)
        rr.log("/", rr.ViewCoordinates.RDF, static=True)
        camera.connect(width=640, height=480, fps=30)

        end_time = time.time() + 10
        while time.time() < end_time:
            point_cloud = camera.capture_video_pointcloud()
            if point_cloud is None:
                continue

            rr.log(
                "Continuous_Pointcloud_Capture",
                rr.Points3D(positions=point_cloud.positions, colors=point_cloud.colors),
            )
    except Exception as e:
        logger.error(f"Unable to stream point cloud. {type(e).__name__}: {e}")
    finally:
        camera.disconnect()


if __name__ == "__main__":
    main()
```

--------------------------------

### Run Example Script

Source: https://docs.telekinesis.ai/skills/pupil/crop_image_using_polygon.html

This command executes the crop_image_using_polygon example from the Telekinesis examples repository. Ensure you have the repository cloned and set up.

```bash
cd telekinesis-examples
python examples/pupil_examples.py --example crop_image_using_polygon
```

--------------------------------

### Get Supported Kinematics Solvers

Source: https://docs.telekinesis.ai/skills/synapse/setup-kinematics-solver.html

Retrieves a list of all kinematics solvers supported by the current Synapse installation. It's recommended to check this list before specifying a solver by name.

```python
solvers = robot.supported_kinematics_solvers
```

--------------------------------

### Run Example Script

Source: https://docs.telekinesis.ai/public/images/vitreous/reconstruct_mesh_using_convex_hull.html

Command to execute the provided example script from the Telekinesis examples repository after setting up the environment.

```bash
cd telekinesis-examples
python examples/vitreous_examples.py --example reconstruct_mesh_using_convex_hull
```

--------------------------------

### Run Project Point Cloud to Plane Example

Source: https://docs.telekinesis.ai/public/images/vitreous/project_point_cloud_to_plane.html

This bash command shows how to execute the `project_point_cloud_to_plane` example from the `telekinesis-examples` repository after setting up the environment. Navigate to the repository and run the specified Python script with the correct argument.

```bash
cd telekinesis-examples
python examples/vitreous_examples.py --example project_point_cloud_to_plane
```
Tokens:
Raw