open3d.t.geometry.PointCloud

class open3d.t.geometry.PointCloud

A point cloud contains a list of 3D points. The point cloud class stores the attribute data in key-value maps, where the key is a string representing the attribute name and the value is a Tensor containing the attribute data.

The attributes of the point cloud have different levels:

import open3d as o3d

device = o3d.core.Device("CPU:0")
dtype = o3d.core.float32

# Create an empty point cloud
# Use pcd.point to access the points' attributes
pcd = o3d.t.geometry.PointCloud(device)

# Default attribute: "positions".
# This attribute is created by default and is required by all point clouds.
# The shape must be (N, 3). The device of "positions" determines the device
# of the point cloud.
pcd.point["positions"] = o3d.core.Tensor([[0, 0, 0],
                                          [1, 1, 1],
                                          [2, 2, 2]], dtype, device)

# Common attributes: "normals", "colors".
# Common attributes are used in built-in point cloud operations. The
# spellings must be correct. For example, if "normal" is used instead of
# "normals", some internal operations that expects "normals" will not work.
# "normals" and "colors" must have shape (N, 3) and must be on the same
# device as the point cloud.
pcd.point["normals"] = o3d.core.Tensor([[0, 0, 1],
                                        [0, 1, 0],
                                        [1, 0, 0]], dtype, device)
pcd.point["colors"] = o3d.core.Tensor([[0.0, 0.0, 0.0],
                                        [0.1, 0.1, 0.1],
                                        [0.2, 0.2, 0.2]], dtype, device)

# User-defined attributes.
# You can also attach custom attributes. The value tensor must be on the
# same device as the point cloud. The are no restrictions on the shape and
# dtype, e.g.,
pcd.point["intensities"] = o3d.core.Tensor([0.3, 0.1, 0.4], dtype, device)
pcd.point["labels"] = o3d.core.Tensor([3, 1, 4], o3d.core.int32, device)
__init__(*args, **kwargs)

Overloaded function.

  1. __init__(self: open3d.cpu.pybind.t.geometry.PointCloud, device: open3d.cpu.pybind.core.Device = CPU:0) -> None

Construct an empty pointcloud on the provided device (default: ‘CPU:0’).

  1. __init__(self: open3d.cpu.pybind.t.geometry.PointCloud, positions: open3d.cpu.pybind.core.Tensor) -> None

  2. __init__(self: open3d.cpu.pybind.t.geometry.PointCloud, map_keys_to_tensors: Dict[str, open3d.cpu.pybind.core.Tensor]) -> None

append(self: open3d.cpu.pybind.t.geometry.PointCloud, arg0: open3d.cpu.pybind.t.geometry.PointCloud) → open3d.cpu.pybind.t.geometry.PointCloud
clear(self)

Clear all elements in the geometry.

Returns

open3d.t.geometry.Geometry

clone(self: open3d.cpu.pybind.t.geometry.PointCloud) → open3d.cpu.pybind.t.geometry.PointCloud

Returns a copy of the point cloud on the same device.

cluster_dbscan(self, eps, min_points, print_progress=False)

Cluster PointCloud using the DBSCAN algorithm Ester et al., ‘A Density-Based Algorithm for Discovering Clusters in Large Spatial Databases with Noise’, 1996. Returns a list of point labels, -1 indicates noise according to the algorithm.

Parameters
  • eps (float) – Density parameter that is used to find neighbouring points.

  • min_points (int) – Minimum number of points to form a cluster.

  • print_progress (bool, optional, default=False) – If true the progress is visualized in the console.

Returns

open3d.core.Tensor

compute_convex_hull(self: open3d.cpu.pybind.t.geometry.PointCloud, joggle_inputs: bool = False) → open3d::t::geometry::TriangleMesh

Compute the convex hull of a triangle mesh using qhull. This runs on the CPU.

Parameters
  • joggle_inputs (default False) –

  • perturbing the input data. Set to True if perturbing the input (randomly) –

  • acceptable but you need convex simplicial output. If False (iis) –

:param : :param neighboring facets may be merged in case of precision problems. See: :param QHull docs for more :param details.:

Returns

