How can I correctly pass a 3D NumPy array to a C function expecting a triple pointer using ctypes?

Below is one explanation and resolution. In your code you build the triple‐pointer structure using

  t_ptr[i][j] = arr_c[i][j].ctypes.data_as(ct.POINTER(ct.c_int))

This causes each “leaf” pointer to be computed from a temporary subarray view rather than from a pointer directly into the contiguous storage. Even though you used ascontiguousarray the “slices” (when you index with [i][j]) yield separate temporary objects and their pointer arithmetic is not relative to the base of the full array. This makes the C function see only the first couple of “elements” correctly while later positions are left unmodified.

The easiest fixes are one of the following:

---

Option 1: Pass a single data pointer

Since your NumPy array is stored in contiguous memory, you can pass its base pointer and then compute indices in C. For example, change your C function to accept an int* and compute the index as:

  index = i * (cols * depth) + j * depth + k

So your C function becomes:

CCopied
void effect_array(int *ptr, int rows, int cols, int depth)
{
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            for (int k = 0; k < depth; k++) {
                ptr[i * cols * depth + j * depth + k] *= 2;
            }
        }
    }
}

And in Python call it like:

PYTHONCopied
import ctypes as ct
import numpy as np

arr = np.array([
    [
        [1, 2, 3, 4],
        [5, 6, 7, 8],
        [9, 10, 11, 12]
    ],
    [
        [13, 14, 15, 16],
        [17, 18, 19, 20],
        [21, 22, 23, 24]
    ]
], dtype=np.int32)

arr_c = np.ascontiguousarray(arr)

lib = ct.CDLL("path/to/share_object.so")
_effect_array = lib.effect_array

_effect_array.argtypes = [ct.POINTER(ct.c_int), ct.c_int, ct.c_int, ct.c_int]
_effect_array.restype = None

rows, cols, depth = arr_c.shape

base_ptr = arr_c.ctypes.data_as(ct.POINTER(ct.c_int))

print("Original array =")
print(arr_c)
print()

_effect_array(base_ptr, rows, cols, depth)

print("Array after pass to function =")
print(arr_c)

This makes indexing work correctly because the C function has a flat pointer and the pointer arithmetic uses the correct stride.

---

Option 2: Build the triple‐pointer with proper pointer arithmetic

If you want to stick with the triple‐pointer API, you must ensure each pointer is computed from the base address rather than from temporary views. For example, compute the offset manually:

PYTHONCopied
import ctypes as ct
import numpy as np

arr = np.array([
    [
        [1, 2, 3, 4],
        [5, 6, 7, 8],
        [9, 10, 11, 12]
    ],
    [
        [13, 14, 15, 16],
        [17, 18, 19, 20],
        [21, 22, 23, 24]
    ]
], dtype=np.int32)

arr_c = np.ascontiguousarray(arr)

rows, cols, depth = arr_c.shape

# Base pointer to the contiguous data block
base_ptr = arr_c.ctypes.data_as(ct.POINTER(ct.c_int))

# Allocate an array for the row pointers
RowArrayType = ct.POINTER(ct.POINTER(ct.c_int)) * rows
t_ptr = RowArrayType()

for i in range(rows):
    # Allocate an array for the column pointers for row i
    ColArrayType = ct.POINTER(ct.c_int) * cols
    t_ptr[i] = ColArrayType()
    for j in range(cols):
        # Compute the offset into the contiguous block:
        offset = (i * cols * depth) + (j * depth)
        t_ptr[i][j] = ct.cast(ct.addressof(base_ptr.contents) + offset * ct.sizeof(ct.c_int), ct.POINTER(ct.c_int))

lib = ct.CDLL("path/to/share_object.so")
_effect_array = lib.effect_array
_effect_array.argtypes = [ct.POINTER(ct.POINTER(ct.POINTER(ct.c_int))), ct.c_int, ct.c_int, ct.c_int]
_effect_array.restype = None

print("Original array =")
print(arr_c)
print()

_effect_array(t_ptr, rows, cols, depth)

print("Array after pass to function =")
print(arr_c)

In this version we construct each pointer from the base address plus an appropriate offset. Now the C function’s triple indexing works as expected.

---

Summary

The original issue stems from passing pointers taken from temporary subarray views rather than computing the correct pointer addresses from the base contiguous memory. Either change the C interface to only require a flat pointer (and do pointer arithmetic on the C side) or build the triple pointer’s components manually by computing the offset from the base pointer.

Either option will result in your desired output where every element is doubled.

Choose the method that best fits your application design.