Add a MWE test illustrating troubles when wrapping vt.vtImage

tst/wrapping_vtImage.py → src/vt/wrapping_vtImage.py

@@ -9,7 +9,7 @@
 import logging
 import numpy as np
 
-import vt
+from vt import vtImage as vt_vtImage
 
 
 def _round_list(input_list, dec_val=6):
@@ -31,12 +31,12 @@ def _round_list(input_list, dec_val=6):
 
 
 def _new_from_vt_image(vt_img):
-    """Extract objects to create an image from a ``vtImage`` or a ``vt.vtImage``.
+    """Extract objects to create an image from a ``vtImage`` or a ``vt_vtImage``.
 
     Parameters
     ----------
-    vt_img : vtImage
-        The vtImage to convert as a SpatialImage
+    vt_img : vt_vtImage or vtImage
+        An image object inheriting from vt_vtImage.
 
     Returns
     -------
@@ -50,28 +50,34 @@ def _new_from_vt_image(vt_img):
         The dictionary of metadata associated to the image.
 
     """
-    # Retreive the shape
+    # - Retrieve the image shape:
     sh = vt_img.shape()  # returns xyz ordered shape
     sh.reverse()  # convert to zyx ordered shape
 
-    vxs = _round_list(vt_img.spacing(), dec_val=6)
+    # - Retrieve the image voxelsize:
+    vxs = _round_list(vt_img.spacing(), dec_val=6)  # round it up to 6 decimals
     vxs = vxs[::-1]  # convert to zyx ordered voxelsize
 
+    # - 2D management:
     if len(sh) == 3 and sh[0] == 1:
         vxs = vxs[1:]
         sh = sh[1:]
 
+    # - Retrieve the array:
     arr = vt_img.copy_to_array()
-    arr = arr.ravel().reshape(sh)
+    # arr = arr.ravel().reshape(sh)
 
+    # - Not so important here...
     ori = getattr(vt_img, 'origin', None)
     md = getattr(vt_img, 'metadata', {})
 
     return arr, vxs, ori, md
 
 
-class vtImage(vt.vtImage):
-    """Python wrapper for vt.vtImage.
+DEFAULT_ORIG_2D, DEFAULT_ORIG_3D = [0, 0], [0, 0, 0]
+
+class vtImage(vt_vtImage):
+    """Python wrapper for vt_vtImage.
 
     Attributes
     ----------
@@ -80,12 +86,12 @@ class vtImage(vt.vtImage):
 
     """
 
-    def __init__(self, image, voxelsize=None):
+    def __init__(self, image, voxelsize=None, **kwargs):
         """ Constructor.
 
         Parameters
         ----------
-        image : str or numpy.ndarray or vt.vtImage
+        image : str or numpy.ndarray or vt_vtImage
             If a ``str``, should match a file path to load.
             If a ``numpy.ndarray``, the array of the image.
             We assume they are sorted as (planes,) rows & columns ([Z,] Y, X).
@@ -94,25 +100,31 @@ class vtImage(vt.vtImage):
             Should be sorted as (planes,) rows & columns ([Z,] Y, X).
 
         """
+        # Parse keyword arguments:
+        origin = kwargs.get('origin', None)
+        metadata = kwargs.get('metadata', {})
+
         if isinstance(image, np.ndarray):
             logging.debug(
                 "``vtImage`` constructor got a ``numpy.ndarray`` as input!")
             if voxelsize is None:
-                super().__init__(image)  # call to `vt.vtImage` init method!
+                super().__init__(image)
             else:
