Open3D

https://www.open3d.org/docs/latest/
Admin
Open3D is an open-source library for rapid development of software that deals with 3D data,...
Tokens:2,932,208
Snippets:26,015
Trust Score:9.4
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Install JupyterLab and start server

Source: https://www.open3d.org/docs/latest/tutorial/visualization/web_visualizer.html

Alternative to the Jupyter installation: installs JupyterLab and starts the JupyterLab server.

```bash
pip install jupyterlab
jupyter-lab

```

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

### Install Jupyter and start notebook

Source: https://www.open3d.org/docs/latest/tutorial/visualization/web_visualizer.html

Installs Jupyter and starts a notebook server for using the WebVisualizer widget in Jupyter mode.

```bash
pip install jupyter
jupyter notebook

```

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

### Getting the example code

Source: https://www.open3d.org/docs/latest/tutorial/t_reconstruction_system/index.html

Commands to clone the Open3D repository and run the dense SLAM GUI example. Shows how to activate the conda environment and display CLI help.

```bash
# Activate your conda environment, where you have installed open3d pip package.
# Clone the Open3D github repository and go to the example.
cd examples/python/t_reconstruction_system/

# Show CLI help for ``dense_slam_gui.py``
python dense_slam_gui.py --help
```

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

### Navigate to example and show CLI help for dense_slam_gui.py

Source: https://www.open3d.org/docs/latest/tutorial/reconstruction_system/system_overview.html

Navigate to the reconstruction system example directory and display the CLI help for dense_slam_gui.py. Requires a conda environment with the Open3D pip package installed and a clone of the Open3D GitHub repository.

```bash
# Activate your conda environment, where you have installed open3d pip package.
# Clone the Open3D github repository and go to the example.
cd examples/python/reconstruction_system/

# Show CLI help for `run_system.py`
python dense_slam_gui.py --help

```

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

### Manage Bundled Examples via CLI

Source: https://www.open3d.org/docs/latest/agent_skills/open3d-python/SKILL.html

List, display, or execute examples included with the Open3D wheel.

```bash
open3d example --list                                   # all categories
open3d example --list geometry                          # one category
open3d example --show geometry/point_cloud_convex_hull  # print source
open3d example geometry/point_cloud_convex_hull         # run it
```

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

### Locate Bundled Examples Directory

Source: https://www.open3d.org/docs/latest/agent_skills/open3d-python/SKILL.html

Print the file system path where the Open3D examples are stored.

```bash
python -c "import open3d,os;print(os.path.join(os.path.dirname(open3d.__file__),'examples'))"
```

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

### Run Open3D CLI example

Source: https://www.open3d.org/docs/latest/cpp_api/index.html

Run the Open3D CLI example for visualization/draw.

```bash
open3d example visualization/draw
```

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

### Verify Docker installation with docker run hello-world

Source: https://www.open3d.org/docs/latest/docker.html

Verifies that Docker is installed correctly and that the docker command can be executed without root privileges. Run this after installing Docker and completing the post-installation steps on Linux.

```bash
# You should be able to run this without sudo.
docker run hello-world

```

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

### Select and run TensorBoard 3D summary examples from CLI

Source: https://www.open3d.org/docs/latest/python_example/visualization/index.html

Command-line entry point that selects which example functions to run based on sys.argv. Valid examples are 'small_scale', 'large_scale', 'property_reference', 'with_material', and 'demo_scene'; if none are provided, it prints usage and defaults to 'property_reference' and 'with_material'. After running, it prints the tensorboard command to visualize the 3D summary.

```python
if __name__ == "__main__":

    examples = ('small_scale', 'large_scale', 'property_reference',
                'with_material', 'demo_scene')
    selected = tuple(eg for eg in sys.argv[1:] if eg in examples)
    if len(selected) == 0:
        print(f'Usage: python {__file__} EXAMPLE...')
        print(f'  where EXAMPLE are from {examples}')
        selected = ('property_reference', 'with_material')

    for eg in selected:
        locals()[eg]()

    print(f"Run 'tensorboard --logdir {BASE_LOGDIR}' to visualize the 3D "
          "summary.")
```

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

### Run selected TensorBoard examples from command line

Source: https://www.open3d.org/docs/latest/python_example/visualization/index.html

Main entry point that selects and runs example functions based on command-line arguments. If no valid example is given, it prints usage and defaults to 'property_reference' and 'with_material'. It closes the async data writer and prints a TensorBoard command to visualize the summary.

```python
if __name__ == "__main__":

    examples = ('small_scale', 'large_scale', 'property_reference',
                'with_material', 'demo_scene')
    selected = tuple(eg for eg in sys.argv[1:] if eg in examples)
    if len(selected) == 0:
        print(f'Usage: python {__file__} EXAMPLE...')
        print(f'  where EXAMPLE are from {examples}')
        selected = ('property_reference', 'with_material')

    try:
        for eg in selected:
            locals()[eg]()
    finally:
        summary._async_data_writer.close()

    print(f"Run 'tensorboard --logdir {BASE_LOGDIR}' to visualize the 3D "
          "summary.")
```

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

### Run Python draw_webrtc example

Source: https://www.open3d.org/docs/latest/tutorial/visualization/web_visualizer.html

Run the Python draw_webrtc example and open the visualizer in a browser. The complete source code is in examples/python/visualization/draw_webrtc.py.

```bash
python examples/python/visualization/draw_webrtc.py
google-chrome http://localhost:8888  # Or, open the address in your browser
```

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