TriangleMesh representing the convexh hull. This contains an extra vertex property “point_indices” that contains the index of the corresponding vertex in the original mesh.

Example

We will load the Eagle dataset, compute and display it’s convex hull:

eagle = o3d.data.EaglePointCloud()
pcd = o3d.t.io.read_point_cloud(eagle.path)
hull = pcd.compute_convex_hull()
o3d.visualization.draw([{'name': 'eagle', 'geometry': pcd}, {'name': 'convex hull', 'geometry': hull}])
cpu(self: open3d.cpu.pybind.t.geometry.PointCloud) → open3d.cpu.pybind.t.geometry.PointCloud

Transfer the point cloud to CPU. If the point cloud is already on CPU, no copy will be performed.

static create_from_depth_image(depth, intrinsics, extrinsics=(with default value), depth_scale=1000.0, depth_max=3.0, stride=1, with_normals=False)

Factory function to create a pointcloud (with only ‘points’) from a depth image and a camera model.

Given depth value d at (u, v) image coordinate, the corresponding 3d point is: z = d / depth_scale

x = (u - cx) * z / fx

y = (v - cy) * z / fy

Parameters
  • depth (open3d.t.geometry.Image) – The input depth image should be a uint16_t image.

  • intrinsics (open3d.core.Tensor) – Intrinsic parameters of the camera.

  • extrinsics (open3d.core.Tensor, optional) –

    Extrinsic parameters of the camera. Default value:

    [[1.0 0.0 0.0 0.0], [0.0 1.0 0.0 0.0], [0.0 0.0 1.0 0.0], [0.0 0.0 0.0 1.0]] Tensor[shape={4, 4}, stride={4, 1}, Float32

    ()

  • depth_scale (float, optional, default=1000.0) – The depth is scaled by 1 / depth_scale.

  • depth_max (float, optional, default=3.0) – Truncated at depth_max distance.

  • stride (int, optional, default=1) – Sampling factor to support coarse point cloud extraction. Unless normals are requested, there is no low pass filtering, so aliasing is possible for stride>1.

  • with_normals (bool, optional, default=False) – Also compute normals for the point cloud. If True, the point cloud will only contain points with valid normals. If normals are requested, the depth map is first filtered to ensure smooth normals.

Returns

open3d.t.geometry.PointCloud

static create_from_rgbd_image(rgbd_image, intrinsics, extrinsics=(with default value), depth_scale=1000.0, depth_max=3.0, stride=1, with_normals=False)

Factory function to create a pointcloud (with properties {‘points’, ‘colors’}) from an RGBD image and a camera model.

Given depth value d at (u, v) image coordinate, the corresponding 3d point is:

z = d / depth_scale

x = (u - cx) * z / fx

y = (v - cy) * z / fy

Parameters
  • rgbd_image (open3d.t.geometry.RGBDImage) – The input RGBD image should have a uint16_t depth image and RGB image with any DType and the same size.

  • intrinsics (open3d.core.Tensor) – Intrinsic parameters of the camera.

  • extrinsics (open3d.core.Tensor, optional) –

    Extrinsic parameters of the camera. Default value:

    [[1.0 0.0 0.0 0.0], [0.0 1.0 0.0 0.0], [0.0 0.0 1.0 0.0], [0.0 0.0 0.0 1.0]] Tensor[shape={4, 4}, stride={4, 1}, Float32

    ()

  • depth_scale (float, optional, default=1000.0) – The depth is scaled by 1 / depth_scale.

  • depth_max (float, optional, default=3.0) – Truncated at depth_max distance.

  • stride (int, optional, default=1) – Sampling factor to support coarse point cloud extraction. Unless normals are requested, there is no low pass filtering, so aliasing is possible for stride>1.

  • with_normals (bool, optional, default=False) – Also compute normals for the point cloud. If True, the point cloud will only contain points with valid normals. If normals are requested, the depth map is first filtered to ensure smooth normals.

Returns

open3d.t.geometry.PointCloud

crop(self, aabb, invert=False)

Function to crop pointcloud into output pointcloud.

Parameters
  • aabb (open3d.t.geometry.AxisAlignedBoundingBox) – AxisAlignedBoundingBox to crop points.

  • invert (bool, optional, default=False) – Crop the points outside of the bounding box or inside of the bounding box.

Returns

open3d.t.geometry.PointCloud

cuda(self: open3d.cpu.pybind.t.geometry.PointCloud, device_id: int = 0) → open3d.cpu.pybind.t.geometry.PointCloud

Transfer the point cloud to a CUDA device. If the point cloud is already on the specified CUDA device, no copy will be performed.

estimate_color_gradients(self: open3d.cpu.pybind.t.geometry.PointCloud, max_nn: int = 30, radius: Optional[float] = None) → None

Function to estimate point color gradients. If radius is provided, then HybridSearch is used, otherwise KNN-Search is used.

estimate_normals(self, max_nn=30, radius=None)

Function to estimate point normals. If the pointcloud normals exists, the estimated normals are oriented with respect to the same. It uses KNN search if only max_nn parameter is provided, and HybridSearch if radius parameter is also provided.

Parameters
  • max_nn (int, optional, default=30) – Neighbor search max neighbors parameter [default = 30].

  • radius (Optional[float], optional, default=None) – neighbors search radius parameter to use HybridSearch. [Recommended ~1.4x voxel size].

Returns

None

static from_legacy(pcd_legacy: open3d.cpu.pybind.geometry.PointCloud, dtype: open3d.cpu.pybind.core.Dtype = Float32, device: open3d.cpu.pybind.core.Device = CPU:0) → open3d.cpu.pybind.t.geometry.PointCloud

Create a PointCloud from a legacy Open3D PointCloud.

get_axis_aligned_bounding_box(self: open3d.cpu.pybind.t.geometry.PointCloud) → open3d::t::geometry::AxisAlignedBoundingBox

Create an axis-aligned bounding box from attribute ‘positions’.

get_center(self: open3d.cpu.pybind.t.geometry.PointCloud) → open3d.cpu.pybind.core.Tensor

Returns the center for point coordinates.

get_max_bound(self: open3d.cpu.pybind.t.geometry.PointCloud) → open3d.cpu.pybind.core.Tensor

Returns the max bound for point coordinates.

get_min_bound(self: open3d.cpu.pybind.t.geometry.PointCloud) → open3d.cpu.pybind.core.Tensor

Returns the min bound for point coordinates.

has_valid_material(self: open3d.cpu.pybind.t.geometry.DrawableGeometry) → bool

Returns true if the geometry’s material is valid.

is_empty(self)

Returns True iff the geometry is empty.

Returns

bool

paint_uniform_color(self, color)

Assigns uniform color to the point cloud.

Parameters

color (open3d.core.Tensor) – Color of the pointcloud. Floating color values are clipped between 0.0 and 1.0.

Returns

open3d.t.geometry.PointCloud

project_to_depth_image()
project_to_depth_image(self: open3d.cpu.pybind.t.geometry.PointCloud, width: int, height: int, intrinsics: open3d.cpu.pybind.core.Tensor, extrinsics: open3d.cpu.pybind.core.Tensor = [[1.0 0.0 0.0 0.0],

[0.0 1.0 0.0 0.0], [0.0 0.0 1.0 0.0], [0.0 0.0 0.0 1.0]]

Tensor[shape={4, 4}, stride={4, 1}, Float32, CPU:0, 0x563f4a6ddf80], depth_scale: float = 1000.0, depth_max: float = 3.0) -> open3d::t::geometry::Image

Project a point cloud to a depth image.

project_to_rgbd_image()
project_to_rgbd_image(self: open3d.cpu.pybind.t.geometry.PointCloud, width: int, height: int, intrinsics: open3d.cpu.pybind.core.Tensor, extrinsics: open3d.cpu.pybind.core.Tensor = [[1.0 0.0 0.0 0.0],

[0.0 1.0 0.0 0.0], [0.0 0.0 1.0 0.0], [0.0 0.0 0.0 1.0]]

Tensor[shape={4, 4}, stride={4, 1}, Float32, CPU:0, 0x563f4a6de9b0], depth_scale: float = 1000.0, depth_max: float = 3.0) -> open3d::t::geometry::RGBDImage

Project a colored point cloud to a RGBD image.

random_down_sample(self, sampling_ratio)

Downsample a pointcloud by selecting random index point and its attributes.

Parameters

sampling_ratio (float) – Sampling ratio, the ratio of sample to total number of points in the pointcloud.

Returns

open3d.t.geometry.PointCloud

remove_non_finite_points(self: open3d.cpu.pybind.t.geometry.PointCloud, remove_nan: bool = True, remove_infinite: bool = True) → Tuple[open3d.cpu.pybind.t.geometry.PointCloud, open3d.cpu.pybind.core.Tensor]

Remove all points from the point cloud that have a nan entry, or infinite value. It also removes the corresponding attributes.

remove_radius_outliers(self, nb_points, search_radius)

Remove points that have less than nb_points neighbors in a sphere of a given search radius.

Parameters
  • nb_points (int) – Number of neighbor points required within the radius.

  • search_radius (float) – Radius of the sphere.

Returns

Tuple[open3d.t.geometry.PointCloud, open3d.core.Tensor]

rotate(self: open3d.cpu.pybind.t.geometry.PointCloud, R: open3d.cpu.pybind.core.Tensor, center: open3d.cpu.pybind.core.Tensor) → open3d.cpu.pybind.t.geometry.PointCloud

Rotate points and normals (if exist).

scale(self: open3d.cpu.pybind.t.geometry.PointCloud, scale: float, center: open3d.cpu.pybind.core.Tensor) → open3d.cpu.pybind.t.geometry.PointCloud

Scale points.

select_by_index(self, indices, invert=False, remove_duplicates=False)

Select points from input pointcloud, based on indices into output point cloud.

Parameters
  • indices (open3d.core.Tensor) – Int64 indexing tensor of shape {n,} containing index value that is to be selected.

  • invert (bool, optional, default=False) – Set to True to invert the selection of indices, and also ignore the duplicated indices.

  • remove_duplicates (bool, optional, default=False) – Set to True to remove the duplicated indices.

Returns

open3d.t.geometry.PointCloud

select_by_mask(self, boolean_mask, invert=False)

Select points from input pointcloud, based on boolean mask indices into output point cloud.

Parameters
  • boolean_mask (open3d.core.Tensor) – Boolean indexing tensor of shape {n,} containing true value for the indices that is to be selected..

  • invert (bool, optional, default=False) – Set to True to invert the selection of indices.

Returns

open3d.t.geometry.PointCloud

to(self: open3d.cpu.pybind.t.geometry.PointCloud, device: open3d.cpu.pybind.core.Device, copy: bool = False) → open3d.cpu.pybind.t.geometry.PointCloud

Transfer the point cloud to a specified device.

to_legacy(self: open3d.cpu.pybind.t.geometry.PointCloud) → open3d.cpu.pybind.geometry.PointCloud

Convert to a legacy Open3D PointCloud.

transform(self: open3d.cpu.pybind.t.geometry.PointCloud, transformation: open3d.cpu.pybind.core.Tensor) → open3d.cpu.pybind.t.geometry.PointCloud

Transforms the points and normals (if exist).

translate(self: open3d.cpu.pybind.t.geometry.PointCloud, translation: open3d.cpu.pybind.core.Tensor, relative: bool = True) → open3d.cpu.pybind.t.geometry.PointCloud

Translates points.

uniform_down_sample(self, every_k_points)

Downsamples a point cloud by selecting every kth index point and its attributes.

Parameters

every_k_points (int) – Sample rate, the selected point indices are [0, k, 2k, …].

Returns

open3d.t.geometry.PointCloud

voxel_down_sample(self, voxel_size)

Downsamples a point cloud with a specified voxel size.

Parameters

voxel_size (float) – Voxel size. A positive number.

Returns

open3d.t.geometry.PointCloud

property device

Returns the device of the geometry.

property is_cpu

Returns true if the geometry is on CPU.

property is_cuda

Returns true if the geometry is on CUDA.

property material
property point

positions, colors, normals, etc.

Type

Point’s attributes