How to Append 28×28 Image Blocks with NumPy Concatenate: Axis Selection, Shapes, and a Faster Pattern

Learn how to correctly use NumPy concatenate for 2D image blocks: pick the right axis, initialize empty arrays (0,28), avoid shape errors, and speed up appends.

Building a 2D NumPy array by incrementally appending image blocks sounds straightforward until axis rules and shapes step in. If you need to accumulate greyscale image data as 28×28 chunks and keep everything in a single array, the way you initialize the array and call concatenate determines whether the code works or fails with type and shape errors.

Example that reproduces the issue

The starting point is an empty array with the right dtype, reshaped to 2D, followed by incremental appends. The sequence below shows where the process goes wrong.

import numpy as np

canvas = np.array([], dtype=np.uint8)
canvas = np.reshape(canvas, newshape=(28, 28))

patch = ...  # some 2D block intended to be appended

# Incorrect concatenate usage (raises a TypeError)
merged = np.concatenate(canvas, patch)

# After fixing the call signature, a shape error appears
merged = np.concatenate((canvas, patch), axis=0)

The first call fails with TypeError: only integer scalar arrays can be converted to a scalar index. After correcting the concatenate signature, the next failure is a ValueError complaining that along dimension 1, the first array has size 0 while the second has size 28. The root cause is the mismatch in non-concatenation dimensions when the empty array has the wrong zero-length axis.

What actually goes wrong

NumPy concatenate requires that all dimensions except the concatenation axis match exactly. If you plan to stack 2D blocks along axis 0, the number of columns must be identical in all arrays. When the empty array is initialized with the wrong shape, you end up with zero on the column dimension, while the incoming block has 28 columns, which violates the rule.

Pay close attention to the dimension requirements of concatenate.

Correct use of concatenate: numpy.concatenate((image, sub_image), axis=?). Reread its docs.

Working fix

The resolution is twofold. First, use the correct concatenate signature by passing a tuple of arrays and specifying the axis. Second, initialize the empty array with a zero length on the concatenation axis and a fixed size on the other axis. For 28×28 blocks appended along axis 0, the empty array should have shape (0, 28).

import numpy as np

canvas = np.reshape(np.array([], dtype=np.uint8), newshape=(0, 28))

patch = ...  # a 2D array with shape (28, 28) or (k, 28) to stack along axis 0

canvas = np.concatenate((canvas, patch), axis=0)

This preserves the required equality of non-concatenation dimensions and allows further appends as needed.

A more memory-efficient pattern

Repeated concatenate calls allocate and copy data many times. To make accumulation more efficient, collect blocks in a Python list and concatenate once at the end.

import numpy as np

tiles = []

tiles.append(patch)  # repeat for many incoming blocks

canvas = np.concatenate(tiles)

This approach avoids repeated copying during the growth phase and creates the final array in one go.

Why this matters

When you stream or batch image data, a subtle shape mismatch can derail the entire pipeline. Correct axis choice and consistent shapes are critical for image preprocessing, augmentation, and any workflow that aggregates 2D data. Proper initialization with a zero-length dimension on the concatenation axis saves time and prevents hard-to-trace runtime errors. For performance, deferring the actual combination step until the end significantly reduces memory traffic.

Takeaways

Use the proper signature for NumPy concatenate by passing a tuple of arrays and setting the axis. Initialize the empty 2D container so that the non-concatenation dimensions already match the incoming blocks—in this case, (0, 28) for appending along axis 0. If you expect many appends, batch them in a list and concatenate once to minimize copying. These small decisions keep array assembly predictable, efficient, and robust when working with 2D image data.