robokudo.vis.multiprocessed_o3d_visualizer¶

Open3D-based visualization for RoboKudo pipelines.

This module provides 3D visualization capabilities for RoboKudo pipelines using Open3D. It handles:

3D geometry visualization
Point cloud rendering
Camera control
Coordinate frame display
Window management

Attributes¶

`T`
`G`

Classes¶

`O3DVisualizer`	Open3D-based visualizer for 3D geometry data.
`MemoryMap`	A base memory map for shared memory.
`ObjectMemoryMap`	A memory map for an object in shared memory.
`ArrayMemoryMap`	A memory map for a numpy array in shared memory.
`Geometry3DMemoryMap`	A memory map for a geometry in shared memory.
`PointCloudMemoryMap`
`LineSetMemoryMap`
`MeshBaseMemoryMap`
`TriangleMeshMemoryMap`
`OrientedBoundingBoxMemoryMap`
`AxisAlignedBoundingBoxMemoryMap`
`TetraMeshMemoryMap`
`MaterialRecordMemoryMap`
`HalfEdgeMemoryMap`
`HalfEdgeTriangleMeshMemoryMap`
`ObjectMemoryMapFactory`	A factory class for creating geometry memory maps from open3d geometry objects.
`Geometry3DMemoryMapFactory`	A factory class for creating geometry memory maps from open3d geometry3d objects.
`MemoryMapTransport`	A message containing geometry data for visualization.
`SharedMemoryManager`	A manager for geometries in shared memory.
`MultiprocessedViewer3DClient`	A client for the MultiprocessedViewer3D server.
`MultiprocessedViewer3D`	A wrapper class for the Viewer3D class to run it in a separate process.

Module Contents¶

class robokudo.vis.multiprocessed_o3d_visualizer.O3DVisualizer(*args: typing_extensions.Any, **kwargs: typing_extensions.Any)¶

Bases: robokudo.vis.visualizer.Visualizer, robokudo.vis.visualizer.Visualizer.Observer

Open3D-based visualizer for 3D geometry data.

This class provides visualization of 3D geometry data from pipeline annotators using Open3D windows. It supports:

3D geometry visualization
Point cloud rendering
Camera control
Coordinate frame display
Shared visualization state

Note

This Visualizer works with a shared state and needs notifications

viewer3d: typing_extensions.Optional[MultiprocessedViewer3D] = None¶: Open3D viewer instance

notify(observable: robokudo.vis.visualizer.Visualizer.Observable, *args: typing_extensions.Any, **kwargs: typing_extensions.Any) → None¶

Handle notification of state changes.

Parameters:: observable – The object that sent the notification

tick() → None¶

Update the visualization display.

This method:

Initializes viewer if needed
Gets current annotator outputs
Updates display if needed
Handles viewer lifecycle

Returns:: False if visualization should terminate, True otherwise

window_title() → str¶: Get the window title for this visualizer.

class robokudo.vis.multiprocessed_o3d_visualizer.MemoryMap¶

Bases: object

A base memory map for shared memory.

byte_size: int¶: Size of the underlying data in bytes.

robokudo.vis.multiprocessed_o3d_visualizer.T¶

class robokudo.vis.multiprocessed_o3d_visualizer.ObjectMemoryMap¶

Bases: MemoryMap, typing_extensions.Generic[T]

A memory map for an object in shared memory.

mapped_attributes = []¶: A list of (attribute name, attribute type) for the attributes mapped by the memory map.

classmethod get_memory_map(obj: typing_extensions.Any) → typing_extensions.Union[ArrayMemoryMap, ObjectMemoryMap]¶

Get the memory map for the given object.

This works for iterables that can be converted to numpy arrays, sets and objects that have a memory map available in ObjectMemoryMapFactory. If the given object is not a set, numpy array or object for which a memory map is available, the default behaviour will try to read it to a numpy array.

Parameters:: obj – The object to get the memory map for.
Returns:: The object or array memory map.