### Install Open3D C++ library

Source: https://www.open3d.org/docs/latest/compilation.html

Installs the Open3D C++ library to the configured prefix.

```bash
make install

```

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

### Build and run C++ DrawWebRTC example

Source: https://www.open3d.org/docs/latest/tutorial/visualization/web_visualizer.html

Build and run the DrawWebRTC example in C++. The complete source code is in examples/cpp/DrawWebRTC.cpp.

```bash
mkdir build && cd build
cmake ..
make DrawWebRTC -j$(nproc)
cd bin/example
./DrawWebRTC
google-chrome http://localhost:8888  # Or, open the address in your browser
```

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

### Install Ubuntu dependencies for building docs

Source: https://www.open3d.org/docs/latest/builddocs.html

Install required system dependencies for building documentation on Ubuntu.

```bash
sudo apt-get -y install doxygen texlive texlive-latex-extra ghostscript pandoc

```

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

### Build and run RealSenseRecorder example

Source: https://www.open3d.org/docs/latest/tutorial/sensor/realsense.html

Build and run the complete C++ RealSenseRecorder example. The recording can be paused/resumed with [SPACE] and stopped with [ESC]. Requires the rs_default_config.json file.

```bash
make RealSenseRecorder
bin/examples/RealSenseRecorder --config ../examples/test_data/rs_default_config.json --record test_data.bag

```

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

### Install and test Open3D wheel

Source: https://www.open3d.org/docs/latest/arm.html

Install the generated Open3D wheel and verify the installation. Optionally activate a virtual environment first. The test commands import Open3D, create a box mesh, and visualize it using either draw_geometries or draw.

```bash
# Optional: activate your virtualenv
conda activate your-virtual-env

# Install and test
pip install open3d-*.whl
python -c "import open3d; print(open3d.__version__)"
python -c "import open3d as o3d; c = o3d.geometry.TriangleMesh.create_box(); o3d.visualization.draw_geometries([c])"
python -c "import open3d as o3d; c = o3d.geometry.TriangleMesh.create_box(); o3d.visualization.draw(c)"

```

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

### Example config for online reconstruction system

Source: https://www.open3d.org/docs/latest/tutorial/t_reconstruction_system/index.html

Example configuration file for the online reconstruction system. Set 'path_dataset' to the data directory and override parameters as needed.

```yaml
name: Default reconstruction system config
fragment_size: 100
# Set to CUDA:0 or SYCL:0 when the corresponding backend is available.
device: CUDA:0
engine: tensor
multiprocessing: false
path_dataset: ''
depth_folder: depth
color_folder: color
path_intrinsic: ''
path_color_intrinsic: ''
depth_min: 0.1
depth_max: 3.0
depth_scale: 1000.0
odometry_method: hybrid
odometry_loop_interval: 10
odometry_loop_weight: 0.1
odometry_distance_thr: 0.07
icp_method: colored
icp_voxelsize: 0.05
icp_distance_thr: 0.07
global_registration_method: ransac
registration_loop_weight: 0.1
integrate_color: true
voxel_size: 0.0058
trunc_voxel_multiplier: 8.0
block_count: 40000
est_point_count: 6000000
surface_weight_thr: 3.0
```

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

### Verify Open3D installation

Source: https://www.open3d.org/docs/latest/getting_started.html

Commands to verify the Open3D installation: check the version, run a Python API example that creates and draws a sphere, and run the Open3D CLI example. If these commands work, Open3D is installed successfully.

```bash
# Verify installation
python -c "import open3d as o3d; print(o3d.__version__)"

# Python API
python -c "import open3d as o3d; \
           mesh = o3d.geometry.TriangleMesh.create_sphere(); \
           mesh.compute_vertex_normals(); \
           o3d.visualization.draw(mesh, raw_mode=True)"

# Open3D CLI
open3d example visualization/draw

```

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

### Install Open3D with pip

Source: https://www.open3d.org/docs/latest/builddocs.html

Install Open3D via pip. Alternatively, build from source as described in the Build from source guide.

```bash
pip install open3d

```

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

### O3DVisualizer.setup_camera()

Source: https://www.open3d.org/docs/latest/python_api/open3d.visualization.O3DVisualizer.html

Sets up the camera with the given parameters.

```APIDOC
## O3DVisualizer.setup_camera()

### Description
Sets up the camera with the given parameters.

### Parameters
- **field_of_view** (float) - Required - The field of view in degrees.
- **center** (list) - Required - The camera center [x, y, z].
- **eye** (list) - Required - The eye position [x, y, z].
- **up** (list) - Required - The up vector [x, y, z].
```

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

### Install Open3D with ML extra

Source: https://www.open3d.org/docs/latest/getting_started.html

Installs Open3D with the 'ml' extra to get the additional Python packages required for Open3D-ML models and pipelines (open3d.ml.torch, open3d.ml.tf). These packages are not installed by default.

```bash
pip install open3d[ml]        # or open3d-cpu[ml] / open3d-xpu[ml]

```

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

### k4a_device_get_installed_count

Source: https://www.open3d.org/docs/latest/cpp_api/_k4a_plugin_8h_source.html

Gets the number of installed Azure Kinect devices.

```APIDOC
## k4a_device_get_installed_count

### Description
Gets the number of installed Azure Kinect devices.

### Signature
```cpp
uint32_t k4a_device_get_installed_count(void);
```

### Returns
- **uint32_t** - Number of installed devices.
```

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