-                super().__init__(image, voxelsize)  # call to `vt.vtImage` init method!
-        elif isinstance(image, vt.vtImage):
+                super().__init__(image, voxelsize)
+        elif isinstance(image, vt_vtImage):
             logging.debug(
-                "``vtImage`` constructor got a ``vt.vtImage`` as input!")
-            arr, vxs, _, _ = _new_from_vt_image(image)
-            super().__init__(arr, vxs[::-1])  # call to `vt.vtImage` init method!
+                "``vtImage`` constructor got a ``{}`` as input!".format(
+                    type(image)))
+            arr, vxs, ori, md = _new_from_vt_image(image)
+            # super().__init__(arr, vxs[::-1])
+            self.__init__(arr, vxs[::-1], origin=ori, metadata=md)
         elif isinstance(image, str):
             logging.debug(
                 "``vtImage`` constructor got a filename ``str`` as input!")
-            super().__init__(image)  # call to `vt.vtImage` init method!
+            super().__init__(image)
         else:
             raise TypeError(
-                "Could not make sense of object given in imput, read the doc!")
+                "Could not make sense of object given in input, read the doc!")
 
         # Specify `ndim` attribute:
         sh = self.shape()
@@ -120,32 +132,81 @@ class vtImage(vt.vtImage):
             ndim = 3
         else:
             ndim = 2
+        if origin is None:
+            if ndim == 3:
+                origin = DEFAULT_ORIG_3D
+            else:
+                origin = DEFAULT_ORIG_2D
 
+        # Defines attributes:
+        self._metadata = metadata
+        self._origin = origin
         self.ndim = ndim
 
 
 if __name__ == '__main__':
-    import vt
+    logging.basicConfig()
+    logging.getLogger().setLevel(logging.DEBUG)
+
     from os.path import abspath, dirname, join
 
-    # Defines the image path:
+    # - Defines the image path:
+    # file_path = '/home/jonathan/Projects/VT_Python/vt-python/data/p58-t0_INT_down_interp_2x.inr'
     file_path = abspath(
-        join(dirname(__file__), "..", "data", "p58-t0_INT_down_interp_2x.inr"))
+        join(dirname(__file__), "../..", "data", "p58-t0_INT_down_interp_2x.inr"))
     print("Image file path is: {}".format(file_path))
 
-    # Load it with vtImage from VT:
-    print("Load it with `vt.vtImage` (i.e. from VT)...")
-    vt_vtim = vt.vtImage(file_path)
-    assert isinstance(vt_vtim, vt.vtImage)
-    print("Successfully created `vt.vtImage` object:")
+    # - Load it with vtImage from VT:
+    print("Load it with `vt_vtImage` (i.e. from VT)...")
+    vt_vtim = vt_vtImage(file_path)
+    assert isinstance(vt_vtim, vt_vtImage)
+    print("Successfully created `vt_vtImage` object:")
     print(vt_vtim)
 
-    # Create a vtImage object (defined above, inherit from vt.vtImage)
-    print("Instantiation of `vtImage` object (INHERIT from `vt.vtImage`)...")
+    # - Manual creation of vt_vtImage from array and voxelsize:
+    arr = vt_vtim.copy_to_array()
+    vxs = vt_vtim.spacing()
+    # vt_vtim2 = vt_vtImage(arr, vxs)
+    # arr2 = vt_vtim2.copy_to_array()
+    # np.testing.assert_array_equal(arr, arr2)
+
+    # - Create a vtImage object a from array and voxelsize:
+    print("\n\n# - Instantiation of `vtImage` object from array and voxelsize...")
+    vtim = vtImage(arr, vxs)
+    isinstance(vtim, vtImage)
+    print("Successfully created `vtImage` object:")
+    print(vtim)
+    print("vtImage.ndim = {}".format(vtim.ndim))
+
+    print("Testing `spacing` method:", end=" ")
+    assert vtim.spacing() == vt_vtim.spacing()
+    print("OK!")
+
+    print("Testing `shape` method:", end=" ")
+    assert vtim.shape() == vt_vtim.shape()
+    print("OK!")
+
+    print("Testing `copy_to_array` method of `vt_vtImage` object:", end=" ")
+    vt_vtarr = vt_vtim.copy_to_array()
+    print("OK!")
+
+    print("Testing `copy_to_array` method of `vtImage` object:", end=" ")
+    vtarr = vtim.copy_to_array()
+    print("OK!")
+
+    print("Comparing arrays from `vt_vtImage` & `vtImage` objects:", end=" ")
+    np.testing.assert_array_equal(vt_vtarr, vtarr)
+    print("OK!")
+
+    # - Create a vtImage object a from `vt_vtImage`
+    print("\n\n# - Instantiation of `vtImage` object from `vt_vtImage`...")
     vtim = vtImage(vt_vtim)
     isinstance(vtim, vtImage)
     print("Successfully created `vtImage` object:")
     print(vtim)