classmethod create_mapped_attributes_memory_maps(obj: typing_extensions.Any) → typing_extensions.Tuple[typing_extensions.Dict[str, typing_extensions.Optional[typing_extensions.Union[MemoryMap, typing_extensions.List[MemoryMap]]]], int]¶

Create memory maps for all mapped attributes using the values of an object.

Parameters:: obj – The object to create memory maps for.
Returns:: A map of attribute name to memory map and the total size of all memory maps.
Raises:: AttributeError – If a mapped attribute is not present in the given object.

static _write_attribute(write_buf: memoryview, write_idx: int, attribute_map: typing_extensions.Union[ArrayMemoryMap, ObjectMemoryMap], geometry_attribute: typing_extensions.Any) → int¶

Write the given geometry attribute to the given buffer using the attribute memory map.

This works for object memory maps, sets and iterables that can be converted to numpy arrays.

Parameters:

write_buf – The buffer to write to.
write_idx – The byte index to start writing at.
attribute_map – The memory map of the attribute.
geometry_attribute – The attribute to write.

Returns:

The byte index after writing.

write_mapped_attributes(input_obj: object, write_buf: memoryview, write_idx: int) → int¶

Write the mapped attributes to a buffer using the data from the given object.

Parameters:

input_obj – The object to write the data from to a buffer.
write_buf – The buffer to write to.
write_idx – The byte index to start writing at.

Returns:

The new byte index to start writing new data at.

Raises:

AttributeError – If a mapped attribute is not present in the given object.

static _read_attribute(attribute_map: typing_extensions.Union[ArrayMemoryMap, ObjectMemoryMap], attribute_type: typing_extensions.Type, read_buf: memoryview, read_idx: int) → typing_extensions.Tuple[typing_extensions.Any, int]¶

Read the given attribute map from the read buffer starting from the byte index.

Parameters:

attribute_map – The memory map of the attribute to read from the buffer.
attribute_type – The type mapped out by the memory map.
read_buf – The buffer to read from.
read_idx – The byte index to start reading at.

Returns:

The data read from the buffer as an instance of attribute_type and the new read byte index.

read_mapped_attributes_to_object(output_obj: object, read_buf: memoryview, read_idx: int) → int¶

Read the mapped attributes from a buffer into the given object.

Parameters:

output_obj – The object to read the data in.
read_buf – The buffer to read from.
read_idx – The byte index to start reading at.

Returns:

The new byte index to start reading new data at.

Raises:

AttributeError – If a mapped attribute is not present in the given object.

classmethod from_object(obj: T) → ObjectMemoryMap[T]¶

Create a new memory map for the given object.

Parameters:: obj – The object to create the memory map from.

write_object(write_buf: memoryview, write_idx: int, obj: T) → int¶

Write the given object to the shared memory using the memory map.

Parameters:

write_buf – The memoryview to write to.
write_idx – The index to start writing at.
obj – The object to write.

Returns:

The new write index.

read_object(read_buf: memoryview, read_idx: int) → typing_extensions.Tuple[T, int]¶

Read an object from the shared memory using the memory map.

Parameters:

read_buf – The memoryview to read from.
read_idx – The index to start reading at.

Returns:

The object and the new read index.

class robokudo.vis.multiprocessed_o3d_visualizer.ArrayMemoryMap¶

Bases: MemoryMap

A memory map for a numpy array in shared memory.

shape: typing_extensions.Tuple¶: Shape of the underlying array.

dtype: str¶: Datatype of the underlying data as a string.

classmethod from_numpy_array(array: numpy.typing.NDArray) → typing_extensions.Self¶: Create a new memory map for the given numpy array.

robokudo.vis.multiprocessed_o3d_visualizer.G¶

class robokudo.vis.multiprocessed_o3d_visualizer.Geometry3DMemoryMap¶

Bases: ObjectMemoryMap[G], typing_extensions.Generic[G]

A memory map for a geometry in shared memory.

name: str¶: Name of the underlying geometry.

type: typing_extensions.Type¶: Type of the underlying geometry.