### Setup

Source: https://www.open3d.org/docs/latest/cpp_api/classopen3d_1_1core_1_1_c_u_d_a_hash_backend_buffer_accessor.html

Initializes the buffer accessor with a hashmap buffer.

```APIDOC
## Setup(HashBackendBuffer &hashmap_buffer)

### Description
Initializes the buffer accessor with a hashmap buffer.

### Method
Setup

### Parameters
- **hashmap_buffer** (HashBackendBuffer&) - Required - The hashmap buffer to set up.

### Returns
void
```

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

### Install and verify Open3D with pip and Python API

Source: https://www.open3d.org/docs/latest/introduction.html

Install Open3D via pip, verify the installation, run a Python API example that creates and draws a sphere, and invoke the Open3D CLI. The open3d-cpu wheel is a smaller CPU-only option for x86_64 Linux (v0.17+).

```bash
# Install
pip install open3d       # or
pip install open3d-cpu   # Smaller CPU only wheel on x86_64 Linux (v0.17+)

# Verify installation
python -c "import open3d as o3d; print(o3d.__version__)"

# Python API
python -c "import open3d as o3d; \
           mesh = o3d.geometry.TriangleMesh.create_sphere(); \
           mesh.compute_vertex_normals(); \
           o3d.visualization.draw(mesh, raw_mode=True)"

# Open3D CLI
open3d example visualization/draw

```

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

### Get Open3D Python module path

Source: https://www.open3d.org/docs/latest/tutorial/sensor/azure_kinect.html

Prints the directory where the Open3D Python module is installed. Useful for locating the DLLs to copy if the K4A library is not found on Windows.

```bash
python -c "import open3d as o3d; import os; print(os.path.dirname(o3d.__file__))"
```

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

### Poor Initialization Setup

Source: https://www.open3d.org/docs/latest/tutorial/t_pipelines/t_icp_registration.html

Sets up the initial transformation as an identity matrix and the maximum correspondence distance for ICP when starting with poor initial alignment. This is the first step before running the registration.

```python
init_source_to_target = o3d.core.Tensor.eye(4, o3d.core.Dtype.Float32)
max_correspondence_distance = 0.07
```

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

### Main function and entry point

Source: https://www.open3d.org/docs/latest/python_example/visualization/index.html

Initializes the GUI application, creates the example window, and runs the event loop. The entry point checks if the script is run directly.

```python
def main():
    # We need to initialize the application, which finds the necessary shaders for
    # rendering and prepares the cross-platform window abstraction.
    gui.Application.instance.initialize()

    w = ExampleWindow()

    # Run the event loop. This will not return until the last window is closed.
    gui.Application.instance.run()


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

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

### Create RaggedTensor with from_row_splits

Source: https://www.open3d.org/docs/latest/python_api/open3d.ml.torch.classes.RaggedTensor.html

Creates a RaggedTensor from values and row_splits. The example shows a tensor with rows [3,1,4,1], [], [5,9,2], [6], and []. The row_splits must be ascending, start at 0, and end at N.

```python
>>> print(ml3d.classes.RaggedTensor.from_row_splits(
...     values=[3, 1, 4, 1, 5, 9, 2, 6],
...     row_splits=[0, 4, 4, 7, 8, 8]))
<RaggedTensor [[3, 1, 4, 1], [], [5, 9, 2], [6], []]>
```

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

### Initialize()

Source: https://www.open3d.org/docs/latest/cpp_api/classopen3d_1_1visualization_1_1rendering_1_1_gaussian_splat_vulkan_context.html

Initializes the Vulkan context by loading Vulkan via BlueVK, selecting the best device, and creating a logical device with compute capabilities. Returns false on failure; call GetLastError() for a diagnostic string.

```APIDOC
## Initialize()

### Description
Initializes the Vulkan context by loading Vulkan via BlueVK, selecting the best device, and creating a logical device with compute capabilities. Returns false on failure; call GetLastError() for a diagnostic string.

### Method
Initialize

### Signature
`bool open3d::visualization::rendering::GaussianSplatVulkanContext::Initialize()`

### Parameters
None

### Returns
- **bool** - True on success, false on failure.

### Details
- Loads Vulkan via BlueVK.
- Scores suitable devices by type: discrete GPU (200), integrated GPU (100), CPU/software renderer (0).
- Selects the first device with the highest score.
- Creates a logical device with compute capabilities.
- Requests two queue indices from the graphics queue family: index 0 for GS compute, index 1 for Filament.
- On single-queue GPUs both indices are 0 and flushAndWait bracketing provides mutual exclusion.

```

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

### Open3D visualization draw.py example

Source: https://www.open3d.org/docs/latest/python_example/visualization/index.html

Complete draw.py example from Open3D visualization documentation. It defines helper functions for point cloud creation and normalization, then demonstrates vis.draw with a single object, multiple objects with bounding boxes and line sets, and interactive actions for Poisson reconstruction and toggling visibility. The final function get_icp_transform is incomplete, showing only the start of correspondence-based ICP transformation estimation.

```python
import math
import numpy as np
import open3d as o3d
import open3d.visualization as vis
import os
import random
import warnings

pyexample_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
test_data_path = os.path.join(os.path.dirname(pyexample_path), 'test_data')


def normalize(v):
    a = 1.0 / math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2])
    return (a * v[0], a * v[1], a * v[2])