+    print("vtImage.ndim = {}".format(vtim.ndim))
+    print("vtImage._origin = {}".format(vtim._origin))
+    print("vtImage._metadata = {}".format(vtim._metadata))
 
     print("Testing `spacing` method:", end=" ")
     assert vtim.spacing() == vt_vtim.spacing()
@@ -155,7 +216,7 @@ if __name__ == '__main__':
     assert vtim.shape() == vt_vtim.shape()
     print("OK!")
 
-    print("Testing `copy_to_array` method of `vt.vtImage` object:", end=" ")
+    print("Testing `copy_to_array` method of `vt_vtImage` object:", end=" ")
     vt_vtarr = vt_vtim.copy_to_array()
     print("OK!")
 
@@ -163,6 +224,6 @@ if __name__ == '__main__':
     vtarr = vtim.copy_to_array()
     print("OK!")
 
-    print("Comparing arrays obtained from `vt.vtImage` & `vtImage` objects:", end=" ")
+    print("Comparing arrays from `vt_vtImage` & `vtImage` objects:", end=" ")
     np.testing.assert_array_equal(vt_vtarr, vtarr)
     print("OK!")

tst/test_wrapping_vtimage.py

+# !/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import unittest
+import numpy as np
+from os.path import abspath, dirname, join
+
+from vt import vtImage as vt_vtImage
+from vt.wrapping_vtImage import vtImage
+
+
+class TestWrappingvtImage(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        # Path to a real image file:
+        cls._file_path = abspath(join(dirname(__file__), "..", "data",
+                                      "p58-t1_INT_down_interp_2x.inr"))
+        # Use vt.vtImage to read image file:
+        cls._vt_vtim = vt_vtImage(cls._file_path)
+
+    def test_init_vt_vtimg_from_copy_to_array(self):
+        """Test creation of vt_vtImage from array and voxelsize. """
+        arr = self._vt_vtim.copy_to_array()
+        assert isinstance(arr, np.ndarray)
+        vxs = self._vt_vtim.spacing()
+        vt_vtim2 = vt_vtImage(arr, vxs)
+        assert isinstance(vt_vtim2, vt_vtImage)
+        arr2 = vt_vtim2.copy_to_array()
+        assert isinstance(arr2, np.ndarray)
+        np.testing.assert_array_equal(arr, arr2)
+
+    def test_init_vtimg_from_copy_to_array(self):
+        """Test creation of vtImage from array and voxelsize. """
+        arr = self._vt_vtim.copy_to_array()
+        assert isinstance(arr, np.ndarray)
+        vxs = self._vt_vtim.spacing()
+        vtim = vtImage(arr, vxs)
+        assert isinstance(vtim, vt_vtImage)
+        arr2 = vtim.copy_to_array()
+        assert isinstance(arr2, np.ndarray)
+        np.testing.assert_array_equal(arr, arr2)
+
+    def test_init_vtimg_from_vt_vtimg(self):
+        """Test creation of vtImage from vt_vtImage. """
+        vtim = vtImage(self._vt_vtim)
+        assert isinstance(vtim, vt_vtImage)
+        arr2 = vtim.copy_to_array()
+        assert isinstance(arr2, np.ndarray)
+        print(np.array(np.where(self._vt_vtim.copy_to_array() != arr2)).T)
+        np.testing.assert_array_equal(self._vt_vtim.copy_to_array(), arr2)