material: typing_extensions.Optional[ObjectMemoryMap] = None¶: Material property of the o3d geometry.

group: typing_extensions.Optional[str] = None¶: Group property of the o3d geometry.

time: typing_extensions.Optional[float] = None¶: Time property of the o3d geometry.

is_visible: typing_extensions.Optional[bool] = None¶: IsVisible property of the o3d geometry.

classmethod from_geometry(name: str, geometry: open3d.geometry.Geometry3D, material: typing_extensions.Optional[open3d.visualization.rendering.MaterialRecord] = None, group: typing_extensions.Optional[str] = None, time: typing_extensions.Optional[float] = None, is_visible: typing_extensions.Optional[bool] = None) → typing_extensions.Self¶

Create a new memory memory map for the given geometry.

Parameters:

name – The o3d name of the geometry.
geometry – The o3d geometry to create a memory map for.
material – The o3d material property of the geometry.
group – The o3d group property of the geometry.
time – The o3d time property of the geometry.
is_visible – The o3d is_visible property of the geometry.

classmethod from_geometry_dict(geometry: typing_extensions.Dict[str, typing_extensions.Any]) → Geometry3DMemoryMap¶

Create a new memory map from a geometry dictionary.

Parameters:: geometry – The geometry dictionary to create a memory map from.
Returns:: The memory map created from the geometry dictionary.

read_geometry_dict(read_buf: memoryview, read_idx: int) → typing_extensions.Tuple[typing_extensions.Dict, int]¶

Create an open3d geometry dict from the memory map.

Parameters:

read_buf – The memory buffer to read from.
read_idx – The byte index to start reading from.

Returns:

The geometry dictionary and the byte index after reading.

write_geometry(write_buf: memoryview, write_idx: int, geometry: typing_extensions.Union[open3d.geometry.Geometry3D, typing_extensions.Dict]) → int¶

Write the given geometry to the shared memory using the memory map.

Parameters:

write_buf – The shared memory to write to.
write_idx – The byte index to start writing at.
geometry – The geometry to write.

Returns:

The byte index after writing.

read_geometry(read_buf: memoryview, read_idx: int) → typing_extensions.Tuple[open3d.geometry.PointCloud, int]¶

Read the geometry from the shared memory using the memory map.

Parameters:

read_buf – The shared memory to read from.
read_idx – The byte index to start reading from.

Returns:

The geometry read from the shared memory and the byte index after reading.

class robokudo.vis.multiprocessed_o3d_visualizer.PointCloudMemoryMap¶

Bases: Geometry3DMemoryMap[open3d.geometry.PointCloud]

points: ArrayMemoryMap¶: Memory map of the point clouds points.

normals: ArrayMemoryMap¶: Memory map of the point clouds point normals.

colors: ArrayMemoryMap¶: Memory map of the point clouds point colors.

covariances: ArrayMemoryMap¶: Memory map of the point clouds point covariances.

mapped_attributes¶

class robokudo.vis.multiprocessed_o3d_visualizer.LineSetMemoryMap¶

Bases: Geometry3DMemoryMap[open3d.geometry.LineSet]

colors: ArrayMemoryMap¶: Memory map of the line set colors.

lines: ArrayMemoryMap¶: Memory map of the line set lines.

points: ArrayMemoryMap¶: Memory map of the line set points.

mapped_attributes¶

class robokudo.vis.multiprocessed_o3d_visualizer.MeshBaseMemoryMap¶

Bases: Geometry3DMemoryMap[open3d.geometry.MeshBase]

vertices: ArrayMemoryMap¶: Memory map of the mesh vertices.

vertex_normals: ArrayMemoryMap¶: Memory map of the vertex normals.

vertex_colors: ArrayMemoryMap¶: Memory map of the vertex colors.

mapped_attributes¶

class robokudo.vis.multiprocessed_o3d_visualizer.TriangleMeshMemoryMap¶

Bases: Geometry3DMemoryMap[open3d.geometry.TriangleMesh]

