Introduction

If you have random sample points and need an approximately uniform grid, the usual solution is not to force the points into a perfect lattice. It is to divide the domain into regular cells and aggregate the samples inside each cell. That gives you a structured approximation that works well for visualization, density estimation, and many preprocessing tasks.

Start by Defining Regular Grid Cells

Assume you have scattered two-dimensional points inside a rectangular domain. You can build an approximate grid by choosing the number of bins along each axis and assigning every sample point to one cell.

1import numpy as np
2
3rng = np.random.default_rng(42)
4points = rng.random((1000, 2))
5
6nx = 10
7ny = 8
8
9x_edges = np.linspace(0.0, 1.0, nx + 1)
10y_edges = np.linspace(0.0, 1.0, ny + 1)
11
12print(x_edges[:3], y_edges[:3])

At this stage, the grid is just a set of evenly spaced boundaries. The random samples are still unstructured, but now there is a uniform cell system that can organize them.

Count Samples Per Cell

If your goal is occupancy or density, counting how many points fall in each cell is often enough. NumPy already provides a fast way to do this.

1import numpy as np
2
3rng = np.random.default_rng(42)
4points = rng.random((1000, 2))
5
6hist, x_edges, y_edges = np.histogram2d(
7    points[:, 0],
8    points[:, 1],
9    bins=(10, 8),
10    range=((0.0, 1.0), (0.0, 1.0)),
11)
12
13print(hist.shape)
14print(hist[:2, :3])

hist is an approximately uniform grid because every cell represents the same spatial size even though the original points were random. This is often the right answer for heatmaps and coarse spatial summaries.

Compute a Representative Value Per Cell

Sometimes a plain count is not enough. You may want one representative point or one average value per cell. In that case, compute cell indices and aggregate manually.

1import numpy as np
2
3rng = np.random.default_rng(42)
4points = rng.random((1000, 2))
5values = points[:, 0] + 2 * points[:, 1]
6
7nx, ny = 10, 8
8grid_sum = np.zeros((nx, ny))
9grid_count = np.zeros((nx, ny), dtype=int)
10
11ix = np.minimum((points[:, 0] * nx).astype(int), nx - 1)
12iy = np.minimum((points[:, 1] * ny).astype(int), ny - 1)
13
14for x_idx, y_idx, value in zip(ix, iy, values):
15    grid_sum[x_idx, y_idx] += value
16    grid_count[x_idx, y_idx] += 1
17
18grid_mean = np.divide(
19    grid_sum,
20    grid_count,
21    out=np.full((nx, ny), np.nan),
22    where=grid_count > 0,
23)
24
25print(grid_mean[:2, :3])

This turns irregular samples into a regular grid of averaged values. Empty cells become NaN, which is often useful because it distinguishes "no data" from a real zero.

Build Grid Centers for Plotting

Many plotting and interpolation tools expect cell centers rather than bin edges. Those are easy to derive from the regular boundaries.

1x_centers = 0.5 * (x_edges[:-1] + x_edges[1:])
2y_centers = 0.5 * (y_edges[:-1] + y_edges[1:])
3
4print(x_centers[:3], y_centers[:3])

With centers plus the aggregated grid values, you can feed the result into contour plots, image plots, or downstream numerical code.

Understand What "Approximately Uniform" Means

The grid is uniform because the cells are regular, not because every cell has the same number of random samples. Some cells will be dense and some sparse. If the sample is large enough and reasonably distributed, the grid approximation improves. If the sample is tiny or highly clustered, many cells may stay empty.

That is why bin count selection matters. Too many bins create a sparse grid with many empty cells. Too few bins smear out important local structure.

When Interpolation Is Better

Binning is not the same as smooth interpolation. If the goal is a continuous surface rather than a cell-based grid, interpolation methods such as nearest-neighbor, linear interpolation, or radial basis functions may fit the problem better. Binning remains the simplest robust starting point because it is fast, explicit, and easy to reason about.

Common Pitfalls

• Choosing too many cells for the sample size and ending up with mostly empty bins.
• Treating empty cells as zero when they actually mean "no sample data."
• Confusing cell counts with interpolated values.
• Forgetting to clamp index calculations at the last bin edge.
• Building a regular grid without checking whether the original sample covers the domain well enough.

Summary

• Build an approximate grid by dividing the domain into regular bins and assigning random samples to them.
• 'numpy.histogram2d is a strong default when you only need counts.'
• For averaged values, compute cell indices and aggregate sums and counts manually.
• Use cell centers when plotting or exporting the structured result.
• The grid can be uniform even when sample density is not.