Indeed that’s a very interesting method you are proposing!
Empirically, I think the loading duration is short enough that I can try to use this for my application!
However, I still have two inquires:
- it feels like the
slicer loading procedure still depends on the size of the image as exemplified below
- is this method applicable to gifti files as well? I couldn’t find a
slicer method in nibabel for gifti objects ; in case it does not exist, do you think it’s implementable?
Example illustrating the fact that slicer still scales linearly in the number of voxels:
I just tried the following snippet (I divided output durations by the number of steps to approximate how much time it takes to actually load these things):
# %%
import numpy as np
import nibabel as nb
import timeit
import tempfile
# %%
number = 100
# %%
with tempfile.NamedTemporaryFile(suffix=".nii.gz") as f:
# prep fake image
Z = np.random.normal(size=(512, 512, 512))
n = nb.Nifti1Image(Z, affine=np.eye(4))
n.to_filename(f.name)
setup = f"""
import numpy as np
import nibabel as nb
# load full image and then slice
def load_full(f, x, y, z) -> None:
img: nb.Nifti1Image = nb.load(f)
_ = img.get_fdata()[x : (x + 1), y : (y + 1), z : (z + 1)]
# load sliced image only
def load_sliced(f, x, y, z) -> None:
n: nb.Nifti1Image = nb.load(f).slicer[x : (x + 1), y : (y + 1), z : (z + 1)]
_ = n.get_fdata()
f = '{f.name}'
x, y, z = 10, 10, 10
"""
print(f"{timeit.timeit(stmt='load_full(f, x, y, z)', setup=setup, number=number)/number}")
print(f"{timeit.timeit(stmt='load_sliced(f, x, y, z)', setup=setup, number=number)/number}")
which yields (careful, it takes 10 minutes to run haha):
5.1362942935799945
0.10730613767998876
Running the same snippet with an image size of (256, 256, 256) yields
0.6240910130699922
0.02270433284007595
which is roughtly 8x faster than with images of size (512, 512, 512), which seems to indicate a linear dependency in n (the number of voxels in the image).