vertices: ArrayMemoryMap¶: Memory map of the mesh vertices.

vertex_normals: ArrayMemoryMap¶: Memory map of the vertex normals.

vertex_colors: ArrayMemoryMap¶: Memory map of the vertex colors.

triangles: ArrayMemoryMap¶: Memory map of the mesh triangles.

triangle_normals: ArrayMemoryMap¶: Memory map of the mesh triangle normals.

triangle_uvs: ArrayMemoryMap¶: Memory map of the mesh triangle uvs.

triangle_material_ids: ArrayMemoryMap¶: Memory map of the mesh triangle material ids.

textures: typing_extensions.List[ArrayMemoryMap]¶: Memory map of the mesh textures.

adjacency_list: typing_extensions.List[ArrayMemoryMap]¶: Memory map of the mesh adjacency list.

mapped_attributes¶

class robokudo.vis.multiprocessed_o3d_visualizer.OrientedBoundingBoxMemoryMap¶

Bases: Geometry3DMemoryMap[open3d.geometry.OrientedBoundingBox]

center: ArrayMemoryMap¶: Memory map of the oriented bounding box center.

color: ArrayMemoryMap¶: Memory map of the oriented bounding box color.

extent: ArrayMemoryMap¶: Memory map of the oriented bounding box extent.

R: ArrayMemoryMap¶: Memory map of the oriented bounding box extent.

mapped_attributes¶

class robokudo.vis.multiprocessed_o3d_visualizer.AxisAlignedBoundingBoxMemoryMap¶

Bases: Geometry3DMemoryMap[open3d.geometry.AxisAlignedBoundingBox]

color: ArrayMemoryMap¶: Memory map of the axis aligned bounding box color.

max_bound: ArrayMemoryMap¶: Memory map of the axis aligned bounding box maximum bound.

min_bound: ArrayMemoryMap¶: Memory map of the axis aligned bounding box maximum bound.

mapped_attributes¶

class robokudo.vis.multiprocessed_o3d_visualizer.TetraMeshMemoryMap¶

Bases: Geometry3DMemoryMap[open3d.geometry.TetraMesh]

tetras: ArrayMemoryMap¶: Memory map of the tetra mesh tetras.

vertex_colors: ArrayMemoryMap¶: Memory map of the tetra mesh vertex colors.

vertex_normals: ArrayMemoryMap¶: Memory map of the tetra mesh vertex normals.

vertices: ArrayMemoryMap¶: Memory map of the tetra mesh vertices.

mapped_attributes¶

class robokudo.vis.multiprocessed_o3d_visualizer.MaterialRecordMemoryMap¶

Bases: ObjectMemoryMap[open3d.visualization.rendering.MaterialRecord]

absorption_color: ArrayMemoryMap¶

absorption_distance: float¶

albedo_img: typing_extensions.Optional[ArrayMemoryMap]¶

anisotropy_img: typing_extensions.Optional[ArrayMemoryMap]¶

ao_img: typing_extensions.Optional[ArrayMemoryMap]¶

ao_rough_metal_img: typing_extensions.Optional[ArrayMemoryMap]¶

aspect_ratio: float¶

base_anisotropy: float¶

base_clearcoat: float¶

base_clearcoat_roughness: float¶

base_color: ArrayMemoryMap¶

base_metallic: float¶

base_reflectance: float¶

base_roughness: float¶

clearcoat_img: typing_extensions.Optional[ArrayMemoryMap]¶

clearcoat_roughness_img: typing_extensions.Optional[ArrayMemoryMap]¶

emissive_color: ArrayMemoryMap¶

ground_plane_axis: float¶

has_alpha: bool¶

metallic_img: typing_extensions.Optional[ArrayMemoryMap]¶

normal_img: typing_extensions.Optional[ArrayMemoryMap]¶

point_size: float¶

reflectance_img: typing_extensions.Optional[ArrayMemoryMap]¶

roughness_img: typing_extensions.Optional[ArrayMemoryMap]¶

