Python : Comment créer et visualiser des nuages ​​de points

1. Introduction

Les applications de nuages ​​de points sont partout : robots, voitures autonomes, systèmes d'assistance, soins de santé, etc. Le nuage de points est une représentation 3D adaptée au traitement de données du monde réel, en particulier lorsque la géométrie de la scène/de l'objet est requise, comme la distance, la forme et la taille de l'objet.

Un nuage de points est un ensemble de points qui représentent une scène dans le monde réel ou un objet dans l'espace. C'est une représentation discrète d'objets et de scènes géométriques. En d'autres termes, le nuage de points PCD est un ensemble de n points, où chaque point Pi est représenté par ses coordonnées 3D :

Notez que d'autres fonctionnalités peuvent également être ajoutées pour décrire le nuage de points, comme RVB. couleur, méthode Ligne, etc. Par exemple, des couleurs RVB peuvent être ajoutées pour fournir des informations sur les couleurs.

2. Génération de nuages ​​de points

Les nuages ​​de points sont généralement générés à l'aide de scanners 3D (scanners laser, scanners à temps de vol et scanners à lumière structurée) ou de modèles de conception assistée par ordinateur (CAO). Dans ce tutoriel, nous allons d'abord créer et visualiser un nuage de points aléatoire. Nous utiliserons ensuite la bibliothèque Open3D pour échantillonner des points de la surface 3D afin de la générer à partir du modèle 3D. Enfin, nous verrons comment les créer à partir de données RGB-D.

Commençons par importer la bibliothèque Python :

import numpy as np
import matplotlib.pyplot as plt
import open3d as o3d

2.1 Nuage de points aléatoires

Le moyen le plus simple est de créer un nuage de points aléatoire. Notez que nous ne créons généralement pas de points aléatoires à traiter, sauf lors de la création de bruit pour les GAN (Generative Adversarial Networks).

Habituellement, les nuages ​​de points sont représentés par des tableaux (n×3), où n est le nombre de points. Créons un nuage de points avec 5 points aléatoires :

number_points = 5
pcd = np.random.rand(number_points, 3)# uniform distribution over [0, 1)
print(pcd)

On pourrait imprimer les points directement, mais ce n'est pas très efficace, surtout dans la plupart des applications si le nombre de points est important. Une meilleure approche consiste à les afficher dans un espace 3D. Visualisons-le à l'aide de la bibliothèque Matplotlib :

# Create Figure:
fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
ax.scatter3D(pcd[:, 0], pcd[:, 1], pcd[:, 2])
# label the axes
ax.set_xlabel("X")
ax.set_ylabel("Y")
ax.set_zlabel("Z")
ax.set_title("Random Point Cloud")
# display:
plt.show()

Visualisation de nuages ​​de points aléatoires

2.2 Échantillonnage de nuages ​​de points

Le traitement direct de modèles 3D prend du temps. Par conséquent, l’échantillonnage de nuages ​​de points à partir de leurs surfaces tridimensionnelles constitue une solution potentielle. Commençons par importer le modèle de lapin depuis l'ensemble de données Open3D :

bunny = o3d.data.BunnyMesh()
mesh = o3d.io.read_triangle_mesh(bunny.path)

Ou importez-le comme ceci :

mesh = o3d.io.read_triangle_mesh("data/bunny.ply")

Ensuite, affichez le modèle 3D pour voir à quoi il ressemble. Vous pouvez déplacer votre souris pour voir sous différents points de vue.

# Visualize:
mesh.compute_vertex_normals() # compute normals for vertices or faces
o3d.visualization.draw_geometries([mesh])

Rabbit 3D Model

Pour échantillonner un nuage de points, il existe plusieurs méthodes. Dans cet exemple, nous échantillonnons uniformément 1 000 points du maillage importé et les visualisons :

# Sample 1000 points:
pcd = mesh.sample_points_uniformly(number_of_points=1000)


# visualize:
o3d.visualization.draw_geometries([pcd])

Rabbit Point Cloud

