3D images made of voxels

A 3D image is a stack of 2D images

A photo on a screen is a grid of small squares called pixels. Each pixel holds a number for its brightness, for example from 0 (black) to 255 (white). Now take many photos of thin slices of an object, one under the next, and stack them. The stack is a 3D image, also called a volume.

Each small box in the stack is a voxel, short for "volume pixel." A voxel has three whole-number indices that say where it sits in the grid: column x, row y, and slice z. It holds one value, the brightness of the material inside that box.

A voxel's size can differ between axes

The voxel size gives the real width, height and depth of one voxel. Microscope images of cells use the nanometer (nm), one billionth of a meter. A thousand nanometers make one micrometer (µm), and a human hair is about 70 µm wide.

When a voxel has the same size on all three axes, the image is isotropic. Often it is not. Some electron microscopes see each slice at 8 nm per pixel, but the slices themselves are cut 40 nm thick. Then each voxel is 8 × 8 × 40 nm, and the image is anisotropic: its voxel size depends on the direction.

The grid hides this. In the array, a step of one voxel along z looks just like a step of one voxel along x. In real space, the z step is 5 times longer.

Distances need physical units

To find the real position of a voxel, multiply each index by the voxel size along that axis. Then use the usual distance formula (see distance between two points) on those positions. If you skip the multiplication, you get a count of voxel steps, which mixes 8 nm steps with 40 nm steps.

Skipping the conversion can even change which point is nearer. Before you use the figure, predict: point C is 4 voxels from A along x, and point D is 1 voxel from A along z. Which is nearer?

The two lengths match at a depth of 32 nm, because C is 4 × 8 = 32 nm from A. At the real depth of 40 nm, C is nearer. Any program that finds nearest points, measures lengths or compares shapes must first turn voxel indices into physical units.

In NumPy, scale the index steps, then measure

voxels.py

import numpy as np

voxel_size = np.array([8.0, 8.0, 40.0])   # nm per voxel along x, y, z

a = np.array([10, 20, 5])   # voxel indices (x, y, z)
b = np.array([13, 24, 8])
print(round(np.linalg.norm(b - a), 2))                 # voxel steps: not a real length
print(round(np.linalg.norm((b - a) * voxel_size), 2))  # nanometers

c = np.array([14, 20, 5])   # 4 voxels from a along x
d = np.array([10, 20, 6])   # 1 voxel from a along z
for p in (c, d):
    print(np.linalg.norm(p - a), np.linalg.norm((p - a) * voxel_size))

5.83
126.49
4.0 32.0
1.0 40.0

Lines 10 and 11 set up C and D. In voxel steps D is nearer (1 against 4). In nanometers C is nearer (32 against 40).