sRGB_color: bool¶

scalar_max: float¶

scalar_min: float¶

shader: str¶

thickness: float¶

transmission: float¶

mapped_attributes¶

classmethod from_object(obj: open3d.visualization.rendering.MaterialRecord) → typing_extensions.Self¶

write_object(write_buf: memoryview, write_idx: int, obj: open3d.visualization.rendering.MaterialRecord) → int¶

Write the given geometry to the shared memory using the memory map.

Parameters:

write_buf – The memory buffer to write to.
write_idx – The byte index to start writing at.
obj – The geometry to write.

Returns:

The byte index after writing.

read_object(read_buf: memoryview, read_idx: int) → typing_extensions.Tuple[open3d.visualization.rendering.MaterialRecord, int]¶

Read the geometry from the shared memory using the memory map.

Parameters:

read_buf – The memory buffer to read from.
read_idx – The byte index to start reading from.

Returns:

The geometry read from the shared memory and the byte index after reading.

class robokudo.vis.multiprocessed_o3d_visualizer.HalfEdgeMemoryMap¶

Bases: ObjectMemoryMap[open3d.geometry.HalfEdge]

data: ArrayMemoryMap¶: Memory map containing next, triangle_index, twin and vertex_indices.

classmethod from_object(obj: open3d.geometry.HalfEdge) → typing_extensions.Self¶

Create a HalfEdgeMemoryMap from a HalfEdge object.

Parameters:: obj – The HalfEdge object to create a HalfEdgeMemoryMap from.
Returns:: The HalfEdgeMemoryMap created from the HalfEdge object.

write_object(write_buf: memoryview, write_idx: int, obj: open3d.geometry.HalfEdge) → int¶

Write the given HalfEdge object to the given buffer using the memory map.

Parameters:

write_buf – The buffer to write to.
write_idx – The byte index to start writing at.
obj – The HalfEdge object to write.

Returns:

The byte index after writing.

read_object(read_buf: memoryview, read_idx: int) → typing_extensions.Tuple[open3d.geometry.HalfEdge, int]¶

Read the given buffer from the given byte index as a HalfEdge object using the memory map.

Parameters:

read_buf – The buffer to read from.
read_idx – The byte index to start reading from.

Returns:

The HalfEdge object read from the buffer and the byte index after reading.

class robokudo.vis.multiprocessed_o3d_visualizer.HalfEdgeTriangleMeshMemoryMap¶

Bases: Geometry3DMemoryMap[open3d.geometry.HalfEdgeTriangleMesh]

half_edges: typing_extensions.List[HalfEdgeMemoryMap]¶: Memory map of the half edge mesh half edges.

ordered_half_edge_from_vertex: typing_extensions.List[ArrayMemoryMap]¶: Memory map of the half edge mesh ordered half edge from vertex.

triangle_normals: ArrayMemoryMap¶: Memory map of the half edge mesh triangle normals.

triangles: ArrayMemoryMap¶: Memory map of the half edge mesh triangles.

vertex_colors: ArrayMemoryMap¶: Memory map of the half edge mesh vertex colors.

vertex_normals: ArrayMemoryMap¶: Memory map of the half edge mesh vertex normals.

vertices: ArrayMemoryMap¶: Memory map of the half edge mesh vertices.

mapped_attributes¶

class robokudo.vis.multiprocessed_o3d_visualizer.ObjectMemoryMapFactory¶

A factory class for creating geometry memory maps from open3d geometry objects.

proxies: typing_extensions.Dict[typing_extensions.Type, typing_extensions.Type[ObjectMemoryMap]]¶: Map of open3d geometry types to their corresponding memory map types.

classmethod has_proxy(obj: typing_extensions.Any) → bool¶

Check whether the factory has a proxy for the given object class.

Parameters:: obj – The object to check.
Returns:: True if there is a proxy available for the given object class, False otherwise.

classmethod from_object(obj: typing_extensions.Any) → ObjectMemoryMap¶

