Built for robotics engineering teams shipping real-world robots: Telekinesis is one Python library that unifies perception, reasoning, execution, and the data that trains all three, so a natural-language prompt becomes a program you can read, review, and deploy on hardware.
Applications
Bin Picking
Pick & Place
Palletizing
Assembly
Machine Tending
Sorting
Packaging
Material Handling
Bin Picking
Pick & Place
Palletizing
Assembly
Machine Tending
Sorting
Packaging
Material Handling
Bin Picking
Pick & Place
Palletizing
Assembly
Machine Tending
Sorting
Packaging
Material Handling
Architecture
The Agentic OS for Physical AI
A full-stack, standardized operating system that turns any robot into an intelligent machine.
AgentA VLM/LLM system that uses Code-as-Policy to turn a natural-language prompt into an executable robot program.
SkillsModular Physical AI capabilities for robotic perception, motion, and planning.
Data EngineData infrastructure for structuring and generating high-quality data for Physical AI training.
Hardware Abstraction LayerUltra-fast robotics communication framework (BabyROS) for cloud-to-robot connectivity.
Robotic Arm
Mobile Robot
Humanoid
Any Robot, Any Form Factor
Skills
Modular building blocks for perception, motion, and planning.
250+ production-grade Skills across four areas: strongly typed Python functions that compose into everything an Agent writes.
Vision AI
2D and 3D perception: detection, segmentation, point clouds, and the geometric operations you compose around them.
Classical Robotics
Cartesian and joint-space motion, kinematics, force and servo control, and full state readback, across every major robot brand.
VLAs & World Action Models
Learned, end-to-end policies and world-model-based behaviors for manipulation and locomotion, trained and deployed like any other Skill.
Reinforcement Learning
Sim-to-sim and sim-to-real policy training and tuning, across Gymnasium, mjlab, and Isaac Lab.
Agent
Code-as-Policy.
A VLM/LLM-powered Physical AI Agent that turns a natural-language prompt into a runnable, auditable robot program by composing Skills under the Code-as-Policy paradigm.
Data Engine
Every deployment makes the next Skill smarter.
Standardized data types, synthetic data generation, and continuous logging that closes the loop between training and deployment. The robots you ship today generate the data that improves the robots you ship next.
BabyROS gives Skills and Agents ultra-low-latency pub/sub and client/server messaging, with ROS-style ergonomics from one pip install, cloud to device over Zenoh.
PublisherSubscriberSubscriberSubscriber
Start Building
Running in five minutes, no hardware required.
Install the SDK, drop in an API key, and run a pre-built example that visualizes robot motion in software, before you ever point it at a real arm.
pip install telekinesis-aiexport TELEKINESIS_API_KEY="..."# run a pre-built example, no hardware required
Skills
The model layer of the OS.
Modular capabilities for robotic perception, motion, and planning, chained into workflows for Physical AI applications. Every Skill is one Python call with strictly typed inputs and outputs, so the output of one Skill feeds directly into the next.
Perform robust color-based segmentation using HSV color space, separating hue, saturation, and value for consistent detection under varying lighting conditions.
Flood fill image segmentation for extracting connected regions based on a seed point and color tolerance for computer vision and image processing pipelines.
Focus region segmentation for identifying in-focus areas based on image sharpness for computer vision, depth estimation, and image processing pipelines.
Adaptive per-pixel threshold segmentation for images with non-uniform lighting, shadows, and varying intensity, with control over the local-averaging method and comparison direction.
Segment objects inside bounding box prompts using Meta's Segment Anything Model (SAM), a deep-learning alternative to GrabCut for precise per-object masks.
Compute the pixel-wise bitwise AND of two same-sized images or masks, keeping only pixels where both inputs are nonzero, such as intersecting a mask with a region.
Compute the pixel-wise absolute difference between two same-sized images, highlighting regions where pixel intensities differ, such as for change or defect detection.
Compute the pixel-wise bitwise XOR of two same-sized images or masks, keeping only pixels that differ between the two, such as highlighting mask disagreement.
Apply Contrast Limited Adaptive Histogram Equalization to boost local contrast per-tile while capping noise amplification, ideal for unevenly lit images.
Automatically correct color casts caused by lighting conditions so that neutral colors in a color image appear natural, with no manual tuning required.
Compute the centroid (center of mass) of the non-zero pixels in a binary mask, returning pixel coordinates for object localization, alignment, or grasp planning.
Learn how to compute the smallest 3D axis-aligned bounding box (AABB) for a point cloud using the Telekinesis Agentic Skill Library. Ideal for Physical AI, robotics, computer vision, and scene understanding pipelines.
Learn how to compute a tightly-fitted, orientation-aware 3D bounding box (OBB) for a point cloud using the Telekinesis Agentic Skill Library. Ideal for Physical AI, robotics, computer vision, pose estimation, and grasp planning.
Learn how to compute the normal vector of a plane from its coefficients using the Telekinesis Agentic Skill Library. Ideal for Physical AI, robotics, computer vision, surface alignment, and plane-based reasoning.
Learn how to compute the geometric center (centroid) of a 3D point cloud using Telekinesis Vitreous. Useful for robotics, Physical AI, object localization, grasp planning, and reference frame computation.
Compute the dominant local direction of a 3D point cloud neighborhood using PCA for grasp planning, fine manipulation, and local feature analysis in industrial robotics.
Compute the principal directions of a 3D point cloud using PCA or OBB for industrial robotic manipulation, grasp planning, and object orientation estimation.
Segment a point cloud into clusters by detecting sharp density changes along a chosen axis using Telekinesis Agentic Skill Library. Ideal for stacked objects, layered structures, or closely packed items in robotics and Physical AI pipelines.
Segment a 3D point cloud into clusters using DBSCAN from the Telekinesis Agentic Skill Library. Ideal for detecting distinct objects, handling noise, and separating spatially distributed items in robotics and perception pipelines.
Learn how to segment point clouds by color using the Vitreous SDK. Ideal for identifying and isolating objects based on color cues in robotics, industrial pipelines, and 3D perception.
Learn how to segment planar surfaces from point clouds using the Vitreous SDK. Ideal for detecting floors, walls, tables, and other flat surfaces in robotics, industrial pipelines, and 3D perception.
Keep or remove points near an infinite 3D line defined by a point and direction vector, using the Telekinesis SDK. Ideal for isolating rods, cables, edges, or other linear structures in a point cloud.
Retain points within specified axis-aligned bounds using a passthrough filter for robotics tasks like workspace region extraction, object isolation, and perception.
Extract points within a 3D axis-aligned bounding box (AABB) to isolate regions of interest in point clouds for robotics, grasp planning, and object detection.
Remove base points from cylindrical meshes to isolate object geometry for robotics applications like pose estimation, grasp planning, and cylinder alignment.
Apply a 2D boolean mask to selectively filter points from an organized point cloud for robotics tasks like object segmentation, ROI extraction, and grasp planning.
Crop a point cloud to a rotated 3D region using an oriented bounding box (OBB) for robotics tasks like object isolation, pose estimation, and manipulation.
Extract points near a plane defined by a reference point and normal vector for robotics tasks like planar surface extraction, ground removal, and tabletop detection.
Extract points near a plane defined by coefficients [a, b, c, d] for robotics tasks like planar surface extraction, ground removal, and tabletop detection.
Retain points on one side of a plane using coefficients [a, b, c, d]. Ideal for robotics tasks like ground removal, workspace segmentation, and object separation.
Remove isolated or noisy points in a point cloud using radius-based neighbor filtering. Ideal for denoising, preprocessing, and improving 3D perception in robotics.
Remove noise from point clouds using statistical analysis of neighbor distances. Ideal for denoising, preprocessing, and improving 3D perception in robotics pipelines.
Reduce point cloud density by selecting every Nth point for faster processing. Ideal for robotics pipelines, preview generation, and preprocessing of large 3D datasets.
Remove occluded points from a point cloud based on a specific viewpoint. Ideal for robotics pipelines, sensor simulation, and occlusion-aware perception.
Reduce point cloud density using voxel downsampling. Ideal for preprocessing, registration, clustering, and segmentation in robotics and 3D point cloud workflows.
Learn how to combine two 3D point clouds into a single unified cloud using the Telekinesis Agentic Skill Library. Perfect for multi-view fusion, sensor aggregation, and robotics pipelines.
Learn how to subtract one point cloud from another using the Vitreous SDK. Ideal for isolating objects, removing backgrounds, or filtering known surfaces in robotics, industrial pipelines, and 3D perception.
Learn how to uniformly scale a point cloud about a center point using the Vitreous SDK. Ideal for resizing objects and scenes in robotics, industrial pipelines, and simulations.
Learn how to move, rotate, or align 3D point clouds using the Telekinesis Agentic Skill Library. Ideal for Physical AI, robotics, computer vision, and multi-view sensor pipelines.
Back-project a depth image into a 3D point cloud using a pinhole camera model and camera intrinsics, with the Telekinesis SDK. Ideal for turning RGB-D/depth sensor output into point clouds for robotics perception pipelines.
Convert 3D triangle meshes into point clouds using the Telekinesis SDK. Ideal for 6D pose estimation, registration, and robotic perception pipelines with controlled point sampling density.
Generate a 3D cylinder mesh using the Telekinesis SDK for pose estimation, 3D detection, and robotics perception pipelines. Ideal for representing rods, pipes, and cylindrical objects with precise geometry.
Generate a 3D plane or cuboid mesh using the Telekinesis SDK for pose estimation, 3D detection, and robotics perception pipelines. Ideal for representing floors, walls, tabletops, or planar reference surfaces.
Generate a 3D spherical mesh using the Telekinesis SDK for pose estimation, 3D detection, and robotics perception pipelines. Ideal for representing balls, spherical markers, or rounded components with precise geometry.
Generate a 3D torus mesh using the Telekinesis SDK for pose estimation, 3D detection, and robotics perception pipelines. Ideal for representing rings, wheels, or circular components with parametric precision.
Learn how to project a 3D point cloud onto a plane using general plane coefficients [a, b, c, d] with the Vitreous SDK. Useful for robotics, AI, and physical pipelines in planar alignment, ground plane removal, and feature extraction.
Learn how to project a 3D point cloud onto a plane using a reference point and normal vector with the Vitreous SDK. Useful for robotics, AI, and physical pipelines in planar alignment, registration, and feature extraction.
Learn how to reconstruct a convex mesh from a 3D point cloud using the Vitreous SDK. Ideal for robotics, AI, and physical pipelines in collision geometry, grasp planning, and simplified object modeling.
Learn how to reconstruct a smooth, watertight 3D mesh from a point cloud with normals using Poisson surface reconstruction with the Vitreous SDK. Ideal for high-quality object surfaces in robotics, AI, and industrial pipelines.
Compute a fast, coarse translation-only alignment between two point clouds by matching their centroids, using the Telekinesis SDK. Ideal as a first step before finer ICP-based registration.
Align two point clouds with an uncertain relative translation by sampling candidate translations on a 3D grid and refining each with ICP, keeping the best-scoring result.
Align two point clouds using Fast Global Registration (FGR), a feature-based method that matches points by FPFH descriptor similarity and does not require the clouds to already be roughly aligned.
Refine the alignment of two roughly pre-aligned point clouds by minimizing each source point's distance to the target surface's tangent plane, using surface normals for faster, more accurate convergence.
Refine the alignment of two roughly pre-aligned point clouds with the classic Iterative Closest Point (ICP) algorithm, minimizing raw point-to-point distances.
Align two point clouds with an uncertain relative rotation by sampling candidate rotations on a grid of Euler angles and refining each with ICP, keeping the best-scoring result.
Complete reference of calibration target types supported by Axon, ChessboardTarget, CharucoTarget, and ArucoTarget, plus target selection best practices.
detect_and_annotate() detects ChArUco corners on an image and returns an annotated copy plus the corner count. API reference for the Telekinesis Axon skill.
find_corners() detects target corners in a set of images with no calibration solve, for detection-only workflows. API reference for the Telekinesis Axon skill.
PerturbationSampler generates a structured sweep of robot poses around one or more home poses for hand-eye data collection. API reference for the Telekinesis Axon skill.
collect() drives a robot through every pose in a sampler and saves a synchronized calibration dataset to disk. API reference for the Telekinesis Axon skill.
load_configs() loads a YAML config file of robot/camera/board/sampler parameters for scripting data collection runs. API reference for the Telekinesis Axon skill.
Read and write the single-camera hand-eye dataset layout directly, for callers managing their own capture loop. API reference for the Telekinesis Axon skill.
calibrate() is the primary skill on every Axon calibrator, IntrinsicCalibrator, EyeInHandCalibrator, and MultiCameraCalibrator. API reference for the Telekinesis Axon skill.
calibrate() detects the calibration target in every image and solves the camera's intrinsic matrix and distortion coefficients via cv::calibrateCamera. API reference for the Telekinesis Axon skill.
calibrate() solves tcp_T_camera, the fixed transform between a robot's TCP and a wrist-mounted camera, via cv::calibrateHandEye. API reference for the Telekinesis Axon skill.
State-reading methods on EyeInHandCalibrator, last_result(), corner_images(), target(), and the TargetConsistencyStats struct. API reference for the Telekinesis Axon skill.
compute_camera_T_target_list() runs ChArUco detection plus solvePnP per frame to precompute target poses for EyeInHandCalibrator. API reference for the Telekinesis Axon skill.
calibrate() solves the pose of every camera in a synchronized rig relative to a reference camera via pairwise cv::stereoCalibrate. API reference for the Telekinesis Axon skill.
format_results(), print_results(), last_result(), target(), num_cameras(), and reference_index() on MultiCameraCalibrator. API reference for the Telekinesis Axon skill.
triangulate() reconstructs ChArUco corners in 3D from a solved rig and validates against known board geometry. API reference for the Telekinesis Axon skill.
calibrate_subsets() calibrates and triangulates every camera subset of a given size to isolate underperforming cameras. API reference for the Telekinesis Axon skill.
run() cross-validates an intrinsic calibration configuration and, optionally, a full eye-in-hand round trip. API reference for the Telekinesis Axon skill.
hand_eye_roundtrip() recovers base_T_board from all frames and reports the reprojection error of that round trip. API reference for the Telekinesis Axon skill.
analyze_rotation_variety() checks whether a captured hand-eye dataset spans enough of SO(3) to be well-determined. API reference for the Telekinesis Axon skill.
compare_hand_eye_methods() re-solves a hand-eye dataset with every method and flags methods that diverge from consensus. API reference for the Telekinesis Axon skill.
Train a PPO policy on any Gymnasium continuous control task with RLBotics, from a two-minute Pendulum check to a MuJoCo humanoid, then export it to ONNX.
Train a PPO policy on an mjlab task with RLBotics, running MuJoCo Warp on the GPU across thousands of parallel environments for legged locomotion and manipulation.
Train a PPO policy on an Isaac Lab task with RLBotics on Isaac Sim, covering the simulator launch order, the task registry, and the ready-made configs for locomotion and manipulation.
Every RLBotics configuration option with its type and default - environment, runner, algorithm, model, distribution and extension configs, the observation group rules, and the annotated reference YAML.
Export a trained RLBotics policy to a single self-contained ONNX file and run it on a robot with numpy and onnxruntime alone, without PyTorch or the training stack.
How to read RLBotics training curves and which hyperparameters matter - the adaptive KL schedule, standard deviation floors, entropy, network capacity, batch size and symmetry.
How the RLBotics codebase is laid out for contributors - the architecture overview, the repository folder structure, and a module-by-module tour with links to every source file on GitHub.
Train RLBotics on your own robot - implement the VecEnv interface from a copy-paste stub, or subclass the mjlab and Isaac Lab adapters for a humanoid or quadruped task.
Plug your own on-policy algorithm into the RLBotics runner - the protocol it drives, how to subclass PPO, how to add hyperparameters, and the known limitations.
View docs →
No matches. Try a different term or clear the filter.
Agents
The intelligence layer of the OS.
A VLM/LLM-powered Physical AI Agent that turns a natural-language prompt into a runnable, auditable robot program by composing Skills under the Code-as-Policy paradigm.
01
Input
A natural-language prompt plus the robot’s camera view.
02
Reasoning
The model composes the task from 250+ existing Skills, generating new ones only where the task actually needs them.
03
Output
Production-grade robot program in readable and executable Python. Nothing runs on hardware until an engineer has read and approved it.
Prompt
Pick up the aluminum parts from the angled tray and place them in the box in a grid format
Robot View
Physical AI Agent
Reasoning
VLM / LLM
Skill Library
250+ Skills
New Skills
Generated Skills
Code-as-Policy
pick_and_place.py
from telekinesis import corneafrom telekinesis.synapse import robot, gripper# Perceive: segment the target partmask = cornea.segment_image_using_sam(image, color="red")pose = estimate_pose_from_mask(mask, intrinsics)# Act: pick and place by composing Skillsrobot.set_cartesian_pose(pose, speed=0.25)gripper.close(force=50.0)robot.set_cartesian_pose(place_pose, speed=0.25)gripper.open()
A natural-language prompt and a robot view are sent to the agent.
The agent reasons with a VLM / LLM, composing from 200+ Skills, and generating new Skills when one doesn't exist yet.
It outputs readable, auditable Code-as-Policy you review before running.
The model never touches the robot directly. It writes a typed program out of the same Skills in the catalogue, so every action it takes is something you can read, diff, and replay before it runs on hardware.
Why Code-as-Policy
A policy you can read, not a black box you have to trust.
VLAs and world models hide behavior inside network weights no engineer can inspect. Our Agents write it as an ordinary program instead: version it, review the diff, roll back a regression. Manufacturing, logistics, and aerospace demand systems you can verify, not something that worked once in a demo.
An end-to-end policy means weeks of data collection to learn a new task, and a retrain-and-hope cycle every time it fails. A Code-as-Policy Agent gets there with a prompt, a line-edit, and a Skill you can reuse on the next robot. Plus it gets better every time you add one.
Category
End-to-End Policy
Code-as-Policy Agent
Output
A stream of low-level actions
A human-readable program
Auditable
No, the weights are opaque
Yes, code review applies
Fix a failure
Retrain the model
Edit the code directly
Data needed
Large, task-specific datasets
A pretrained model + existing Skills
Benchmarks
State-of-the-art, not just production-ready.
On LIBERO-PRO, the standard Physical AI benchmark, our Code-as-Policy agent outperforms every leading published VLA model, both zero-shot and fine-tuned, across object, spatial, and goal-conditioned tasks.
LIBERO-OBJECT
Telekinesis Agent (fine-tuned)
100 percent success rate
Telekinesis Agent (zero-shot)
79 percent success rate
Cap-X - Nvidia, UC Berkeley, Stanford
22 percent success rate
Pi0.5 - Physical Intelligence
20 percent success rate
UniVLA - Chinese Academy of Sciences
0 percent success rate
Pi0 - Physical Intelligence
0 percent success rate
OpenVLA - Stanford, UC Berkeley, DeepMind
0 percent success rate
LIBERO-SPATIAL
Telekinesis Agent (fine-tuned)
63 percent success rate
Telekinesis Agent (zero-shot)
36 percent success rate
Pi0.5 - Physical Intelligence
20 percent success rate
Cap-X - Nvidia, UC Berkeley, Stanford
12 percent success rate
UniVLA - Chinese Academy of Sciences
10 percent success rate
Pi0 - Physical Intelligence
0 percent success rate
OpenVLA - Stanford, UC Berkeley, DeepMind
0 percent success rate
LIBERO-GOAL
Telekinesis Agent (fine-tuned)
44 percent success rate
Telekinesis Agent (zero-shot)
43 percent success rate
Pi0.5 - Physical Intelligence
38 percent success rate
Cap-X - Nvidia, UC Berkeley, Stanford
26 percent success rate
UniVLA - Chinese Academy of Sciences
10 percent success rate
Pi0 - Physical Intelligence
0 percent success rate
OpenVLA - Stanford, UC Berkeley, DeepMind
0 percent success rate
Modes
Two ways to work, one agent underneath.
Tzara, our Physical AI Agent, adapts to how you build. Either refine interactively or generate straight to production.
Interactive refinement and debugging of generated code, inside a native VS Code extension.
Best forExploring capabilities, debugging generated code, learning by example
Code Generation
Prompt straight to Python, built for pipelines rather than back-and-forth.
Best forQuick prototyping, batch code generation, CI/CD pipelines
Data Engine
The data infrastructure layer of the OS.
Standardized data types, synthetic data generation, and continuous logging that closes the loop between training and deployment.
Overview
The robots you ship today train the robots you ship tomorrow.
Synthetic data bootstraps a new Skill before any real robot has run it. That Skill deploys to production, every run it makes is captured back into the same standardized datatypes, and that data trains the next version of the Skill, with each pass around the loop compounding on the last.
The more robots run a Skill, the faster it improves, and the faster the next deployment ships.
Synthetic data seeds the first Skills.
Skills are trained on the data.
Trained Skills deploy and execute on real robots.
Every run is captured as new data — which feeds back into training.
Synthetic Data
Skill Training
Training Loss
Deployment
Data Collection
t (ms)positions (m)
0[0.00, 0.00, 0.30]
20[0.01, −0.02, 0.29]
40[0.03, −0.05, 0.27]
60[0.06, −0.08, 0.24]
80[0.09, −0.10, 0.21]
100[0.12, −0.11, 0.19]
120[0.14, −0.11, 0.18]
140[0.15, −0.10, 0.18]
0[0.00, 0.00, 0.30]
20[0.01, −0.02, 0.29]
40[0.03, −0.05, 0.27]
60[0.06, −0.08, 0.24]
80[0.09, −0.10, 0.21]
100[0.12, −0.11, 0.19]
120[0.14, −0.11, 0.18]
140[0.15, −0.10, 0.18]
Continuous Learning Loop
Synthetic Data Generation
Photorealistic data, without a robot in the loop.
The Data Engine generates photorealistic, perfectly labeled synthetic datasets at scale, with no manual collection or annotation. Extreme Domain Randomization (EDR) aggressively varies lighting, texture, geometry, material, and pose, forcing a Skill to learn what is actually invariant about a task before it ever sees a real robot.
Randomized on every render
Lighting
Texture
Geometry
Material
Pose
SegmentationRendered
1 / 10
Data Logging and Continual Learning
Every run is captured, and every capture is training data.
Every Skill run in production is captured through the same standardized types: typed inputs and outputs, sensor streams, transforms, trajectories, and outcomes. Contract-shaped data flows straight into training, the resulting Skills redeploy, and each run becomes the training set for the next: continual learning, not a one-time export.
Live Feed
→
→
Detection Logger
→
Dataset
📁 images/0
train/
val/
test/
📁 labels/
📄 data.yaml
80%10%10%
Datatypes as Contracts
A typed contract for every signal.
Every signal exchanged between a Skill, an Agent, and the Data Engine moves through a strongly typed contract. Because the shape is known up front, the Data Engine can fix it, turning asynchronous, mismatched-rate robot data into the synchronous, aligned, fixed-size batches training actually expects.
Return type of COCOObjectDetectionAnnotations.as_masks().
View docs →
No results. Try a shorter word, or clear the filter.
Communication
The hardware communication layer of the OS.
Ultra-fast, lightweight middleware for cloud-to-robot communication, built on Zenoh. One-to-many pub/sub streaming and request/response client/server messaging in Python with zero schema files: no DDS complexity, no .msg files, native cloud-to-device messaging without ROS 2’s setup overhead.
Built for speed
Publisher / Subscriber
One-to-many, one-way streaming: a node publishes on a topic and every subscriber gets it, with no reply expected.
Client / Server
Request/response, round-trip: a client calls a service and waits on exactly one server to answer.
No ROS 2, No DDS
One install. No middleware to configure.
Every setup step ROS 2 requires gets replaced with something simpler. Install becomes one pip command. Message schemas become plain Python objects. DDS becomes Zenoh, handling shared memory and cloud-to-device out of the box. Python and Zenoh are the only dependencies left.
RETINA
Robotic Arm
Mobile Robot
Humanoid
RETINA
RETINA
RETINA
RETINA
RETINA
CORNEA
CORNEA
CORNEA
CORNEA
CORNEA
CORNEA
CORNEA
CORNEA
CORNEA
CORNEA
CORNEA
CORNEA
CORNEA
CORNEA
CORNEA
CORNEA
CORNEA
CORNEA
CORNEA
CORNEA
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
PUPIL
VITREOUS
SYNAPSE
SYNAPSE
SYNAPSE
SYNAPSE
SYNAPSE
SYNAPSE
SYNAPSE
SYNAPSE
SYNAPSE
SYNAPSE
TF
TF
TF
TF
TF
TF
TF
TF
TF
SYNTHETIC DATA
SYNTHETIC DATA
SYNTHETIC DATA
SYNTHETIC DATA
SYNTHETIC DATA
SYNTHETIC DATA
SYNTHETIC DATA
SYNTHETIC DATA
SYNTHETIC DATA
SYNTHETIC DATA
SYNTHETIC DATA
SYNTHETIC DATA
SYNTHETIC DATA
SYNTHETIC DATA
SYNTHETIC DATA
SYNTHETIC DATA
SYNTHETIC DATA
SYNTHETIC DATA
SYNTHETIC DATA
SYNTHETIC DATA
SYNTHETIC DATA
SYNTHETIC DATA
SYNTHETIC DATA
SYNTHETIC DATA
SYNTHETIC DATA