Split Mask_volume into a function for voxels and a function for volume in mm3

- use a mask-like volume for testing

Author: JulianKlug

nibabel/cmdline/stats.py

@@ -13,7 +13,7 @@
 
 import argparse
 from nibabel.loadsave import load
-from nibabel.imagestats import mask_volume
+from nibabel.imagestats import mask_volume, count_nonzero_voxels
 
 
 def _get_parser():
@@ -34,6 +34,11 @@ def main(args=None):
     from_img = load(opts.infile)
 
     if opts.Volume:
-        computed_volume = mask_volume(from_img, opts.units)
+        if opts.units == 'mm3':
+            computed_volume = mask_volume(from_img)
+        elif opts.units == 'vox':
+            computed_volume = count_nonzero_voxels(from_img)
+        else:
+            raise ValueError(f'{opts.units} is not a valid unit. Choose "mm3" or "vox".')
         print(computed_volume)
         return 0

nibabel/cmdline/tests/test_stats.py

@@ -8,17 +8,40 @@
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
 
-from nibabel.testing import test_data
+from io import StringIO
+import sys
+import numpy as np
+
+from nibabel.loadsave import save
 from nibabel.cmdline.stats import main
+from nibabel import Nifti1Image
+
+
+class Capturing(list):
+    def __enter__(self):
+        self._stdout = sys.stdout
+        sys.stdout = self._stringio = StringIO()
+        return self
+    def __exit__(self, *args):
+        self.extend(self._stringio.getvalue().splitlines())
+        del self._stringio    # free up some memory
+        sys.stdout = self._stdout
 
 
-def test_volume():
-    infile = test_data(fname="anatomical.nii")
+def test_volume(tmpdir):
+    mask_data = np.zeros((20, 20, 20), dtype='u1')
+    mask_data[5:15, 5:15, 5:15] = 1
+    img = Nifti1Image(mask_data, np.eye(4))
+
+    infile = tmpdir / "input.nii"
+    save(img, infile)
+
     args = (f"{infile} --Volume")
-    vol_mm3 = main(args.split())
+    with Capturing() as vol_mm3:
+        main(args.split())
     args = (f"{infile} --Volume --units vox")
-    vol_vox = main(args.split())
-
-    assert float(vol_mm3) == 2273328656.0
-    assert float(vol_vox) == 284166082.0
+    with Capturing() as vol_vox:
+        main(args.split())
 
+    assert float(vol_mm3[0]) == 1000.0
+    assert int(vol_vox[0]) == 1000

nibabel/imagestats.py

@@ -13,8 +13,23 @@
 import numpy as np
 from nibabel.imageclasses import spatial_axes_first
 
+def count_nonzero_voxels(img):
+    """
+    Count number of non-zero voxels
+    Parameters
+    ----------
+    img : ``SpatialImage``
+        All voxels of the mask should be of value 1, background should have value 0.
+
+    Returns
+    -------
+    non zero voxel volume: int
+        Number of non-zero voxels
+
+    """
+    return np.count_nonzero(img.dataobj)
 
-def mask_volume(img, units='mm3'):
+def mask_volume(img):
     """ Compute volume of mask image.
     Equivalent to "fslstats /path/file.nii -V"
 
@@ -23,36 +38,24 @@ def mask_volume(img, units='mm3'):
     img : ``SpatialImage``
         All voxels of the mask should be of value 1, background should have value 0.
 
-    units : string {"mm3", "vox"}, optional
-        Unit of the returned mask volume. Defaults to "mm3".
 
     Returns
     -------
-    mask_volume_vx: float
-        Volume of mask expressed in voxels.
-
-    or
-
     mask_volume_mm3: float
         Volume of mask expressed in mm3.
 
     Examples
     --------
-    >>> import nibabel as nf
-    >>> path = 'path/to/nifti/mask.nii'
-    >>> img = nf.load(path) # path is contains a path to an example nifti mask
-    >>> mask_volume(img)
-    50.3021
+    >>> import nibabel as nb
+    >>> mask_data = np.zeros((20, 20, 20), dtype='u1')
+    >>> mask_data[5:15, 5:15, 5:15] = 1
+    >>> nb.imagestats.mask_volume(nb.Nifti1Image(mask_data, np.eye(4))
+    1000.0
     """
     if not spatial_axes_first(img):
         raise ValueError("Cannot calculate voxel volume for image with unknown spatial axes")
     voxel_volume_mm3 = np.prod(img.header.get_zooms()[:3])
-    mask_volume_vx = np.count_nonzero(img.dataobj)
+    mask_volume_vx = count_nonzero_voxels(img)
     mask_volume_mm3 = mask_volume_vx * voxel_volume_mm3
 
-    if units == 'vox':
-        return mask_volume_vx
-    elif units == 'mm3':
-        return mask_volume_mm3
-    else:
-        raise ValueError(f'{units} is not a valid unit. Choose "mm3" or "vox".')
+    return mask_volume_mm3

nibabel/tests/test_imagestats.py

@@ -11,19 +11,21 @@
 import numpy as np
 
 from .. import imagestats
-from nibabel.testing import test_data
-from nibabel.loadsave import load
+from .. import Nifti1Image
 
 import pytest
 
 
 def test_mask_volume():
     # Test mask volume computation
-    infile = test_data(fname="anatomical.nii")
-    img = load(infile)
+
+    mask_data = np.zeros((20, 20, 20), dtype='u1')
+    mask_data[5:15, 5:15, 5:15] = 1
+    img = Nifti1Image(mask_data, np.eye(4))
+
     vol_mm3 = imagestats.mask_volume(img)
-    vol_vox = imagestats.mask_volume(img, units='vox')
+    vol_vox = imagestats.count_nonzero_voxels(img)
 
-    assert float(vol_mm3) == 2273328656.0
-    assert float(vol_vox) == 284166082.0
+    assert vol_mm3 == 1000.0
+    assert vol_vox == 1000
 

setup.cfg

@@ -73,6 +73,7 @@ console_scripts =
     nib-ls=nibabel.cmdline.ls:main
     nib-dicomfs=nibabel.cmdline.dicomfs:main
     nib-diff=nibabel.cmdline.diff:main
+    nib-stats=nibabel.cmdline.stats:main
     nib-nifti-dx=nibabel.cmdline.nifti_dx:main
     nib-tck2trk=nibabel.cmdline.tck2trk:main
     nib-trk2tck=nibabel.cmdline.trk2tck:main