Shapes as point clouds

A point cloud is a table of points, one row per point

Picture a donut dusted with flour. Each grain of flour sits at one spot on the surface. If you write down where every grain sits, you can draw the donut again from that list alone. That list is a point cloud: a set of points that together show a shape.

Each point is a position in space, written as three numbers (see vectors). So a point cloud with N points is a table with N rows and 3 columns. In Python this table is an array of shape (N, 3) (see arrays in NumPy).

Before you use the viewer below, guess: how many points do you need before you can tell that the shape is a donut?

With a few hundred points the hole becomes clear. With a few thousand the surface looks smooth. The shape did not change. Only the number of samples did.

The order of the rows does not matter

The table lists the points in some order, but the order carries no meaning. Swap two rows and the shape stays the same. So a point cloud is really a set: a collection where only membership counts, not position in a list.

This fact shapes every program that reads point clouds. A program should give the same answer for both numberings above. A function with that property is called permutation invariant; the unit order doesn't matter explains how a model can have it.

A point cloud stores only where the shape is

Another way to store a shape is a 3D grid of tiny boxes that are each full or empty (see voxels). A grid spends memory on every box, including all the empty space around the shape. A point cloud spends memory only on the shape itself.

The price is that a point cloud has a fixed level of detail. Between two points, it says nothing. If a part of the shape is thinner than the gap between points, that part can vanish. Programs often choose a fixed number of points per shape, spread evenly; farthest-point sampling is one way to choose them.

In NumPy, a point cloud is an array with three columns

This snippet builds the eight corners of a cube as a point cloud, shuffles the rows, and checks that the shape is unchanged.

point_clouds.py

import numpy as np

# The 8 corners of a cube with side 2, centered at the origin.
# Each corner takes x, y and z from (-1, 1); dtype=float stores them as decimals.
cloud = np.array([[x, y, z] for x in (-1, 1) for y in (-1, 1) for z in (-1, 1)], dtype=float)
print(cloud.shape)

rng = np.random.default_rng(0)
shuffled = cloud[rng.permutation(len(cloud))]   # the same points, rows in a new order
print(cloud[0], shuffled[0])                     # the first rows differ
print(cloud.mean(axis=0), shuffled.mean(axis=0)) # the center does not
# np.array_equal: do the two sorted lists of rows match?
print(np.array_equal(np.unique(cloud, axis=0), np.unique(shuffled, axis=0)))

(8, 3)
[-1. -1. -1.] [-1.  1. -1.]
[0. 0. 0.] [0. 0. 0.]
True

The center, the mean of all the points, does not depend on the order. Neither does the sorted list of rows that np.unique returns. Both are examples of permutation-invariant summaries.