Nous pouvons enregistrer le nuage de points créé au format .ply comme suit. Montré :

# Save into ply file:
o3d.io.write_point_cloud("output/bunny_pcd.ply", pcd)

2.3 Point cloud à partir de données RVB-D

Les données RVB-D sont collectées à l'aide d'un capteur RVB-D (tel que Microsoft Kinect), qui fournit à la fois des images RVB et des images de profondeur. Les capteurs RVB-D sont largement utilisés dans la navigation intérieure, l'évitement d'obstacles et d'autres domaines. Étant donné que les images RVB fournissent des couleurs de pixels, chaque pixel de l'image de profondeur représente sa distance par rapport à la caméra.

Open3D fournit un ensemble de fonctions pour le traitement des images RVB-D. Pour créer un nuage de points à partir de données RVB-D à l'aide des fonctions Open3D, importez simplement deux images, créez un objet image RVB-D et calculez enfin le nuage de points comme suit :

# read the color and the depth image:
color_raw = o3d.io.read_image("../data/rgb.jpg")
depth_raw = o3d.io.read_image("../data/depth.png")


# create an rgbd image object:
rgbd_image = o3d.geometry.RGBDImage.create_from_color_and_depth(
color_raw, depth_raw, convert_rgb_to_intensity=False)
# use the rgbd image to create point cloud:
pcd = o3d.geometry.PointCloud.create_from_rgbd_image(
rgbd_image,
o3d.camera.PinholeCameraIntrinsic(
o3d.camera.PinholeCameraIntrinsicParameters.PrimeSenseDefault))


# visualize:
o3d.visualization.draw_geometries([pcd])

Couleur générée à partir de RVB-D image Nuages ​​de points

3, Open3D et NumPy

Parfois, vous devez basculer entre Open3D et NumPy. Par exemple, disons que nous voulons convertir un nuage de points NumPy en un objet Open3D.PointCloud pour la visualisation et utiliser Matplotlib pour visualiser un modèle 3D d'un lapin.

3.1 De NumPy à Open3D

Dans cet exemple, nous créons 2000 points aléatoires à l'aide de la fonction NumPy.random.rand(), qui crée des échantillons aléatoires à partir d'une distribution uniforme de [0,1]. Nous créons ensuite un objet Open3D.PointCloud et définissons sa fonctionnalité Open3D.PointCloud.points sur des points aléatoires à l'aide de la fonction Open3D.utility.Vector3dVector().

# Create numpy pointcloud:
number_points = 2000
pcd_np = np.random.rand(number_points, 3)


# Convert to Open3D.PointCLoud:
pcd_o3d = o3d.geometry.PointCloud()# create point cloud object
pcd_o3d.points = o3d.utility.Vector3dVector(pcd_np)# set pcd_np as the point cloud points


# Visualize:
o3d.visualization.draw_geometries([pcd_o3d])

Visualisation Open3D d'un nuage de points aléatoires

3.2 从 Open3D到NumPy

这里，我们首先使用Open3D.io.read_point_cloud()函数从.ply文件中读取点云，该函数返回一个Open3D.PointCloud对象。现在我们只需要使用NumPy.asarray()函数将表示点的Open3D.PointCloud.points特征转换为NumPy数组。最后，我们像上面那样显示获得的数组。

# Read the bunny point cloud file:
pcd_o3d = o3d.io.read_point_cloud("../data/bunny_pcd.ply")


# Convert the open3d object to numpy:
pcd_np = np.asarray(pcd_o3d.points)


# Display using matplotlib:
fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
ax.scatter3D(pcd_np[:, 0], pcd_np[:, 2], pcd_np[:, 1])
# label the axes
ax.set_xlabel("X")
ax.set_ylabel("Y")
ax.set_zlabel("Z")
ax.set_title("Bunny Point Cloud")
# display:
plt.show()

使用 Matplotlib 显示的兔子点云

4、最后

在本教程中，我们学习了如何创建和可视化点云。在接下来的教程中，我们将学习如何处理它们。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!