def make_point_cloud(npts, center, radius, colorize):
    pts = np.random.uniform(-radius, radius, size=[npts, 3]) + center
    cloud = o3d.geometry.PointCloud()
    cloud.points = o3d.utility.Vector3dVector(pts)
    if colorize:
        colors = np.random.uniform(0.0, 1.0, size=[npts, 3])
        cloud.colors = o3d.utility.Vector3dVector(colors)
    return cloud


def single_object():
    # No colors, no normals, should appear unlit black
    cube = o3d.geometry.TriangleMesh.create_box(1, 2, 4)
    vis.draw(cube)


def multi_objects():
    pc_rad = 1.0
    pc_nocolor = make_point_cloud(100, (0, -2, 0), pc_rad, False)
    pc_color = make_point_cloud(100, (3, -2, 0), pc_rad, True)
    r = 0.4
    sphere_unlit = o3d.geometry.TriangleMesh.create_sphere(r)
    sphere_unlit.translate((0, 1, 0))
    sphere_colored_unlit = o3d.geometry.TriangleMesh.create_sphere(r)
    sphere_colored_unlit.paint_uniform_color((1.0, 0.0, 0.0))
    sphere_colored_unlit.translate((2, 1, 0))
    sphere_lit = o3d.geometry.TriangleMesh.create_sphere(r)
    sphere_lit.compute_vertex_normals()
    sphere_lit.translate((4, 1, 0))
    sphere_colored_lit = o3d.geometry.TriangleMesh.create_sphere(r)
    sphere_colored_lit.compute_vertex_normals()
    sphere_colored_lit.paint_uniform_color((0.0, 1.0, 0.0))
    sphere_colored_lit.translate((6, 1, 0))
    big_bbox = o3d.geometry.AxisAlignedBoundingBox((-pc_rad, -3, -pc_rad),
                                                   (6.0 + r, 1.0 + r, pc_rad))
    big_bbox.color = (0.0, 0.0, 0.0)
    sphere_bbox = sphere_unlit.get_axis_aligned_bounding_box()
    sphere_bbox.color = (1.0, 0.5, 0.0)
    lines = o3d.geometry.LineSet.create_from_axis_aligned_bounding_box(
        sphere_lit.get_axis_aligned_bounding_box())
    lines.paint_uniform_color((0.0, 1.0, 0.0))
    lines_colored = o3d.geometry.LineSet.create_from_axis_aligned_bounding_box(
        sphere_colored_lit.get_axis_aligned_bounding_box())
    lines_colored.paint_uniform_color((0.0, 0.0, 1.0))

    vis.draw([
        pc_nocolor, pc_color, sphere_unlit, sphere_colored_unlit, sphere_lit,
        sphere_colored_lit, big_bbox, sphere_bbox, lines, lines_colored
    ])


def actions():
    SOURCE_NAME = "Source"
    RESULT_NAME = "Result (Poisson reconstruction)"
    TRUTH_NAME = "Ground truth"

    bunny = o3d.data.BunnyMesh()
    bunny_mesh = o3d.io.read_triangle_mesh(bunny.path)
    bunny_mesh.compute_vertex_normals()

    bunny_mesh.paint_uniform_color((1, 0.75, 0))
    bunny_mesh.compute_vertex_normals()
    cloud = o3d.geometry.PointCloud()
    cloud.points = bunny_mesh.vertices
    cloud.normals = bunny_mesh.vertex_normals

    def make_mesh(o3dvis):
        # TODO: call o3dvis.get_geometry instead of using bunny_mesh
        mesh, _ = o3d.geometry.TriangleMesh.create_from_point_cloud_poisson(
            cloud)
        mesh.paint_uniform_color((1, 1, 1))
        mesh.compute_vertex_normals()
        o3dvis.add_geometry({"name": RESULT_NAME, "geometry": mesh})
        o3dvis.show_geometry(SOURCE_NAME, False)

    def toggle_result(o3dvis):
        truth_vis = o3dvis.get_geometry(TRUTH_NAME).is_visible
        o3dvis.show_geometry(TRUTH_NAME, not truth_vis)
        o3dvis.show_geometry(RESULT_NAME, truth_vis)

    vis.draw([{
        "name": SOURCE_NAME,
        "geometry": cloud
    }, {
        "name": TRUTH_NAME,
        "geometry": bunny_mesh,
        "is_visible": False
    }],
             actions=[("Create Mesh", make_mesh),
                      ("Toggle truth/result", toggle_result)])


def get_icp_transform(source, target, source_indices, target_indices):
    corr = np.zeros((len(source_indices), 2))
    corr[:, 0] = source_indices
    corr[:, 1] = target_indices

    # Estimate rough transformation using correspondences
```

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

### setup_camera(*args, **kwargs) -> None

Source: https://www.open3d.org/docs/latest/python_api/open3d.visualization.gui.SceneWidget.html

Overloaded function to configure the camera. Three overloads are available: (1) setup_camera(field_of_view, model_bounds, center_of_rotation), (2) setup_camera(intrinsics, extrinsic_matrix, model_bounds), (3) setup_camera(intrinsic_matrix, extrinsic_matrix, intrinsic_width_px, intrinsic_height_px, model_bounds).

```APIDOC
## setup_camera(*args, **kwargs) -> None

### Description
Overloaded function to configure the camera. Three overloads are available: (1) setup_camera(field_of_view, model_bounds, center_of_rotation), (2) setup_camera(intrinsics, extrinsic_matrix, model_bounds), (3) setup_camera(intrinsic_matrix, extrinsic_matrix, intrinsic_width_px, intrinsic_height_px, model_bounds).

