Avoid eager C-order copy in NibabelReader (fixes #8107) (#8825)

## Summary

- `NibabelReader._get_array_data` forced `np.asanyarray(img.dataobj,
order="C")`, triggering a full dense memory reorder on every load on top
of the file read/decompression step. This is the hot path reported in
#8107.
- Drop the forced C-order conversion and keep nibabel's native (F-order)
layout. This aligns the CPU path with the existing GPU/cupy branch just
above, which already returns F-order via `.reshape(data_shape,
order="F")`.
- Downstream MONAI conversion paths
(`convert_to_tensor`/`convert_to_numpy` in
`monai/utils/type_conversion.py`, `monai/data/image_writer.py`, recon
utils) already call `ascontiguousarray` where they actually need
C-contiguous memory, so the reader does not need to pay that cost
eagerly at load time.

Biggest wins are on uncompressed `.nii`, where nibabel's memmap view is
returned lazily rather than being materialized by a forced reorder.
Compressed `.nii.gz` still pays the decompression cost but skips the
subsequent reorder pass, which matches the "twice as long" observation
from @ericspod in the issue thread.

## Compatibility note

The returned array's memory layout changes from C-contiguous to whatever
nibabel provides (typically F-contiguous). Any external caller consuming
`reader.get_data(...)[0]` directly via `.tobytes()` or a raw C-extension
buffer without first calling `ascontiguousarray` would see a different
byte order. All in-repo consumers already guard themselves.

## Test plan

- [x] New regression test in `tests/data/test_init_reader.py` loads a
small NIfTI through `NibabelReader` for both `.nii` and `.nii.gz`,
asserts array equality, and asserts the returned data is not
C-contiguous (i.e. no eager C copy).
- [x] `pytest tests/data/test_init_reader.py` passes locally.
- [x] `runtests.sh`-equivalent checks: `ruff`, `black
--skip-magic-trailing-comma --check`, `isort --check`, `pycln`,
pre-commit hooks — all clean on touched files.

Fixes #8107

---------

Signed-off-by: Soumya Snigdha Kundu <soumya_snigdha.kundu@kcl.ac.uk>
Signed-off-by: Eric Kerfoot <17726042+ericspod@users.noreply.github.com>
Co-authored-by: Eric Kerfoot <17726042+ericspod@users.noreply.github.com>

Author: aymuos15

monai/data/image_reader.py

@@ -1102,7 +1102,8 @@ def get_data(self, img) -> tuple[np.ndarray, dict]:
         This function returns two objects, first is numpy array of image data, second is dict of metadata.
         It constructs `affine`, `original_affine`, and `spatial_shape` and stores them in meta dict.
         When loading a list of files, they are stacked together at a new dimension as the first dimension,
-        and the metadata of the first image is used to present the output metadata.
+        and the metadata of the first image is used to present the output metadata. The returned arrays
+        preserve the ordering in the original data, typically this is F-ordering for NIfTI files.
 
         Args:
             img: a Nibabel image object loaded from an image file or a list of Nibabel image objects.
@@ -1217,7 +1218,7 @@ def _get_array_data(self, img, filename):
             data_offset = img.dataobj.offset
             data_dtype = img.dataobj.dtype
             return image[data_offset:].view(data_dtype).reshape(data_shape, order="F")
-        return np.asanyarray(img.dataobj, order="C")
+        return np.asanyarray(img.dataobj)
 
 
 class NumpyReader(ImageReader):

tests/data/test_init_reader.py

@@ -11,8 +11,12 @@
 
 from __future__ import annotations
 
+import os
+import tempfile
 import unittest
 
+import numpy as np
+
 from monai.data import ITKReader, NibabelReader, NrrdReader, NumpyReader, PILReader, PydicomReader
 from monai.transforms import LoadImage, LoadImaged
 from tests.test_utils import SkipIfNoModule
@@ -76,6 +80,26 @@ def test_readers_to_gpu(self):
             inst = NibabelReader(to_gpu=to_gpu)
             self.assertIsInstance(inst, NibabelReader)
 
+    @SkipIfNoModule("nibabel")
+    def test_nibabel_reader_avoids_eager_c_order_copy(self):
+        import nibabel as nib
+
+        test_image = np.arange(2 * 3 * 4, dtype=np.int16).reshape(2, 3, 4)
+        with tempfile.TemporaryDirectory() as tempdir:
+            for suffix in (".nii", ".nii.gz"):
+                with self.subTest(suffix=suffix):
+                    filename = os.path.join(tempdir, f"test_image{suffix}")
+                    nib.save(nib.Nifti1Image(test_image, np.eye(4)), filename)
+
+                    reader = NibabelReader(mmap=False)
+                    img = reader.read(filename)
+                    data, _ = reader.get_data(img)
+
+                    np.testing.assert_array_equal(data, test_image)
+                    # The reader must not force an eager C-order copy; the native
+                    # (F-order) layout from nibabel should be preserved here.
+                    self.assertFalse(data.flags.c_contiguous)
+
 
 if __name__ == "__main__":
     unittest.main()