Python Interface

For the C++ interface, see here.

Install Open3D Python package

For installing Open3D Python package, see here.

Install Open3D from source

For installing from source, see here.

Getting started

This tutorial shows how to import the open3d module and use it to load and inspect a point cloud.

[1]:
import open3d as o3d
Using external Open3D-ML in /home/runner/work/Open3D/Open3D/Open3D-ML
Open3D was not compiled with BUILD_GUI, but script is importing open3d.visualization.gui
Open3D was not compiled with BUILD_GUI, but script is importing open3d.visualization.rendering

Note:

Depending on the environment, the name of the Python library may not be open3d.so. Regardless of the file name, import open3d should work.

[2]:
pcd = o3d.io.read_point_cloud("../../test_data/ICP/cloud_bin_0.pcd")
print(pcd)
PointCloud with 198835 points.

This imports the read_point_cloud function from the open3d module. It reads a point cloud file and returns an instance of the PointCloud class. print(pcd) prints some brief information about the point cloud.

Using built-in help function

Browse Open3D

help(open3d) prints a description of the open3d module.

[3]:
help(o3d)
Help on package open3d:

NAME
    open3d

DESCRIPTION
    # ----------------------------------------------------------------------------
    # -                        Open3D: www.open3d.org                            -
    # ----------------------------------------------------------------------------
    # The MIT License (MIT)
    #
    # Copyright (c) 2018-2021 www.open3d.org
    #
    # Permission is hereby granted, free of charge, to any person obtaining a copy
    # of this software and associated documentation files (the "Software"), to deal
    # in the Software without restriction, including without limitation the rights
    # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    # copies of the Software, and to permit persons to whom the Software is
    # furnished to do so, subject to the following conditions:
    #
    # The above copyright notice and this permission notice shall be included in
    # all copies or substantial portions of the Software.
    #
    # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
    # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
    # IN THE SOFTWARE.
    # ----------------------------------------------------------------------------

PACKAGE CONTENTS
    _build_config
    _ml3d (package)
    core
    ml (package)
    visualization (package)
    web_visualizer

SUBMODULES
    camera
    cpu
    geometry
    io
    pipelines
    pybind
    t
    utility

DATA
    __DEVICE_API__ = 'cpu'

VERSION
    0.13.0+ec16c02

FILE
    /opt/hostedtoolcache/Python/3.6.15/x64/lib/python3.6/site-packages/open3d/__init__.py


Description of a class in Open3D

help(open3d.PointCloud) provides a description of the PointCloud class.

[4]:
help(o3d.geometry.PointCloud)
Help on class PointCloud in module open3d.cpu.pybind.geometry:

class PointCloud(Geometry3D)
 |  PointCloud class. A point cloud consists of point coordinates, and optionally point colors and point normals.
 |
 |  Method resolution order:
 |      PointCloud
 |      Geometry3D
 |      Geometry
 |      pybind11_builtins.pybind11_object
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __add__(...)
 |      __add__(self: open3d.cpu.pybind.geometry.PointCloud, arg0: open3d.cpu.pybind.geometry.PointCloud) -> open3d.cpu.pybind.geometry.PointCloud
 |
 |  __copy__(...)
 |      __copy__(self: open3d.cpu.pybind.geometry.PointCloud) -> open3d.cpu.pybind.geometry.PointCloud
 |
 |  __deepcopy__(...)
 |      __deepcopy__(self: open3d.cpu.pybind.geometry.PointCloud, arg0: dict) -> open3d.cpu.pybind.geometry.PointCloud
 |
 |  __iadd__(...)
 |      __iadd__(self: open3d.cpu.pybind.geometry.PointCloud, arg0: open3d.cpu.pybind.geometry.PointCloud) -> open3d.cpu.pybind.geometry.PointCloud
 |
 |  __init__(...)
 |      __init__(*args, **kwargs)
 |      Overloaded function.
 |
 |      1. __init__(self: open3d.cpu.pybind.geometry.PointCloud) -> None
 |
 |      Default constructor
 |
 |      2. __init__(self: open3d.cpu.pybind.geometry.PointCloud, arg0: open3d.cpu.pybind.geometry.PointCloud) -> None
 |
 |      Copy constructor
 |
 |      3. __init__(self: open3d.cpu.pybind.geometry.PointCloud, points: open3d.cpu.pybind.utility.Vector3dVector) -> None
 |
 |      Create a PointCloud from points
 |
 |  __repr__(...)
 |      __repr__(self: open3d.cpu.pybind.geometry.PointCloud) -> str
 |
 |  cluster_dbscan(...)
 |      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.
 |
 |      Args:
 |          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.utility.IntVector
 |
 |  compute_convex_hull(...)
 |      compute_convex_hull(self)
 |      Computes the convex hull of the point cloud.
 |
 |      Returns:
 |          Tuple[open3d.geometry.TriangleMesh, List[int]]
 |
 |  compute_mahalanobis_distance(...)
 |      compute_mahalanobis_distance(self)
 |      Function to compute the Mahalanobis distance for points in a point cloud. See: https://en.wikipedia.org/wiki/Mahalanobis_distance.
 |
 |      Returns:
 |          open3d.utility.DoubleVector
 |
 |  compute_mean_and_covariance(...)
 |      compute_mean_and_covariance(self)
 |      Function to compute the mean and covariance matrix of a point cloud.
 |
 |      Returns:
 |          Tuple[numpy.ndarray[numpy.float64[3, 1]], numpy.ndarray[numpy.float64[3, 3]]]
 |
 |  compute_nearest_neighbor_distance(...)
 |      compute_nearest_neighbor_distance(self)
 |      Function to compute the distance from a point to its nearest neighbor in the point cloud
 |
 |      Returns:
 |          open3d.utility.DoubleVector
 |
 |  compute_point_cloud_distance(...)
 |      compute_point_cloud_distance(self, target)
 |      For each point in the source point cloud, compute the distance to the target point cloud.
 |
 |      Args:
 |          target (open3d.geometry.PointCloud): The target point cloud.
 |
 |      Returns:
 |          open3d.utility.DoubleVector
 |
 |  crop(...)
 |      crop(*args, **kwargs)
 |      Overloaded function.
 |
 |
 |      1. crop(self, bounding_box)
 |          Function to crop input pointcloud into output pointcloud
 |
 |      Args:
 |          bounding_box (open3d.geometry.AxisAlignedBoundingBox): AxisAlignedBoundingBox to crop points
 |
 |      Returns:
 |          open3d.geometry.PointCloud
 |
 |      2. crop(self, bounding_box)
 |          Function to crop input pointcloud into output pointcloud
 |
 |      Args:
 |          bounding_box (open3d.geometry.OrientedBoundingBox): AxisAlignedBoundingBox to crop points
 |
 |      Returns:
 |          open3d.geometry.PointCloud
 |
 |  estimate_covariances(...)
 |      estimate_covariances(self, search_param=KDTreeSearchParamKNN with knn = 30)
 |      Function to compute the covariance matrix for each point in the point cloud
 |
 |      Args:
 |          search_param (open3d.geometry.KDTreeSearchParam, optional, default=KDTreeSearchParamKNN with knn = 30): The KDTree search parameters for neighborhood search.
 |
 |      Returns:
 |          None
 |
 |  estimate_normals(...)
 |      estimate_normals(self, search_param=KDTreeSearchParamKNN with knn = 30, fast_normal_computation=True)
 |      Function to compute the normals of a point cloud. Normals are oriented with respect to the input point cloud if normals exist
 |
 |      Args:
 |          search_param (open3d.geometry.KDTreeSearchParam, optional, default=KDTreeSearchParamKNN with knn = 30): The KDTree search parameters for neighborhood search.
 |          fast_normal_computation (bool, optional, default=True): If true, the normal estimation uses a non-iterative method to extract the eigenvector from the covariance matrix. This is faster, but is not as numerical stable.
 |
 |      Returns:
 |          None
 |
 |  has_colors(...)
 |      has_colors(self)
 |      Returns ``True`` if the point cloud contains point colors.
 |
 |      Returns:
 |          bool
 |
 |  has_covariances(...)
 |      has_covariances(self: open3d.cpu.pybind.geometry.PointCloud) -> bool
 |
 |      Returns ``True`` if the point cloud contains covariances.
 |
 |  has_normals(...)
 |      has_normals(self)
 |      Returns ``True`` if the point cloud contains point normals.
 |
 |      Returns:
 |          bool
 |
 |  has_points(...)
 |      has_points(self)
 |      Returns ``True`` if the point cloud contains points.
 |
 |      Returns:
 |          bool
 |
 |  hidden_point_removal(...)
 |      hidden_point_removal(self, camera_location, radius)
 |      Removes hidden points from a point cloud and returns a mesh of the remaining points. Based on Katz et al. 'Direct Visibility of Point Sets', 2007. Additional information about the choice of radius for noisy point clouds can be found in Mehra et. al. 'Visibility of Noisy Point Cloud Data', 2010.
 |
 |      Args:
 |          camera_location (numpy.ndarray[numpy.float64[3, 1]]): All points not visible from that location will be reomved
 |          radius (float): The radius of the sperical projection
 |
 |      Returns:
 |          Tuple[open3d.geometry.TriangleMesh, List[int]]
 |
 |  normalize_normals(...)
 |      normalize_normals(self)
 |      Normalize point normals to length 1.
 |
 |      Returns:
 |          open3d.geometry.PointCloud
 |
 |  orient_normals_consistent_tangent_plane(...)
 |      orient_normals_consistent_tangent_plane(self, k)
 |      Function to orient the normals with respect to consistent tangent planes
 |
 |      Args:
 |          k (int): Number of k nearest neighbors used in constructing the Riemannian graph used to propogate normal orientation.
 |
 |      Returns:
 |          None
 |
 |  orient_normals_to_align_with_direction(...)
 |      orient_normals_to_align_with_direction(self, orientation_reference=array([0., 0., 1.]))
 |      Function to orient the normals of a point cloud
 |
 |      Args:
 |          orientation_reference (numpy.ndarray[numpy.float64[3, 1]], optional, default=array([0., 0., 1.])): Normals are oriented with respect to orientation_reference.
 |
 |      Returns:
 |          None
 |
 |  orient_normals_towards_camera_location(...)
 |      orient_normals_towards_camera_location(self, camera_location=array([0., 0., 0.]))
 |      Function to orient the normals of a point cloud
 |
 |      Args:
 |          camera_location (numpy.ndarray[numpy.float64[3, 1]], optional, default=array([0., 0., 0.])): Normals are oriented with towards the camera_location.
 |
 |      Returns:
 |          None
 |
 |  paint_uniform_color(...)
 |      paint_uniform_color(self, color)
 |      Assigns each point in the PointCloud the same color.
 |
 |      Args:
 |          color (numpy.ndarray[numpy.float64[3, 1]]): RGB color for the PointCloud.
 |
 |      Returns:
 |          open3d.geometry.PointCloud
 |
 |  random_down_sample(...)
 |      random_down_sample(self, sampling_ratio)
 |      Function to downsample input pointcloud into output pointcloud randomly. The sample is generated by randomly sampling the indexes from the point cloud.
 |
 |      Args:
 |          sampling_ratio (float): Sampling ratio, the ratio of number of selected points to total number of points[0-1]
 |
 |      Returns:
 |          open3d.geometry.PointCloud
 |
 |  remove_non_finite_points(...)
 |      remove_non_finite_points(self, remove_nan=True, remove_infinite=True)
 |      Function to remove non-finite points from the PointCloud
 |
 |      Args:
 |          remove_nan (bool, optional, default=True): Remove NaN values from the PointCloud
 |          remove_infinite (bool, optional, default=True): Remove infinite values from the PointCloud
 |
 |      Returns:
 |          open3d.geometry.PointCloud
 |
 |  remove_radius_outlier(...)
 |      remove_radius_outlier(self, nb_points, radius)
 |      Function to remove points that have less than nb_points in a given sphere of a given radius
 |
 |      Args:
 |          nb_points (int): Number of points within the radius.
 |          radius (float): Radius of the sphere.
 |
 |      Returns:
 |          Tuple[open3d.geometry.PointCloud, List[int]]
 |
 |  remove_statistical_outlier(...)
 |      remove_statistical_outlier(self, nb_neighbors, std_ratio)
 |      Function to remove points that are further away from their neighbors in average
 |
 |      Args:
 |          nb_neighbors (int): Number of neighbors around the target point.
 |          std_ratio (float): Standard deviation ratio.
 |
 |      Returns:
 |          Tuple[open3d.geometry.PointCloud, List[int]]
 |
 |  segment_plane(...)
 |      segment_plane(self, distance_threshold, ransac_n, num_iterations)
 |      Segments a plane in the point cloud using the RANSAC algorithm.
 |
 |      Args:
 |          distance_threshold (float): Max distance a point can be from the plane model, and still be considered an inlier.
 |          ransac_n (int): Number of initial points to be considered inliers in each iteration.
 |          num_iterations (int): Number of iterations.
 |
 |      Returns:
 |          Tuple[numpy.ndarray[numpy.float64[4, 1]], List[int]]
 |
 |  select_by_index(...)
 |      select_by_index(self, indices, invert=False)
 |      Function to select points from input pointcloud into output pointcloud.
 |
 |      Args:
 |          indices (List[int]): Indices of points to be selected.
 |          invert (bool, optional, default=False): Set to ``True`` to invert the selection of indices.
 |
 |      Returns:
 |          open3d.geometry.PointCloud
 |
 |  uniform_down_sample(...)
 |      uniform_down_sample(self, every_k_points)
 |      Function to downsample input pointcloud into output pointcloud uniformly. The sample is performed in the order of the points with the 0-th point always chosen, not at random.
 |
 |      Args:
 |          every_k_points (int): Sample rate, the selected point indices are [0, k, 2k, ...]
 |
 |      Returns:
 |          open3d.geometry.PointCloud
 |
 |  voxel_down_sample(...)
 |      voxel_down_sample(self, voxel_size)
 |      Function to downsample input pointcloud into output pointcloud with a voxel. Normals and colors are averaged if they exist.
 |
 |      Args:
 |          voxel_size (float): Voxel size to downsample into.
 |
 |      Returns:
 |          open3d.geometry.PointCloud
 |
 |  voxel_down_sample_and_trace(...)
 |      voxel_down_sample_and_trace(self, voxel_size, min_bound, max_bound, approximate_class=False)
 |      Function to downsample using PointCloud.VoxelDownSample. Also records point cloud index before downsampling
 |
 |      Args:
 |          voxel_size (float): Voxel size to downsample into.
 |          min_bound (numpy.ndarray[numpy.float64[3, 1]]): Minimum coordinate of voxel boundaries
 |          max_bound (numpy.ndarray[numpy.float64[3, 1]]): Maximum coordinate of voxel boundaries
 |          approximate_class (bool, optional, default=False)
 |
 |      Returns:
 |          Tuple[open3d.geometry.PointCloud, numpy.ndarray[numpy.int32[m, n]], List[open3d.utility.IntVector]]
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  create_from_depth_image(...) from builtins.PyCapsule
 |      create_from_depth_image(depth, intrinsic, extrinsic=(with default value), depth_scale=1000.0, depth_trunc=1000.0, stride=1, project_valid_depth_only=True)
 |      Factory function to create a pointcloud from a depth image and a
 |      camera. 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
 |
 |      Args:
 |          depth (open3d.geometry.Image): The input depth image can be either a float image, or a uint16_t image.
 |          intrinsic (open3d.camera.PinholeCameraIntrinsic): Intrinsic parameters of the camera.
 |          extrinsic (numpy.ndarray[numpy.float64[4, 4]], optional) Default value:
 |
 |              array([[1., 0., 0., 0.],
 |              [0., 1., 0., 0.],
 |              [0., 0., 1., 0.],
 |              [0., 0., 0., 1.]])
 |          depth_scale (float, optional, default=1000.0): The depth is scaled by 1 / depth_scale.
 |          depth_trunc (float, optional, default=1000.0): Truncated at depth_trunc distance.
 |          stride (int, optional, default=1): Sampling factor to support coarse point cloud extraction.
 |          project_valid_depth_only (bool, optional, default=True)
 |
 |      Returns:
 |          open3d.geometry.PointCloud
 |
 |  create_from_rgbd_image(...) from builtins.PyCapsule
 |      create_from_rgbd_image(image, intrinsic, extrinsic=(with default value), project_valid_depth_only=True)
 |      Factory function to create a pointcloud from an RGB-D image and a camera. 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
 |
 |      Args:
 |          image (open3d.geometry.RGBDImage): The input image.
 |          intrinsic (open3d.camera.PinholeCameraIntrinsic): Intrinsic parameters of the camera.
 |          extrinsic (numpy.ndarray[numpy.float64[4, 4]], optional) Default value:
 |
 |              array([[1., 0., 0., 0.],
 |              [0., 1., 0., 0.],
 |              [0., 0., 1., 0.],
 |              [0., 0., 0., 1.]])
 |          project_valid_depth_only (bool, optional, default=True)
 |
 |      Returns:
 |          open3d.geometry.PointCloud
 |
 |  estimate_point_covariances(...) from builtins.PyCapsule
 |      estimate_point_covariances(input, search_param=KDTreeSearchParamKNN with knn = 30)
 |      Static function to compute the covariance matrix for each point in the given point cloud, doesn't change the input
 |
 |      Args:
 |          input (open3d.geometry.PointCloud): The input point cloud.
 |          search_param (open3d.geometry.KDTreeSearchParam, optional, default=KDTreeSearchParamKNN with knn = 30): The KDTree search parameters for neighborhood search.
 |
 |      Returns:
 |          open3d.utility.Matrix3dVector
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  colors
 |      ``float64`` array of shape ``(num_points, 3)``, range ``[0, 1]`` , use ``numpy.asarray()`` to access data: RGB colors of points.
 |
 |  covariances
 |      ``float64`` array of shape ``(num_points, 3, 3)``, use ``numpy.asarray()`` to access data: Points covariances.
 |
 |  normals
 |      ``float64`` array of shape ``(num_points, 3)``, use ``numpy.asarray()`` to access data: Points normals.
 |
 |  points
 |      ``float64`` array of shape ``(num_points, 3)``, use ``numpy.asarray()`` to access data: Points coordinates.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Geometry3D:
 |
 |  get_axis_aligned_bounding_box(...)
 |      get_axis_aligned_bounding_box(self)
 |      Returns an axis-aligned bounding box of the geometry.
 |
 |      Returns:
 |          open3d.geometry.AxisAlignedBoundingBox
 |
 |  get_center(...)
 |      get_center(self)
 |      Returns the center of the geometry coordinates.
 |
 |      Returns:
 |          numpy.ndarray[numpy.float64[3, 1]]
 |
 |  get_max_bound(...)
 |      get_max_bound(self)
 |      Returns max bounds for geometry coordinates.
 |
 |      Returns:
 |          numpy.ndarray[numpy.float64[3, 1]]
 |
 |  get_min_bound(...)
 |      get_min_bound(self)
 |      Returns min bounds for geometry coordinates.
 |
 |      Returns:
 |          numpy.ndarray[numpy.float64[3, 1]]
 |
 |  get_oriented_bounding_box(...)
 |      get_oriented_bounding_box(self)
 |      Returns an oriented bounding box of the geometry.
 |
 |      Returns:
 |          open3d.geometry.OrientedBoundingBox
 |
 |  rotate(...)
 |      rotate(*args, **kwargs)
 |      Overloaded function.
 |
 |
 |      1. rotate(self, R)
 |          Apply rotation to the geometry coordinates and normals.
 |
 |      Args:
 |          R (numpy.ndarray[numpy.float64[3, 3]]): The rotation matrix
 |
 |      Returns:
 |          open3d.geometry.Geometry3D
 |
 |      2. rotate(self, R, center)
 |          Apply rotation to the geometry coordinates and normals.
 |
 |      Args:
 |          R (numpy.ndarray[numpy.float64[3, 3]]): The rotation matrix
 |          center (numpy.ndarray[numpy.float64[3, 1]]): Rotation center used for transformation.
 |
 |      Returns:
 |          open3d.geometry.Geometry3D
 |
 |  scale(...)
 |      scale(*args, **kwargs)
 |      Overloaded function.
 |
 |
 |      1. scale(self, scale, center)
 |          Apply scaling to the geometry coordinates.
 |
 |      Args:
 |          scale (float): The scale parameter that is multiplied to the points/vertices of the geometry.
 |          center (numpy.ndarray[numpy.float64[3, 1]]): Scale center used for transformation.
 |
 |      Returns:
 |          open3d.geometry.Geometry3D
 |
 |      2. scale(self, scale, center)
 |          Apply scaling to the geometry coordinates.
 |
 |      Args:
 |          scale (float): The scale parameter that is multiplied to the points/vertices of the geometry.
 |          center (numpy.ndarray[numpy.float64[3, 1]]): Scale center used for transformation.
 |
 |      Returns:
 |          open3d.geometry.Geometry3D
 |
 |  transform(...)
 |      transform(self, arg0)
 |      Apply transformation (4x4 matrix) to the geometry coordinates.
 |
 |      Args:
 |          arg0 (numpy.ndarray[numpy.float64[4, 4]])
 |
 |      Returns:
 |          open3d.geometry.Geometry3D
 |
 |  translate(...)
 |      translate(self, translation, relative=True)
 |      Apply translation to the geometry coordinates.
 |
 |      Args:
 |          translation (numpy.ndarray[numpy.float64[3, 1]]): A 3D vector to transform the geometry
 |          relative (bool, optional, default=True): If true, the translation vector is directly added to the geometry coordinates. Otherwise, the center is moved to the translation vector.
 |
 |      Returns:
 |          open3d.geometry.Geometry3D
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from Geometry3D:
 |
 |  get_rotation_matrix_from_axis_angle(...) from builtins.PyCapsule
 |      get_rotation_matrix_from_axis_angle(rotation: numpy.ndarray[numpy.float64[3, 1]]) -> numpy.ndarray[numpy.float64[3, 3]]
 |
 |  get_rotation_matrix_from_quaternion(...) from builtins.PyCapsule
 |      get_rotation_matrix_from_quaternion(rotation: numpy.ndarray[numpy.float64[4, 1]]) -> numpy.ndarray[numpy.float64[3, 3]]
 |
 |  get_rotation_matrix_from_xyz(...) from builtins.PyCapsule
 |      get_rotation_matrix_from_xyz(rotation: numpy.ndarray[numpy.float64[3, 1]]) -> numpy.ndarray[numpy.float64[3, 3]]
 |
 |  get_rotation_matrix_from_xzy(...) from builtins.PyCapsule
 |      get_rotation_matrix_from_xzy(rotation: numpy.ndarray[numpy.float64[3, 1]]) -> numpy.ndarray[numpy.float64[3, 3]]
 |
 |  get_rotation_matrix_from_yxz(...) from builtins.PyCapsule
 |      get_rotation_matrix_from_yxz(rotation: numpy.ndarray[numpy.float64[3, 1]]) -> numpy.ndarray[numpy.float64[3, 3]]
 |
 |  get_rotation_matrix_from_yzx(...) from builtins.PyCapsule
 |      get_rotation_matrix_from_yzx(rotation: numpy.ndarray[numpy.float64[3, 1]]) -> numpy.ndarray[numpy.float64[3, 3]]
 |
 |  get_rotation_matrix_from_zxy(...) from builtins.PyCapsule
 |      get_rotation_matrix_from_zxy(rotation: numpy.ndarray[numpy.float64[3, 1]]) -> numpy.ndarray[numpy.float64[3, 3]]
 |
 |  get_rotation_matrix_from_zyx(...) from builtins.PyCapsule
 |      get_rotation_matrix_from_zyx(rotation: numpy.ndarray[numpy.float64[3, 1]]) -> numpy.ndarray[numpy.float64[3, 3]]
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Geometry:
 |
 |  clear(...)
 |      clear(self)
 |      Clear all elements in the geometry.
 |
 |      Returns:
 |          open3d.geometry.Geometry
 |
 |  dimension(...)
 |      dimension(self)
 |      Returns whether the geometry is 2D or 3D.
 |
 |      Returns:
 |          int
 |
 |  get_geometry_type(...)
 |      get_geometry_type(self)
 |      Returns one of registered geometry types.
 |
 |      Returns:
 |          open3d.geometry.Geometry.GeometryType
 |
 |  is_empty(...)
 |      is_empty(self)
 |      Returns ``True`` iff the geometry is empty.
 |
 |      Returns:
 |          bool
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from Geometry:
 |
 |  HalfEdgeTriangleMesh = <Type.HalfEdgeTriangleMesh: 7>
 |
 |  Image = <Type.Image: 8>
 |
 |  LineSet = <Type.LineSet: 4>
 |
 |  PointCloud = <Type.PointCloud: 1>
 |
 |  RGBDImage = <Type.RGBDImage: 9>
 |
 |  TetraMesh = <Type.TetraMesh: 10>
 |
 |  TriangleMesh = <Type.TriangleMesh: 6>
 |
 |  Type = <class 'open3d.cpu.pybind.geometry.Geometry.Type'>
 |      Enum class for Geometry types.
 |
 |  Unspecified = <Type.Unspecified: 0>
 |
 |  VoxelGrid = <Type.VoxelGrid: 2>
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from pybind11_builtins.pybind11_object:
 |
 |  __new__(*args, **kwargs) from pybind11_builtins.pybind11_type
 |      Create and return a new object.  See help(type) for accurate signature.

Description of a function in Open3D

help(open3d.read_point_cloud) provides a description of the input arguments and return type of the read_point_cloud function.

[5]:
help(o3d.io.read_point_cloud)
Help on built-in function read_point_cloud in module open3d.cpu.pybind.io:

read_point_cloud(...) method of builtins.PyCapsule instance
    read_point_cloud(filename, format='auto', remove_nan_points=False, remove_infinite_points=False, print_progress=False)
    Function to read PointCloud from file

    Args:
        filename (str): Path to file.
        format (str, optional, default='auto'): The format of the input file. When not specified or set as ``auto``, the format is inferred from file extension name.
        remove_nan_points (bool, optional, default=False): If true, all points that include a NaN are removed from the PointCloud.
        remove_infinite_points (bool, optional, default=False): If true, all points that include an infinite value are removed from the PointCloud.
        print_progress (bool, optional, default=False): If set to true a progress bar is visualized in the console

    Returns:
        open3d.geometry.PointCloud