Create a geometry proxy from a Geometry3D object.

Parameters:: obj – The object to create a proxy for.
Raises:: KeyError – If the factory has no proxy for the geometry type.

class robokudo.vis.multiprocessed_o3d_visualizer.Geometry3DMemoryMapFactory¶

A factory class for creating geometry memory maps from open3d geometry3d objects.

proxies: typing_extensions.Dict[typing_extensions.Type, typing_extensions.Type[Geometry3DMemoryMap]]¶: Map of open3d geometry types to their corresponding memory map types.

classmethod has_proxy(obj: typing_extensions.Any) → bool¶

Check whether the factory has a proxy for the given object class.

Parameters:: obj – The object to check.
Returns:: True if there is a proxy available for the given object class, False otherwise.

classmethod from_geometry(name: str, geometry: open3d.geometry.Geometry3D) → Geometry3DMemoryMap¶

Create a geometry proxy from a Geometry3D object.

Parameters:

name – The name of the geometry used to add the geometry to the O3DVisualizer.
geometry – The geometry object to create a proxy for.

Raises:

KeyError – If the factory has no proxy for the geometry type.

classmethod from_geometry_dict(geometry: typing_extensions.Dict) → Geometry3DMemoryMap¶

Create a geometry proxy from a Geometry3D object.

Parameters:: geometry – The geometry dictionary to create a proxy for.
Returns:: The geometry proxy created from the geometry dictionary.
Raises:: KeyError – If the factory has no proxy for the geometry type.

class robokudo.vis.multiprocessed_o3d_visualizer.MemoryMapTransport¶

Bases: object

A message containing geometry data for visualization.

shm_name: str¶: The shared memory to read from.

memory_maps: typing_extensions.List[Geometry3DMemoryMap] = []¶: The memory mappings for the geometries.

class robokudo.vis.multiprocessed_o3d_visualizer.SharedMemoryManager¶

Bases: object

A manager for geometries in shared memory.

_shm: multiprocessing.shared_memory.SharedMemory¶: The shared memory managed by the instance.

memory_maps: typing_extensions.List[Geometry3DMemoryMap] = []¶: A list of all memory maps managed by this object.

memory_maps_size: int = 0¶: The total size of all memory maps managed by this object.

write_cursor: int = 0¶: The current end byte index of the shared memory (sum of all memory map sizes).

classmethod with_shm(size: int) → typing_extensions.Self¶

Create a SharedMemoryManager with a newly created shared memory of the given size.

Parameters:: size – The size of the shared memory to create.
Returns:: A SharedMemoryManager instance with the newly created shared memory.

classmethod for_shm(name: str) → typing_extensions.Self¶

Create a SharedMemoryManager for an existing shared memory with the given name.

Parameters:: name – The name of the shared memory to use.
Returns:: A SharedMemoryManager instance for the existing shared memory.

property name: str¶: The name of the shared memory managed by the instance.

append(memory_map: Geometry3DMemoryMap) → None¶

Add a memory map to the shared memory manager.

Parameters:: memory_map – MemoryMap to add to the shared memory manager.
Returns:: The byte index to start writing to for the appended memory map

extend(memory_maps: typing_extensions.List[Geometry3DMemoryMap]) → None¶

Add a list of memory maps to the shared memory manager.

Returns:: The byte indices to start writing to for each of the appended memory maps

write_geometry(geometry_dict: typing_extensions.Union[typing_extensions.Dict, open3d.geometry.Geometry3D], memory_map: Geometry3DMemoryMap) → None¶

Write a geometry to the shared memory using the given memory map.

Parameters:

geometry_dict – The geometry dictionary to write to the shared memory.
memory_map – The memory map to use for writing the geometry.

read_geometries() → typing_extensions.Iterator[typing_extensions.Dict]¶

Read all memory maps from the shared memory manager.

Returns:: An iterator over the geometries read from the shared memory.

reset() → None¶: Reset the shared memory manager to its initial state.

close() → None¶: Close the underlying shared memory.