### Overload 1
#### Parameters
- **field_of_view** (SupportsFloat) - The field of view.
- **model_bounds** (AxisAlignedBoundingBox) - The model bounds.
- **center_of_rotation** (ArrayLike[float32, '[3, 1]']) - The center of rotation.

### Overload 2
#### Parameters
- **intrinsics** (PinholeCameraIntrinsic) - The camera intrinsics.
- **extrinsic_matrix** (ArrayLike[float64, '[4, 4]']) - The extrinsic matrix.
- **model_bounds** (AxisAlignedBoundingBox) - The model bounds.

### Overload 3
#### Parameters
- **intrinsic_matrix** (ArrayLike[float64, '[3, 3]']) - The intrinsic matrix.
- **extrinsic_matrix** (ArrayLike[float64, '[4, 4]']) - The extrinsic matrix.
- **intrinsic_width_px** (SupportsInt) - The intrinsic width in pixels.
- **intrinsic_height_px** (SupportsInt) - The intrinsic height in pixels.
- **model_bounds** (AxisAlignedBoundingBox) - The model bounds.

### Returns
None
```

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

### Debug output from full_registration

Source: https://www.open3d.org/docs/latest/tutorial/pipelines/multiway_registration.html

Example debug output from full_registration showing point-to-plane ICP iterations with fitness, RMSE, and residual values. The output includes two ICP runs and ends with building the pose graph and starting another ICP run.

```text
Full registration ...
Apply point-to-plane ICP
[Open3D DEBUG] ICP Iteration #0: Fitness 0.6258, RMSE 0.1566
[Open3D DEBUG] Residual : 1.85e-02 (# of elements : 17029)
[Open3D DEBUG] ICP Iteration #1: Fitness 0.6873, RMSE 0.1427
[Open3D DEBUG] Residual : 1.34e-02 (# of elements : 18703)
[Open3D DEBUG] ICP Iteration #2: Fitness 0.7258, RMSE 0.1364
[Open3D DEBUG] Residual : 1.11e-02 (# of elements : 19751)
[Open3D DEBUG] ICP Iteration #3: Fitness 0.7514, RMSE 0.1330
[Open3D DEBUG] Residual : 1.02e-02 (# of elements : 20446)
[Open3D DEBUG] ICP Iteration #4: Fitness 0.7743, RMSE 0.1296
[Open3D DEBUG] Residual : 9.36e-03 (# of elements : 21070)
[Open3D DEBUG] ICP Iteration #5: Fitness 0.7881, RMSE 0.1214
[Open3D DEBUG] Residual : 7.82e-03 (# of elements : 21444)
[Open3D DEBUG] ICP Iteration #6: Fitness 0.7959, RMSE 0.1142
[Open3D DEBUG] Residual : 6.81e-03 (# of elements : 21657)
[Open3D DEBUG] ICP Iteration #7: Fitness 0.8024, RMSE 0.1127
[Open3D DEBUG] Residual : 6.56e-03 (# of elements : 21833)
[Open3D DEBUG] ICP Iteration #8: Fitness 0.8026, RMSE 0.1108
[Open3D DEBUG] Residual : 6.34e-03 (# of elements : 21840)
[Open3D DEBUG] ICP Iteration #9: Fitness 0.7959, RMSE 0.1050
[Open3D DEBUG] Residual : 5.79e-03 (# of elements : 21658)
[Open3D DEBUG] ICP Iteration #10: Fitness 0.7816, RMSE 0.0914
[Open3D DEBUG] Residual : 4.30e-03 (# of elements : 21268)
[Open3D DEBUG] ICP Iteration #11: Fitness 0.7676, RMSE 0.0758
[Open3D DEBUG] Residual : 2.52e-03 (# of elements : 20887)
[Open3D DEBUG] ICP Iteration #12: Fitness 0.7573, RMSE 0.0682
[Open3D DEBUG] Residual : 1.73e-03 (# of elements : 20606)
[Open3D DEBUG] ICP Iteration #13: Fitness 0.7525, RMSE 0.0656
[Open3D DEBUG] Residual : 1.48e-03 (# of elements : 20475)
[Open3D DEBUG] ICP Iteration #14: Fitness 0.7500, RMSE 0.0645
[Open3D DEBUG] Residual : 1.40e-03 (# of elements : 20407)
[Open3D DEBUG] ICP Iteration #15: Fitness 0.7489, RMSE 0.0639
[Open3D DEBUG] Residual : 1.36e-03 (# of elements : 20377)
[Open3D DEBUG] ICP Iteration #16: Fitness 0.7482, RMSE 0.0635
[Open3D DEBUG] Residual : 1.32e-03 (# of elements : 20358)
[Open3D DEBUG] ICP Iteration #17: Fitness 0.7477, RMSE 0.0632
[Open3D DEBUG] Residual : 1.31e-03 (# of elements : 20347)
[Open3D DEBUG] ICP Iteration #18: Fitness 0.7476, RMSE 0.0631
[Open3D DEBUG] Residual : 1.30e-03 (# of elements : 20342)
[Open3D DEBUG] ICP Iteration #19: Fitness 0.7475, RMSE 0.0631
[Open3D DEBUG] Residual : 1.29e-03 (# of elements : 20341)
[Open3D DEBUG] ICP Iteration #20: Fitness 0.7475, RMSE 0.0630
[Open3D DEBUG] Residual : 1.29e-03 (# of elements : 20339)
[Open3D DEBUG] ICP Iteration #21: Fitness 0.7473, RMSE 0.0629
[Open3D DEBUG] Residual : 1.29e-03 (# of elements : 20335)
[Open3D DEBUG] ICP Iteration #22: Fitness 0.7473, RMSE 0.0629
[Open3D DEBUG] Residual : 1.28e-03 (# of elements : 20334)
[Open3D DEBUG] ICP Iteration #23: Fitness 0.7472, RMSE 0.0628
[Open3D DEBUG] Residual : 1.28e-03 (# of elements : 20331)
[Open3D DEBUG] ICP Iteration #24: Fitness 0.7471, RMSE 0.0627
[Open3D DEBUG] Residual : 1.28e-03 (# of elements : 20329)
[Open3D DEBUG] ICP Iteration #25: Fitness 0.7470, RMSE 0.0627
[Open3D DEBUG] Residual : 1.27e-03 (# of elements : 20326)
[Open3D DEBUG] ICP Iteration #26: Fitness 0.7469, RMSE 0.0626
[Open3D DEBUG] Residual : 1.27e-03 (# of elements : 20325)
[Open3D DEBUG] ICP Iteration #27: Fitness 0.7469, RMSE 0.0626
[Open3D DEBUG] Residual : 1.27e-03 (# of elements : 20324)
[Open3D DEBUG] ICP Iteration #28: Fitness 0.7469, RMSE 0.0626
[Open3D DEBUG] Residual : 1.26e-03 (# of elements : 20323)
[Open3D DEBUG] ICP Iteration #29: Fitness 0.7469, RMSE 0.0626
[Open3D DEBUG] Residual : 1.26e-03 (# of elements : 20323)
[Open3D DEBUG] ICP Iteration #0: Fitness 0.5852, RMSE 0.0139
[Open3D DEBUG] Residual : 1.17e-04 (# of elements : 15924)
[Open3D DEBUG] ICP Iteration #1: Fitness 0.6369, RMSE 0.0121
[Open3D DEBUG] Residual : 7.15e-05 (# of elements : 17332)
[Open3D DEBUG] ICP Iteration #2: Fitness 0.6395, RMSE 0.0102
[Open3D DEBUG] Residual : 3.27e-05 (# of elements : 17402)
[Open3D DEBUG] ICP Iteration #3: Fitness 0.6390, RMSE 0.0101
[Open3D DEBUG] Residual : 3.13e-05 (# of elements : 17388)
[Open3D DEBUG] ICP Iteration #4: Fitness 0.6392, RMSE 0.0101
[Open3D DEBUG] Residual : 3.13e-05 (# of elements : 17392)
[Open3D DEBUG] ICP Iteration #5: Fitness 0.6391, RMSE 0.0101
[Open3D DEBUG] Residual : 3.13e-05 (# of elements : 17390)
Build o3d.pipelines.registration.PoseGraph
Apply point-to-plane ICP
[Open3D DEBUG] ICP Iteration #0: Fitness 0.5669, RMSE 0.1655

```

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

### Build Draw executable with pkg-config

Source: https://www.open3d.org/docs/latest/cpp_project.html

Use pkg-config to build the Draw executable from the example project. Set PKG_CONFIG_PATH to the Open3D install's pkgconfig directory, then compile with c++. The pkg-config --libs options must appear after source files to avoid unrecognized symbol linker errors.

```bash
export PKG_CONFIG_PATH="$PKG_CONFIG_PATH:<Open3D_install_path>/lib/pkgconfig"
c++ Draw.cpp -o Draw $(pkg-config --cflags --libs Open3D)

```

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

### Capture and record RealSense frames in Python

Source: https://www.open3d.org/docs/latest/tutorial/sensor/realsense.html

Python equivalent of the C++ RealSense capture example. Loads the sensor configuration from a JSON file, initializes the sensor, starts capture with recording, captures 150 aligned frames, and stops capture. For high-resolution capture, consider deferring alignment by setting align_depth_to_color=false during capture.

```python
import json
import open3d as o3d
with open(config_filename) as cf:
    rs_cfg = o3d.t.io.RealSenseSensorConfig(json.load(cf))

rs = o3d.t.io.RealSenseSensor()
rs.init_sensor(rs_cfg, 0, bag_filename)
rs.start_capture(True)  # true: start recording with capture
for fid in range(150):
    im_rgbd = rs.capture_frame(True, True)  # wait for frames and align them
    # process im_rgbd.depth and im_rgbd.color

rs.stop_capture()

```

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

### Verify Open3D installation

Source: https://www.open3d.org/docs/latest/cpp_api/index.html

Verify the Open3D installation by printing the installed version.

```bash
python -c "import open3d as o3d; print(o3d.__version__)"
```

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

### Main script: argument parsing, Mitsuba variant selection, and input validation

Source: https://www.open3d.org/docs/latest/python_example/visualization/index.html

Main entry point: parses command-line arguments, initializes Mitsuba variant based on device (llvm_ad_rgb for CPU, cuda_ad_rgb for GPU), and verifies that the required input files exist. Exits with an error message if any required file is missing.

```python
if __name__ == '__main__':
    parser = argparse.ArgumentParser(
        description=
        "Script that estimates texture and environment map from an input image and geometry. You can find data to test this script here: https://github.com/isl-org/open3d_downloads/releases/download/mitsuba-demos/raven_mitsuba.zip.",
        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
    parser.add_argument(
        'object_path',
        type=Path,
        help=
        "Path to geometry for which to estimate albedo. It is assumed that in the same directory will be an object-name.npz which contains the camera pose information and an object-name.png which is the input image"
    )
    parser.add_argument('--env-width', type=int, default=1024)
    parser.add_argument('--tex-width',
                        type=int,
                        default=2048,
                        help="The dimensions of the texture")
    parser.add_argument(
        '--device',
        default='cuda' if o3d.core.cuda.is_available() else 'cpu',
        choices=('cpu', 'cuda'),
        help="Run Mitsuba on 'cuda' or 'cpu'")
    parser.add_argument('--iterations',
                        type=int,
                        default=40,
                        help="Number of iterations")
    parser.add_argument(
        '--total-variation',
        type=float,
        default=0.01,
        help="Factor to apply to total_variation loss. 0.0 disables TV")

    if len(sys.argv) < 2:
        parser.print_help(sys.stderr)
        sys.exit(1)
    args = parser.parse_args()
    print("Arguments: ", vars(args))

    # Initialize Mitsuba
    if args.device == 'cpu':
        mi.set_variant('llvm_ad_rgb')
    else:
        mi.set_variant('cuda_ad_rgb')

    # Confirm that the 3 required inputs exist
    object_path = args.object_path
    object_name = object_path.stem
    datadir = args.object_path.parent
    camera_pose = datadir / (object_name + '.npz')
    input_image = datadir / (object_name + '.png')
    if not object_path.exists():
        print(f'{object_path} does not exist!')
        sys.exit()
    if not camera_pose.exists():
        print(f'{camera_pose} does not exist!')
        sys.exit()
    if not input_image.exists():
        print(f'{input_image} does not exist!')
        sys.exit()

    # Load input data
```

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

### Install Open3D development wheels with pip

Source: https://www.open3d.org/docs/latest/dev_wheels.html

Use these pip commands to install the latest development version of Open3D from the main branch. The first command installs open3d (Linux x86_64 CUDA, others CPU), the second installs open3d-cpu (Linux), the third installs open3d-xpu (Windows, Linux), and the fourth installs open3d-cuda (Windows CUDA Preview).

```bash
pip install -U -f https://www.open3d.org/docs/latest/dev_wheels.html open3d        # Linux x86_64 CUDA, others CPU
```

```bash
pip install -U -f https://www.open3d.org/docs/latest/dev_wheels.html open3d-cpu    # Linux
```

```bash
pip install -U -f https://www.open3d.org/docs/latest/dev_wheels.html open3d-xpu    # Windows, Linux
```

```bash
pip install -U -f https://www.open3d.org/docs/latest/dev_wheels.html open3d-cuda   # Windows CUDA Preview
```

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

### SampleRedwoodRGBDImages.__init__()

Source: https://www.open3d.org/docs/latest/python_api/open3d.data.SampleRedwoodRGBDImages.html

Initializes a new SampleRedwoodRGBDImages instance.

```APIDOC
## SampleRedwoodRGBDImages.__init__()

### Description
Initializes a new SampleRedwoodRGBDImages instance.

### Method
Constructor

### Parameters
- **self** (open3d.pybind.data.SampleRedwoodRGBDImages) - The instance being constructed.
- **data_root** (str) - Optional - Root directory for data storage. Defaults to empty string.

### Returns
None

```

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

### Install Open3D ARM64 wheel and test visualizers

Source: https://www.open3d.org/docs/latest/arm.html

Install the pre-compiled ARM64 wheel with pip, then test the legacy visualizer with draw_geometries and the new GUI visualizer with draw. The legacy visualizer works on Linux and macOS, while the new GUI requires full OpenGL and is not supported on Linux with OpenGL ES.

```bash
pip install open3d
python -c "import open3d; print(open3d.__version__)"

# Test the legacy visualizer
python -c "import open3d as o3d; c = o3d.geometry.TriangleMesh.create_box(); o3d.visualization.draw_geometries([c])"

# Test the new GUI visualizer
python -c "import open3d as o3d; c = o3d.geometry.TriangleMesh.create_box(); o3d.visualization.draw(c)"
```

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

### Build and install Python packages

Source: https://www.open3d.org/docs/latest/compilation.html

Three ways to build and install the Open3D Python library. Install into the current environment, create a Python package, or create a pip wheel for manual installation.

```bash
# Activate the virtualenv first
# Install pip package in the current python environment
make install-pip-package

# Create Python package in build/lib
make python-package

# Create pip wheel in build/lib
# This creates a .whl file that you can install manually.
make pip-package

```

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

### ViewControl.set_up

Source: https://www.open3d.org/docs/latest/python_api/open3d.visualization.ViewControl.html

Sets the up vector of the visualizer.

```APIDOC
## ViewControl.set_up

### Description
Sets the up vector of the visualizer.

### Method
set_up

### Signature
`set_up(self: open3d.pybind.visualization.ViewControl_, up: Annotated[numpy.typing.ArrayLike, numpy.float64, '[3, 1]']) -> None`

### Parameters
- **up** (Annotated[numpy.typing.ArrayLike, numpy.float64, '[3, 1]']) - Required - The up vector.

### Returns
None
```

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

### Capture and record RealSense frames in C++

Source: https://www.open3d.org/docs/latest/tutorial/sensor/realsense.html

C++ example for capturing 150 RGBD frames from a RealSense camera and recording them to a bag file. Initializes the sensor with a configuration file, starts capture with recording enabled, captures aligned frames, and stops capture. Frame processing should complete within the frame interval (~33ms for 30fps) to avoid frame drops.

```cpp
#include <open3d/open3d.hpp>
open3d::t::io::RealSenseSensorConfig rs_cfg;
open3d::io::ReadIJsonConvertible(config_filename, rs_cfg);
RealSenseSensor rs;
rs.InitSensor(rs_cfg, 0, bag_filename);
rs.StartCapture(true);  // true: start recording with capture
for(size_t fid = 0; fid<150; ++fid) {
    im_rgbd = rs.CaptureFrame(true, true);  // wait for frames and align them
    // process im_rgbd.depth_ and im_rgbd.color_
}
rs.StopCapture();

```

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

### Main workflow: parse args, load manifest, draw geometries

Source: https://www.open3d.org/docs/latest/python_example/visualization/index.html

Main entry point: handles help, downloads example assets if no CSV is provided, reads the manifest, loads and transforms each row, and draws all geometries with o3d.visualization.draw. Uses black background, no skybox, and ibl_intensity 100000. Returns 1 on errors or if no entries are displayed.

```python
if len(sys.argv) > 1 and sys.argv[1] in ("-h", "--help"):
    print(__doc__)
    return 0
if len(sys.argv) == 1:
    print(
        "No CSV provided, downloading example assets and using generated manifest."
    )
    csv_path = _download_example_assets()
else:
    csv_path = Path(sys.argv[1]).resolve()
base_dir = csv_path.parent
try:
    manifest = _read_manifest(csv_path)
except ValueError as e:
    print(f"[Open3D][error] {e}", file=sys.stderr)
    print(__doc__)
    return 1
```

```python
draw_list: list[dict] = []
for row in manifest:
    relp = Path(row["filename"].strip())
    path = relp if relp.is_absolute() else (base_dir / relp)
    srt = tuple(
        float(row[x].strip())
        for x in ["scale", "rx_deg", "ry_deg", "rz_deg", "tx", "ty", "tz"])
    out = _load_and_transform_row(path, srt)
    if not out:
        continue
    object_name = f"l{row['_line']}_{path.stem}"
    for d in out:
        d["name"] = object_name
    draw_list.extend(out)
```

```python
if not draw_list:
    print("No entries to display.", file=sys.stderr)
    return 1
o3d.visualization.draw(
    draw_list,
    show_ui=True,
    title=csv_path.stem,
    show_skybox=False,
    bg_color=(0.0, 0.0, 0.0, 1.0),
    ibl_intensity=100000,
)
return 0
```

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

### Install ccache on Ubuntu 22.04+

Source: https://www.open3d.org/docs/latest/compilation.html

Install ccache via apt. Note that this may install version 3.x, which does not support CUDA caching.

```bash
sudo apt install ccache

```

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

### Install Open3D C++ library with CMake

Source: https://www.open3d.org/docs/latest/compilation.html

Install the Open3D C++ library by building the INSTALL target. This can be done in the terminal or in Visual Studio.

```batch
cmake --build . --config Release --target INSTALL

```

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

### ViewControl.set_up()

Source: https://www.open3d.org/docs/latest/python_api/open3d.visualization.ViewControl.html

Sets the up direction of the camera.

```APIDOC
## ViewControl.set_up()

### Description
Sets the up direction of the camera.

### Method
Method

### Parameters
None

### Returns
None
```

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

### ColorGrading.__init__()

Source: https://www.open3d.org/docs/latest/python_api/open3d.visualization.rendering.ColorGrading.html

Initializes a ColorGrading instance with a quality level and a tone mapping algorithm.

```APIDOC
## ColorGrading.__init__()

### Description
Initializes a ColorGrading instance with a quality level and a tone mapping algorithm.

### Method
Constructor

### Signature
__init__(self: open3d.pybind.visualization.rendering.ColorGrading, arg0: open3d.pybind.visualization.rendering.ColorGrading.Quality, arg1: open3d.pybind.visualization.rendering.ColorGrading.ToneMapping) -> None

### Parameters
- **arg0** (ColorGrading.Quality) - Required - Quality level of color grading operations.
- **arg1** (ColorGrading.ToneMapping) - Required - Tone mapping algorithm to apply.

### Returns
None
```

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

### Start()

Source: https://www.open3d.org/docs/latest/cpp_api/classopen3d_1_1io_1_1rpc_1_1_z_m_q_receiver.html

Starts the receiver mainloop in a new thread.

```APIDOC
## Start()

### Description
Starts the receiver mainloop in a new thread.

### Method
Start

### Signature
void open3d::io::rpc::ZMQReceiver::Start()

### Parameters
None

### Returns
void
```

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

### Initialize Visualizer class

Source: https://www.open3d.org/docs/latest/tutorial/visualization/non_blocking_visualization.html

Creates a Visualizer instance, opens a window, adds the source and target geometries, and sets parameters for ICP iterations and optional image saving.

```python
def demo_non_blocking_visualization():
    o3d.utility.set_verbosity_level(o3d.utility.VerbosityLevel.Debug)

    source, target = prepare_data()
    vis = o3d.visualization.Visualizer()
    vis.create_window()
    vis.add_geometry(source)
    vis.add_geometry(target)
    threshold = 0.05
    icp_iteration = 100
    save_image = False
```
Tokens:
Raw