unlink_and_close() → None¶: Unlink and close the underlying shared memory.

class robokudo.vis.multiprocessed_o3d_visualizer.MultiprocessedViewer3DClient(title: str, cmd_conn: multiprocessing.connection.Connection, tick_return: multiprocessing.Event)¶

Bases: object

A client for the MultiprocessedViewer3D server.

rk_logger: logging.Logger = None¶: Logger instance

viewer3d¶: Viewer3D instance for visualization.

cmd_conn¶: Communication connection for sending and receiving commands from the main process.

tick_return¶: Event indicating that the o3d visualizer shut down.

name_to_shm_manager: typing_extensions.Dict[str, SharedMemoryManager]¶: Mapping of shared memory names to shared memory instances.

visualized_geometries: typing_extensions.List[str] = []¶: List of the names of the currently visualized geometries

geometries_lock: threading.Lock¶: Lock for synchronizing access to the geometries list.

geometries: typing_extensions.List[typing_extensions.Union[typing_extensions.Dict, open3d.geometry.Geometry3D]] = []¶: List of the geometries to use for updating the viewer.

receiver_thread¶: A thread for listening to commands from the main process.

get_shm_manager(shm_name: str) → SharedMemoryManager¶

Get the current shared memory manager.

Parameters:: shm_name – The name of the shared memory to get the manager for.
Returns:: The shared memory manager for the given shared memory name.

run() → None¶: Run the visualization client.

close() → None¶: Close the visualization client and clean up resources.

update_geometry() → None¶: Update the geometry in the viewer.

listen() → None¶: Listen for commands from the main process and handle them accordingly.

class robokudo.vis.multiprocessed_o3d_visualizer.MultiprocessedViewer3D(title: str, shm_size: int = 5000000000)¶

Bases: object

A wrapper class for the Viewer3D class to run it in a separate process.

rk_logger: logging.Logger = None¶: Logger instance

buffer_count = 2¶: Number of buffers to use for communication.

buffer_write_cursor = 0¶: Index of the memory manager to use for writing.

buffer_read_cursor = 1¶: Index of the memory manager to use for reading.

tick_return¶: Event indicating that the o3d visualizer shut down.

memory_manager¶: Manager instances for shared memory handling.

parent_cmd_conn: multiprocessing.connection.Connection¶: Pipe connection for sending and receiving commands from the main process.

child_cmd_conn: multiprocessing.connection.Connection¶: Pipe connection for sending and receiving commands on the visualizer process.

visualizer_process: multiprocessing.Process¶: A process running a viewer3d instance.

static run_visualizer(title: str, cmd_conn: multiprocessing.connection.Connection, tick_return: multiprocessing.Event) → None¶

Run the viewer3d instance in a separate process.

Parameters:

title – Window title for the viewer.
cmd_conn – Connection for sending and receiving commands from the main process.
tick_return – Event indicating that the o3d visualizer shut down to the main process.

property _read_manager: SharedMemoryManager¶: The manager for the shared memory that is currently readable.

property _write_manager: SharedMemoryManager¶: The manager for the shared memory that is currently writeable.

_swap_buffers() → typing_extensions.Tuple[int, int]¶

Rotate the read and write buffers.

Returns:: The indices of the new buffers in format (read_buffer, write_buffer)

tick() → bool¶

Dummy tick method indicating whether the visualizer has shut down.

Returns:: True if the visualizer has shut down, False otherwise.

update_cloud(geometries: typing_extensions.Optional[typing_extensions.Union[open3d.geometry.Geometry, typing_extensions.Dict, typing_extensions.List]]) → None¶

Update the displayed geometries.

This method updates the Open3D visualizer based on the outputs of the annotators. For the first update, it also sets up the camera and coordinate frame.

Parameters:: geometries – Geometries to display. Can be:

Note

The dict format follows Open3D’s draw() convention. See: https://github.com/isl-org/Open3D/blob/master/examples/python/visualization/draw.py

close() → None¶: Clean up shared memory and process resources.