Add files using upload-large-folder tool

MindEyeV2/antspy/ants/contrib/__init__.py

@@ -0,0 +1,4 @@
+
+from .sampling import *
+# from .sklearn_interface import *
+

MindEyeV2/antspy/ants/contrib/sampling/__init__.py

@@ -0,0 +1,4 @@
+
+from .transforms import *
+from .affine2d import *
+from .affine3d import *

MindEyeV2/antspy/ants/contrib/sampling/affine2d.py

@@ -0,0 +1,654 @@
+"""
+Affine transforms
+
+See http://www.cs.cornell.edu/courses/cs4620/2010fa/lectures/03transforms3D.pdf
+"""
+
+__all__ = [
+    "Zoom2D",
+    "RandomZoom2D",
+    "Rotate2D",
+    "RandomRotate2D",
+    "Shear2D",
+    "RandomShear2D",
+    "Translate2D",
+    "RandomTranslate2D",
+]
+
+import random
+import math
+import numpy as np
+
+from ...core import ants_transform as tio
+
+
+class Translate2D(object):
+    """
+    Create an ANTs Affine Transform with a specified translation.
+    """
+
+    def __init__(self, translation, reference=None, lazy=False):
+        """
+        Initialize a Translate2D object
+
+        Arguments
+        ---------
+        translation : list or tuple
+            translation values for each axis, in degrees.
+            Negative values can be used for translation in the
+            other direction
+
+        reference : ANTsImage (optional but recommended)
+            image providing the reference space for the transform.
+            this will also set the transform fixed parameters.
+
+        lazy : boolean (default = False)
+            if True, calling the `transform` method only returns
+            the randomly generated transform and does not actually
+            transform the image
+        """
+        if (not isinstance(translation, (list, tuple))) or (len(translation) != 2):
+            raise ValueError("translation argument must be list/tuple with two values!")
+
+        self.translation = translation
+        self.lazy = lazy
+        self.reference = reference
+
+        self.tx = tio.ANTsTransform(
+            precision="float", dimension=2, transform_type="AffineTransform"
+        )
+        if self.reference is not None:
+            self.tx.set_fixed_parameters(self.reference.get_center_of_mass())
+
+    def transform(self, X=None, y=None):
+        """
+        Transform an image using an Affine transform with the given
+        translation parameters.  Return the transform if X=None.
+
+        Arguments
+        ---------
+        X : ANTsImage
+            Image to transform
+
+        y : ANTsImage (optional)
+            Another image to transform
+
+        Returns
+        -------
+        ANTsImage if y is None, else a tuple of ANTsImage types
+
+        Examples
+        --------
+        >>> import ants
+        >>> img = ants.image_read(ants.get_data('r16'))
+        >>> tx = ants.contrib.Translate2D(translation=(10,0))
+        >>> img2_x = tx.transform(img)
+        >>> tx = ants.contrib.Translate2D(translation=(-10,0)) # other direction
+        >>> img2_x = tx.transform(img)
+        >>> tx = ants.contrib.Translate2D(translation=(0,10))
+        >>> img2_z = tx.transform(img)
+        >>> tx = ants.contrib.Translate2D(translation=(10,10))
+        >>> img2 = tx.transform(img)
+        """
+        # convert to radians and unpack
+        translation_x, translation_y = self.translation
+
+        translation_matrix = np.array([[1, 0, translation_x], [0, 1, translation_y]])
+        self.tx.set_parameters(translation_matrix)
+        if self.lazy or X is None:
+            return self.tx
+        else:
+            if y is None:
+                return self.tx.apply_to_image(X, reference=self.reference)
+            else:
+                return (
+                    self.tx.apply_to_image(X, reference=self.reference),
+                    self.tx.apply_to_image(y, reference=self.reference),
+                )
+
+
+class RandomTranslate2D(object):
+    """
+    Apply a Translate2D transform to an image, but with the
+    parameters randomly generated from a user-specified range.
+    The range is determined by a mean (first parameter) and standard deviation
+    (second parameter) via calls to random.gauss.
+    """
+
+    def __init__(self, translation_range, reference=None, lazy=False):
+        """
+        Initialize a RandomTranslate2D object
+
+        Arguments
+        ---------
+        translation_range : list or tuple
+            Lower and Upper bounds on rotation parameter, in degrees.
+            e.g. translation_range = (-10,10) will result in a random
+            draw of the rotation parameters between -10 and 10 degrees
+
+        reference : ANTsImage (optional but recommended)
+            image providing the reference space for the transform.
+            this will also set the transform fixed parameters.
+
+        lazy : boolean (default = False)
+            if True, calling the `transform` method only returns
+            the randomly generated transform and does not actually
+            transform the image
+        """
+        if (not isinstance(translation_range, (list, tuple))) or (
+            len(translation_range) != 2
+        ):
+            raise ValueError("shear_range argument must be list/tuple with two values!")
+
+        self.translation_range = translation_range
+        self.reference = reference
+        self.lazy = lazy
+
+    def transform(self, X=None, y=None):
+        """
+        Transform an image using an Affine transform with
+        translation parameters randomly generated from the user-specified
+        range.   Return the transform if X=None.
+
+        Arguments
+        ---------
+        X : ANTsImage
+            Image to transform
+
+        y : ANTsImage (optional)
+            Another image to transform
+
+        Returns
+        -------
+        ANTsImage if y is None, else a tuple of ANTsImage types
+
+        Examples
+        --------
+        >>> import ants
+        >>> img = ants.image_read(ants.get_data('r16'))
+        >>> tx = ants.contrib.RandomShear2D(translation_range=(-10,10))
+        >>> img2 = tx.transform(img)
+        """
+        # random draw in translation range
+        translation_x = random.gauss(
+            self.translation_range[0], self.translation_range[1]
+        )
+        translation_y = random.gauss(
+            self.translation_range[0], self.translation_range[1]
+        )
+        self.params = (translation_x, translation_y)
+
+        tx = Translate2D(
+            (translation_x, translation_y), reference=self.reference, lazy=self.lazy
+        )
+
+        return tx.transform(X, y)
+
+
+class Shear2D(object):
+    """
+    Create an ANTs Affine Transform with a specified shear.
+    """
+
+    def __init__(self, shear, reference=None, lazy=False):
+        """
+        Initialize a Shear2D object
+
+        Arguments
+        ---------
+        shear : list or tuple
+            shear values for each axis, in degrees.
+            Negative values can be used for shear in the
+            other direction
+
+        reference : ANTsImage (optional but recommended)
+            image providing the reference space for the transform.
+            this will also set the transform fixed parameters.
+
+        lazy : boolean (default = False)
+            if True, calling the `transform` method only returns
+            the randomly generated transform and does not actually
+            transform the image
+        """
+        if (not isinstance(shear, (list, tuple))) or (len(shear) != 2):
+            raise ValueError("shear argument must be list/tuple with two values!")
+
+        self.shear = shear
+        self.lazy = lazy
+        self.reference = reference
+
+        self.tx = tio.ANTsTransform(
+            precision="float", dimension=2, transform_type="AffineTransform"
+        )
+        if self.reference is not None:
+            self.tx.set_fixed_parameters(self.reference.get_center_of_mass())
+
+    def transform(self, X=None, y=None):
+        """
+        Transform an image using an Affine transform with the given
+        shear parameters.   Return the transform if X=None.
+
+        Arguments
+        ---------
+        X : ANTsImage
+            Image to transform
+
+        y : ANTsImage (optional)
+            Another image to transform
+
+        Returns
+        -------
+        ANTsImage if y is None, else a tuple of ANTsImage types
+
+        Examples
+        --------
+        >>> import ants
+        >>> img = ants.image_read(ants.get_data('r16'))
+        >>> tx = ants.contrib.Shear2D(shear=(10,0,0))
+        >>> img2_x = tx.transform(img)# x axis stays same
+        >>> tx = ants.contrib.Shear2D(shear=(-10,0,0)) # other direction
+        >>> img2_x = tx.transform(img)# x axis stays same
+        >>> tx = ants.contrib.Shear2D(shear=(0,10,0))
+        >>> img2_y = tx.transform(img) # y axis stays same
+        >>> tx = ants.contrib.Shear2D(shear=(0,0,10))
+        >>> img2_z = tx.transform(img) # z axis stays same
+        >>> tx = ants.contrib.Shear2D(shear=(10,10,10))
+        >>> img2 = tx.transform(img)
+        """
+        # convert to radians and unpack
+        shear = [math.pi / 180 * s for s in self.shear]
+        shear_x, shear_y = shear
+
+        shear_matrix = np.array([[1, shear_x, 0], [shear_y, 1, 0]])
+        self.tx.set_parameters(shear_matrix)
+        if self.lazy or X is None:
+            return self.tx
+        else:
+            if y is None:
+                return self.tx.apply_to_image(X, reference=self.reference)
+            else:
+                return (
+                    self.tx.apply_to_image(X, reference=self.reference),
+                    self.tx.apply_to_image(y, reference=self.reference),
+                )
+
+
+class RandomShear2D(object):
+    """
+    Apply a Shear2D transform to an image, but with the shear
+    parameters randomly generated from a user-specified range.
+    The range is determined by a mean (first parameter) and standard deviation
+    (second parameter) via calls to random.gauss.
+    """
+
+    def __init__(self, shear_range, reference=None, lazy=False):
+        """
+        Initialize a RandomShear2D object
+
+        Arguments
+        ---------
+        shear_range : list or tuple
+            Lower and Upper bounds on rotation parameter, in degrees.
+            e.g. shear_range = (-10,10) will result in a random
+            draw of the rotation parameters between -10 and 10 degrees
+
+        reference : ANTsImage (optional but recommended)
+            image providing the reference space for the transform.
+            this will also set the transform fixed parameters.
+
+        lazy : boolean (default = False)
+            if True, calling the `transform` method only returns
+            the randomly generated transform and does not actually
+            transform the image
+        """
+        if (not isinstance(shear_range, (list, tuple))) or (len(shear_range) != 2):
+            raise ValueError("shear_range argument must be list/tuple with two values!")
+
+        self.shear_range = shear_range
+        self.reference = reference
+        self.lazy = lazy
+
+    def transform(self, X=None, y=None):
+        """
+        Transform an image using an Affine transform with
+        shear parameters randomly generated from the user-specified
+        range.   Return the transform if X=None.
+
+        Arguments
+        ---------
+        X : ANTsImage
+            Image to transform
+
+        y : ANTsImage (optional)
+            Another image to transform
+
+        Returns
+        -------
+        ANTsImage if y is None, else a tuple of ANTsImage types
+
+        Examples
+        --------
+        >>> import ants
+        >>> img = ants.image_read(ants.get_data('r16'))
+        >>> tx = ants.contrib.RandomShear2D(shear_range=(-10,10))
+        >>> img2 = tx.transform(img)
+        """
+        # random draw in shear range
+        shear_x = random.gauss(self.shear_range[0], self.shear_range[1])
+        shear_y = random.gauss(self.shear_range[0], self.shear_range[1])
+        self.params = (shear_x, shear_y)
+
+        tx = Shear2D((shear_x, shear_y), reference=self.reference, lazy=self.lazy)
+
+        return tx.transform(X, y)
+
+
+class Rotate2D(object):
+    """
+    Create an ANTs Affine Transform with a specified level
+    of rotation.
+    """
+
+    def __init__(self, rotation, reference=None, lazy=False):
+        """
+        Initialize a Rotate2D object
+
+        Arguments
+        ---------
+        rotation : scalar
+            rotation value in degrees.
+            Negative values can be used for rotation in the
+            other direction
+
+        reference : ANTsImage (optional but recommended)
+            image providing the reference space for the transform.
+            this will also set the transform fixed parameters.
+
+        lazy : boolean (default = False)
+            if True, calling the `transform` method only returns
+            the randomly generated transform and does not actually
+            transform the image
+        """
+        self.rotation = rotation
+        self.lazy = lazy
+        self.reference = reference
+
+        self.tx = tio.ANTsTransform(
+            precision="float", dimension=2, transform_type="AffineTransform"
+        )
+        if self.reference is not None:
+            self.tx.set_fixed_parameters(self.reference.get_center_of_mass())
+
+    def transform(self, X=None, y=None):
+        """
+        Transform an image using an Affine transform with the given
+        rotation parameters.   Return the transform if X=None.
+
+        Arguments
+        ---------
+        X : ANTsImage
+            Image to transform
+
+        y : ANTsImage (optional)
+            Another image to transform
+
+        Returns
+        -------
+        ANTsImage if y is None, else a tuple of ANTsImage types
+
+        Examples
+        --------
+        >>> import ants
+        >>> img = ants.image_read(ants.get_data('r16'))
+        >>> tx = ants.contrib.Rotate2D(rotation=(10,-5,12))
+        >>> img2 = tx.transform(img)
+        """
+        # unpack zoom range
+        rotation = self.rotation
+
+        # Rotation about X axis
+        theta = math.pi / 180 * rotation
+        rotation_matrix = np.array(
+            [[np.cos(theta), -np.sin(theta), 0], [np.sin(theta), np.cos(theta), 0]]
+        )
+
+        self.tx.set_parameters(rotation_matrix)
+        if self.lazy or X is None:
+            return self.tx
+        else:
+            if y is None:
+                return self.tx.apply_to_image(X, reference=self.reference)
+            else:
+                return (
+                    self.tx.apply_to_image(X, reference=self.reference),
+                    self.tx.apply_to_image(y, reference=self.reference),
+                )
+
+
+class RandomRotate2D(object):
+    """
+    Apply a Rotated2D transform to an image, but with the zoom
+    parameters randomly generated from a user-specified range.
+    The range is determined by a mean (first parameter) and standard deviation
+    (second parameter) via calls to random.gauss.
+    """
+
+    def __init__(self, rotation_range, reference=None, lazy=False):
+        """
+        Initialize a RandomRotate2D object
+
+        Arguments
+        ---------
+        rotation_range : list or tuple
+            Lower and Upper bounds on rotation parameter, in degrees.
+            e.g. rotation_range = (-10,10) will result in a random
+            draw of the rotation parameters between -10 and 10 degrees
+
+        reference : ANTsImage (optional but recommended)
+            image providing the reference space for the transform.
+            this will also set the transform fixed parameters.
+
+        lazy : boolean (default = False)
+            if True, calling the `transform` method only returns
+            the randomly generated transform and does not actually
+            transform the image
+        """
+        if (not isinstance(rotation_range, (list, tuple))) or (
+            len(rotation_range) != 2
+        ):
+            raise ValueError(
+                "rotation_range argument must be list/tuple with two values!"
+            )
+
+        self.rotation_range = rotation_range
+        self.reference = reference
+        self.lazy = lazy
+
+    def transform(self, X=None, y=None):
+        """
+        Transform an image using an Affine transform with
+        rotation parameters randomly generated from the user-specified
+        range.   Return the transform if X=None.
+
+        Arguments
+        ---------
+        X : ANTsImage
+            Image to transform
+
+        y : ANTsImage (optional)
+            Another image to transform
+
+        Returns
+        -------
+        ANTsImage if y is None, else a tuple of ANTsImage types
+
+        Examples
+        --------
+        >>> import ants
+        >>> img = ants.image_read(ants.get_data('r16'))
+        >>> tx = ants.contrib.RandomRotate2D(rotation_range=(-10,10))
+        >>> img2 = tx.transform(img)
+        """
+        # random draw in rotation range
+        rotation = random.gauss(self.rotation_range[0], self.rotation_range[1])
+        self.params = rotation
+
+        tx = Rotate2D(rotation, reference=self.reference, lazy=self.lazy)
+
+        return tx.transform(X, y)
+
+
+class Zoom2D(object):
+    """
+    Create an ANTs Affine Transform with a specified level
+    of zoom. Any value greater than 1 implies a "zoom-out" and anything
+    less than 1 implies a "zoom-in".
+    """
+
+    def __init__(self, zoom, reference=None, lazy=False):
+        """
+        Initialize a Zoom2D object
+
+        Arguments
+        ---------
+        zoom_range : list or tuple
+            Lower and Upper bounds on zoom parameter.
+            e.g. zoom_range = (0.7,0.9) will result in a random
+            draw of the zoom parameters between 0.7 and 0.9
+
+        reference : ANTsImage (optional but recommended)
+            image providing the reference space for the transform.
+            this will also set the transform fixed parameters.
+
+        lazy : boolean (default = False)
+            if True, calling the `transform` method only returns
+            the randomly generated transform and does not actually
+            transform the image
+        """
+        if (not isinstance(zoom, (list, tuple))) or (len(zoom) != 2):
+            raise ValueError("zoom_range argument must be list/tuple with two values!")
+
+        self.zoom = zoom
+        self.lazy = lazy
+        self.reference = reference
+
+        self.tx = tio.ANTsTransform(
+            precision="float", dimension=2, transform_type="AffineTransform"
+        )
+        if self.reference is not None:
+            self.tx.set_fixed_parameters(self.reference.get_center_of_mass())
+
+    def transform(self, X=None, y=None):
+        """
+        Transform an image using an Affine transform with the given
+        zoom parameters.   Return the transform if X=None.
+
+        Arguments
+        ---------
+        X : ANTsImage
+            Image to transform
+
+        y : ANTsImage (optional)
+            Another image to transform
+
+        Returns
+        -------
+        ANTsImage if y is None, else a tuple of ANTsImage types
+
+        Examples
+        --------
+        >>> import ants
+        >>> img = ants.image_read(ants.get_data('r16'))
+        >>> tx = ants.contrib.Zoom2D(zoom=(0.8,0.8,0.8))
+        >>> img2 = tx.transform(img)
+        """
+        # unpack zoom range
+        zoom_x, zoom_y = self.zoom
+
+        self.params = (zoom_x, zoom_y)
+        zoom_matrix = np.array([[zoom_x, 0, 0], [0, zoom_y, 0]])
+        self.tx.set_parameters(zoom_matrix)
+        if self.lazy or X is None:
+            return self.tx
+        else:
+            if y is None:
+                return self.tx.apply_to_image(X, reference=self.reference)
+            else:
+                return (
+                    self.tx.apply_to_image(X, reference=self.reference),
+                    self.tx.apply_to_image(y, reference=self.reference),
+                )
+
+
+class RandomZoom2D(object):
+    """
+    Apply a Zoom2D transform to an image, but with the zoom
+    parameters randomly generated from a user-specified range.
+    The range is determined by a mean (first parameter) and standard deviation
+    (second parameter) via calls to random.gauss.
+    """
+
+    def __init__(self, zoom_range, reference=None, lazy=False):
+        """
+        Initialize a RandomZoom2D object
+
+        Arguments
+        ---------
+        zoom_range : list or tuple
+            Lower and Upper bounds on zoom parameter.
+            e.g. zoom_range = (0.7,0.9) will result in a random
+            draw of the zoom parameters between 0.7 and 0.9
+
+        reference : ANTsImage (optional but recommended)
+            image providing the reference space for the transform.
+            this will also set the transform fixed parameters.
+
+        lazy : boolean (default = False)
+            if True, calling the `transform` method only returns
+            the randomly generated transform and does not actually
+            transform the image
+        """
+        if (not isinstance(zoom_range, (list, tuple))) or (len(zoom_range) != 2):
+            raise ValueError("zoom_range argument must be list/tuple with two values!")
+
+        self.zoom_range = zoom_range
+        self.reference = reference
+        self.lazy = lazy
+
+    def transform(self, X=None, y=None):
+        """
+        Transform an image using an Affine transform with
+        zoom parameters randomly generated from the user-specified
+        range.  Return the transform if X=None.
+
+        Arguments
+        ---------
+        X : ANTsImage
+            Image to transform
+
+        y : ANTsImage (optional)
+            Another image to transform
+
+        Returns
+        -------
+        ANTsImage if y is None, else a tuple of ANTsImage types
+
+        Examples
+        --------
+        >>> import ants
+        >>> img = ants.image_read(ants.get_data('r16'))
+        >>> tx = ants.contrib.RandomZoom2D(zoom_range=(0.8,0.9))
+        >>> img2 = tx.transform(img)
+        """
+        # random draw in zoom range
+        zoom_x = np.exp(
+            random.gauss(np.log(self.zoom_range[0]), np.log(self.zoom_range[1]))
+        )
+        zoom_y = np.exp(
+            random.gauss(np.log(self.zoom_range[0]), np.log(self.zoom_range[1]))
+        )
+        self.params = (zoom_x, zoom_y)
+
+        tx = Zoom2D((zoom_x, zoom_y), reference=self.reference, lazy=self.lazy)
+
+        return tx.transform(X, y)

MindEyeV2/antspy/ants/contrib/sampling/affine3d.py

@@ -0,0 +1,802 @@
+"""
+Affine transforms
+
+See http://www.cs.cornell.edu/courses/cs4620/2010fa/lectures/03transforms3d.pdf
+"""
+
+__all__ = [
+    "Zoom3D",
+    "RandomZoom3D",
+    "Rotate3D",
+    "RandomRotate3D",
+    "Shear3D",
+    "RandomShear3D",
+    "Translate3D",
+    "RandomTranslate3D",
+    "Affine3D",
+]
+
+import random
+import math
+import numpy as np
+
+from ...core import ants_transform as tio
+
+class Affine3D(object):
+    """
+    Create a specified ANTs Affine Transform
+    """
+
+    def __init__(self, transformation, reference=None, lazy=False):
+        """
+        Initialize a Affine object
+
+        Arguments
+        ---------
+        transformation : array
+            affine transformation array (3x4)
+
+        reference : ANTsImage (optional but recommended)
+            image providing the reference space for the transform.
+            this will also set the transform fixed parameters.
+
+        lazy : boolean (default = False)
+            if True, calling the `transform` method only returns
+            the randomly generated transform and does not actually
+            transform the image
+        """
+        if (not isinstance(transformation, np.ndarray) or transformation.shape != (3,4)):
+            raise ValueError(
+                "transformation argument must be 3x4 Numpy array!"
+            )
+
+        self.transformation = transformation
+        self.lazy = lazy
+        self.reference = reference
+
+        self.tx = tio.ANTsTransform(
+            precision="float", dimension=3, transform_type="AffineTransform"
+        )
+        if self.reference is not None:
+            self.tx.set_fixed_parameters(self.reference.get_center_of_mass())
+
+    def transform(self, X=None, y=None):
+        """
+        Transform an image using an Affine transform with the given
+        translation parameters.  Return the transform if X=None.
+
+        Arguments
+        ---------
+        X : ANTsImage
+            Image to transform
+
+        y : ANTsImage (optional)
+            Another image to transform
+
+        Returns
+        -------
+        ANTsImage if y is None, else a tuple of ANTsImage types
+
+        Examples
+        --------
+        >>> import ants
+        >>> img = ants.image_read(ants.get_data('ch2'))
+        >>> tx = ants.contrib.Affine3D(transformation=np.array([[1, 0, 0, dx], [0, 1, 0, dy],[0, 0, 1, dz]])
+        >>> img2_x = tx.transform(img)# image translated by (dx, dy, dz)
+        """
+        # unpack
+
+        transformation_matrix = self.transformation
+
+
+        self.tx.set_parameters(transformation_matrix)
+        if self.lazy or X is None:
+            return self.tx
+        else:
+            if y is None:
+                return self.tx.apply_to_image(X, reference=self.reference)
+            else:
+                return (
+                    self.tx.apply_to_image(X, reference=self.reference),
+                    self.tx.apply_to_image(y, reference=self.reference),
+                )
+
+
+class Translate3D(object):
+    """
+    Create an ANTs Affine Transform with a specified translation.
+    """
+
+    def __init__(self, translation, reference=None, lazy=False):
+        """
+        Initialize a Translate3D object
+
+        Arguments
+        ---------
+        translation : list or tuple
+            translation values for each axis, in degrees.
+            Negative values can be used for translation in the
+            other direction
+
+        reference : ANTsImage (optional but recommended)
+            image providing the reference space for the transform.
+            this will also set the transform fixed parameters.
+
+        lazy : boolean (default = False)
+            if True, calling the `transform` method only returns
+            the randomly generated transform and does not actually
+            transform the image
+        """
+        if (not isinstance(translation, (list, tuple))) or (len(translation) != 3):
+            raise ValueError(
+                "translation argument must be list/tuple with three values!"
+            )
+
+        self.translation = translation
+        self.lazy = lazy
+        self.reference = reference
+
+        self.tx = tio.ANTsTransform(
+            precision="float", dimension=3, transform_type="AffineTransform"
+        )
+        if self.reference is not None:
+            self.tx.set_fixed_parameters(self.reference.get_center_of_mass())
+
+    def transform(self, X=None, y=None):
+        """
+        Transform an image using an Affine transform with the given
+        translation parameters.  Return the transform if X=None.
+
+        Arguments
+        ---------
+        X : ANTsImage
+            Image to transform
+
+        y : ANTsImage (optional)
+            Another image to transform
+
+        Returns
+        -------
+        ANTsImage if y is None, else a tuple of ANTsImage types
+
+        Examples
+        --------
+        >>> import ants
+        >>> img = ants.image_read(ants.get_data('ch2'))
+        >>> tx = ants.contrib.Translate3D(translation=(10,0,0))
+        >>> img2_x = tx.transform(img)# x axis stays same
+        >>> tx = ants.contrib.Translate3D(translation=(-10,0,0)) # other direction
+        >>> img2_x = tx.transform(img)# x axis stays same
+        >>> tx = ants.contrib.Translate3D(translation=(0,10,0))
+        >>> img2_y = tx.transform(img) # y axis stays same
+        >>> tx = ants.contrib.Translate3D(translation=(0,0,10))
+        >>> img2_z = tx.transform(img) # z axis stays same
+        >>> tx = ants.contrib.Translate3D(translation=(10,10,10))
+        >>> img2 = tx.transform(img)
+        """
+        # unpack
+        translation_x, translation_y, translation_z = self.translation
+
+        translation_matrix = np.array(
+            [
+                [1, 0, 0, translation_x],
+                [0, 1, 0, translation_y],
+                [0, 0, 1, translation_z],
+            ]
+        )
+        self.tx.set_parameters(translation_matrix)
+        if self.lazy or X is None:
+            return self.tx
+        else:
+            if y is None:
+                return self.tx.apply_to_image(X, reference=self.reference)
+            else:
+                return (
+                    self.tx.apply_to_image(X, reference=self.reference),
+                    self.tx.apply_to_image(y, reference=self.reference),
+                )
+
+
+class RandomTranslate3D(object):
+    """
+    Apply a Translate3D transform to an image, but with the shear
+    parameters randomly generated from a user-specified range.
+    The range is determined by a mean (first parameter) and standard deviation
+    (second parameter) via calls to random.gauss.
+    """
+
+    def __init__(self, translation_range, reference=None, lazy=False):
+        """
+        Initialize a RandomTranslate3D object
+
+        Arguments
+        ---------
+        translation_range : list or tuple
+            Lower and Upper bounds on rotation parameter, in degrees.
+            e.g. translation_range = (-10,10) will result in a random
+            draw of the rotation parameters between -10 and 10 degrees
+
+        reference : ANTsImage (optional but recommended)
+            image providing the reference space for the transform.
+            this will also set the transform fixed parameters.
+
+        lazy : boolean (default = False)
+            if True, calling the `transform` method only returns
+            the randomly generated transform and does not actually
+            transform the image
+        """
+        if (not isinstance(translation_range, (list, tuple))) or (
+            len(translation_range) != 2
+        ):
+            raise ValueError("shear_range argument must be list/tuple with two values!")
+
+        self.translation_range = translation_range
+        self.reference = reference
+        self.lazy = lazy
+
+    def transform(self, X=None, y=None):
+        """
+        Transform an image using an Affine transform with
+        translation parameters randomly generated from the user-specified
+        range.  Return the transform if X=None.
+
+        Arguments
+        ---------
+        X : ANTsImage
+            Image to transform
+
+        y : ANTsImage (optional)
+            Another image to transform
+
+        Returns
+        -------
+        ANTsImage if y is None, else a tuple of ANTsImage types
+
+        Examples
+        --------
+        >>> import ants
+        >>> img = ants.image_read(ants.get_data('ch2'))
+        >>> tx = ants.contrib.RandomShear3D(translation_range=(-10,10))
+        >>> img2 = tx.transform(img)
+        """
+        # random draw in translation range
+        translation_x = random.gauss(
+            self.translation_range[0], self.translation_range[1]
+        )
+        translation_y = random.gauss(
+            self.translation_range[0], self.translation_range[1]
+        )
+        translation_z = random.gauss(
+            self.translation_range[0], self.translation_range[1]
+        )
+        self.params = (translation_x, translation_y, translation_z)
+
+        tx = Translate3D(
+            (translation_x, translation_y, translation_z),
+            reference=self.reference,
+            lazy=self.lazy,
+        )
+
+        return tx.transform(X, y)
+
+
+class Shear3D(object):
+    """
+    Create an ANTs Affine Transform with a specified shear.
+    """
+
+    def __init__(self, shear, reference=None, lazy=False):
+        """
+        Initialize a Shear3D object
+
+        Arguments
+        ---------
+        shear : list or tuple
+            shear values for each axis, in degrees.
+            Negative values can be used for shear in the
+            other direction
+
+        reference : ANTsImage (optional but recommended)
+            image providing the reference space for the transform.
+            this will also set the transform fixed parameters.
+
+        lazy : boolean (default = False)
+            if True, calling the `transform` method only returns
+            the randomly generated transform and does not actually
+            transform the image
+        """
+        if (not isinstance(shear, (list, tuple))) or (len(shear) != 3):
+            raise ValueError("shear argument must be list/tuple with three values!")
+
+        self.shear = shear
+        self.lazy = lazy
+        self.reference = reference
+
+        self.tx = tio.ANTsTransform(
+            precision="float", dimension=3, transform_type="AffineTransform"
+        )
+        if self.reference is not None:
+            self.tx.set_fixed_parameters(self.reference.get_center_of_mass())
+
+    def transform(self, X=None, y=None):
+        """
+        Transform an image using an Affine transform with the given
+        shear parameters.  Return the transform if X=None.
+
+        Arguments
+        ---------
+        X : ANTsImage
+            Image to transform
+
+        y : ANTsImage (optional)
+            Another image to transform
+
+        Returns
+        -------
+        ANTsImage if y is None, else a tuple of ANTsImage types
+
+        Examples
+        --------
+        >>> import ants
+        >>> img = ants.image_read(ants.get_data('ch2'))
+        >>> tx = ants.contrib.Shear3D(shear=(10,0,0))
+        >>> img2_x = tx.transform(img)# x axis stays same
+        >>> tx = ants.contrib.Shear3D(shear=(-10,0,0)) # other direction
+        >>> img2_x = tx.transform(img)# x axis stays same
+        >>> tx = ants.contrib.Shear3D(shear=(0,10,0))
+        >>> img2_y = tx.transform(img) # y axis stays same
+        >>> tx = ants.contrib.Shear3D(shear=(0,0,10))
+        >>> img2_z = tx.transform(img) # z axis stays same
+        >>> tx = ants.contrib.Shear3D(shear=(10,10,10))
+        >>> img2 = tx.transform(img)
+        """
+        # convert to radians and unpack
+        shear = [math.pi / 180 * s for s in self.shear]
+        shear_x, shear_y, shear_z = shear
+
+        shear_matrix = np.array(
+            [
+                [1, shear_x, shear_x, 0],
+                [shear_y, 1, shear_y, 0],
+                [shear_z, shear_z, 1, 0],
+            ]
+        )
+        self.tx.set_parameters(shear_matrix)
+        if self.lazy or X is None:
+            return self.tx
+        else:
+            if y is None:
+                return self.tx.apply_to_image(X, reference=self.reference)
+            else:
+                return (
+                    self.tx.apply_to_image(X, reference=self.reference),
+                    self.tx.apply_to_image(y, reference=self.reference),
+                )
+
+
+class RandomShear3D(object):
+    """
+    Apply a Shear3D transform to an image, but with the shear
+    parameters randomly generated from a user-specified range.
+    The range is determined by a mean (first parameter) and standard deviation
+    (second parameter) via calls to random.gauss.
+    """
+
+    def __init__(self, shear_range, reference=None, lazy=False):
+        """
+        Initialize a RandomShear3D object
+
+        Arguments
+        ---------
+        shear_range : list or tuple
+            Lower and Upper bounds on rotation parameter, in degrees.
+            e.g. shear_range = (-10,10) will result in a random
+            draw of the rotation parameters between -10 and 10 degrees
+
+        reference : ANTsImage (optional but recommended)
+            image providing the reference space for the transform.
+            this will also set the transform fixed parameters.
+
+        lazy : boolean (default = False)
+            if True, calling the `transform` method only returns
+            the randomly generated transform and does not actually
+            transform the image
+        """
+        if (not isinstance(shear_range, (list, tuple))) or (len(shear_range) != 2):
+            raise ValueError("shear_range argument must be list/tuple with two values!")
+
+        self.shear_range = shear_range
+        self.reference = reference
+        self.lazy = lazy
+
+    def transform(self, X=None, y=None):
+        """
+        Transform an image using an Affine transform with
+        shear parameters randomly generated from the user-specified
+        range.  Return the transform if X=None.
+
+        Arguments
+        ---------
+        X : ANTsImage
+            Image to transform
+
+        y : ANTsImage (optional)
+            Another image to transform
+
+        Returns
+        -------
+        ANTsImage if y is None, else a tuple of ANTsImage types
+
+        Examples
+        --------
+        >>> import ants
+        >>> img = ants.image_read(ants.get_data('ch2'))
+        >>> tx = ants.contrib.RandomShear3D(shear_range=(-10,10))
+        >>> img2 = tx.transform(img)
+        """
+        # random draw in shear range
+        shear_x = random.gauss(self.shear_range[0], self.shear_range[1])
+        shear_y = random.gauss(self.shear_range[0], self.shear_range[1])
+        shear_z = random.gauss(self.shear_range[0], self.shear_range[1])
+        self.params = (shear_x, shear_y, shear_z)
+
+        tx = Shear3D(
+            (shear_x, shear_y, shear_z), reference=self.reference, lazy=self.lazy
+        )
+
+        return tx.transform(X, y)
+
+
+class Rotate3D(object):
+    """
+    Create an ANTs Affine Transform with a specified level
+    of rotation.
+    """
+
+    def __init__(self, rotation, reference=None, lazy=False):
+        """
+        Initialize a Rotate3D object
+
+        Arguments
+        ---------
+        rotation : list or tuple
+            rotation values for each axis, in degrees.
+            Negative values can be used for rotation in the
+            other direction
+
+        reference : ANTsImage (optional but recommended)
+            image providing the reference space for the transform.
+            this will also set the transform fixed parameters.
+
+        lazy : boolean (default = False)
+            if True, calling the `transform` method only returns
+            the randomly generated transform and does not actually
+            transform the image
+        """
+        if (not isinstance(rotation, (list, tuple))) or (len(rotation) != 3):
+            raise ValueError("rotation argument must be list/tuple with three values!")
+
+        self.rotation = rotation
+        self.lazy = lazy
+        self.reference = reference
+
+        self.tx = tio.ANTsTransform(
+            precision="float", dimension=3, transform_type="AffineTransform"
+        )
+        if self.reference is not None:
+            self.tx.set_fixed_parameters(self.reference.get_center_of_mass())
+
+    def transform(self, X=None, y=None):
+        """
+        Transform an image using an Affine transform with the given
+        rotation parameters.  Return the transform if X=None.
+
+        Arguments
+        ---------
+        X : ANTsImage
+            Image to transform
+
+        y : ANTsImage (optional)
+            Another image to transform
+
+        Returns
+        -------
+        ANTsImage if y is None, else a tuple of ANTsImage types
+
+        Examples
+        --------
+        >>> import ants
+        >>> img = ants.image_read(ants.get_data('ch2'))
+        >>> tx = ants.contrib.Rotate3D(rotation=(10,-5,12))
+        >>> img2 = tx.transform(img)
+        """
+        # unpack zoom range
+        rotation_x, rotation_y, rotation_z = self.rotation
+
+        # Rotation about X axis
+        theta_x = math.pi / 180 * rotation_x
+        rotate_matrix_x = np.array(
+            [
+                [1, 0, 0, 0],
+                [0, math.cos(theta_x), -math.sin(theta_x), 0],
+                [0, math.sin(theta_x), math.cos(theta_x), 0],
+                [0, 0, 0, 1],
+            ]
+        )
+
+        # Rotation about Y axis
+        theta_y = math.pi / 180 * rotation_y
+        rotate_matrix_y = np.array(
+            [
+                [math.cos(theta_y), 0, math.sin(theta_y), 0],
+                [0, 1, 0, 0],
+                [-math.sin(theta_y), 0, math.cos(theta_y), 0],
+                [0, 0, 0, 1],
+            ]
+        )
+
+        # Rotation about Z axis
+        theta_z = math.pi / 180 * rotation_z
+        rotate_matrix_z = np.array(
+            [
+                [math.cos(theta_z), -math.sin(theta_z), 0, 0],
+                [math.sin(theta_z), math.cos(theta_z), 0, 0],
+                [0, 0, 1, 0],
+                [0, 0, 0, 1],
+            ]
+        )
+        rotate_matrix = rotate_matrix_x.dot(rotate_matrix_y).dot(rotate_matrix_z)[:3, :]
+
+        self.tx.set_parameters(rotate_matrix)
+        if self.lazy or X is None:
+            return self.tx
+        else:
+            if y is None:
+                return self.tx.apply_to_image(X, reference=self.reference)
+            else:
+                return (
+                    self.tx.apply_to_image(X, reference=self.reference),
+                    self.tx.apply_to_image(y, reference=self.reference),
+                )
+
+
+class RandomRotate3D(object):
+    """
+    Apply a Rotate3D transform to an image, but with the zoom
+    parameters randomly generated from a user-specified range.
+    The range is determined by a mean (first parameter) and standard deviation
+    (second parameter) via calls to random.gauss.
+    """
+
+    def __init__(self, rotation_range, reference=None, lazy=False):
+        """
+        Initialize a RandomRotate3D object
+
+        Arguments
+        ---------
+        rotation_range : list or tuple
+            Lower and Upper bounds on rotation parameter, in degrees.
+            e.g. rotation_range = (-10,10) will result in a random
+            draw of the rotation parameters between -10 and 10 degrees
+
+        reference : ANTsImage (optional but recommended)
+            image providing the reference space for the transform.
+            this will also set the transform fixed parameters.
+
+        lazy : boolean (default = False)
+            if True, calling the `transform` method only returns
+            the randomly generated transform and does not actually
+            transform the image
+        """
+        if (not isinstance(rotation_range, (list, tuple))) or (
+            len(rotation_range) != 2
+        ):
+            raise ValueError(
+                "rotation_range argument must be list/tuple with two values!"
+            )
+
+        self.rotation_range = rotation_range
+        self.reference = reference
+        self.lazy = lazy
+
+    def transform(self, X=None, y=None):
+        """
+        Transform an image using an Affine transform with
+        rotation parameters randomly generated from the user-specified
+        range.  Return the transform if X=None.
+
+        Arguments
+        ---------
+        X : ANTsImage
+            Image to transform
+
+        y : ANTsImage (optional)
+            Another image to transform
+
+        Returns
+        -------
+        ANTsImage if y is None, else a tuple of ANTsImage types
+
+        Examples
+        --------
+        >>> import ants
+        >>> img = ants.image_read(ants.get_data('ch2'))
+        >>> tx = ants.contrib.RandomRotate3D(rotation_range=(-10,10))
+        >>> img2 = tx.transform(img)
+        """
+        # random draw in rotation range
+        rotation_x = random.gauss(self.rotation_range[0], self.rotation_range[1])
+        rotation_y = random.gauss(self.rotation_range[0], self.rotation_range[1])
+        rotation_z = random.gauss(self.rotation_range[0], self.rotation_range[1])
+        self.params = (rotation_x, rotation_y, rotation_z)
+
+        tx = Rotate3D(
+            (rotation_x, rotation_y, rotation_z),
+            reference=self.reference,
+            lazy=self.lazy,
+        )
+
+        return tx.transform(X, y)
+
+
+class Zoom3D(object):
+    """
+    Create an ANTs Affine Transform with a specified level
+    of zoom. Any value greater than 1 implies a "zoom-out" and anything
+    less than 1 implies a "zoom-in".
+    """
+
+    def __init__(self, zoom, reference=None, lazy=False):
+        """
+        Initialize a Zoom3D object
+
+        Arguments
+        ---------
+        zoom_range : list or tuple
+            Lower and Upper bounds on zoom parameter.
+            e.g. zoom_range = (0.7,0.9) will result in a random
+            draw of the zoom parameters between 0.7 and 0.9
+
+        reference : ANTsImage (optional but recommended)
+            image providing the reference space for the transform.
+            this will also set the transform fixed parameters.
+
+        lazy : boolean (default = False)
+            if True, calling the `transform` method only returns
+            the randomly generated transform and does not actually
+            transform the image
+        """
+        if (not isinstance(zoom, (list, tuple))) or (len(zoom) != 3):
+            raise ValueError(
+                "zoom_range argument must be list/tuple with three values!"
+            )
+
+        self.zoom = zoom
+        self.lazy = lazy
+        self.reference = reference
+
+        self.tx = tio.ANTsTransform(
+            precision="float", dimension=3, transform_type="AffineTransform"
+        )
+        if self.reference is not None:
+            self.tx.set_fixed_parameters(self.reference.get_center_of_mass())
+
+    def transform(self, X=None, y=None):
+        """
+        Transform an image using an Affine transform with the given
+        zoom parameters.  Return the transform if X=None.
+
+        Arguments
+        ---------
+        X : ANTsImage
+            Image to transform
+
+        y : ANTsImage (optional)
+            Another image to transform
+
+        Returns
+        -------
+        ANTsImage if y is None, else a tuple of ANTsImage types
+
+        Examples
+        --------
+        >>> import ants
+        >>> img = ants.image_read(ants.get_data('ch2'))
+        >>> tx = ants.contrib.Zoom3D(zoom=(0.8,0.8,0.8))
+        >>> img2 = tx.transform(img)
+        """
+        # unpack zoom range
+        zoom_x, zoom_y, zoom_z = self.zoom
+
+        self.params = (zoom_x, zoom_y, zoom_z)
+        zoom_matrix = np.array(
+            [[zoom_x, 0, 0, 0], [0, zoom_y, 0, 0], [0, 0, zoom_z, 0]]
+        )
+        self.tx.set_parameters(zoom_matrix)
+        if self.lazy or X is None:
+            return self.tx
+        else:
+            if y is None:
+                return self.tx.apply_to_image(X, reference=self.reference)
+            else:
+                return (
+                    self.tx.apply_to_image(X, reference=self.reference),
+                    self.tx.apply_to_image(y, reference=self.reference),
+                )
+
+
+class RandomZoom3D(object):
+    """
+    Apply a Zoom3D transform to an image, but with the zoom
+    parameters randomly generated from a user-specified range.
+    The range is determined by a mean (first parameter) and standard deviation
+    (second parameter) via calls to random.gauss.
+    """
+
+    def __init__(self, zoom_range, reference=None, lazy=False):
+        """
+        Initialize a RandomZoom3D object
+
+        Arguments
+        ---------
+        zoom_range : list or tuple
+            Lower and Upper bounds on zoom parameter.
+            e.g. zoom_range = (0.7,0.9) will result in a random
+            draw of the zoom parameters between 0.7 and 0.9
+
+        reference : ANTsImage (optional but recommended)
+            image providing the reference space for the transform
+            this will also set the transform fixed parameters.
+
+        lazy : boolean (default = False)
+            if True, calling the `transform` method only returns
+            the randomly generated transform and does not actually
+            transform the image
+        """
+        if (not isinstance(zoom_range, (list, tuple))) or (len(zoom_range) != 2):
+            raise ValueError("zoom_range argument must be list/tuple with two values!")
+
+        self.zoom_range = zoom_range
+        self.reference = reference
+        self.lazy = lazy
+
+    def transform(self, X=None, y=None):
+        """
+        Transform an image using an Affine transform with
+        zoom parameters randomly generated from the user-specified
+        range.  Return the transform if X=None.
+
+        Arguments
+        ---------
+        X : ANTsImage
+            Image to transform
+
+        y : ANTsImage (optional)
+            Another image to transform
+
+        Returns
+        -------
+        ANTsImage if y is None, else a tuple of ANTsImage types
+
+        Examples
+        --------
+        >>> import ants
+        >>> img = ants.image_read(ants.get_data('ch2'))
+        >>> tx = ants.contrib.RandomZoom3D(zoom_range=(0.8,0.9))
+        >>> img2 = tx.transform(img)
+        """
+        # random draw in zoom range
+        zoom_x = np.exp(
+            random.gauss(np.log(self.zoom_range[0]), np.log(self.zoom_range[1]))
+        )
+        zoom_y = np.exp(
+            random.gauss(np.log(self.zoom_range[0]), np.log(self.zoom_range[1]))
+        )
+        zoom_z = np.exp(
+            random.gauss(np.log(self.zoom_range[0]), np.log(self.zoom_range[1]))
+        )
+        self.params = (zoom_x, zoom_y, zoom_z)
+
+        tx = Zoom3D((zoom_x, zoom_y, zoom_z), reference=self.reference, lazy=self.lazy)
+
+        return tx.transform(X, y)

MindEyeV2/antspy/ants/contrib/sampling/transforms.py

@@ -0,0 +1,766 @@
+"""
+Various data augmentation transforms for ANTsImage types
+
+List of Transformations:
+======================
+- CastIntensity
+- BlurIntensity
+- NormalizeIntensity
+- RescaleIntensity
+- ShiftScaleIntensity
+- SigmoidIntensity
+======================
+- FlipImage
+- TranslateImage
+
+TODO
+----
+- RotateImage
+- ShearImage
+- ScaleImage
+- DeformImage
+- PadImage
+- HistogramEqualizeIntensity
+- TruncateIntensity
+- SharpenIntensity
+- MorpholigicalIntensity
+    - MD
+    - ME
+    - MO
+    - MC
+    - GD
+    - GE
+    - GO
+    - GC
+"""
+__all__ = ['CastIntensity',
+           'BlurIntensity',
+           'LocallyBlurIntensity',
+           'NormalizeIntensity',
+           'RescaleIntensity',
+           'ShiftScaleIntensity',
+           'SigmoidIntensity',
+           'FlipImage',
+           'ScaleImage',
+           'TranslateImage',
+           'MultiResolutionImage']
+
+from ... import utils
+from ...core import ants_image as iio
+
+
+class MultiResolutionImage(object):
+    """
+    Generate a set of images at multiple resolutions from an original image
+    """
+    def __init__(self, levels=4, keep_shape=False):
+        self.levels = levels
+        self.keep_shape = keep_shape
+
+    def transform(self, X, y=None):
+        """
+        Generate a set of multi-resolution ANTsImage types
+
+        Arguments
+        ---------
+        X : ANTsImage
+            image to transform
+
+        y : ANTsImage (optional)
+            another image to transform
+
+        Example
+        -------
+        >>> import ants
+        >>> multires = ants.contrib.MultiResolutionImage(levels=4)
+        >>> img = ants.image_read(ants.get_data('r16'))
+        >>> imgs = multires.transform(img)
+        """
+        insuffix = X._libsuffix
+        multires_fn = utils.get_lib_fn('multiResolutionAntsImage%s' % (insuffix))
+        casted_ptrs = multires_fn(X.pointer, self.levels)
+        
+        imgs = []
+        for casted_ptr in casted_ptrs:
+            img = iio.ANTsImage(pixeltype=X.pixeltype, dimension=X.dimension,
+                                components=X.components, pointer=casted_ptr)
+            if self.keep_shape:
+                img = img.resample_image_to_target(X)
+            imgs.append(img)
+
+        return imgs
+
+
+## Intensity Transforms ##
+
+class CastIntensity(object):
+    """
+    Cast the pixeltype of an ANTsImage to a given type. 
+    This code uses the C++ ITK library directly, so it is fast.
+    
+    NOTE: This offers a ~2.5x speedup over using img.clone(pixeltype):
+    
+    Timings vs Cloning
+    ------------------
+    >>> import ants
+    >>> import time
+    >>> caster = ants.contrib.CastIntensity('float')
+    >>> img = ants.image_read(ants.get_data('mni')).clone('unsigned int')
+    >>> s = time.time()
+    >>> for i in range(1000):
+    ...     img_float = caster.transform(img)
+    >>> e = time.time()
+    >>> print(e - s) # 9.6s
+    >>> s = time.time()
+    >>> for i in range(1000):
+    ...     img_float = img.clone('float')
+    >>> e = time.time()
+    >>> print(e - s) # 25.3s
+    """
+    def __init__(self, pixeltype):
+        """
+        Initialize a CastIntensity transform
+    
+        Arguments
+        ---------
+        pixeltype : string
+            pixeltype to which images will be casted
+
+        Example
+        -------
+        >>> import ants
+        >>> caster = ants.contrib.CastIntensity('float')
+        """
+        self.pixeltype = pixeltype
+
+    def transform(self, X, y=None):
+        """
+        Transform an image by casting its type
+
+        Arguments
+        ---------
+        X : ANTsImage
+            image to cast
+
+        y : ANTsImage (optional)
+            another image to cast.
+
+        Example
+        -------
+        >>> import ants
+        >>> caster = ants.contrib.CastIntensity('float')
+        >>> img2d = ants.image_read(ants.get_data('r16')).clone('unsigned int')
+        >>> img2d_float = caster.transform(img2d)
+        >>> print(img2d.pixeltype, '- ', img2d_float.pixeltype)
+        >>> img3d = ants.image_read(ants.get_data('mni')).clone('unsigned int')
+        >>> img3d_float = caster.transform(img3d)
+        >>> print(img3d.pixeltype, ' - ' , img3d_float.pixeltype)
+        """
+        insuffix = X._libsuffix
+        outsuffix = '%s%i' % (utils.short_ptype(self.pixeltype), X.dimension)
+        cast_fn = utils.get_lib_fn('castAntsImage%s%s' % (insuffix, outsuffix))
+        casted_ptr = cast_fn(X.pointer)
+        return iio.ANTsImage(pixeltype=self.pixeltype, dimension=X.dimension,
+                             components=X.components, pointer=casted_ptr)
+
+
+class BlurIntensity(object):
+    """
+    Transform for blurring the intensity of an ANTsImage
+    using a Gaussian Filter
+    """
+    def __init__(self, sigma, width):
+        """
+        Initialize a BlurIntensity transform
+
+        Arguments
+        ---------
+        sigma : float
+            variance of gaussian kernel intensity
+            increasing this value increasing the amount
+            of blur
+
+        width : int
+            width of gaussian kernel shape
+            increasing this value increase the number of
+            neighboring voxels which are used for blurring
+
+        Example
+        -------
+        >>> import ants
+        >>> blur = ants.contrib.BlurIntensity(2,3)
+        """
+        self.sigma = sigma
+        self.width = width
+
+    def transform(self, X, y=None):
+        """
+        Blur an image by applying a gaussian filter.
+
+        Arguments
+        ---------
+        X : ANTsImage
+            image to transform
+
+        y : ANTsImage (optional)
+            another image to transform.
+
+        Example
+        -------
+        >>> import ants
+        >>> blur = ants.contrib.BlurIntensity(2,3)
+        >>> img2d = ants.image_read(ants.get_data('r16'))
+        >>> img2d_b = blur.transform(img2d)
+        >>> ants.plot(img2d)
+        >>> ants.plot(img2d_b)
+        >>> img3d = ants.image_read(ants.get_data('mni'))
+        >>> img3d_b = blur.transform(img3d)
+        >>> ants.plot(img3d)
+        >>> ants.plot(img3d_b)
+        """
+        if X.pixeltype != 'float':
+            raise ValueError('image.pixeltype must be float ... use TypeCast transform or clone to float')
+
+        insuffix = X._libsuffix
+        cast_fn = utils.get_lib_fn('blurAntsImage%s' % (insuffix))
+        casted_ptr = cast_fn(X.pointer, self.sigma, self.width)
+        return iio.ANTsImage(pixeltype=X.pixeltype, dimension=X.dimension,
+                             components=X.components, pointer=casted_ptr,
+                             origin=X.origin)
+
+
+class LocallyBlurIntensity(object):
+    """
+    Blur an ANTsImage locally using a gradient anisotropic
+    diffusion filter, thereby preserving the sharpeness of edges as best 
+    as possible.
+    """
+    def __init__(self, conductance=1, iters=5):
+        self.conductance = conductance
+        self.iters = iters
+
+    def transform(self, X, y=None):
+        """
+        Locally blur an image by applying a gradient anisotropic diffusion filter.
+
+        Arguments
+        ---------
+        X : ANTsImage
+            image to transform
+
+        y : ANTsImage (optional)
+            another image to transform.
+
+        Example
+        -------
+        >>> import ants
+        >>> blur = ants.contrib.LocallyBlurIntensity(1,5)
+        >>> img2d = ants.image_read(ants.get_data('r16'))
+        >>> img2d_b = blur.transform(img2d)
+        >>> ants.plot(img2d)
+        >>> ants.plot(img2d_b)
+        >>> img3d = ants.image_read(ants.get_data('mni'))
+        >>> img3d_b = blur.transform(img3d)
+        >>> ants.plot(img3d)
+        >>> ants.plot(img3d_b)
+        """
+        #if X.pixeltype != 'float':
+        #    raise ValueError('image.pixeltype must be float ... use TypeCast transform or clone to float')
+        insuffix = X._libsuffix
+        cast_fn = utils.get_lib_fn('locallyBlurAntsImage%s' % (insuffix))
+        casted_ptr = cast_fn(X.pointer, self.iters, self.conductance)
+        return iio.ANTsImage(pixeltype=X.pixeltype, dimension=X.dimension,
+                             components=X.components, pointer=casted_ptr)
+
+
+class NormalizeIntensity(object):
+    """
+    Normalize the intensity values of an ANTsImage to have
+    zero mean and unit variance
+
+    NOTE: this transform is more-or-less the same in speed
+    as an equivalent numpy+scikit-learn solution.
+
+    Timing vs Numpy+Scikit-Learn
+    ----------------------------
+    >>> import ants
+    >>> import numpy as np
+    >>> from sklearn.preprocessing import StandardScaler
+    >>> import time
+    >>> img = ants.image_read(ants.get_data('mni'))
+    >>> arr = img.numpy().reshape(1,-1)
+    >>> normalizer = ants.contrib.NormalizeIntensity()
+    >>> normalizer2 = StandardScaler()
+    >>> s = time.time()
+    >>> for i in range(100):
+    ...     img_scaled = normalizer.transform(img)
+    >>> e = time.time()
+    >>> print(e - s) # 3.3s
+    >>> s = time.time()
+    >>> for i in range(100):
+    ...     arr_scaled = normalizer2.fit_transform(arr)
+    >>> e = time.time()
+    >>> print(e - s) # 3.5s
+    """
+    def __init__(self):
+        """
+        Initialize a NormalizeIntensity transform
+        """
+        pass
+
+    def transform(self, X, y=None):
+        """
+        Transform an image by normalizing its intensity values to 
+        have zero mean and unit variance.
+
+        Arguments
+        ---------
+        X : ANTsImage
+            image to transform
+
+        y : ANTsImage (optional)
+            another image to transform.
+
+        Example
+        -------
+        >>> import ants
+        >>> normalizer = ants.contrib.NormalizeIntensity()
+        >>> img2d = ants.image_read(ants.get_data('r16'))
+        >>> img2d_r = normalizer.transform(img2d)
+        >>> print(img2d.mean(), ',', img2d.std(), ' -> ', img2d_r.mean(), ',', img2d_r.std())
+        >>> img3d = ants.image_read(ants.get_data('mni'))
+        >>> img3d_r = normalizer.transform(img3d)
+        >>> print(img3d.mean(), ',' , img3d.std(), ',', ' -> ', img3d_r.mean(), ',' , img3d_r.std())  
+        """
+        if X.pixeltype != 'float':
+            raise ValueError('image.pixeltype must be float ... use TypeCast transform or clone to float')
+
+        insuffix = X._libsuffix
+        cast_fn = utils.get_lib_fn('normalizeAntsImage%s' % (insuffix))
+        casted_ptr = cast_fn(X.pointer)
+        return iio.ANTsImage(pixeltype=X.pixeltype, dimension=X.dimension,
+                             components=X.components, pointer=casted_ptr)
+
+
+class RescaleIntensity(object):
+    """
+    Rescale the pixeltype of an ANTsImage linearly to be between a given
+    minimum and maximum value. 
+    This code uses the C++ ITK library directly, so it is fast.
+    
+    NOTE: this offered a ~5x speedup over using built-in arithmetic operations in ANTs.
+    It is also more-or-less the same in speed as an equivalent numpy+scikit-learn
+    solution.
+
+    Timing vs Built-in Operations
+    -----------------------------
+    >>> import ants
+    >>> import time
+    >>> rescaler = ants.contrib.RescaleIntensity(0,1)
+    >>> img = ants.image_read(ants.get_data('mni'))
+    >>> s = time.time()
+    >>> for i in range(100):
+    ...     img_float = rescaler.transform(img)
+    >>> e = time.time()
+    >>> print(e - s) # 2.8s
+    >>> s = time.time()
+    >>> for i in range(100):
+    ...     maxval = img.max()
+    ...     img_float = (img - maxval) / (maxval - img.min())
+    >>> e = time.time()
+    >>> print(e - s) # 13.9s
+
+    Timing vs Numpy+Scikit-Learn
+    ----------------------------
+    >>> import ants
+    >>> import numpy as np
+    >>> from sklearn.preprocessing import MinMaxScaler
+    >>> import time
+    >>> img = ants.image_read(ants.get_data('mni'))
+    >>> arr = img.numpy().reshape(1,-1)
+    >>> rescaler = ants.contrib.RescaleIntensity(-1,1)
+    >>> rescaler2 = MinMaxScaler((-1,1)).fit(arr)
+    >>> s = time.time()
+    >>> for i in range(100):
+    ...     img_scaled = rescaler.transform(img)
+    >>> e = time.time()
+    >>> print(e - s) # 2.8s
+    >>> s = time.time()
+    >>> for i in range(100):
+    ...     arr_scaled = rescaler2.transform(arr)
+    >>> e = time.time()
+    >>> print(e - s) # 3s
+    """
+
+    def __init__(self, min_val, max_val):
+        """
+        Initialize a RescaleIntensity transform.
+
+        Arguments
+        ---------
+        min_val : float
+            minimum value to which image(s) will be rescaled
+
+        max_val : float
+            maximum value to which image(s) will be rescaled
+        
+        Example
+        -------
+        >>> import ants
+        >>> rescaler = ants.contrib.RescaleIntensity(0,1)
+        """
+        self.min_val = min_val
+        self.max_val = max_val
+
+    def transform(self, X, y=None):
+        """
+        Transform an image by linearly rescaling its intensity to
+        be between a minimum and maximum value
+
+        Arguments
+        ---------
+        X : ANTsImage
+            image to transform
+
+        y : ANTsImage (optional)
+            another image to transform.
+
+        Example
+        -------
+        >>> import ants
+        >>> rescaler = ants.contrib.RescaleIntensity(0,1)
+        >>> img2d = ants.image_read(ants.get_data('r16'))
+        >>> img2d_r = rescaler.transform(img2d)
+        >>> print(img2d.min(), ',', img2d.max(), ' -> ', img2d_r.min(), ',', img2d_r.max())
+        >>> img3d = ants.image_read(ants.get_data('mni'))
+        >>> img3d_r = rescaler.transform(img3d)
+        >>> print(img3d.min(), ',' , img3d.max(), ' -> ', img3d_r.min(), ',' , img3d_r.max())
+        """
+        if X.pixeltype != 'float':
+            raise ValueError('image.pixeltype must be float ... use TypeCast transform or clone to float')
+
+        insuffix = X._libsuffix
+        cast_fn = utils.get_lib_fn('rescaleAntsImage%s' % (insuffix))
+        casted_ptr = cast_fn(X.pointer, self.min_val, self.max_val)
+        return iio.ANTsImage(pixeltype=X.pixeltype, dimension=X.dimension,
+                             components=X.components, pointer=casted_ptr)
+
+
+class ShiftScaleIntensity(object):
+    """
+    Shift and scale the intensity of an ANTsImage
+    """
+    def __init__(self, shift, scale):
+        """
+        Initialize a ShiftScaleIntensity transform
+
+        Arguments
+        ---------
+        shift : float
+            shift all of the intensity values by the given amount through addition.
+            For example, if the minimum image value is 0.0 and the shift
+            is 10.0, then the new minimum value (before scaling) will be 10.0
+
+        scale : float
+            scale all the intensity values by the given amount through multiplication.
+            For example, if the min/max image values are 10/20 and the scale
+            is 2.0, then then new min/max values will be 20/40
+
+        Example
+        -------
+        >>> import ants
+        >>> shiftscaler = ants.contrib.ShiftScaleIntensity(shift=10, scale=2)
+        """
+        self.shift = shift
+        self.scale = scale
+
+    def transform(self, X, y=None):
+        """
+        Transform an image by shifting and scaling its intensity values.
+
+        Arguments
+        ---------
+        X : ANTsImage
+            image to transform
+
+        y : ANTsImage (optional)
+            another image to transform.
+
+        Example
+        -------
+        >>> import ants
+        >>> shiftscaler = ants.contrib.ShiftScaleIntensity(10,2.)
+        >>> img2d = ants.image_read(ants.get_data('r16'))
+        >>> img2d_r = shiftscaler.transform(img2d)
+        >>> print(img2d.min(), ',', img2d.max(), ' -> ', img2d_r.min(), ',', img2d_r.max())
+        >>> img3d = ants.image_read(ants.get_data('mni'))
+        >>> img3d_r = shiftscaler.transform(img3d)
+        >>> print(img3d.min(), ',' , img3d.max(), ',', ' -> ', img3d_r.min(), ',' , img3d_r.max())  
+        """
+        if X.pixeltype != 'float':
+            raise ValueError('image.pixeltype must be float ... use TypeCast transform or clone to float')
+
+        insuffix = X._libsuffix
+        cast_fn = utils.get_lib_fn('shiftScaleAntsImage%s' % (insuffix))
+        casted_ptr = cast_fn(X.pointer, self.scale, self.shift)
+        return iio.ANTsImage(pixeltype=X.pixeltype, dimension=X.dimension,
+                             components=X.components, pointer=casted_ptr)
+
+
+class SigmoidIntensity(object):
+    """
+    Transform an image using a sigmoid function
+    """
+    def __init__(self, min_val, max_val, alpha, beta):
+        """
+        Initialize a SigmoidIntensity transform
+
+        Arguments
+        ---------
+        min_val : float
+            minimum value
+
+        max_val : float
+            maximum value
+
+        alpha : float
+            alpha value for sigmoid
+
+        beta : flaot
+            beta value for sigmoid
+
+        Example
+        -------
+        >>> import ants
+        >>> sigscaler = ants.contrib.SigmoidIntensity(0,1,1,1)
+        """
+        self.min_val = min_val
+        self.max_val = max_val
+        self.alpha = alpha
+        self.beta = beta
+
+    def transform(self, X, y=None):
+        """
+        Transform an image by applying a sigmoid function.
+
+        Arguments
+        ---------
+        X : ANTsImage
+            image to transform
+
+        y : ANTsImage (optional)
+            another image to transform.
+
+        Example
+        -------
+        >>> import ants
+        >>> sigscaler = ants.contrib.SigmoidIntensity(0,1,1,1)
+        >>> img2d = ants.image_read(ants.get_data('r16'))
+        >>> img2d_r = sigscaler.transform(img2d)
+        >>> img3d = ants.image_read(ants.get_data('mni'))
+        >>> img3d_r = sigscaler.transform(img3d)
+        """
+        if X.pixeltype != 'float':
+            raise ValueError('image.pixeltype must be float ... use TypeCast transform or clone to float')
+
+        insuffix = X._libsuffix
+        cast_fn = utils.get_lib_fn('sigmoidAntsImage%s' % (insuffix))
+        casted_ptr = cast_fn(X.pointer, self.min_val, self.max_val, self.alpha, self.beta)
+        return iio.ANTsImage(pixeltype=X.pixeltype, dimension=X.dimension,
+                             components=X.components, pointer=casted_ptr)
+
+
+## Physical Transforms ##
+
+class FlipImage(object):
+    """
+    Transform an image by flipping two axes. 
+    """
+    def __init__(self, axis1, axis2):
+        """
+        Initialize a SigmoidIntensity transform
+
+        Arguments
+        ---------
+        axis1 : int
+            axis to flip
+
+        axis2 : int
+            other axis to flip
+
+        Example
+        -------
+        >>> import ants
+        >>> flipper = ants.contrib.FlipImage(0,1)
+        """
+        self.axis1 = axis1
+        self.axis2 = axis2
+
+    def transform(self, X, y=None):
+        """
+        Transform an image by applying a sigmoid function.
+
+        Arguments
+        ---------
+        X : ANTsImage
+            image to transform
+
+        y : ANTsImage (optional)
+            another image to transform.
+
+        Example
+        -------
+        >>> import ants
+        >>> flipper = ants.contrib.FlipImage(0,1)
+        >>> img2d = ants.image_read(ants.get_data('r16'))
+        >>> img2d_r = flipper.transform(img2d)
+        >>> ants.plot(img2d)
+        >>> ants.plot(img2d_r)
+        >>> flipper2 = ants.contrib.FlipImage(1,0)
+        >>> img2d = ants.image_read(ants.get_data('r16'))
+        >>> img2d_r = flipper2.transform(img2d)
+        >>> ants.plot(img2d)
+        >>> ants.plot(img2d_r)
+        """
+        if X.pixeltype != 'float':
+            raise ValueError('image.pixeltype must be float ... use TypeCast transform or clone to float')
+
+        insuffix = X._libsuffix
+        cast_fn = utils.get_lib_fn('flipAntsImage%s' % (insuffix))
+        casted_ptr = cast_fn(X.pointer, self.axis1, self.axis2)
+        return iio.ANTsImage(pixeltype=X.pixeltype, dimension=X.dimension,
+                             components=X.components, pointer=casted_ptr,
+                             origin=X.origin)
+
+
+class TranslateImage(object):
+    """
+    Translate an image in physical space. This function calls 
+    highly optimized ITK/C++ code.
+    """
+    def __init__(self, translation, reference=None, interp='linear'):
+        """
+        Initialize a TranslateImage transform
+
+        Arguments
+        ---------
+        translation : list, tuple, or numpy.ndarray
+            absolute pixel transformation in each axis
+
+        reference : ANTsImage (optional)
+            image which provides the reference physical space in which
+            to perform the transform
+
+        interp : string
+            type of interpolation to use
+            options: linear, nearest
+
+        Example
+        -------
+        >>> import ants
+        >>> translater = ants.contrib.TranslateImage((10,10), interp='linear')
+        """
+        if interp not in {'linear', 'nearest'}:
+            raise ValueError('interp must be one of {linear, nearest}')
+
+        self.translation = list(translation)
+        self.reference = reference
+        self.interp = interp
+
+    def transform(self, X, y=None):
+        """
+        Example
+        -------
+        >>> import ants
+        >>> translater = ants.contrib.TranslateImage((40,0))
+        >>> img2d = ants.image_read(ants.get_data('r16'))
+        >>> img2d_r = translater.transform(img2d)
+        >>> ants.plot(img2d, img2d_r)
+        >>> translater = ants.contrib.TranslateImage((40,0,0))
+        >>> img3d = ants.image_read(ants.get_data('mni'))
+        >>> img3d_r = translater.transform(img3d)
+        >>> ants.plot(img3d, img3d_r, axis=2)
+        """
+        if X.pixeltype != 'float':
+            raise ValueError('image.pixeltype must be float ... use TypeCast transform or clone to float')
+
+        if len(self.translation) != X.dimension:
+            raise ValueError('must give a translation value for each image dimension')
+
+        if self.reference is None:
+            reference = X
+        else:
+            reference = self.reference
+
+        insuffix = X._libsuffix
+        cast_fn = utils.get_lib_fn('translateAntsImage%s_%s' % (insuffix, self.interp))
+        casted_ptr = cast_fn(X.pointer, reference.pointer, self.translation)
+        return iio.ANTsImage(pixeltype=X.pixeltype, dimension=X.dimension,
+                             components=X.components, pointer=casted_ptr)
+
+
+class ScaleImage(object):
+    """
+    Scale an image in physical space. This function calls 
+    highly optimized ITK/C++ code.
+    """
+    def __init__(self, scale, reference=None, interp='linear'):
+        """
+        Initialize a TranslateImage transform
+
+        Arguments
+        ---------
+        scale : list, tuple, or numpy.ndarray
+            relative scaling along each axis
+
+        reference : ANTsImage (optional)
+            image which provides the reference physical space in which
+            to perform the transform
+
+        interp : string
+            type of interpolation to use
+            options: linear, nearest
+
+        Example
+        -------
+        >>> import ants
+        >>> translater = ants.contrib.TranslateImage((10,10), interp='linear')
+        """
+        if interp not in {'linear', 'nearest'}:
+            raise ValueError('interp must be one of {linear, nearest}')
+
+        self.scale = list(scale)
+        self.reference = reference
+        self.interp = interp
+
+    def transform(self, X, y=None):
+        """
+        Example
+        -------
+        >>> import ants
+        >>> scaler = ants.contrib.ScaleImage((1.2,1.2))
+        >>> img2d = ants.image_read(ants.get_data('r16'))
+        >>> img2d_r = scaler.transform(img2d)
+        >>> ants.plot(img2d, img2d_r)
+        >>> scaler = ants.contrib.ScaleImage((1.2,1.2,1.2))
+        >>> img3d = ants.image_read(ants.get_data('mni'))
+        >>> img3d_r = scaler.transform(img3d)
+        >>> ants.plot(img3d, img3d_r)
+        """
+        if X.pixeltype != 'float':
+            raise ValueError('image.pixeltype must be float ... use TypeCast transform or clone to float')
+
+        if len(self.scale) != X.dimension:
+            raise ValueError('must give a scale value for each image dimension')
+
+        if self.reference is None:
+            reference = X
+        else:
+            reference = self.reference
+
+        insuffix = X._libsuffix
+        cast_fn = utils.get_lib_fn('scaleAntsImage%s_%s' % (insuffix, self.interp))
+        casted_ptr = cast_fn(X.pointer, reference.pointer, self.scale)
+        return iio.ANTsImage(pixeltype=X.pixeltype, dimension=X.dimension,
+                             components=X.components, pointer=casted_ptr)
+

MindEyeV2/antspy/ants/contrib/sklearn_interface/__init__.py

@@ -0,0 +1,3 @@
+
+
+from .sklearn_registration import *

MindEyeV2/antspy/ants/contrib/sklearn_interface/sklearn_registration.py

@@ -0,0 +1,149 @@
+
+
+__all__ = ['RigidRegistration']
+
+from ...registration import interface, apply_transforms
+
+
+class Registration(object):
+    """
+    How would it work:
+
+    # Co-registration within-visit
+    reg = Registration('Rigid', fixed_image=t1_template, 
+                       save_dir=save_dir, save_suffix='_coreg')
+    for img in other_imgs:
+        reg.fit(img)
+    
+    for img in [flair_img, t2_img]:
+        reg = Registration('Rigid', fixed_image=t1_template,
+                           save_dir=save_dir, save_suffix='_coreg')
+        reg.fit(img)
+    
+    # Co-registration across-visit
+    reg = Registration('Rigid', fixed_image=t1)
+    reg.fit(moving=t1_followup)
+    
+    # now align all followups with first visit
+    for img in [flair_follwup, t2_followup]:
+        img_reg = reg.transform(img)
+    
+    # conversly, align all first visits with followups
+    for img in [flair, t2]:
+        img_reg = reg.inverse_transform(img)
+    """
+
+    def __init__(self, type_of_transform, fixed_image):
+        """
+        Properties:
+            type_of_transform
+            fixed_image (template)
+            save_dir (where to save outputs)
+            save_suffix (what to append to saved outputs)
+            save_prefix (what to preppend to saved outputs)
+        """
+        self.type_of_transform = type_of_transform
+        self.fixed_image = fixed_image
+
+    def fit(self, X, y=None):
+        """
+        X : ANTsImage | string | list of ANTsImage types | list of strings
+            images to register to fixed image
+
+        y : string | list of strings
+            labels for images
+        """
+        moving_images = X if isinstance(X, (list,tuple)) else [X]
+        moving_labels = y if y is not None else [i for i in range(len(moving_images))]
+        fixed_image = self.fixed_image
+
+        self.fwdtransforms_ = {}
+        self.invtransforms_ = {}
+        self.warpedmovout_ = {}
+        self.warpedfixout_ = {}
+        
+        for moving_image, moving_label in zip(moving_images, moving_labels):
+            fit_result = interface.registration(fixed_image,
+                                                moving_image,
+                                                type_of_transform=self.type_of_transform,
+                                                initial_transform=None,
+                                                outprefix='',
+                                                mask=None,
+                                                grad_step=0.2,
+                                                flow_sigma=3,
+                                                total_sigma=0,
+                                                aff_metric='mattes',
+                                                aff_sampling=32,
+                                                syn_metric='mattes',
+                                                syn_sampling=32,
+                                                reg_iterations=(40,20,0),
+                                                verbose=False)
+
+            self.fwdtransforms_[moving_label] = fit_result['fwdtransforms']
+            self.invtransforms_[moving_label] = fit_result['invtransforms']
+            self.warpedmovout_[moving_label]  = fit_result['warpedmovout']
+            self.warpedfixout_[moving_label]  = fit_result['warpedfixout']
+
+        return self
+
+    def transform(self, X, y=None):
+        pass
+
+
+class RigidRegistration(object):
+    """
+    Rigid Registration as a Scikit-Learn compatible transform class
+
+    Example
+    -------
+    >>> import ants
+    >>> import ants.extra as extrants
+    >>> fi = ants.image_read(ants.get_data('r16'))
+    >>> mi = ants.image_read(ants.get_data('r64'))
+    >>> regtx = extrants.RigidRegistration()
+    >>> regtx.fit(fi, mi)
+    >>> mi_r = regtx.transform(mi)
+    >>> ants.plot(fi, mi_r.iMath_Canny(1, 2, 4).iMath('MD',1))
+    """
+    def __init__(self, fixed_image=None):
+        self.type_of_transform = 'Rigid'
+        self.fixed_image = fixed_image
+
+    def fit(self, moving_image, fixed_image=None):
+        if fixed_image is None:
+            if self.fixed_image is None:
+                raise ValueError('must give fixed_image in fit() or set it in __init__')
+            fixed_image = self.fixed_image
+
+        fit_result = interface.registration(fixed_image,
+                                            moving_image,
+                                            type_of_transform=self.type_of_transform,
+                                            initial_transform=None,
+                                            outprefix='',
+                                            mask=None,
+                                            grad_step=0.2,
+                                            flow_sigma=3,
+                                            total_sigma=0,
+                                            aff_metric='mattes',
+                                            aff_sampling=32,
+                                            syn_metric='mattes',
+                                            syn_sampling=32,
+                                            reg_iterations=(40,20,0),
+                                            verbose=False)
+        self._fit_result = fit_result
+        self.fwdtransforms_ = fit_result['fwdtransforms']
+        self.invtransforms_ = fit_result['invtransforms']
+        self.warpedmovout_ = fit_result['warpedmovout']
+        self.warpedfiout_ = fit_result['warpedfixout']
+
+    def transform(self, moving_image, fixed_image=None):
+        result = apply_transforms(fixed=fixed_image, moving=moving_image,
+                                  transformlist=self.fwdtransforms)
+        return result
+
+    def inverse_transform(self, moving_image, fixed_image=None):
+        result = apply_transforms(fixed=fixed_image, moving=moving_image,
+                                  transformlist=self.invtransforms)
+        return result
+
+

MindEyeV2/antspy/ants/plotting/__init__.py

@@ -0,0 +1,8 @@
+
+from .plot import plot
+from .movie import movie
+from .plot_hist import plot_hist
+from .plot_grid import plot_grid
+from .plot_ortho import plot_ortho
+from .plot_ortho_stack import plot_ortho_stack
+from .plot_directory import plot_directory

MindEyeV2/antspy/ants/plotting/movie.py

@@ -0,0 +1,87 @@
+"""
+Functions for plotting ants images
+"""
+
+
+__all__ = [
+    "movie"
+]
+
+import fnmatch
+import math
+import os
+import warnings
+
+from matplotlib import gridspec
+import matplotlib.pyplot as plt
+import matplotlib.patheffects as path_effects
+import matplotlib.lines as mlines
+import matplotlib.patches as patches
+import matplotlib.mlab as mlab
+import matplotlib.animation as animation
+from mpl_toolkits.axes_grid1.inset_locator import inset_axes
+
+
+import numpy as np
+from ants.decorators import image_method
+
+@image_method
+def movie(image, filename=None, writer=None, fps=30):
+    """
+    Create and save a movie - mp4, gif, etc - of the various
+    2D slices of a 3D ants image
+
+    Try this:
+        conda install -c conda-forge ffmpeg
+
+    Example
+    -------
+    >>> import ants
+    >>> mni = ants.image_read(ants.get_data('mni'))
+    >>> ants.movie(mni, filename='~/desktop/movie.mp4')
+    """
+
+    image = image.pad_image()
+    img_arr = image.numpy()
+
+    minidx = max(0, np.where(image > 0)[0][0] - 5)
+    maxidx = max(image.shape[0], np.where(image > 0)[0][-1] + 5)
+
+    # Creare your figure and axes
+    fig, ax = plt.subplots(1)
+
+    im = ax.imshow(
+        img_arr[minidx, :, :],
+        animated=True,
+        cmap="Greys_r",
+        vmin=image.quantile(0.05),
+        vmax=image.quantile(0.95),
+    )
+
+    ax.axis("off")
+
+    def init():
+        fig.axes("off")
+        return (im,)
+
+    def updatefig(frame):
+        im.set_array(img_arr[frame, :, :])
+        return (im,)
+
+    ani = animation.FuncAnimation(
+        fig,
+        updatefig,
+        frames=np.arange(minidx, maxidx),
+        # init_func=init,
+        interval=50,
+        blit=True,
+    )
+
+    if writer is None:
+        writer = animation.FFMpegWriter(fps=fps)
+
+    if filename is not None:
+        filename = os.path.expanduser(filename)
+        ani.save(filename, writer=writer)
+    else:
+        plt.show()

MindEyeV2/antspy/ants/plotting/plot.py

@@ -0,0 +1,486 @@
+"""
+Functions for plotting ants images
+"""
+
+
+__all__ = [
+    "plot"
+]
+
+import fnmatch
+import math
+import os
+import warnings
+
+from matplotlib import gridspec
+import matplotlib.pyplot as plt
+import matplotlib.patheffects as path_effects
+import matplotlib.lines as mlines
+import matplotlib.patches as patches
+import matplotlib.mlab as mlab
+import matplotlib.animation as animation
+from mpl_toolkits.axes_grid1.inset_locator import inset_axes
+
+import numpy as np
+import ants
+from ants.decorators import image_method
+
+@image_method
+def plot(
+    image,
+    overlay=None,
+    blend=False,
+    alpha=1,
+    cmap="Greys_r",
+    overlay_cmap="turbo",
+    overlay_alpha=0.9,
+    vminol=None,
+    vmaxol=None,
+    cbar=False,
+    cbar_length=0.8,
+    cbar_dx=0.0,
+    cbar_vertical=True,
+    axis=0,
+    nslices=12,
+    slices=None,
+    ncol=None,
+    slice_buffer=None,
+    black_bg=True,
+    bg_thresh_quant=0.01,
+    bg_val_quant=0.99,
+    domain_image_map=None,
+    crop=False,
+    scale=False,
+    reverse=False,
+    title=None,
+    title_fontsize=20,
+    title_dx=0.0,
+    title_dy=0.0,
+    filename=None,
+    dpi=500,
+    figsize=1.5,
+    reorient=True,
+    resample=True,
+):
+    """
+    Plot an ANTsImage.
+
+    Use mask_image and/or threshold_image to preprocess images to be be
+    overlaid and display the overlays in a given range. See the wiki examples.
+
+    By default, images will be reoriented to 'LAI' orientation before plotting.
+    So, if axis == 0, the images will be ordered from the
+    left side of the brain to the right side of the brain. If axis == 1,
+    the images will be ordered from the anterior (front) of the brain to
+    the posterior (back) of the brain. And if axis == 2, the images will
+    be ordered from the inferior (bottom) of the brain to the superior (top)
+    of the brain.
+
+    ANTsR function: `plot.antsImage`
+
+    Arguments
+    ---------
+    image : ANTsImage
+        image to plot
+
+    overlay : ANTsImage
+        image to overlay on base image
+
+    cmap : string
+        colormap to use for base image. See matplotlib.
+
+    overlay_cmap : string
+        colormap to use for overlay images, if applicable. See matplotlib.
+
+    overlay_alpha : float
+        level of transparency for any overlays. Smaller value means
+        the overlay is more transparent. See matplotlib.
+
+    axis : integer
+        which axis to plot along if image is 3D
+
+    nslices : integer
+        number of slices to plot if image is 3D
+
+    slices : list or tuple of integers
+        specific slice indices to plot if image is 3D.
+        If given, this will override `nslices`.
+        This can be absolute array indices (e.g. (80,100,120)), or
+        this can be relative array indices (e.g. (0.4,0.5,0.6))
+
+    ncol : integer
+        Number of columns to have on the plot if image is 3D.
+
+    slice_buffer : integer
+        how many slices to buffer when finding the non-zero slices of
+        a 3D images. So, if slice_buffer = 10, then the first slice
+        in a 3D image will be the first non-zero slice index plus 10 more
+        slices.
+
+    black_bg : boolean
+        if True, the background of the image(s) will be black.
+        if False, the background of the image(s) will be determined by the
+            values `bg_thresh_quant` and `bg_val_quant`.
+
+    bg_thresh_quant : float
+        if white_bg=True, the background will be determined by thresholding
+        the image at the `bg_thresh` quantile value and setting the background
+        intensity to the `bg_val` quantile value.
+        This value should be in [0, 1] - somewhere around 0.01 is recommended.
+            - equal to 1 will threshold the entire image
+            - equal to 0 will threshold none of the image
+
+    bg_val_quant : float
+        if white_bg=True, the background will be determined by thresholding
+        the image at the `bg_thresh` quantile value and setting the background
+        intensity to the `bg_val` quantile value.
+        This value should be in [0, 1]
+            - equal to 1 is pure white
+            - equal to 0 is pure black
+            - somewhere in between is gray
+
+    domain_image_map : ANTsImage
+        this input ANTsImage or list of ANTsImage types contains a reference image
+        `domain_image` and optional reference mapping named `domainMap`.
+        If supplied, the image(s) to be plotted will be mapped to the domain
+        image space before plotting - useful for non-standard image orientations.
+
+    crop : boolean
+        if true, the image(s) will be cropped to their bounding boxes, resulting
+        in a potentially smaller image size.
+        if false, the image(s) will not be cropped
+
+    scale : boolean or 2-tuple
+        if true, nothing will happen to intensities of image(s) and overlay(s)
+        if false, dynamic range will be maximized when visualizing overlays
+        if 2-tuple, the image will be dynamically scaled between these quantiles
+
+    reverse : boolean
+        if true, the order in which the slices are plotted will be reversed.
+        This is useful if you want to plot from the front of the brain first
+        to the back of the brain, or vice-versa
+
+    title : string
+        add a title to the plot
+
+    filename : string
+        if given, the resulting image will be saved to this file
+
+    dpi : integer
+        determines resolution of image if saved to file. Higher values
+        result in higher resolution images, but at a cost of having a
+        larger file size
+
+    resample : bool
+        if true, resample image if spacing is very unbalanced.
+
+    Example
+    -------
+    >>> import ants
+    >>> import numpy as np
+    >>> img = ants.image_read(ants.get_data('r16'))
+    >>> segs = img.kmeans_segmentation(k=3)['segmentation']
+    >>> ants.plot(img, segs*(segs==1), crop=True)
+    >>> ants.plot(img, segs*(segs==1), crop=False)
+    >>> mni = ants.image_read(ants.get_data('mni'))
+    >>> segs = mni.kmeans_segmentation(k=3)['segmentation']
+    >>> ants.plot(mni, segs*(segs==1), crop=False)
+    """
+    if (axis == "x") or (axis == "saggittal"):
+        axis = 0
+    if (axis == "y") or (axis == "coronal"):
+        axis = 1
+    if (axis == "z") or (axis == "axial"):
+        axis = 2
+
+    def mirror_matrix(x):
+        return x[::-1, :]
+
+    def rotate270_matrix(x):
+        return mirror_matrix(x.T)
+
+    def rotate180_matrix(x):
+        return x[::-1, ::-1]
+
+    def rotate90_matrix(x):
+        return x.T
+
+    def reorient_slice(x, axis):
+        if axis != 2:
+            x = rotate90_matrix(x)
+        if axis == 2:
+            x = rotate270_matrix(x)
+        x = mirror_matrix(x)
+        return x
+
+
+    # handle `image` argument
+    if isinstance(image, str):
+        image = ants.image_read(image)
+    if not ants.is_image(image):
+        raise ValueError("image argument must be an ANTsImage")
+
+    if np.all(np.equal(image.numpy(), 0.0)):
+        warnings.warn("Image must be non-zero. will not plot.")
+        return
+
+    # need this hack because of a weird NaN warning from matplotlib with overlays
+    warnings.simplefilter("ignore")
+
+    if (image.pixeltype not in {"float", "double"}) or (image.is_rgb):
+        scale = False  # turn off scaling if image is discrete
+
+    # handle `overlay` argument
+    if overlay is not None:
+        if isinstance(overlay, str):
+            overlay = ants.image_read(overlay)
+        if vminol is None:
+            vminol = overlay.min()
+        if vmaxol is None:
+            vmaxol = overlay.max()
+        if not ants.is_image(overlay):
+            raise ValueError("overlay argument must be an ANTsImage")
+        if overlay.components > 1:
+            raise ValueError("overlay cannot have more than one voxel component")
+
+        if not ants.image_physical_space_consistency(image, overlay):
+            overlay = ants.resample_image_to_target(overlay, image, interp_type="nearestNeighbor")
+
+        if blend:
+            if alpha == 1:
+                alpha = 0.5
+            image = image * alpha + overlay * (1 - alpha)
+            overlay = None
+            alpha = 1.0
+
+    # handle `domain_image_map` argument
+    if domain_image_map is not None:
+        tx = ants.new_ants_transform(
+            precision="float",
+            transform_type="AffineTransform",
+            dimension=image.dimension,
+        )
+        image = ants.apply_ants_transform_to_image(tx, image, domain_image_map)
+        if overlay is not None:
+            overlay = ants.apply_ants_transform_to_image(
+                tx, overlay, domain_image_map, interpolation="nearestNeighbor"
+            )
+
+    ## single-channel images ##
+    if image.components == 1:
+
+        # potentially crop image
+        if crop:
+            plotmask = image.get_mask(cleanup=0)
+            if plotmask.max() == 0:
+                plotmask += 1
+            image = image.crop_image(plotmask)
+            if overlay is not None:
+                overlay = overlay.crop_image(plotmask)
+
+        # potentially find dynamic range
+        if scale == True:
+            vmin, vmax = image.quantile((0.05, 0.95))
+        elif isinstance(scale, (list, tuple)):
+            if len(scale) != 2:
+                raise ValueError(
+                    "scale argument must be boolean or list/tuple with two values"
+                )
+            vmin, vmax = image.quantile(scale)
+        else:
+            vmin = None
+            vmax = None
+
+        # Plot 2D image
+        if image.dimension == 2:
+
+            img_arr = image.numpy()
+            img_arr = rotate90_matrix(img_arr)
+
+            if not black_bg:
+                img_arr[img_arr < image.quantile(bg_thresh_quant)] = image.quantile(
+                    bg_val_quant
+                )
+
+            if overlay is not None:
+                ov_arr = overlay.numpy()
+                mask = ov_arr == 0
+                mask = np.ma.masked_where(mask == 0, mask)
+                ov_arr = np.ma.masked_array(ov_arr, mask)
+                ov_arr = rotate90_matrix(ov_arr)
+
+            fig = plt.figure()
+            if title is not None:
+                fig.suptitle(
+                    title, fontsize=title_fontsize, x=0.5 + title_dx, y=0.95 + title_dy
+                )
+
+            ax = plt.subplot(111)
+
+            # plot main image
+            im = ax.imshow(img_arr, cmap=cmap, alpha=alpha, vmin=vmin, vmax=vmax)
+
+            if overlay is not None:
+                im = ax.imshow(ov_arr, alpha=overlay_alpha, cmap=overlay_cmap,
+                    vmin=vminol, vmax=vmaxol )
+
+            if cbar:
+                cbar_orient = "vertical" if cbar_vertical else "horizontal"
+                fig.colorbar(im, orientation=cbar_orient)
+
+            plt.axis("off")
+
+        # Plot 3D image
+        elif image.dimension == 3:
+            # resample image if spacing is very unbalanced
+            spacing = [s for i, s in enumerate(image.spacing) if i != axis]
+            was_resampled = False
+            if (max(spacing) / min(spacing)) > 3.0 and resample:
+                was_resampled = True
+                new_spacing = (1, 1, 1)
+                image = image.resample_image(tuple(new_spacing))
+                if overlay is not None:
+                    overlay = overlay.resample_image(tuple(new_spacing))
+
+            if reorient:
+                image = image.reorient_image2("LAI")
+            img_arr = image.numpy()
+            # reorder dims so that chosen axis is first
+            img_arr = np.rollaxis(img_arr, axis)
+
+            if overlay is not None:
+                if reorient:
+                    overlay = overlay.reorient_image2("LAI")
+                ov_arr = overlay.numpy()
+                mask = ov_arr == 0
+                mask = np.ma.masked_where(mask == 0, mask)
+                ov_arr = np.ma.masked_array(ov_arr, mask)
+                ov_arr = np.rollaxis(ov_arr, axis)
+
+            if slices is None:
+                if not isinstance(slice_buffer, (list, tuple)):
+                    if slice_buffer is None:
+                        slice_buffer = (
+                            int(img_arr.shape[1] * 0.1),
+                            int(img_arr.shape[2] * 0.1),
+                        )
+                    else:
+                        slice_buffer = (slice_buffer, slice_buffer)
+                nonzero = np.where(img_arr.sum(axis=(1, 2)) > 0.01)[0]
+                min_idx = nonzero[0] + slice_buffer[0]
+                max_idx = nonzero[-1] - slice_buffer[1]
+                if min_idx > max_idx:
+                    temp = min_idx
+                    min_idx = max_idx
+                    max_idx = temp
+                if max_idx > nonzero.max():
+                    max_idx = nonzero.max()
+                if min_idx < 0:
+                    min_idx = 0
+                slice_idxs = np.linspace(min_idx, max_idx, nslices).astype("int")
+                if reverse:
+                    slice_idxs = np.array(list(reversed(slice_idxs)))
+            else:
+                if isinstance(slices, (int, float)):
+                    slices = [slices]
+                # if all slices are less than 1, infer that they are relative slices
+                if sum([s > 1 for s in slices]) == 0:
+                    slices = [int(s * img_arr.shape[0]) for s in slices]
+                slice_idxs = slices
+                nslices = len(slices)
+
+            if was_resampled:
+                # re-calculate slices to account for new image shape
+                slice_idxs = np.unique(
+                    np.array(
+                        [
+                            int(s * (image.shape[axis] / img_arr.shape[0]))
+                            for s in slice_idxs
+                        ]
+                    )
+                )
+
+            # only have one row if nslices <= 6 and user didnt specify ncol
+            if ncol is None:
+                if nslices <= 6:
+                    ncol = nslices
+                else:
+                    ncol = int(round(math.sqrt(nslices)))
+
+            # calculate grid size
+            nrow = math.ceil(nslices / ncol)
+            xdim = img_arr.shape[2]
+            ydim = img_arr.shape[1]
+
+            dim_ratio = ydim / xdim
+            fig = plt.figure(
+                figsize=((ncol + 1) * figsize * dim_ratio, (nrow + 1) * figsize)
+            )
+            if title is not None:
+                fig.suptitle(
+                    title, fontsize=title_fontsize, x=0.5 + title_dx, y=0.95 + title_dy
+                )
+
+            gs = gridspec.GridSpec(
+                nrow,
+                ncol,
+                wspace=0.0,
+                hspace=0.0,
+                top=1.0 - 0.5 / (nrow + 1),
+                bottom=0.5 / (nrow + 1),
+                left=0.5 / (ncol + 1),
+                right=1 - 0.5 / (ncol + 1),
+            )
+
+            slice_idx_idx = 0
+            for i in range(nrow):
+                for j in range(ncol):
+                    if slice_idx_idx < len(slice_idxs):
+                        imslice = img_arr[slice_idxs[slice_idx_idx]]
+                        imslice = reorient_slice(imslice, axis)
+                        if not black_bg:
+                            imslice[
+                                imslice < image.quantile(bg_thresh_quant)
+                            ] = image.quantile(bg_val_quant)
+                    else:
+                        imslice = np.zeros_like(img_arr[0])
+                        imslice = reorient_slice(imslice, axis)
+
+                    ax = plt.subplot(gs[i, j])
+                    im = ax.imshow(imslice, cmap=cmap, vmin=vmin, vmax=vmax)
+
+                    if overlay is not None:
+                        if slice_idx_idx < len(slice_idxs):
+                            ovslice = ov_arr[slice_idxs[slice_idx_idx]]
+                            ovslice = reorient_slice(ovslice, axis)
+                            im = ax.imshow(
+                                ovslice, alpha=overlay_alpha, cmap=overlay_cmap,
+                                    vmin=vminol, vmax=vmaxol )
+                    ax.axis("off")
+                    slice_idx_idx += 1
+
+            if cbar:
+                cbar_start = (1 - cbar_length) / 2
+                if cbar_vertical:
+                    cax = fig.add_axes([0.9 + cbar_dx, cbar_start, 0.03, cbar_length])
+                    cbar_orient = "vertical"
+                else:
+                    cax = fig.add_axes([cbar_start, 0.08 + cbar_dx, cbar_length, 0.03])
+                    cbar_orient = "horizontal"
+                fig.colorbar(im, cax=cax, orientation=cbar_orient)
+
+    ## multi-channel images ##
+    elif image.has_components:
+        raise Exception('Plotting images with components is not currently supported.')
+
+    if filename is not None:
+        filename = os.path.expanduser(filename)
+        plt.savefig(filename, dpi=dpi, transparent=True, bbox_inches="tight")
+        plt.close(fig)
+    else:
+        plt.show()
+
+    # turn warnings back to default
+    warnings.simplefilter("default")
+
+

MindEyeV2/antspy/ants/plotting/plot_directory.py

@@ -0,0 +1,118 @@
+"""
+Functions for plotting ants images
+"""
+
+
+__all__ = [
+    "plot_directory"
+]
+
+import fnmatch
+import math
+import os
+import warnings
+
+from matplotlib import gridspec
+import matplotlib.pyplot as plt
+import matplotlib.patheffects as path_effects
+import matplotlib.lines as mlines
+import matplotlib.patches as patches
+import matplotlib.mlab as mlab
+import matplotlib.animation as animation
+from mpl_toolkits.axes_grid1.inset_locator import inset_axes
+
+
+import numpy as np
+
+import ants
+
+
+def plot_directory(
+    directory,
+    recursive=False,
+    regex="*",
+    save_prefix="",
+    save_suffix="",
+    axis=None,
+    **kwargs
+):
+    """
+    Create and save an ANTsPy plot for every image matching a given regular
+    expression in a directory, optionally recursively. This is a good function
+    for quick visualize exploration of all of images in a directory
+
+    ANTsR function: N/A
+
+    Arguments
+    ---------
+    directory : string
+        directory in which to search for images and plot them
+
+    recursive : boolean
+        If true, this function will search through all directories under
+        the given directory recursively to make plots.
+        If false, this function will only create plots for images in the
+        given directory
+
+    regex : string
+        regular expression used to filter out certain filenames or suffixes
+
+    save_prefix : string
+        sub-string that will be appended to the beginning of all saved plot filenames.
+        Default is to add nothing.
+
+    save_suffix : string
+        sub-string that will be appended to the end of all saved plot filenames.
+        Default is add nothing.
+
+    kwargs : keyword arguments
+        any additional arguments to pass onto the `ants.plot` function.
+        e.g. overlay, alpha, cmap, etc. See `ants.plot` for more options.
+
+    Example
+    -------
+    >>> import ants
+    >>> ants.plot_directory(directory='~/desktop/testdir',
+                            recursive=False, regex='*')
+    """
+
+    def has_acceptable_suffix(fname):
+        suffixes = {".nii.gz"}
+        return sum([fname.endswith(sx) for sx in suffixes]) > 0
+
+    if directory.startswith("~"):
+        directory = os.path.expanduser(directory)
+
+    if not os.path.isdir(directory):
+        raise ValueError("directory %s does not exist!" % directory)
+
+    for root, dirnames, fnames in os.walk(directory):
+        for fname in fnames:
+            if fnmatch.fnmatch(fname, regex) and has_acceptable_suffix(fname):
+                load_fname = os.path.join(root, fname)
+                fname = fname.replace(".".join(fname.split(".")[1:]), "png")
+                fname = fname.replace(".png", "%s.png" % save_suffix)
+                fname = "%s%s" % (save_prefix, fname)
+                save_fname = os.path.join(root, fname)
+                img = ants.image_read(load_fname)
+
+                if axis is None:
+                    axis_range = [i for i in range(img.dimension)]
+                else:
+                    axis_range = axis if isinstance(axis, (list, tuple)) else [axis]
+
+                if img.dimension > 2:
+                    for axis_idx in axis_range:
+                        filename = save_fname.replace(".png", "_axis%i.png" % axis_idx)
+                        ncol = int(math.sqrt(img.shape[axis_idx]))
+                        ants.plot(
+                            img,
+                            axis=axis_idx,
+                            nslices=img.shape[axis_idx],
+                            ncol=ncol,
+                            filename=filename,
+                            **kwargs
+                        )
+                else:
+                    filename = save_fname
+                    ants.plot(img, filename=filename, **kwargs)

MindEyeV2/antspy/ants/plotting/plot_grid.py

@@ -0,0 +1,355 @@
+"""
+Functions for plotting ants images
+"""
+
+
+__all__ = [
+    "plot_grid"
+]
+
+import fnmatch
+import math
+import os
+import warnings
+
+from matplotlib import gridspec
+import matplotlib.pyplot as plt
+import matplotlib.patheffects as path_effects
+import matplotlib.lines as mlines
+import matplotlib.patches as patches
+import matplotlib.mlab as mlab
+import matplotlib.animation as animation
+from mpl_toolkits.axes_grid1.inset_locator import inset_axes
+
+
+import numpy as np
+
+
+def plot_grid(
+    images,
+    slices=None,
+    axes=2,
+    # general figure arguments
+    figsize=1.0,
+    rpad=0,
+    cpad=0,
+    vmin=None,
+    vmax=None,
+    colorbar=True,
+    cmap="Greys_r",
+    # title arguments
+    title=None,
+    tfontsize=20,
+    title_dx=0,
+    title_dy=0,
+    # row arguments
+    rlabels=None,
+    rfontsize=14,
+    rfontcolor="white",
+    rfacecolor="black",
+    # column arguments
+    clabels=None,
+    cfontsize=14,
+    cfontcolor="white",
+    cfacecolor="black",
+    # save arguments
+    filename=None,
+    dpi=400,
+    transparent=True,
+    # other args
+    **kwargs
+):
+    """
+    Plot a collection of images in an arbitrarily-defined grid
+
+    Matplotlib named colors: https://matplotlib.org/examples/color/named_colors.html
+
+    Arguments
+    ---------
+    images : list of ANTsImage types
+        image(s) to plot.
+        if one image, this image will be used for all grid locations.
+        if multiple images, they should be arrange in a list the same
+        shape as the `gridsize` argument.
+
+    slices : integer or list of integers
+        slice indices to plot
+        if one integer, this slice index will be used for all images
+        if multiple integers, they should be arranged in a list the same
+        shape as the `gridsize` argument
+
+    axes : integer or list of integers
+        axis or axes along which to plot image slices
+        if one integer, this axis will be used for all images
+        if multiple integers, they should be arranged in a list the same
+        shape as the `gridsize` argument
+
+    Example
+    -------
+    >>> import ants
+    >>> import numpy as np
+    >>> mni1 = ants.image_read(ants.get_data('mni'))
+    >>> mni2 = mni1.smooth_image(1.)
+    >>> mni3 = mni1.smooth_image(2.)
+    >>> mni4 = mni1.smooth_image(3.)
+    >>> images = np.asarray([[mni1, mni2],
+    ...                      [mni3, mni4]])
+    >>> slices = np.asarray([[100, 100],
+    ...                      [100, 100]])
+    >>> ants.plot_grid(images=images, slices=slices, title='2x2 Grid')
+    >>> images2d = np.asarray([[mni1.slice_image(2,100), mni2.slice_image(2,100)],
+    ...                        [mni3.slice_image(2,100), mni4.slice_image(2,100)]])
+    >>> ants.plot_grid(images=images2d, title='2x2 Grid Pre-Sliced')
+    >>> ants.plot_grid(images.reshape(1,4), slices.reshape(1,4), title='1x4 Grid')
+    >>> ants.plot_grid(images.reshape(4,1), slices.reshape(4,1), title='4x1 Grid')
+
+    >>> # Padding between rows and/or columns
+    >>> ants.plot_grid(images, slices, cpad=0.02, title='Col Padding')
+    >>> ants.plot_grid(images, slices, rpad=0.02, title='Row Padding')
+    >>> ants.plot_grid(images, slices, rpad=0.02, cpad=0.02, title='Row and Col Padding')
+
+    >>> # Adding plain row and/or column labels
+    >>> ants.plot_grid(images, slices, title='Adding Row Labels', rlabels=['Row #1', 'Row #2'])
+    >>> ants.plot_grid(images, slices, title='Adding Col Labels', clabels=['Col #1', 'Col #2'])
+    >>> ants.plot_grid(images, slices, title='Row and Col Labels',
+                       rlabels=['Row 1', 'Row 2'], clabels=['Col 1', 'Col 2'])
+
+    >>> # Making a publication-quality image
+    >>> images = np.asarray([[mni1, mni2, mni2],
+    ...                      [mni3, mni4, mni4]])
+    >>> slices = np.asarray([[100, 100, 100],
+    ...                      [100, 100, 100]])
+    >>> axes = np.asarray([[0, 1, 2],
+                           [0, 1, 2]])
+    >>> ants.plot_grid(images, slices, axes, title='Publication Figures with ANTsPy',
+                       tfontsize=20, title_dy=0.03, title_dx=-0.04,
+                       rlabels=['Row 1', 'Row 2'],
+                       clabels=['Col 1', 'Col 2', 'Col 3'],
+                       rfontsize=16, cfontsize=16)
+    """
+
+    def mirror_matrix(x):
+        return x[::-1, :]
+
+    def rotate270_matrix(x):
+        return mirror_matrix(x.T)
+
+    def rotate180_matrix(x):
+        return x[::-1, ::-1]
+
+    def rotate90_matrix(x):
+        return mirror_matrix(x).T
+
+    def flip_matrix(x):
+        return mirror_matrix(rotate180_matrix(x))
+
+    def reorient_slice(x, axis):
+        if axis != 1:
+            x = rotate90_matrix(x)
+        if axis == 1:
+            x = rotate90_matrix(x)
+        x = mirror_matrix(x)
+        return x
+
+    def slice_image(img, axis, idx):
+        if axis == 0:
+            return img[idx, :, :].numpy()
+        elif axis == 1:
+            return img[:, idx, :].numpy()
+        elif axis == 2:
+            return img[:, :, idx].numpy()
+        elif axis == -1:
+            return img[:, :, idx].numpy()
+        elif axis == -2:
+            return img[:, idx, :].numpy()
+        elif axis == -3:
+            return img[idx, :, :].numpy()
+        else:
+            raise ValueError("axis %i not valid" % axis)
+
+    if isinstance(images, np.ndarray):
+        images = images.tolist()
+    if not isinstance(images, list):
+        raise ValueError("images argument must be of type list")
+    if not isinstance(images[0], list):
+        images = [images]
+
+    if slices is None:
+        one_slice = True
+    if isinstance(slices, int):
+        one_slice = True
+    if isinstance(slices, np.ndarray):
+        slices = slices.tolist()
+    if isinstance(slices, list):
+        one_slice = False
+        if not isinstance(slices[0], list):
+            slices = [slices]
+        nslicerow = len(slices)
+        nslicecol = len(slices[0])
+
+    nrow = len(images)
+    ncol = len(images[0])
+
+    if rlabels is None:
+        rlabels = [None] * nrow
+    if clabels is None:
+        clabels = [None] * ncol
+
+    if not one_slice:
+        if (nrow != nslicerow) or (ncol != nslicecol):
+            raise ValueError(
+                "`images` arg shape (%i,%i) must equal `slices` arg shape (%i,%i)!"
+                % (nrow, ncol, nslicerow, nslicecol)
+            )
+
+    fig = plt.figure(figsize=((ncol + 1) * 2.5 * figsize, (nrow + 1) * 2.5 * figsize))
+
+    if title is not None:
+        basex = 0.5
+        basey = 0.9 if clabels[0] is None else 0.95
+        fig.suptitle(title, fontsize=tfontsize, x=basex + title_dx, y=basey + title_dy)
+
+    if (cpad > 0) and (rpad > 0):
+        bothgridpad = max(cpad, rpad)
+        cpad = 0
+        rpad = 0
+    else:
+        bothgridpad = 0.0
+
+    gs = gridspec.GridSpec(
+        nrow,
+        ncol,
+        wspace=bothgridpad,
+        hspace=0.0,
+        top=1.0 - 0.5 / (nrow + 1),
+        bottom=0.5 / (nrow + 1) + cpad,
+        left=0.5 / (ncol + 1) + rpad,
+        right=1 - 0.5 / (ncol + 1),
+    )
+
+    if isinstance(vmin, (int, float)):
+        vmins = [vmin] * nrow
+    elif vmin is None:
+        vmins = [None] * nrow
+    else:
+        vmins = vmin
+
+    if isinstance(vmax, (int, float)):
+        vmaxs = [vmax] * nrow
+    elif vmax is None:
+        vmaxs = [None] * nrow
+    else:
+        vmaxs = vmax
+
+    if isinstance(cmap, str):
+        cmaps = [cmap] * nrow
+    elif cmap is None:
+        cmaps = [None] * nrow
+    else:
+        cmaps = cmap
+
+    for rowidx, rvmin, rvmax, rcmap in zip(range(nrow), vmins, vmaxs, cmaps):
+        for colidx in range(ncol):
+            ax = plt.subplot(gs[rowidx, colidx])
+
+            if colidx == 0:
+                if rlabels[rowidx] is not None:
+                    bottom, height = 0.25, 0.5
+                    top = bottom + height
+                    # add label text
+                    ax.text(
+                        -0.07,
+                        0.5 * (bottom + top),
+                        rlabels[rowidx],
+                        horizontalalignment="right",
+                        verticalalignment="center",
+                        rotation="vertical",
+                        transform=ax.transAxes,
+                        color=rfontcolor,
+                        fontsize=rfontsize,
+                    )
+
+                    # add label background
+                    extra = 0.3 if rowidx == 0 else 0.0
+
+                    rect = patches.Rectangle(
+                        (-0.3, 0),
+                        0.3,
+                        1.0 + extra,
+                        facecolor=rfacecolor,
+                        alpha=1.0,
+                        transform=ax.transAxes,
+                        clip_on=False,
+                    )
+                    ax.add_patch(rect)
+
+            if rowidx == 0:
+                if clabels[colidx] is not None:
+                    bottom, height = 0.25, 0.5
+                    left, width = 0.25, 0.5
+                    right = left + width
+                    top = bottom + height
+                    ax.text(
+                        0.5 * (left + right),
+                        0.09 + top + bottom,
+                        clabels[colidx],
+                        horizontalalignment="center",
+                        verticalalignment="center",
+                        rotation="horizontal",
+                        transform=ax.transAxes,
+                        color=cfontcolor,
+                        fontsize=cfontsize,
+                    )
+
+                    # add label background
+                    rect = patches.Rectangle(
+                        (0, 1.0),
+                        1.0,
+                        0.3,
+                        facecolor=cfacecolor,
+                        alpha=1.0,
+                        transform=ax.transAxes,
+                        clip_on=False,
+                    )
+                    ax.add_patch(rect)
+
+            tmpimg = images[rowidx][colidx]
+            if isinstance(axes, int):
+                tmpaxis = axes
+            else:
+                tmpaxis = axes[rowidx][colidx]
+            
+            if tmpimg.dimension == 2:
+                tmpslice = tmpimg.numpy()
+                tmpslice = reorient_slice(tmpslice, tmpaxis)
+            else:
+                sliceidx = slices[rowidx][colidx] if not one_slice else slices
+                if sliceidx is None:
+                    sliceidx = math.ceil(tmpimg.shape[tmpaxis] / 2)
+                tmpslice = slice_image(tmpimg, tmpaxis, sliceidx)
+                tmpslice = reorient_slice(tmpslice, tmpaxis)
+            
+            im = ax.imshow(tmpslice, cmap=rcmap, aspect="auto", vmin=rvmin, vmax=rvmax)
+            ax.axis("off")
+
+        # A colorbar solution with make_axes_locatable will not allow y-scaling of the colorbar.
+        # from mpl_toolkits.axes_grid1 import make_axes_locatable
+        # divider = make_axes_locatable(ax)
+        # cax = divider.append_axes('right', size='5%', pad=0.05)
+        if colorbar:
+            axins = inset_axes(ax,
+                               width="5%",  # width = 5% of parent_bbox width
+                               height="90%",  # height : 50%
+                               loc='center left',
+                               bbox_to_anchor=(1.03, 0., 1, 1),
+                               bbox_transform=ax.transAxes,
+                               borderpad=0,
+            )
+            fig.colorbar(im, cax=axins, orientation='vertical')
+
+    if filename is not None:
+        filename = os.path.expanduser(filename)
+        plt.savefig(filename, dpi=dpi, transparent=transparent, bbox_inches="tight")
+        plt.close(fig)
+    else:
+        plt.show()

MindEyeV2/antspy/ants/plotting/plot_hist.py

@@ -0,0 +1,73 @@
+"""
+Functions for plotting ants images
+"""
+
+
+__all__ = [
+    "plot_hist"
+]
+
+import fnmatch
+import math
+import os
+import warnings
+
+from matplotlib import gridspec
+import matplotlib.pyplot as plt
+import matplotlib.patheffects as path_effects
+import matplotlib.lines as mlines
+import matplotlib.patches as patches
+import matplotlib.mlab as mlab
+import matplotlib.animation as animation
+from mpl_toolkits.axes_grid1.inset_locator import inset_axes
+
+
+import numpy as np
+from ants.decorators import image_method
+
+@image_method
+def plot_hist(
+    image,
+    threshold=0.0,
+    fit_line=False,
+    normfreq=True,
+    ## plot label arguments
+    title=None,
+    grid=True,
+    xlabel=None,
+    ylabel=None,
+    ## other plot arguments
+    facecolor="green",
+    alpha=0.75,
+):
+    """
+    Plot a histogram from an ANTsImage
+
+    Arguments
+    ---------
+    image : ANTsImage
+        image from which histogram will be created
+    """
+    img_arr = image.numpy().flatten()
+    img_arr = img_arr[np.abs(img_arr) > threshold]
+
+    if normfreq != False:
+        normfreq = 1.0 if normfreq == True else normfreq
+    n, bins, patches = plt.hist(
+        img_arr, 50, facecolor=facecolor, alpha=alpha
+    )
+
+    if fit_line:
+        # add a 'best fit' line
+        y = mlab.normpdf(bins, img_arr.mean(), img_arr.std())
+        l = plt.plot(bins, y, "r--", linewidth=1)
+
+    if xlabel is not None:
+        plt.xlabel(xlabel)
+    if ylabel is not None:
+        plt.ylabel(ylabel)
+    if title is not None:
+        plt.title(title)
+
+    plt.grid(grid)
+    plt.show()

MindEyeV2/antspy/ants/plotting/plot_ortho.py

@@ -0,0 +1,612 @@
+"""
+Functions for plotting ants images
+"""
+
+
+__all__ = [
+    "plot_ortho"
+]
+
+import fnmatch
+import math
+import os
+import warnings
+
+from matplotlib import gridspec
+import matplotlib.pyplot as plt
+import matplotlib.patheffects as path_effects
+import matplotlib.lines as mlines
+import matplotlib.patches as patches
+import matplotlib.mlab as mlab
+import matplotlib.animation as animation
+from mpl_toolkits.axes_grid1.inset_locator import inset_axes
+
+
+import numpy as np
+import ants
+from ants.decorators import image_method
+
+@image_method
+def plot_ortho(
+    image,
+    overlay=None,
+    reorient=True,
+    blend=False,
+    # xyz arguments
+    xyz=None,
+    xyz_lines=True,
+    xyz_color="red",
+    xyz_alpha=0.6,
+    xyz_linewidth=2,
+    xyz_pad=5,
+    orient_labels=True,
+    # base image arguments
+    alpha=1,
+    cmap="Greys_r",
+    # overlay arguments
+    overlay_cmap="jet",
+    overlay_alpha=0.9,
+    cbar=False,
+    cbar_length=0.8,
+    cbar_dx=0.0,
+    cbar_vertical=True,
+    # background arguments
+    black_bg=True,
+    bg_thresh_quant=0.01,
+    bg_val_quant=0.99,
+    # scale/crop/domain arguments
+    crop=False,
+    scale=False,
+    domain_image_map=None,
+    # title arguments
+    title=None,
+    titlefontsize=24,
+    title_dx=0,
+    title_dy=0,
+    # 4th panel text arguemnts
+    text=None,
+    textfontsize=24,
+    textfontcolor="white",
+    text_dx=0,
+    text_dy=0,
+    # save & size arguments
+    filename=None,
+    dpi=500,
+    figsize=1.0,
+    flat=False,
+    transparent=True,
+    resample=False,
+    allow_xyz_change=True,
+):
+    """
+    Plot an orthographic view of a 3D image
+
+    Use mask_image and/or threshold_image to preprocess images to be be
+    overlaid and display the overlays in a given range. See the wiki examples.
+
+    ANTsR function: N/A
+
+    Arguments
+    ---------
+    image : ANTsImage
+        image to plot
+
+    overlay : ANTsImage
+        image to overlay on base image
+
+    xyz : list or tuple of 3 integers
+        selects index location on which to center display
+        if given, solid lines will be drawn to converge at this coordinate.
+        This is useful for pinpointing a specific location in the image.
+
+    flat : boolean
+        if true, the ortho image will be plot in one row
+        if false, the ortho image will be a 2x2 grid with the bottom
+            left corner blank
+
+    cmap : string
+        colormap to use for base image. See matplotlib.
+
+    overlay_cmap : string
+        colormap to use for overlay images, if applicable. See matplotlib.
+
+    overlay_alpha : float
+        level of transparency for any overlays. Smaller value means
+        the overlay is more transparent. See matplotlib.
+
+    cbar: boolean
+        if true, a colorbar will be added to the plot
+
+    cbar_length: float
+        length of the colorbar relative to the image
+
+    cbar_dx: float
+        horizontal shift of the colorbar relative to the image
+
+    cbar_vertical: boolean
+        if true, the colorbar will be vertical, if false, it will be
+        horizontal underneath the image
+
+    axis : integer
+        which axis to plot along if image is 3D
+
+    black_bg : boolean
+        if True, the background of the image(s) will be black.
+        if False, the background of the image(s) will be determined by the
+            values `bg_thresh_quant` and `bg_val_quant`.
+
+    bg_thresh_quant : float
+        if white_bg=True, the background will be determined by thresholding
+        the image at the `bg_thresh` quantile value and setting the background
+        intensity to the `bg_val` quantile value.
+        This value should be in [0, 1] - somewhere around 0.01 is recommended.
+            - equal to 1 will threshold the entire image
+            - equal to 0 will threshold none of the image
+
+    bg_val_quant : float
+        if white_bg=True, the background will be determined by thresholding
+        the image at the `bg_thresh` quantile value and setting the background
+        intensity to the `bg_val` quantile value.
+        This value should be in [0, 1]
+            - equal to 1 is pure white
+            - equal to 0 is pure black
+            - somewhere in between is gray
+
+    domain_image_map : ANTsImage
+        this input ANTsImage or list of ANTsImage types contains a reference image
+        `domain_image` and optional reference mapping named `domainMap`.
+        If supplied, the image(s) to be plotted will be mapped to the domain
+        image space before plotting - useful for non-standard image orientations.
+
+    crop : boolean
+        if true, the image(s) will be cropped to their bounding boxes, resulting
+        in a potentially smaller image size.
+        if false, the image(s) will not be cropped
+
+    scale : boolean or 2-tuple
+        if true, nothing will happen to intensities of image(s) and overlay(s)
+        if false, dynamic range will be maximized when visualizing overlays
+        if 2-tuple, the image will be dynamically scaled between these quantiles
+
+    title : string
+        add a title to the plot
+
+    filename : string
+        if given, the resulting image will be saved to this file
+
+    dpi : integer
+        determines resolution of image if saved to file. Higher values
+        result in higher resolution images, but at a cost of having a
+        larger file size
+
+    resample : resample image in case of unbalanced spacing
+
+    allow_xyz_change : boolean will attempt to adjust xyz after padding
+
+    Example
+    -------
+    >>> import ants
+    >>> mni = ants.image_read(ants.get_data('mni'))
+    >>> ants.plot_ortho(mni, xyz=(100,100,100))
+    >>> mni2 = mni.threshold_image(7000, mni.max())
+    >>> ants.plot_ortho(mni, overlay=mni2)
+    >>> ants.plot_ortho(mni, overlay=mni2, flat=True)
+    >>> ants.plot_ortho(mni, overlay=mni2, xyz=(110,110,110), xyz_lines=False,
+                        text='Lines Turned Off', textfontsize=22)
+    >>> ants.plot_ortho(mni, mni2, xyz=(120,100,100),
+                        text=' Example \nOrtho Text', textfontsize=26,
+                        title='Example Ortho Title', titlefontsize=26)
+    """
+
+    def mirror_matrix(x):
+        return x[::-1, :]
+
+    def rotate270_matrix(x):
+        return mirror_matrix(x.T)
+
+    def reorient_slice(x, axis):
+        return rotate270_matrix(x)
+
+    # need this hack because of a weird NaN warning from matplotlib with overlays
+    warnings.simplefilter("ignore")
+
+    # handle `image` argument
+    if isinstance(image, str):
+        image = ants.image_read(image)
+    if not ants.is_image(image):
+        raise ValueError("image argument must be an ANTsImage")
+    if image.dimension != 3:
+        raise ValueError("Input image must have 3 dimensions!")
+
+    # handle `overlay` argument
+    if overlay is not None:
+        if isinstance(overlay, str):
+            overlay = ants.image_read(overlay)
+        vminol = overlay.min()
+        vmaxol = overlay.max()
+        if not ants.is_image(overlay):
+            raise ValueError("overlay argument must be an ANTsImage")
+        if overlay.components > 1:
+            raise ValueError("overlay cannot have more than one voxel component")
+        if overlay.dimension != 3:
+            raise ValueError("Overlay image must have 3 dimensions!")
+
+        if not ants.image_physical_space_consistency(image, overlay):
+            overlay = ants.resample_image_to_target(overlay, image, interp_type="linear")
+
+    if blend:
+        if alpha == 1:
+            alpha = 0.5
+        image = image * alpha + overlay * (1 - alpha)
+        overlay = None
+        alpha = 1.0
+
+    if image.pixeltype not in {"float", "double"}:
+        scale = False  # turn off scaling if image is discrete
+
+    # reorient images
+    if reorient != False:
+        if reorient == True:
+            reorient = "RPI"
+        image = image.reorient_image2("RPI")
+        if overlay is not None:
+            overlay = overlay.reorient_image2("RPI")
+
+    # handle `slices` argument
+    if xyz is None:
+        xyz = [int(s / 2) for s in image.shape]
+    for i in range(3):
+        if xyz[i] is None:
+            xyz[i] = int(image.shape[i] / 2)
+
+    # resample image if spacing is very unbalanced
+    spacing = [s for i, s in enumerate(image.spacing)]
+    if (max(spacing) / min(spacing)) > 3.0 and resample:
+        new_spacing = (1, 1, 1)
+        image = image.resample_image(tuple(new_spacing))
+        if overlay is not None:
+            overlay = overlay.resample_image(tuple(new_spacing))
+        xyz = [
+            int(sl * (sold / snew)) for sl, sold, snew in zip(xyz, spacing, new_spacing)
+        ]
+
+
+    # potentially crop image
+    if crop:
+        plotmask = image.get_mask(cleanup=0)
+        if plotmask.max() == 0:
+            plotmask += 1
+        image = image.crop_image(plotmask)
+        if overlay is not None:
+            overlay = overlay.crop_image(plotmask)
+
+    # pad images
+    if True:
+        image, lowpad, uppad = image.pad_image(return_padvals=True)
+        if allow_xyz_change:
+            xyz = [v + l for v, l in zip(xyz, lowpad)]
+        if overlay is not None:
+            overlay = overlay.pad_image()
+
+
+    # handle `domain_image_map` argument
+    if domain_image_map is not None:
+        if ants.is_image(domain_image_map):
+            tx = ants.new_ants_transform(
+                precision="float",
+                transform_type="AffineTransform",
+                dimension=image.dimension,
+            )
+            image = ants.apply_ants_transform_to_image(tx, image, domain_image_map)
+            if overlay is not None:
+                overlay = ants.apply_ants_transform_to_image(
+                    tx, overlay, domain_image_map, interpolation="linear"
+                )
+        else:
+            raise Exception('The domain_image_map must be an image.')
+
+    ## single-channel images ##
+    if image.components == 1:
+
+        # potentially find dynamic range
+        if scale == True:
+            vmin, vmax = image.quantile((0.05, 0.95))
+        elif isinstance(scale, (list, tuple)):
+            if len(scale) != 2:
+                raise ValueError(
+                    "scale argument must be boolean or list/tuple with two values"
+                )
+            vmin, vmax = image.quantile(scale)
+        else:
+            vmin = None
+            vmax = None
+
+        if not flat:
+            nrow = 2
+            ncol = 2
+        else:
+            nrow = 1
+            ncol = 3
+
+        fig = plt.figure(figsize=(9 * figsize, 9 * figsize))
+        if title is not None:
+            basey = 0.88 if not flat else 0.66
+            basex = 0.5
+            fig.suptitle(
+                title, fontsize=titlefontsize, color=textfontcolor, x=basex + title_dx, y=basey + title_dy
+            )
+
+        gs = gridspec.GridSpec(
+            nrow,
+            ncol,
+            wspace=0.0,
+            hspace=0.0,
+            top=1.0 - 0.5 / (nrow + 1),
+            bottom=0.5 / (nrow + 1),
+            left=0.5 / (ncol + 1),
+            right=1 - 0.5 / (ncol + 1),
+        )
+
+        # pad image to have isotropic array dimensions
+        imageReturn = image.clone()
+        image = image.numpy()
+        overlayReturn = None
+        if overlay is not None:
+            overlayReturn = overlay.clone()
+            overlay = overlay.numpy()
+            if overlay.dtype not in ["uint8", "uint32"]:
+                overlay = np.ma.masked_where( np.abs(overlay) <= 1e-16, overlay)
+#                overlay[np.abs(overlay) == 0] = np.nan
+
+        yz_slice = reorient_slice(image[xyz[0], :, :], 0)
+        ax = plt.subplot(gs[0, 0])
+        ax.imshow(yz_slice, cmap=cmap, vmin=vmin, vmax=vmax)
+        if overlay is not None:
+            yz_overlay = reorient_slice(overlay[xyz[0], :, :], 0)
+            ax.imshow(yz_overlay, alpha=overlay_alpha, cmap=overlay_cmap, vmin=vminol, vmax=vmaxol )
+        if xyz_lines:
+            # add lines
+            l = mlines.Line2D(
+                [yz_slice.shape[0] - xyz[1], yz_slice.shape[0] - xyz[1]],
+                [xyz_pad, yz_slice.shape[0] - xyz_pad],
+                color=xyz_color,
+                alpha=xyz_alpha,
+                linewidth=xyz_linewidth,
+            )
+            ax.add_line(l)
+            l = mlines.Line2D(
+                [xyz_pad, yz_slice.shape[1] - xyz_pad],
+                [yz_slice.shape[1] - xyz[2], yz_slice.shape[1] - xyz[2]],
+                color=xyz_color,
+                alpha=xyz_alpha,
+                linewidth=xyz_linewidth,
+            )
+            ax.add_line(l)
+        if orient_labels:
+            ax.text(
+                0.5,
+                0.98,
+                "S",
+                horizontalalignment="center",
+                verticalalignment="top",
+                fontsize=20 * figsize,
+                color=textfontcolor,
+                transform=ax.transAxes,
+            )
+            ax.text(
+                0.5,
+                0.02,
+                "I",
+                horizontalalignment="center",
+                verticalalignment="bottom",
+                fontsize=20 * figsize,
+                color=textfontcolor,
+                transform=ax.transAxes,
+            )
+            ax.text(
+                0.98,
+                0.5,
+                "A",
+                horizontalalignment="right",
+                verticalalignment="center",
+                fontsize=20 * figsize,
+                color=textfontcolor,
+                transform=ax.transAxes,
+            )
+            ax.text(
+                0.02,
+                0.5,
+                "P",
+                horizontalalignment="left",
+                verticalalignment="center",
+                fontsize=20 * figsize,
+                color=textfontcolor,
+                transform=ax.transAxes,
+            )
+        ax.axis("off")
+
+        xz_slice = reorient_slice(image[:, xyz[1], :], 1)
+        ax = plt.subplot(gs[0, 1])
+        ax.imshow(xz_slice, cmap=cmap, vmin=vmin, vmax=vmax)
+        if overlay is not None:
+            xz_overlay = reorient_slice(overlay[:, xyz[1], :], 1)
+            ax.imshow(xz_overlay, alpha=overlay_alpha, cmap=overlay_cmap, vmin=vminol, vmax=vmaxol )
+
+        if xyz_lines:
+            # add lines
+            l = mlines.Line2D(
+                [xz_slice.shape[0] - xyz[0], xz_slice.shape[0] - xyz[0]],
+                [xyz_pad, xz_slice.shape[0] - xyz_pad],
+                color=xyz_color,
+                alpha=xyz_alpha,
+                linewidth=xyz_linewidth,
+            )
+            ax.add_line(l)
+            l = mlines.Line2D(
+                [xyz_pad, xz_slice.shape[1] - xyz_pad],
+                [xz_slice.shape[1] - xyz[2], xz_slice.shape[1] - xyz[2]],
+                color=xyz_color,
+                alpha=xyz_alpha,
+                linewidth=xyz_linewidth,
+            )
+            ax.add_line(l)
+        if orient_labels:
+            ax.text(
+                0.5,
+                0.98,
+                "S",
+                horizontalalignment="center",
+                verticalalignment="top",
+                fontsize=20 * figsize,
+                color=textfontcolor,
+                transform=ax.transAxes,
+            )
+            ax.text(
+                0.5,
+                0.02,
+                "I",
+                horizontalalignment="center",
+                verticalalignment="bottom",
+                fontsize=20 * figsize,
+                color=textfontcolor,
+                transform=ax.transAxes,
+            )
+            ax.text(
+                0.98,
+                0.5,
+                "L",
+                horizontalalignment="right",
+                verticalalignment="center",
+                fontsize=20 * figsize,
+                color=textfontcolor,
+                transform=ax.transAxes,
+            )
+            ax.text(
+                0.02,
+                0.5,
+                "R",
+                horizontalalignment="left",
+                verticalalignment="center",
+                fontsize=20 * figsize,
+                color=textfontcolor,
+                transform=ax.transAxes,
+            )
+        ax.axis("off")
+
+        xy_slice = reorient_slice(image[:, :, xyz[2]], 2)
+        if not flat:
+            ax = plt.subplot(gs[1, 1])
+        else:
+            ax = plt.subplot(gs[0, 2])
+        im = ax.imshow(xy_slice, cmap=cmap, vmin=vmin, vmax=vmax)
+        if overlay is not None:
+            xy_overlay = reorient_slice(overlay[:, :, xyz[2]], 2)
+            im = ax.imshow(xy_overlay, alpha=overlay_alpha, cmap=overlay_cmap, vmin=vminol, vmax=vmaxol)
+
+        if xyz_lines:
+            # add lines
+            l = mlines.Line2D(
+                [xy_slice.shape[0] - xyz[0], xy_slice.shape[0] - xyz[0]],
+                [xyz_pad, xy_slice.shape[0] - xyz_pad],
+                color=xyz_color,
+                alpha=xyz_alpha,
+                linewidth=xyz_linewidth,
+            )
+            ax.add_line(l)
+            l = mlines.Line2D(
+                [xyz_pad, xy_slice.shape[1] - xyz_pad],
+                [xy_slice.shape[1] - xyz[1], xy_slice.shape[1] - xyz[1]],
+                color=xyz_color,
+                alpha=xyz_alpha,
+                linewidth=xyz_linewidth,
+            )
+            ax.add_line(l)
+        if orient_labels:
+            ax.text(
+                0.5,
+                0.98,
+                "A",
+                horizontalalignment="center",
+                verticalalignment="top",
+                fontsize=20 * figsize,
+                color=textfontcolor,
+                transform=ax.transAxes,
+            )
+            ax.text(
+                0.5,
+                0.02,
+                "P",
+                horizontalalignment="center",
+                verticalalignment="bottom",
+                fontsize=20 * figsize,
+                color=textfontcolor,
+                transform=ax.transAxes,
+            )
+            ax.text(
+                0.98,
+                0.5,
+                "L",
+                horizontalalignment="right",
+                verticalalignment="center",
+                fontsize=20 * figsize,
+                color=textfontcolor,
+                transform=ax.transAxes,
+            )
+            ax.text(
+                0.02,
+                0.5,
+                "R",
+                horizontalalignment="left",
+                verticalalignment="center",
+                fontsize=20 * figsize,
+                color=textfontcolor,
+                transform=ax.transAxes,
+            )
+        ax.axis("off")
+
+        if not flat:
+            # empty corner
+            ax = plt.subplot(gs[1, 0])
+            if text is not None:
+                # add text
+                left, width = 0.25, 0.5
+                bottom, height = 0.25, 0.5
+                right = left + width
+                top = bottom + height
+                ax.text(
+                    0.5 * (left + right) + text_dx,
+                    0.5 * (bottom + top) + text_dy,
+                    text,
+                    horizontalalignment="center",
+                    verticalalignment="center",
+                    fontsize=textfontsize,
+                    color=textfontcolor,
+                    transform=ax.transAxes,
+                )
+            # ax.text(0.5, 0.5)
+            ax.imshow(np.zeros(image.shape[:-1]), cmap="Greys_r")
+            ax.axis("off")
+
+        if cbar:
+            cbar_start = (1 - cbar_length) / 2
+            if cbar_vertical:
+                cax = fig.add_axes([0.9 + cbar_dx, cbar_start, 0.03, cbar_length])
+                cbar_orient = "vertical"
+            else:
+                cax = fig.add_axes([cbar_start, 0.08 + cbar_dx, cbar_length, 0.03])
+                cbar_orient = "horizontal"
+            fig.colorbar(im, cax=cax, orientation=cbar_orient)
+
+    ## multi-channel images ##
+    elif image.components > 1:
+        raise ValueError("Multi-channel images not currently supported!")
+
+    if filename is not None:
+        plt.savefig(filename, dpi=dpi, transparent=transparent)
+        plt.close(fig)
+    else:
+        plt.show()
+
+    # turn warnings back to default
+    warnings.simplefilter("default")
+

MindEyeV2/antspy/ants/plotting/plot_ortho_stack.py

@@ -0,0 +1,505 @@
+"""
+Functions for plotting ants images
+"""
+
+
+__all__ = [
+    "plot_ortho_stack"
+]
+
+import fnmatch
+import math
+import os
+import warnings
+
+from matplotlib import gridspec
+import matplotlib.pyplot as plt
+import matplotlib.patheffects as path_effects
+import matplotlib.lines as mlines
+import matplotlib.patches as patches
+import matplotlib.mlab as mlab
+import matplotlib.animation as animation
+from mpl_toolkits.axes_grid1.inset_locator import inset_axes
+
+
+import numpy as np
+import ants
+
+
+
+
+def plot_ortho_stack(
+    images,
+    overlays=None,
+    reorient=True,
+    # xyz arguments
+    xyz=None,
+    xyz_lines=False,
+    xyz_color="red",
+    xyz_alpha=0.6,
+    xyz_linewidth=2,
+    xyz_pad=5,
+    # base image arguments
+    cmap="Greys_r",
+    alpha=1,
+    # overlay arguments
+    overlay_cmap="jet",
+    overlay_alpha=0.9,
+    # background arguments
+    black_bg=True,
+    bg_thresh_quant=0.01,
+    bg_val_quant=0.99,
+    # scale/crop/domain arguments
+    crop=False,
+    scale=False,
+    domain_image_map=None,
+    # title arguments
+    title=None,
+    titlefontsize=24,
+    title_dx=0,
+    title_dy=0,
+    # 4th panel text arguemnts
+    text=None,
+    textfontsize=24,
+    textfontcolor="white",
+    text_dx=0,
+    text_dy=0,
+    # save & size arguments
+    filename=None,
+    dpi=500,
+    figsize=1.0,
+    colpad=0,
+    rowpad=0,
+    transpose=False,
+    transparent=True,
+    orient_labels=True,
+):
+    """
+    Create a stack of orthographic plots with optional overlays.
+
+    Use mask_image and/or threshold_image to preprocess images to be be
+    overlaid and display the overlays in a given range. See the wiki examples.
+
+    Example
+    -------
+    >>> import ants
+    >>> mni = ants.image_read(ants.get_data('mni'))
+    >>> ch2 = ants.image_read(ants.get_data('ch2'))
+    >>> ants.plot_ortho_stack([mni,mni,mni])
+    """
+
+    def mirror_matrix(x):
+        return x[::-1, :]
+
+    def rotate270_matrix(x):
+        return mirror_matrix(x.T)
+
+    def reorient_slice(x, axis):
+        return rotate270_matrix(x)
+
+    # need this hack because of a weird NaN warning from matplotlib with overlays
+    warnings.simplefilter("ignore")
+
+    n_images = len(images)
+
+    # handle `image` argument
+    for i in range(n_images):
+        if isinstance(images[i], str):
+            images[i] = ants.image_read(images[i])
+        if not ants.is_image(images[i]):
+            raise ValueError("image argument must be an ANTsImage")
+        if images[i].dimension != 3:
+            raise ValueError("Input image must have 3 dimensions!")
+
+    if overlays is None:
+        overlays = [None] * n_images
+    # handle `overlay` argument
+    for i in range(n_images):
+        if overlays[i] is not None:
+            if isinstance(overlays[i], str):
+                overlays[i] = ants.image_read(overlays[i])
+            if not ants.is_image(overlays[i]):
+                raise ValueError("overlay argument must be an ANTsImage")
+            if overlays[i].components > 1:
+                raise ValueError("overlays[i] cannot have more than one voxel component")
+            if overlays[i].dimension != 3:
+                raise ValueError("Overlay image must have 3 dimensions!")
+
+            if not ants.image_physical_space_consistency(images[i], overlays[i]):
+                overlays[i] = ants.resample_image_to_target(
+                    overlays[i], images[i], interp_type="linear"
+                )
+
+    for i in range(1, n_images):
+        if not ants.image_physical_space_consistency(images[0], images[i]):
+            images[i] = ants.resample_image_to_target(
+                images[0], images[i], interp_type="linear"
+            )
+
+    # reorient images
+    if reorient != False:
+        if reorient == True:
+            reorient = "RPI"
+
+        for i in range(n_images):
+            images[i] = images[i].reorient_image2(reorient)
+
+        if overlays[i] is not None:
+            overlays[i] = overlays[i].reorient_image2(reorient)
+
+    # handle `slices` argument
+    if xyz is None:
+        xyz = [int(s / 2) for s in images[0].shape]
+    for i in range(3):
+        if xyz[i] is None:
+            xyz[i] = int(images[0].shape[i] / 2)
+
+    # resample image if spacing is very unbalanced
+    spacing = [s for i, s in enumerate(images[0].spacing)]
+    if (max(spacing) / min(spacing)) > 3.0:
+        new_spacing = (1, 1, 1)
+        for i in range(n_images):
+            images[i] = images[i].resample_image(tuple(new_spacing))
+        if overlays[i] is not None:
+            overlays[i] = overlays[i].resample_image(tuple(new_spacing))
+        xyz = [
+            int(sl * (sold / snew)) for sl, sold, snew in zip(xyz, spacing, new_spacing)
+        ]
+
+    # potentially crop image
+    if crop:
+        for i in range(n_images):
+            plotmask = images[i].get_mask(cleanup=0)
+            if plotmask.max() == 0:
+                plotmask += 1
+            images[i] = images[i].crop_image(plotmask)
+            if overlays[i] is not None:
+                overlays[i] = overlays[i].crop_image(plotmask)
+
+    # pad images
+    for i in range(n_images):
+        if i == 0:
+            images[i], lowpad, uppad = images[i].pad_image(return_padvals=True)
+        else:
+            images[i] = images[i].pad_image()
+        if overlays[i] is not None:
+            overlays[i] = overlays[i].pad_image()
+    xyz = [v + l for v, l in zip(xyz, lowpad)]
+
+    # handle `domain_image_map` argument
+    if domain_image_map is not None:
+        if ants.is_image(domain_image_map):
+            tx = ants.new_ants_transform(
+                precision="float", transform_type="AffineTransform", dimension=3
+            )
+            for i in range(n_images):
+                images[i] = ants.apply_ants_transform_to_image(
+                    tx, images[i], domain_image_map
+                )
+
+                if overlays[i] is not None:
+                    overlays[i] = ants.apply_ants_transform_to_image(
+                        tx, overlays[i], domain_image_map, interpolation="linear"
+                    )
+        else:
+            raise Exception('The domain_image_map must be an ants image.')
+
+    # potentially find dynamic range
+    if scale == True:
+        vmins = []
+        vmaxs = []
+        for i in range(n_images):
+            vmin, vmax = images[i].quantile((0.05, 0.95))
+            vmins.append(vmin)
+            vmaxs.append(vmax)
+    elif isinstance(scale, (list, tuple)):
+        if len(scale) != 2:
+            raise ValueError(
+                "scale argument must be boolean or list/tuple with two values"
+            )
+        vmins = []
+        vmaxs = []
+        for i in range(n_images):
+            vmin, vmax = images[i].quantile(scale)
+            vmins.append(vmin)
+            vmaxs.append(vmax)
+    else:
+        vmin = None
+        vmax = None
+
+    if not transpose:
+        nrow = n_images
+        ncol = 3
+    else:
+        nrow = 3
+        ncol = n_images
+
+    fig = plt.figure(figsize=((ncol + 1) * 2.5 * figsize, (nrow + 1) * 2.5 * figsize))
+    if title is not None:
+        basey = 0.93
+        basex = 0.5
+        fig.suptitle(
+            title, fontsize=titlefontsize, color=textfontcolor, x=basex + title_dx, y=basey + title_dy
+        )
+
+    if (colpad > 0) and (rowpad > 0):
+        bothgridpad = max(colpad, rowpad)
+        colpad = 0
+        rowpad = 0
+    else:
+        bothgridpad = 0.0
+
+    gs = gridspec.GridSpec(
+        nrow,
+        ncol,
+        wspace=bothgridpad,
+        hspace=0.0,
+        top=1.0 - 0.5 / (nrow + 1),
+        bottom=0.5 / (nrow + 1) + colpad,
+        left=0.5 / (ncol + 1) + rowpad,
+        right=1 - 0.5 / (ncol + 1),
+    )
+
+    # pad image to have isotropic array dimensions
+    vminols=[]
+    vmaxols=[]
+    for i in range(n_images):
+        images[i] = images[i].numpy()
+        if overlays[i] is not None:
+            vminols.append( overlays[i].min() )
+            vmaxols.append( overlays[i].max() )
+            overlays[i] = overlays[i].numpy()
+            if overlays[i].dtype not in ["uint8", "uint32"]:
+                overlays[i][np.abs(overlays[i]) == 0] = np.nan
+
+    ####################
+    ####################
+    for i in range(n_images):
+        yz_slice = reorient_slice(images[i][xyz[0], :, :], 0)
+        if not transpose:
+            ax = plt.subplot(gs[i, 0])
+        else:
+            ax = plt.subplot(gs[0, i])
+        ax.imshow(yz_slice, cmap=cmap, vmin=vmin, vmax=vmax)
+        if overlays[i] is not None:
+            yz_overlay = reorient_slice(overlays[i][xyz[0], :, :], 0)
+            ax.imshow(yz_overlay, alpha=overlay_alpha, cmap=overlay_cmap,
+                vmin=vminols[i], vmax=vmaxols[i])
+        if xyz_lines:
+            # add lines
+            l = mlines.Line2D(
+                [yz_slice.shape[0] - xyz[1], yz_slice.shape[0] - xyz[1]],
+                [xyz_pad, yz_slice.shape[0] - xyz_pad],
+                color=xyz_color,
+                alpha=xyz_alpha,
+                linewidth=xyz_linewidth,
+            )
+            ax.add_line(l)
+            l = mlines.Line2D(
+                [xyz_pad, yz_slice.shape[1] - xyz_pad],
+                [yz_slice.shape[1] - xyz[2], yz_slice.shape[1] - xyz[2]],
+                color=xyz_color,
+                alpha=xyz_alpha,
+                linewidth=xyz_linewidth,
+            )
+            ax.add_line(l)
+        if orient_labels:
+            ax.text(
+                0.5,
+                0.98,
+                "S",
+                horizontalalignment="center",
+                verticalalignment="top",
+                fontsize=20 * figsize,
+                color=textfontcolor,
+                transform=ax.transAxes,
+            )
+            ax.text(
+                0.5,
+                0.02,
+                "I",
+                horizontalalignment="center",
+                verticalalignment="bottom",
+                fontsize=20 * figsize,
+                color=textfontcolor,
+                transform=ax.transAxes,
+            )
+            ax.text(
+                0.98,
+                0.5,
+                "A",
+                horizontalalignment="right",
+                verticalalignment="center",
+                fontsize=20 * figsize,
+                color=textfontcolor,
+                transform=ax.transAxes,
+            )
+            ax.text(
+                0.02,
+                0.5,
+                "P",
+                horizontalalignment="left",
+                verticalalignment="center",
+                fontsize=20 * figsize,
+                color=textfontcolor,
+                transform=ax.transAxes,
+            )
+        ax.axis("off")
+        ####################
+        ####################
+
+        xz_slice = reorient_slice(images[i][:, xyz[1], :], 1)
+        if not transpose:
+            ax = plt.subplot(gs[i, 1])
+        else:
+            ax = plt.subplot(gs[1, i])
+        ax.imshow(xz_slice, cmap=cmap, vmin=vmin, vmax=vmax)
+        if overlays[i] is not None:
+            xz_overlay = reorient_slice(overlays[i][:, xyz[1], :], 1)
+            ax.imshow(xz_overlay, alpha=overlay_alpha, cmap=overlay_cmap,
+                vmin=vminols[i], vmax=vmaxols[i])
+        if xyz_lines:
+            # add lines
+            l = mlines.Line2D(
+                [xz_slice.shape[0] - xyz[0], xz_slice.shape[0] - xyz[0]],
+                [xyz_pad, xz_slice.shape[0] - xyz_pad],
+                color=xyz_color,
+                alpha=xyz_alpha,
+                linewidth=xyz_linewidth,
+            )
+            ax.add_line(l)
+            l = mlines.Line2D(
+                [xyz_pad, xz_slice.shape[1] - xyz_pad],
+                [xz_slice.shape[1] - xyz[2], xz_slice.shape[1] - xyz[2]],
+                color=xyz_color,
+                alpha=xyz_alpha,
+                linewidth=xyz_linewidth,
+            )
+            ax.add_line(l)
+        if orient_labels:
+            ax.text(
+                0.5,
+                0.98,
+                "I",
+                horizontalalignment="center",
+                verticalalignment="top",
+                fontsize=20 * figsize,
+                color=textfontcolor,
+                transform=ax.transAxes,
+            )
+            ax.text(
+                0.5,
+                0.02,
+                "S",
+                horizontalalignment="center",
+                verticalalignment="bottom",
+                fontsize=20 * figsize,
+                color=textfontcolor,
+                transform=ax.transAxes,
+            )
+            ax.text(
+                0.98,
+                0.5,
+                "L",
+                horizontalalignment="right",
+                verticalalignment="center",
+                fontsize=20 * figsize,
+                color=textfontcolor,
+                transform=ax.transAxes,
+            )
+            ax.text(
+                0.02,
+                0.5,
+                "R",
+                horizontalalignment="left",
+                verticalalignment="center",
+                fontsize=20 * figsize,
+                color=textfontcolor,
+                transform=ax.transAxes,
+            )
+        ax.axis("off")
+
+        ####################
+        ####################
+        xy_slice = reorient_slice(images[i][:, :, xyz[2]], 2)
+        if not transpose:
+            ax = plt.subplot(gs[i, 2])
+        else:
+            ax = plt.subplot(gs[2, i])
+        ax.imshow(xy_slice, cmap=cmap, vmin=vmin, vmax=vmax)
+        if overlays[i] is not None:
+            xy_overlay = reorient_slice(overlays[i][:, :, xyz[2]], 2)
+            ax.imshow(xy_overlay, alpha=overlay_alpha, cmap=overlay_cmap,
+                vmin=vminols[i], vmax=vmaxols[i])
+        if xyz_lines:
+            # add lines
+            l = mlines.Line2D(
+                [xy_slice.shape[0] - xyz[0], xy_slice.shape[0] - xyz[0]],
+                [xyz_pad, xy_slice.shape[0] - xyz_pad],
+                color=xyz_color,
+                alpha=xyz_alpha,
+                linewidth=xyz_linewidth,
+            )
+            ax.add_line(l)
+            l = mlines.Line2D(
+                [xyz_pad, xy_slice.shape[1] - xyz_pad],
+                [xy_slice.shape[1] - xyz[1], xy_slice.shape[1] - xyz[1]],
+                color=xyz_color,
+                alpha=xyz_alpha,
+                linewidth=xyz_linewidth,
+            )
+            ax.add_line(l)
+        if orient_labels:
+            ax.text(
+                0.5,
+                0.98,
+                "A",
+                horizontalalignment="center",
+                verticalalignment="top",
+                fontsize=20 * figsize,
+                color=textfontcolor,
+                transform=ax.transAxes,
+            )
+            ax.text(
+                0.5,
+                0.02,
+                "P",
+                horizontalalignment="center",
+                verticalalignment="bottom",
+                fontsize=20 * figsize,
+                color=textfontcolor,
+                transform=ax.transAxes,
+            )
+            ax.text(
+                0.98,
+                0.5,
+                "L",
+                horizontalalignment="right",
+                verticalalignment="center",
+                fontsize=20 * figsize,
+                color=textfontcolor,
+                transform=ax.transAxes,
+            )
+            ax.text(
+                0.02,
+                0.5,
+                "R",
+                horizontalalignment="left",
+                verticalalignment="center",
+                fontsize=20 * figsize,
+                color=textfontcolor,
+                transform=ax.transAxes,
+            )
+        ax.axis("off")
+
+    ####################
+    ####################
+
+    if filename is not None:
+        plt.savefig(filename, dpi=dpi, transparent=transparent)
+        plt.close(fig)
+    else:
+        plt.show()
+
+    # turn warnings back to default
+    warnings.simplefilter("default")

MindEyeV2/antspy/ants/utils/__init__.py

@@ -0,0 +1,15 @@
+from .channels import merge_channels, split_channels
+from .consistency import image_physical_space_consistency, allclose
+from .get_ants_data import get_ants_data, get_data
+from .matrix_image import (matrix_to_images,
+                           images_from_matrix,
+                           image_list_to_matrix,
+                           images_to_matrix,
+                           matrix_from_images,
+                           timeseries_to_matrix,
+                           matrix_to_timeseries)
+from .mni2tal import mni2tal
+from .ndimage_to_list import ndimage_to_list, list_to_ndimage
+from .nifti_to_ants import nifti_to_ants
+from .scalar_rgb_vector import rgb_to_vector, vector_to_rgb, scalar_to_rgb
+from .sitk_to_ants import from_sitk, to_sitk

MindEyeV2/antspy/ants/utils/channels.py

@@ -0,0 +1,95 @@
+
+ 
+
+__all__ = ['merge_channels',
+           'split_channels']
+
+
+
+
+import ants
+from ants.internal import get_lib_fn
+from ants.decorators import image_method
+
+
+def merge_channels(image_list, channels_first=False):
+    """
+    Merge channels of multiple scalar ANTsImage types into one 
+    multi-channel ANTsImage
+    
+    ANTsR function: `mergeChannels`
+
+    Arguments
+    ---------
+    image_list : list/tuple of ANTsImage types
+        scalar images to merge
+    
+    Returns
+    -------
+    ANTsImage
+
+    Example
+    -------
+    >>> import ants
+    >>> image = ants.image_read(ants.get_ants_data('r16'))
+    >>> image2 = ants.image_read(ants.get_ants_data('r16'))
+    >>> image3 = ants.merge_channels([image,image2])
+    >>> image3 = ants.merge_channels([image,image2], channels_first=True)
+    >>> image3.numpy()
+    >>> image3.components == 2
+    """
+    inpixeltype = image_list[0].pixeltype
+    dimension = image_list[0].dimension
+    components = len(image_list)
+
+    for image in image_list:
+        if not ants.is_image(image):
+            raise ValueError('list may only contain ANTsImage objects')
+        if image.pixeltype != inpixeltype:
+            raise ValueError('all images must have the same pixeltype')
+
+    libfn = get_lib_fn('mergeChannels')
+    image_ptr = libfn([image.pointer for image in image_list])
+    
+    image = ants.from_pointer(image_ptr)
+    image.channels_first = channels_first
+    return image
+
+@image_method
+def split_channels(image):
+    """
+    Split channels of a multi-channel ANTsImage into a collection
+    of scalar ANTsImage types
+    
+    Arguments
+    ---------
+    image : ANTsImage
+        multi-channel image to split
+
+    Returns
+    -------
+    list of ANTsImage types
+
+    Example
+    -------
+    >>> import ants
+    >>> image = ants.image_read(ants.get_ants_data('r16'), 'float')
+    >>> image2 = ants.image_read(ants.get_ants_data('r16'), 'float')
+    >>> imagemerge = ants.merge_channels([image,image2])
+    >>> imagemerge.components == 2
+    >>> images_unmerged = ants.split_channels(imagemerge)
+    >>> len(images_unmerged) == 2
+    >>> images_unmerged[0].components == 1
+    """
+    inpixeltype = image.pixeltype
+    dimension = image.dimension
+    components = 1
+
+    libfn = get_lib_fn('splitChannels')
+    itkimages = libfn(image.pointer)
+    antsimages = [ants.from_pointer(itkimage) for itkimage in itkimages]
+    return antsimages
+
+
+
+

MindEyeV2/antspy/ants/utils/consistency.py

@@ -0,0 +1,73 @@
+import numpy as np
+import ants
+from ants.decorators import image_method
+
+__all__ = ['image_physical_space_consistency',
+           'allclose']
+
+@image_method
+def image_physical_space_consistency(image1, image2, tolerance=1e-2, datatype=False):
+    """
+    Check if two or more ANTsImage objects occupy the same physical space
+
+    ANTsR function: `antsImagePhysicalSpaceConsistency`
+
+    Arguments
+    ---------
+    *images : ANTsImages
+        images to compare
+
+    tolerance : float
+        tolerance when checking origin and spacing
+
+    data_type : boolean
+        If true, also check that the image data types are the same
+
+    Returns
+    -------
+    boolean
+        true if images share same physical space, false otherwise
+    """
+    images = [image1, image2]
+
+    img1 = images[0]
+    for img2 in images[1:]:
+        if (not ants.is_image(img1)) or (not ants.is_image(img2)):
+            raise ValueError('Both images must be of class `AntsImage`')
+
+        # image dimension check
+        if img1.dimension != img2.dimension:
+            return False
+
+        # image spacing check
+        space_diffs = sum([abs(s1-s2)>tolerance for s1, s2 in zip(img1.spacing, img2.spacing)])
+        if space_diffs > 0:
+            return False
+
+        # image origin check
+        origin_diffs = sum([abs(s1-s2)>tolerance for s1, s2 in zip(img1.origin, img2.origin)])
+        if origin_diffs > 0:
+            return False
+
+        # image direction check
+        origin_diff = np.allclose(img1.direction, img2.direction, atol=tolerance)
+        if not origin_diff:
+            return False
+
+        # data type
+        if datatype == True:
+            if img1.pixeltype != img2.pixeltype:
+                return False
+
+            if img1.components != img2.components:
+                return False
+
+    return True
+
+
+@image_method
+def allclose(image1, image2):
+    """
+    Check if two images have the same array values
+    """
+    return np.allclose(image1.numpy(), image2.numpy())

MindEyeV2/antspy/ants/utils/get_ants_data.py

@@ -0,0 +1,108 @@
+"""
+Get local ANTsPy data
+"""
+
+__all__ = ['get_ants_data',
+           'get_data']
+
+import os
+import requests
+import tempfile
+
+def get_data(file_id=None, target_file_name=None, antsx_cache_directory=None):
+    """
+    Get ANTsPy test data file
+
+    ANTsR function: `getANTsRData`
+
+    Arguments
+    ---------
+    name : string
+        name of test image tag to retrieve
+        Options:
+            - 'r16'
+            - 'r27'
+            - 'r30'
+            - 'r62'
+            - 'r64'
+            - 'r85'
+            - 'ch2'
+            - 'mni'
+            - 'surf'
+            - 'pcasl'
+    Returns
+    -------
+    string
+        filepath of test image
+
+    Example
+    -------
+    >>> import ants
+    >>> mnipath = ants.get_ants_data('mni')
+    """
+
+    def switch_data(argument):
+        switcher = {
+            "r16": "https://ndownloader.figshare.com/files/28726512",
+            "r27": "https://ndownloader.figshare.com/files/28726515",
+            "r30": "https://ndownloader.figshare.com/files/28726518",
+            "r62": "https://ndownloader.figshare.com/files/28726521",
+            "r64": "https://ndownloader.figshare.com/files/28726524",
+            "r85": "https://ndownloader.figshare.com/files/28726527",
+            "ch2": "https://ndownloader.figshare.com/files/28726494",
+            "mni": "https://ndownloader.figshare.com/files/28726500",
+            "surf": "https://ndownloader.figshare.com/files/28726530",
+            "pcasl": "http://files.figshare.com/1862041/101_pcasl.nii.gz",
+        }
+        return(switcher.get(argument, "Invalid argument."))
+
+    if antsx_cache_directory is None:
+        antsx_cache_directory = os.path.expanduser('~/.antspy/')
+    os.makedirs(antsx_cache_directory, exist_ok=True)
+
+    if os.path.isdir(antsx_cache_directory) == False:
+        antsx_cache_directory = tempfile.TemporaryDirectory()
+
+    valid_list = ("r16",
+                  "r27",
+                  "r30",
+                  "r62",
+                  "r64",
+                  "r85",
+                  "ch2",
+                  "mni",
+                  "surf",
+                  "pcasl",
+                  "show")
+
+    if file_id == "show" or file_id is None:
+       return(valid_list)
+
+    url = switch_data(file_id)
+
+    if target_file_name == None:
+        if file_id == "pcasl":
+            target_file_name = antsx_cache_directory + "pcasl.nii.gz"
+        else:
+            extension = ".jpg"
+            if file_id == "ch2" or file_id == "mni" or file_id == "surf":
+                extension = ".nii.gz"
+            if extension == ".jpg":
+                target_file_name = antsx_cache_directory + file_id + "slice" + extension
+            else:
+                target_file_name = antsx_cache_directory + file_id + extension
+
+    target_file_name_path = target_file_name
+    if target_file_name == None:
+        target_file = tempfile.NamedTemporaryFile(prefix=target_file_name, dir=antsx_cache_directory)
+        target_file_name_path = target_file.name
+        target_file.close()
+
+    if not os.path.exists(target_file_name_path):
+        r = requests.get(url)
+        with open(target_file_name_path, 'wb') as f:
+            f.write(r.content)
+
+    return(target_file_name_path)
+
+get_ants_data = get_data

MindEyeV2/antspy/ants/utils/matrix_image.py

@@ -0,0 +1,202 @@
+
+__all__ = [
+    "matrix_to_images",
+    "images_from_matrix",
+    "image_list_to_matrix",
+    "images_to_matrix",
+    "matrix_from_images",
+    "timeseries_to_matrix",
+    "matrix_to_timeseries"
+]
+
+import os
+import json
+import numpy as np
+import warnings
+
+import ants
+from ants.decorators import image_method
+
+@image_method
+def matrix_to_timeseries(image, matrix, mask=None):
+    """
+    converts a matrix to a ND image.
+
+    ANTsR function: `matrix2timeseries`
+
+    Arguments
+    ---------
+
+    image: reference ND image
+
+    matrix: matrix to convert to image
+
+    mask: mask image defining voxels of interest
+
+
+    Returns
+    -------
+    ANTsImage
+
+    Example
+    -------
+    >>> import ants
+    >>> img = ants.make_image( (10,10,10,5 ) )
+    >>> mask = ants.ndimage_to_list( img )[0] * 0
+    >>> mask[ 4:8, 4:8, 4:8 ] = 1
+    >>> mat = ants.timeseries_to_matrix( img, mask = mask )
+    >>> img2 = ants.matrix_to_timeseries( img,  mat, mask)
+    """
+
+    if mask is None:
+        mask = temp[0] * 0 + 1
+    temp = matrix_to_images(matrix, mask)
+    newImage = ants.list_to_ndimage(image, temp)
+    ants.copy_image_info(image, newImage)
+    return newImage
+
+
+def matrix_to_images(data_matrix, mask):
+    """
+    Unmasks rows of a matrix and writes as images
+
+    ANTsR function: `matrixToImages`
+
+    Arguments
+    ---------
+    data_matrix : numpy.ndarray
+        each row corresponds to an image
+        array should have number of columns equal to non-zero voxels in the mask
+
+    mask : ANTsImage
+        image containing a binary mask. Rows of the matrix are
+        unmasked and written as images. The mask defines the output image space
+
+    Returns
+    -------
+    list of ANTsImage types
+
+    Example
+    -------
+    >>> import ants
+    >>> img = ants.image_read(ants.get_ants_data('r16'))
+    >>> msk = ants.get_mask( img )
+    >>> img2 = ants.image_read(ants.get_ants_data('r16'))
+    >>> img3 = ants.image_read(ants.get_ants_data('r16'))
+    >>> mat = ants.image_list_to_matrix([img,img2,img3], msk )
+    >>> ilist = ants.matrix_to_images( mat, msk )
+    """
+
+    if data_matrix.ndim > 2:
+        data_matrix = data_matrix.reshape(data_matrix.shape[0], -1)
+
+    numimages = len(data_matrix)
+    numVoxelsInMatrix = data_matrix.shape[1]
+    numVoxelsInMask = (mask >= 0.5).sum()
+    if numVoxelsInMask != numVoxelsInMatrix:
+        raise ValueError(
+            "Num masked voxels %i must match data matrix %i"
+            % (numVoxelsInMask, numVoxelsInMatrix)
+        )
+
+    imagelist = []
+    for i in range(numimages):
+        img = mask.clone()
+        img[mask >= 0.5] = data_matrix[i, :]
+        imagelist.append(img)
+    return imagelist
+
+
+images_from_matrix = matrix_to_images
+
+
+def images_to_matrix(image_list, mask=None, sigma=None, epsilon=0.5):
+    """
+    Read images into rows of a matrix, given a mask - much faster for
+    large datasets as it is based on C++ implementations.
+
+    ANTsR function: `imagesToMatrix`
+
+    Arguments
+    ---------
+    image_list : list of ANTsImage types
+        images to convert to ndarray
+
+    mask : ANTsImage (optional)
+        Mask image, voxels in the mask (>= epsilon) are placed in the matrix. If None,
+        the first image in image_list is thresholded at its mean value to create a mask.
+
+    sigma : scaler (optional)
+        smoothing factor
+
+    epsilon : scalar
+        threshold for mask, values >= epsilon are included in the mask.
+
+    Returns
+    -------
+    ndarray
+        array with a row for each image
+        shape = (N_IMAGES, N_VOXELS)
+
+    Example
+    -------
+    >>> import ants
+    >>> img = ants.image_read(ants.get_ants_data('r16'))
+    >>> img2 = ants.image_read(ants.get_ants_data('r16'))
+    >>> img3 = ants.image_read(ants.get_ants_data('r16'))
+    >>> mat = ants.image_list_to_matrix([img,img2,img3])
+    """
+    if mask is None:
+        mask = ants.get_mask(image_list[0])
+
+    num_images = len(image_list)
+    mask_thresh = mask.clone() >= epsilon
+    mask_arr = mask.numpy() >= epsilon
+    num_voxels = np.sum(mask_arr)
+
+    data_matrix = np.empty((num_images, num_voxels))
+    do_smooth = sigma is not None
+    for i, img in enumerate(image_list):
+        if do_smooth:
+            img = ants.smooth_image(img, sigma, sigma_in_physical_coordinates=True)
+        if np.sum(np.array(img.shape) - np.array(mask_thresh.shape)) != 0:
+            img = ants.resample_image_to_target(img, mask_thresh, 2)
+        data_matrix[i, :] = img[mask_thresh]
+    return data_matrix
+
+
+image_list_to_matrix = images_to_matrix
+matrix_from_images = images_to_matrix
+
+@image_method
+def timeseries_to_matrix(image, mask=None):
+    """
+    Convert a timeseries image into a matrix.
+
+    ANTsR function: `timeseries2matrix`
+
+    Arguments
+    ---------
+    image : image whose slices we convert to a matrix. E.g. a 3D image of size
+           x by y by z will convert to a z by x*y sized matrix
+
+    mask : ANTsImage (optional)
+        image containing binary mask. voxels in the mask are placed in the matrix
+
+    Returns
+    -------
+    ndarray
+        array with a row for each image
+        shape = (N_IMAGES, N_VOXELS)
+
+    Example
+    -------
+    >>> import ants
+    >>> img = ants.make_image( (10,10,10,5 ) )
+    >>> mat = ants.timeseries_to_matrix( img )
+    """
+    temp = ants.ndimage_to_list(image)
+    if mask is None:
+        mask = temp[0] * 0 + 1
+    return image_list_to_matrix(temp, mask)
+

MindEyeV2/antspy/ants/utils/mni2tal.py

@@ -0,0 +1,59 @@
+
+__all__ = ['mni2tal']
+
+def mni2tal(xin):
+    """
+    mni2tal for converting from ch2/mni space to tal - very approximate.
+
+    This is a standard approach but it's not very accurate.
+
+    ANTsR function: `mni2tal`
+
+    Arguments
+    ---------
+    xin : tuple
+        point in mni152 space.
+
+    Returns
+    -------
+    tuple
+
+    Example
+    -------
+    >>> import ants
+    >>> ants.mni2tal( (10,12,14) )
+
+    References
+    ----------
+    http://bioimagesuite.yale.edu/mni2tal/501_95733_More\\%20Accurate\\%20Talairach\\%20Coordinates\\%20SLIDES.pdf
+    http://imaging.mrc-cbu.cam.ac.uk/imaging/MniTalairach
+    """
+    if (not isinstance(xin, (tuple,list))) or (len(xin) != 3):
+        raise ValueError('xin must be tuple/list with 3 coordinates')
+
+    x = list(xin)
+    # The input image is in RAS coordinates but we use ITK which returns LPS
+    # coordinates.  So we need to flip the coordinates such that L => R and P => A to
+    # get RAS (MNI) coordinates
+    x[0] = x[0] * (-1)  # flip X
+    x[1] = x[1] * (-1)  # flip Y
+    
+    xout = x
+    
+    if (x[2] >= 0):
+        xout[0] = x[0] * 0.99
+        xout[1] = x[1] * 0.9688 + 0.046 * x[2]
+        xout[2] = x[1] * (-0.0485) + 0.9189 * x[2]
+    
+    if (x[2] < 0):
+        xout[0] = x[0] * 0.99
+        xout[1] = x[1] * 0.9688 + 0.042 * x[2]
+        xout[2] = x[1] * (-0.0485) + 0.839 * x[2]
+    
+    return(xout)
+
+
+
+
+
+

MindEyeV2/antspy/ants/utils/ndimage_to_list.py

@@ -0,0 +1,111 @@
+__all__ = ['ndimage_to_list',
+           'list_to_ndimage']
+
+
+import numpy as np
+
+import ants
+from ants.decorators import image_method
+
+@image_method
+def list_to_ndimage( image, image_list ):
+    """
+    Merge list of multiple scalar ANTsImage types of dimension into one
+    ANTsImage of dimension plus one
+
+    ANTsR function: `mergeListToNDImage`
+
+    Arguments
+    ---------
+    image : target image space
+    image_list : list/tuple of ANTsImage types
+        scalar images to merge into target image space
+
+    Returns
+    -------
+    ANTsImage
+
+    Example
+    -------
+    >>> import ants
+    >>> image = ants.image_read(ants.get_ants_data('r16'))
+    >>> image2 = ants.image_read(ants.get_ants_data('r16'))
+    >>> imageTar = ants.make_image( ( *image2.shape, 2 ) )
+    >>> image3 = ants.list_to_ndimage( imageTar, [image,image2])
+    >>> image3.dimension == 3
+    """
+    inpixeltype = image_list[0].pixeltype
+    dimension = image_list[0].dimension
+    components = len(image_list)
+
+    for imageL in image_list:
+        if not ants.is_image(imageL):
+            raise ValueError('list may only contain ANTsImage objects')
+        if image.pixeltype != inpixeltype:
+            raise ValueError('all images must have the same pixeltype')
+
+    dimensionout = ( *image_list[0].shape, len( image_list )  )
+    newImage = ants.make_image(
+      dimensionout,
+      spacing = ants.get_spacing( image ),
+      origin = ants.get_origin( image ),
+      direction = ants.get_direction( image ),
+      pixeltype = inpixeltype
+      )
+    # FIXME - should implement paste image filter from ITK
+    for x in range( len( image_list ) ):
+        if dimension == 2:
+            newImage[:,:,x] = image_list[x][:,:]
+        if dimension == 3:
+            newImage[:,:,:,x] = image_list[x][:,:,:]
+    return newImage
+
+
+@image_method
+def ndimage_to_list(image):
+    """
+    Split a n dimensional ANTsImage into a list
+    of n-1 dimensional ANTsImages
+
+    Arguments
+    ---------
+    image : ANTsImage
+        n-dimensional image to split
+
+    Returns
+    -------
+    list of ANTsImage types
+
+    Example
+    -------
+    >>> import ants
+    >>> image = ants.image_read(ants.get_ants_data('r16'))
+    >>> image2 = ants.image_read(ants.get_ants_data('r16'))
+    >>> imageTar = ants.make_image( ( *image2.shape, 2 ) )
+    >>> image3 = ants.list_to_ndimage( imageTar, [image,image2])
+    >>> image3.dimension == 3
+    >>> images_unmerged = ants.ndimage_to_list( image3 )
+    >>> len(images_unmerged) == 2
+    >>> images_unmerged[0].dimension == 2
+    """
+    inpixeltype = image.pixeltype
+    dimension = image.dimension
+    components = 1
+    imageShape = image.shape
+    nSections = imageShape[ dimension - 1 ]
+    subdimension = dimension - 1
+    suborigin = ants.get_origin( image )[0:subdimension]
+    subspacing = ants.get_spacing( image )[0:subdimension]
+    subdirection = np.eye( subdimension )
+    for i in range( subdimension ):
+        subdirection[i,:] = ants.get_direction( image )[i,0:subdimension]
+    subdim = image.shape[ 0:subdimension ]
+    imagelist = []
+    for i in range( nSections ):
+        img = ants.slice_image( image, axis = subdimension, idx = i )
+        ants.set_spacing( img, subspacing )
+        ants.set_origin( img, suborigin )
+        ants.set_direction( img, subdirection )
+        imagelist.append( img )
+
+    return imagelist

MindEyeV2/antspy/ants/utils/nifti_to_ants.py

@@ -0,0 +1,39 @@
+__all__ = ["nifti_to_ants"]
+
+import numpy as np
+import ants
+
+def nifti_to_ants( nib_image ):
+    """
+    Converts a given Nifti image into an ANTsPy image
+
+    Parameters
+    ----------
+        img: NiftiImage
+
+    Returns
+    -------
+        ants_image: ANTsImage
+    """
+    ndim = nib_image.ndim
+
+    if ndim < 3:
+        print("Dimensionality is less than 3.")
+        return None
+
+    q_form = nib_image.get_qform()
+    spacing = nib_image.header["pixdim"][1 : ndim + 1]
+
+    origin = np.zeros((ndim))
+    origin[:3] = q_form[:3, 3]
+
+    direction = np.diag(np.ones(ndim))
+    direction[:3, :3] = q_form[:3, :3] / spacing[:3]
+
+    ants_img = ants.from_numpy(
+        data = nib_image.get_data().astype( np.float ),
+        origin = origin.tolist(),
+        spacing = spacing.tolist(),
+        direction = direction )
+    
+    return ants_img

MindEyeV2/antspy/ants/utils/scalar_rgb_vector.py

@@ -0,0 +1,92 @@
+
+
+__all__ = ['rgb_to_vector', 
+           'vector_to_rgb', 
+           'scalar_to_rgb']
+
+import os
+from tempfile import mktemp
+
+import numpy as np
+
+import ants
+from ants.internal import get_lib_fn, process_arguments
+from ants.decorators import image_method
+
+def scalar_to_rgb(image, mask=None, filename=None, cmap='red', custom_colormap_file=None, 
+                  min_input=None, max_input=None, min_rgb_output=None, max_rgb_output=None,
+                  vtk_lookup_table=None):
+    """
+    Usage: ConvertScalarImageToRGB imageDimension inputImage outputImage mask colormap 
+    [customColormapFile] [minimumInput] [maximumInput] [minimumRGBOutput=0] 
+    [maximumRGBOutput=255] <vtkLookupTable>
+    Possible colormaps: grey, red, green, blue, copper, jet, hsv, spring, summer, autumn, winter, hot, cool, overunder, custom
+    
+    Example
+    -------
+    >>> import ants
+    >>> img = ants.image_read(ants.get_data('r16'))
+    >>> img_color = ants.scalar_to_rgb(img, cmap='jet')
+    """
+    raise Exception('This function is currently not supported.')
+
+@image_method
+def rgb_to_vector(image):
+    """
+    Convert an RGB ANTsImage to a Vector ANTsImage
+
+    Arguments
+    ---------
+    image : ANTsImage
+        RGB image to be converted
+
+    Returns
+    -------
+    ANTsImage
+
+    Example
+    -------
+    >>> import ants
+    >>> mni = ants.image_read(ants.get_data('mni'))
+    >>> mni_rgb = ants.scalar_to_rgb(mni)
+    >>> mni_vector = mni.rgb_to_vector()
+    >>> mni_rgb2 = mni.vector_to_rgb()
+    """
+    if image.pixeltype != 'unsigned char':
+        image = image.clone('unsigned char')
+    idim = image.dimension
+    libfn = get_lib_fn('RgbToVector%i' % idim)
+    new_ptr = libfn(image.pointer)
+    new_img = ants.from_pointer(new_ptr)
+    return new_img
+
+@image_method
+def vector_to_rgb(image):
+    """
+    Convert an Vector ANTsImage to a RGB ANTsImage
+
+    Arguments
+    ---------
+    image : ANTsImage
+        RGB image to be converted
+
+    Returns
+    -------
+    ANTsImage
+
+    Example
+    -------
+    >>> import ants
+    >>> img = ants.image_read(ants.get_data('r16'), pixeltype='unsigned char')
+    >>> img_rgb = ants.scalar_to_rgb(img.clone())
+    >>> img_vec = img_rgb.rgb_to_vector()
+    >>> img_rgb2 = img_vec.vector_to_rgb()
+    """
+    if image.pixeltype != 'unsigned char':
+        image = image.clone('unsigned char')
+    idim = image.dimension
+    libfn = get_lib_fn('VectorToRgb%i' % idim)
+    new_ptr = libfn(image.pointer)
+    new_img = ants.from_pointer(new_ptr)
+    return new_img
+

MindEyeV2/antspy/ants/utils/sitk_to_ants.py

@@ -0,0 +1,63 @@
+import numpy as np
+import ants
+
+
+def from_sitk(sitk_image: "SimpleITK.Image") -> ants.ANTsImage:
+    """
+    Converts a given SimpleITK image into an ANTsPy image
+
+    Parameters
+    ----------
+        img: SimpleITK.Image
+
+    Returns
+    -------
+        ants_image: ANTsImage
+    """
+    import SimpleITK as sitk
+
+    ndim = sitk_image.GetDimension()
+
+    if ndim < 3:
+        print("Dimensionality is less than 3.")
+        return None
+
+    direction = np.asarray(sitk_image.GetDirection()).reshape((3, 3))
+    spacing = list(sitk_image.GetSpacing())
+    origin = list(sitk_image.GetOrigin())
+
+    data = sitk.GetArrayViewFromImage(sitk_image)
+
+    ants_img: ants.ANTsImage = ants.from_numpy(
+        data=data.ravel(order="F").reshape(data.shape[::-1]),
+        origin=origin,
+        spacing=spacing,
+        direction=direction,
+    )
+
+    return ants_img
+
+
+def to_sitk(ants_image: ants.ANTsImage) -> "SimpleITK.Image":
+    """
+    Converts a given ANTsPy image into an SimpleITK image
+
+    Parameters
+    ----------
+        ants_image: ANTsImage
+
+    Returns
+    -------
+        img: SimpleITK.Image
+    """
+
+    import SimpleITK as sitk
+
+    data = ants_image.view()
+    shape = ants_image.shape
+
+    sitk_img = sitk.GetImageFromArray(data.ravel(order="F").reshape(shape[::-1]))
+    sitk_img.SetOrigin(ants_image.origin)
+    sitk_img.SetSpacing(ants_image.spacing)
+    sitk_img.SetDirection(ants_image.direction.flatten())
+    return sitk_img

MindEyeV2/antspy/docs/Makefile

@@ -0,0 +1,27 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line.
+SPHINXOPTS    =
+SPHINXBUILD   = sphinx-build
+SPHINXPROJ    = ANTsPy
+SOURCEDIR     = source
+BUILDDIR      = build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+docset: html
+	doc2dash --name $(SPHINXPROJ) --icon $(SOURCEDIR)/_static/img/antspy-logo-icon.png --enable-js --online-redirect-url http://ncullen.github.io/docs/ --force $(BUILDDIR)/html/
+
+	# Manually fix because Zeal doesn't deal well with `icon.png`-only at 2x resolution.
+	cp $(SPHINXPROJ).docset/icon.png $(SPHINXPROJ).docset/icon@2x.png
+	convert $(SPHINXPROJ).docset/icon@2x.png -resize 16x16 $(SPHINXPROJ).docset/icon.png
+
+.PHONY: help Makefile docset
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

MindEyeV2/antspy/docs/make.bat

@@ -0,0 +1,36 @@
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=source
+set BUILDDIR=build
+set SPHINXPROJ=ANTsPy
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.http://sphinx-doc.org/
+	exit /b 1
+)
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
+
+:end
+popd

MindEyeV2/antspy/docs/other/ANTsR_Comparison.md

@@ -0,0 +1,16 @@
+
+```R
+library(ANTsR)
+img <- antsImageRead( getANTsRData("r16") , 2 )
+img <- resampleImage( img, c(64,64), 1, 0 )
+mask <- getMask(img)
+segs1 <- atropos( a = img, m = '[0.2,1x1]', c = '[2,0]',  i = 'kmeans[3]', x = mask )
+```
+
+```python     
+import ants
+img = ants.image_read(ants.get_ants_data('r16'))
+img = ants.resample_image(img, (64,64), 1, 0)
+mask = ants.get_mask(img)
+ants.atropos(a = img, m = '[0.2,1x1]', c = '[2,0]',  i = 'kmeans[3]', x = mask )
+```

MindEyeV2/antspy/docs/other/All_Functions.md

@@ -0,0 +1,180 @@
+
+ANTsR_Name ANTsPy_Name Description 
+abpN4 |  | 
+affineInitializer |  |   a multi-start optimizer for affine registration
+mean |  |,antsImage-method   arith.antsImage
+antsImageClone |  |  
+antsMotionCalculation |  |   Correct 4D time-series data for motion.
+antsRegistration |  |    
+antsImagePhysicalSpaceConsistency |  |   Check for physical space consistency
+antsImageRead |  |   
+antsrimpute |  | 
+antsImageHeaderInfo |  | Read file info from image header
+antsMotionCorr |  |  Motion Correction
+antsImageGetSet |  | antsImageGetSet
+antsImageMutualInformation |  |  mutual information between two images
+antsImageWrite |  |  
+antsSetPixels |  |   Set a pixel value at an index
+aslDenoiseR |  | 
+aslPerfusion |  |    
+antsTransformIndexToPhysicalPoint |  |   Get Spatial Point from Index
+as.antsImage  |  |
+antsTransformPhysicalPointToIndex |  |   Get Index from Spatial Point
+antsSpatialICAfMRI |  |  
+aslOutlierRejection |  | Pair-wise subtraction based outlier rejection.
+atropos |  | FMM Segmentation
+as.antsMatrix |  |   as.antsMatrix
+combineNuisancePredictors |  |   Combine and reduce dimensionality of nuisance predictors.
+clusterTimeSeries |  |   Split time series image into k distinct images
+bigLMStats |  |  
+bayesianlm |  |  Simple bayesian regression function.
+computeDVARS |  |    computeDVARS
+compcor |  | 
+basicInPaint |  |    Inpaints missing imaging data from boundary data
+bayesianCBF |  | Uses probabilistic segmentation to constrain pcasl-based cbf computation.
+blockStimulus |  |   
+bold_correlation_matrix |  | bold_correlation_matrix
+crossvalidatedR2 |  |    Cross-Validated R^2 value
+createJacobianDeterminantImage |  |  createJacobianDeterminantImage
+DesikanKillianyTourville |  |    DesikanKillianyTourville
+eigSeg |  |  
+cropImage |  |   crop a sub-image via a mask
+cropIndices |  | crop a sub-image by image indices
+convolveImage |  |   convolve one image with another
+corw |  |    
+cvEigenanatomy |  |  
+decropImage |  | decrop a sub-image back into the full image
+getMask |  | 
+getfMRInuisanceVariables |  |    
+getNeighborhoodInMask |  |   Get neighborhoods for voxels within mask
+getPixels |  |   Get Pixels
+icawhiten |  |   
+image2ClusterImages |  | 
+imageFileNames2ImageList |  |    
+imageListToMatrix |  |   
+iMath |  |   iMath
+iMathOps |  |    iMathOps
+maskImage |  |   
+matrix2timeseries |  |   Simple matrix2timeseries function.
+getAverageOfTimeSeries |  |  
+getCentroids |  |    
+hemodynamicRF |  |   Linear Model for FMRI Data
+iBind |  |   iBind
+initializeEigenanatomy |  |  
+interleaveMatrixWithItself |  |  
+labelStats |  |  labelStats
+lappend |  | 
+makeGraph |  |   
+makeImage |  |   
+partialVolumeCorrection |  | 
+projectImageAlongAxis |  |   
+perfusionregression |  | 
+quantifyCBF |  | 
+sparseDecom |  | 
+sparseDecom2 |  |    
+usePkg |  |  Use any package. If package is not installed, this will install from CRAN.
+vwnrfs |  |  voxelwise neighborhood random forest segmentation and prediction
+antsApplyTransforms |  | 
+n4BiasFieldCorrection |  |   Bias Field Correction
+reorientImage |  |   reorient image by its principal axis
+renderSurfaceFunction |  |   
+rfSegmentationPredict |  |   
+subjectDataToGroupDataFrame |  | 
+timeseries2matrix |  |   
+rsfDenoise |  |  
+taskFMRI |  |    
+timeseriesN3 |  |    Run N3 on slices of timeseries.
+filterfMRIforNetworkAnalysis |  |    
+getNeighborhoodAtVoxel |  |  Get a hypercube neighborhood at a voxel
+imagesToMatrix |  |  
+getMultivariateTemplateCoordinates |  |  
+lowrankRowMatrix |  |    Produces a low rank version of the input matrix
+imageMath |  |   R access to the ANTs program ImageMath
+labelGeometryMeasures |  |   labelGeometryMeasures
+labelImageCentroids |  | labelImageCentroids
+frequencyFilterfMRI |  | 
+antsBOLDNetworkAnalysis |  | a basic framework for network analysis that produces graph metrics
+antsCopyImageInfo |  |   Copy header info
+getANTsRData |  |    getANTsRData
+plotBasicNetwork |  |    
+getASLNoisePredictors |  |   Get nuisance predictors from ASL images
+is.antsImage   |  |  is.antsImage
+joinEigenanatomy |  |    
+invariantImageSimilarity |  |    similarity metrics between two images as a function of geometry
+jointIntensityFusion |  |    joint intensity fusion
+aal |  | aal
+plot.antsImage |  | Plotting an image slice or multi-slice with optional color overlay.
+abpBrainExtraction |  |  
+getTemplateCoordinates |  |  
+extractSlice |  |    extract a slice from an image
+%>%  |  |  Pipe an object forward
+exemplarInpainting |  |  Uses example images to inpaint or approximate an existing image.
+quantifySNPs |  |    Simple quantifySNPs function.
+rapidlyInspectImageData |  | Simple rapidlyInspectImageData function.
+whiten |  |  
+temporalwhiten |  |  
+thresholdImage |  |  Threshold Image
+jointIntensityFusion3D |  |  jointIntensityFusion3D
+antsAverageImages |  |   Computes average of image list
+kellyKapowski |  |   Compute cortical thickness using the DiReCT algorithm.
+mrvnrfs  |  | multi-res voxelwise neighborhood random forest segmentation learning
+mrvnrfs.predict  |  |  multi-res voxelwise neighborhood random forest segmentation
+n3BiasFieldCorrection |  |   Bias Field Correction
+plotPrettyGraph |  | 
+preprocessfMRI |  |  Preprocess BOLD fMRI image data.
+reflectImage |  |    reflectImage
+sparseDecom2boot |  |    
+sparseDecomboot |  | 
+regressionNetworkViz |  |    
+timeserieswindow2matrix |  | 
+tracts |  |  tracts
+save.ANTsR  |  | save.ANTsR
+segmentShapeFromImage |  |   convolution-based shape identification
+kmeansSegmentation |  |  k means image segmentation.
+labelClusters |  |   
+matrixToImages |  |  
+networkEiganat |  |  
+mni2tal |  | 
+pairwiseImageDistanceMatrix |  | 
+regressProjections |  |  
+renderImageLabels |  |   
+sliceTimingCorrection |  |   slice timing correction for fMRI.
+sparseRegression |  |    
+smoothImage |  | Smooth image
+spatialbayesianlm |  |   spatially constrained bayesian regression function.
+make3ViewPNG |  |    
+resampleImage |  |   resampleImage
+rfSegmentation |  |  
+splitData |  |   
+subgradientL1Regression |  | 
+antsPreprocessfMRI |  |  
+as.matrix   |  | 
+as.numeric   |  |
+perfusion-predictors   |  |  
+getROIValues |  |    
+phantom_population_study |  |    
+fastwhiten |  |  
+Motion-Correction  |  |   
+sccan |  |   
+as.antsImage  |  |    
+as.array   |  |
+MeasureMinMaxMean |  |   
+plotANTsImage |  |   
+renderNetwork |  |   
+visualizeBlob |  |   
+inspectImageData3D |  |  
+antsImage-class  |  | 
+CBF |  | 
+simple_roi_analysis |  | 
+simple_voxel_based_analysis |  | 
+KellyKapowski |  |   
+Atropos |  | 
+Extract |  | 
+SmoothImage |  | 
+N3BiasFieldCorrection |  |   
+ImageMath |  |   
+Comparison |  |  
+ThresholdImage |  |  
+antsMatrix-class   |  |  An S4 class to hold an antsMatrix imported from ITK types
+antsRegion-class   |  |  An S4 class to hold a region of an antsImage
+%>%  |  | Pipe an object forward

MindEyeV2/antspy/docs/other/_config.yml

@@ -0,0 +1 @@
+theme: jekyll-theme-minimal

MindEyeV2/antspy/docs/requirements.txt

@@ -0,0 +1,2 @@
+sphinx
+-e git+https://github.com/snide/sphinx_rtd_theme.git#egg=sphinx_rtd_theme

MindEyeV2/antspy/docs/source/ants.core.rst

@@ -0,0 +1,62 @@
+ants.core package
+=================
+
+Submodules
+----------
+
+ants.core.ants\_image module
+----------------------------
+
+.. automodule:: ants.core.ants_image
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+ants.core.ants\_image\_io module
+--------------------------------
+
+.. automodule:: ants.core.ants_image_io
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+ants.core.ants\_metric module
+-----------------------------
+
+.. automodule:: ants.core.ants_metric
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+ants.core.ants\_metric\_io module
+---------------------------------
+
+.. automodule:: ants.core.ants_metric_io
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+ants.core.ants\_transform module
+--------------------------------
+
+.. automodule:: ants.core.ants_transform
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+ants.core.ants\_transform\_io module
+------------------------------------
+
+.. automodule:: ants.core.ants_transform_io
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+
+Module contents
+---------------
+
+.. automodule:: ants.core
+   :members:
+   :undoc-members:
+   :show-inheritance:

MindEyeV2/antspy/docs/source/ants.learn.rst

@@ -0,0 +1,22 @@
+ants.learn package
+==================
+
+Submodules
+----------
+
+ants.learn.decomposition module
+-------------------------------
+
+.. automodule:: ants.learn.decomposition
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+
+Module contents
+---------------
+
+.. automodule:: ants.learn
+   :members:
+   :undoc-members:
+   :show-inheritance:

MindEyeV2/antspy/docs/source/ants.lib.rst

@@ -0,0 +1,10 @@
+ants.lib package
+================
+
+Module contents
+---------------
+
+.. automodule:: ants.lib
+   :members:
+   :undoc-members:
+   :show-inheritance:

MindEyeV2/antspy/docs/source/ants.rst

@@ -0,0 +1,35 @@
+ants package
+============
+
+Subpackages
+-----------
+
+.. toctree::
+
+   ants.core
+   ants.learn
+   ants.lib
+   ants.registration
+   ants.segmentation
+   ants.utils
+   ants.viz
+
+Submodules
+----------
+
+ants.version module
+-------------------
+
+.. automodule:: ants.version
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+
+Module contents
+---------------
+
+.. automodule:: ants
+   :members:
+   :undoc-members:
+   :show-inheritance:

MindEyeV2/antspy/docs/source/ants.segmentation.rst

@@ -0,0 +1,78 @@
+ants.segmentation package
+=========================
+
+Submodules
+----------
+
+ants.segmentation.anti\_alias module
+------------------------------------
+
+.. automodule:: ants.segmentation.anti_alias
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+ants.segmentation.atropos module
+--------------------------------
+
+.. automodule:: ants.segmentation.atropos
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+ants.segmentation.joint\_label\_fusion module
+---------------------------------------------
+
+.. automodule:: ants.segmentation.joint_label_fusion
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+ants.segmentation.kelly\_kapowski module
+----------------------------------------
+
+.. automodule:: ants.segmentation.kelly_kapowski
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+ants.segmentation.kmeans module
+-------------------------------
+
+.. automodule:: ants.segmentation.kmeans
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+ants.segmentation.label\_geometry\_measures module
+--------------------------------------------------
+
+.. automodule:: ants.segmentation.label_geometry_measures
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+ants.segmentation.otsu module
+-----------------------------
+
+.. automodule:: ants.segmentation.otsu
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+ants.segmentation.prior\_based\_segmentation module
+---------------------------------------------------
+
+.. automodule:: ants.segmentation.prior_based_segmentation
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+
+Module contents
+---------------
+
+.. automodule:: ants.segmentation
+   :members:
+   :undoc-members:
+   :show-inheritance:

MindEyeV2/antspy/docs/source/conf.py

@@ -0,0 +1,233 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# ANTsPy documentation build configuration file, created by
+# sphinx-quickstart on Fri Dec 23 13:31:47 2016.
+#
+# This file is execfile()d with the current directory set to its
+# containing dir.
+#
+# Note that not all possible configuration values are present in this
+# autogenerated file.
+#
+# All configuration values have a default; values that are commented out
+# serve to show the default.
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+
+import os
+import sys
+import shutil
+
+on_rtd = os.environ.get('READTHEDOCS') == 'True'
+
+    # add package to local path
+sys.path.insert(0, os.path.abspath('../../'))
+autodoc_mock_imports = ['_tkinter', 'matplotlib']
+if on_rtd:
+    # replace lib __init__ with empty init file since RTD cant handle C++ extensions
+    os.makedirs('../../ants/lib', exist_ok=True)
+    shutil.copyfile('emptyinit.py', '../../ants/lib/__init__.py')
+
+import ants
+import numpy as np
+import sphinx_rtd_theme
+
+
+# -- General configuration ------------------------------------------------
+
+# If your documentation needs a minimal Sphinx version, state it here.
+#
+# needs_sphinx = '1.0'
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    'sphinx.ext.autodoc',
+    'sphinx.ext.autosummary',
+    'sphinx.ext.doctest',
+    'sphinx.ext.intersphinx',
+    'sphinx.ext.todo',
+    'sphinx.ext.coverage',
+    'sphinx.ext.mathjax',
+    'sphinx.ext.napoleon',
+    'sphinx.ext.viewcode',
+]
+
+napoleon_use_ivar = True
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# The suffix(es) of source filenames.
+# You can specify multiple suffix as a list of string:
+#
+# source_suffix = ['.rst', '.md']
+source_suffix = '.rst'
+
+# The master toctree document.
+master_doc = 'index'
+
+# General information about the project.
+project = 'ANTsPy'
+copyright = '2017, ANTs Contributors'
+author = 'ANTs Contributors'
+
+# The version info for the project you're documenting, acts as replacement for
+# |version| and |release|, also used in various other places throughout the
+# built documents.
+#
+# The short X.Y version.
+# TODO: change to [:2] at v1.0
+version = 'master (0.1.3)'
+# The full version, including alpha/beta/rc tags.
+# TODO: verify this works as expected
+release = 'master'
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#
+# This is also used if you do content translation via gettext catalogs.
+# Usually you set "language" from the command line for these cases.
+language = None
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This patterns also effect to html_static_path and html_extra_path
+exclude_patterns = []
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = 'sphinx'
+
+# If true, `todo` and `todoList` produce output, else they produce nothing.
+todo_include_todos = True
+
+
+# -- Options for HTML output ----------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+html_theme = 'alabaster'
+#html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
+
+# Theme options are theme-specific and customize the look and feel of a theme
+# further.  For a list of options available for each theme, see the
+# documentation.
+#
+#html_theme_options = {
+#    'collapse_navigation': False,
+#    'display_version': True,
+#    'logo_only': True,
+#}
+
+html_logo = '_static/img/antspy-logo.png'
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static']
+
+#html_style_path = '_static/css/ants_theme.css'
+#html_context = {
+#    'css_files': [
+#        'https://fonts.googleapis.com/css?family=Lato',
+#        '_static/css/ants_theme.css'
+#    ],
+#}
+
+
+# -- Options for HTMLHelp output ------------------------------------------
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = 'ANTsPydoc'
+
+
+# -- Options for LaTeX output ---------------------------------------------
+
+
+
+# -- Options for manual page output ---------------------------------------
+
+# One entry per manual page. List of tuples
+# (source start file, name, description, authors, manual section).
+man_pages = [
+    (master_doc, 'ANTsPy', 'ANTsPy Documentation',
+     [author], 1)
+]
+
+
+# -- Options for Texinfo output -------------------------------------------
+
+# Grouping the document tree into Texinfo files. List of tuples
+# (source start file, target name, title, author,
+#  dir menu entry, description, category)
+texinfo_documents = [
+    (master_doc, 'ANTsPy', 'ANTsPy Documentation',
+     author, 'ANTsPy', 'One line description of project.',
+     'Miscellaneous'),
+]
+
+
+# Example configuration for intersphinx: refer to the Python standard library.
+intersphinx_mapping = {
+    'python': ('https://docs.python.org/', None),
+    'numpy': ('http://docs.scipy.org/doc/numpy/', None),
+}
+
+# -- A patch that prevents Sphinx from cross-referencing ivar tags -------
+# See http://stackoverflow.com/a/41184353/3343043
+
+from docutils import nodes
+from sphinx.util.docfields import TypedField
+from sphinx import addnodes
+
+
+def patched_make_field(self, types, domain, items, **kw):
+    # `kw` catches `env=None` needed for newer sphinx while maingaining
+    #  backwards compatibility when passed along further down!
+
+    # type: (List, unicode, Tuple) -> nodes.field
+    def handle_item(fieldarg, content):
+        par = nodes.paragraph()
+        par += addnodes.literal_strong('', fieldarg)  # Patch: this line added
+        # par.extend(self.make_xrefs(self.rolename, domain, fieldarg,
+        #                           addnodes.literal_strong))
+        if fieldarg in types:
+            par += nodes.Text(' (')
+            # NOTE: using .pop() here to prevent a single type node to be
+            # inserted twice into the doctree, which leads to
+            # inconsistencies later when references are resolved
+            fieldtype = types.pop(fieldarg)
+            if len(fieldtype) == 1 and isinstance(fieldtype[0], nodes.Text):
+                typename = u''.join(n.astext() for n in fieldtype)
+                typename = typename.replace('int', 'python:int')
+                typename = typename.replace('long', 'python:long')
+                typename = typename.replace('float', 'python:float')
+                typename = typename.replace('type', 'python:type')
+                par.extend(self.make_xrefs(self.typerolename, domain, typename,
+                                           addnodes.literal_emphasis, **kw))
+            else:
+                par += fieldtype
+            par += nodes.Text(')')
+        par += nodes.Text(' -- ')
+        par += content
+        return par
+
+    fieldname = nodes.field_name('', self.label)
+    if len(items) == 1 and self.can_collapse:
+        fieldarg, content = items[0]
+        bodynode = handle_item(fieldarg, content)
+    else:
+        bodynode = self.list_type()
+        for fieldarg, content in items:
+            bodynode += nodes.list_item('', handle_item(fieldarg, content))
+    fieldbody = nodes.field_body('', bodynode)
+    return nodes.field('', fieldname, fieldbody)
+
+TypedField.make_field = patched_make_field
+

MindEyeV2/antspy/docs/source/core.rst

@@ -0,0 +1,57 @@
+Core
+===================================
+.. automodule:: ants
+
+Images
+----------------------------------
+
+ANTsImage
+~~~~~~~~~~~~~~~~~~~~~~
+.. autoclass:: ants.core.ants_image.ANTsImage
+   :members:
+
+ANTsImage IO
+~~~~~~~~~~~~~~~~~~~~~~
+.. autofunction:: image_clone
+.. autofunction:: image_header_info
+.. autofunction:: image_read
+.. autofunction:: image_write
+.. autofunction:: make_image
+.. autofunction:: from_numpy
+.. autofunction:: matrix_to_images
+.. autofunction:: images_from_matrix
+.. autofunction:: image_list_to_matrix
+.. autofunction:: images_to_matrix
+.. autofunction:: matrix_from_images
+
+Transforms
+----------------------------------
+
+ANTsTransform
+~~~~~~~~~~~~~~~~~~~~~~
+.. autoclass:: ants.core.ants_transform.ANTsTransform
+   :members:
+
+ANTsTransform IO
+~~~~~~~~~~~~~~~~~~~~~~
+.. autofunction:: create_ants_transform
+.. autofunction:: new_ants_transform
+.. autofunction:: read_transform
+.. autofunction:: write_transform
+.. autofunction:: transform_from_displacement_field
+
+Metrics
+----------------------------------
+
+ANTsMetric
+~~~~~~~~~~~~~~~~~~~~~~
+.. autoclass:: ants.core.ants_metric.ANTsImageToImageMetric
+   :members:
+
+ANTsMetric IO
+~~~~~~~~~~~~~~~~~~~~~~
+.. autofunction:: new_ants_metric
+.. autofunction:: create_ants_metric
+.. autofunction:: supported_metrics
+
+

MindEyeV2/antspy/docs/source/modules.rst

@@ -0,0 +1,8 @@
+ANTsPy
+======
+
+.. toctree::
+   :maxdepth: 4
+
+   ants
+   setup

MindEyeV2/antspy/docs/source/registration.rst

@@ -0,0 +1,16 @@
+Registration
+===================================
+.. automodule:: ants
+
+.. autofunction:: registration
+.. autofunction:: affine_initializer
+.. autofunction:: apply_transforms
+.. autofunction:: create_jacobian_determinant_image
+.. autofunction:: create_warped_grid
+.. autofunction:: fsl2antstransform
+.. autofunction:: image_mutual_information
+.. autofunction:: reflect_image
+.. autofunction:: reorient_image
+.. autofunction:: get_center_of_mass
+.. autofunction:: resample_image
+.. autofunction:: resample_image_to_target

MindEyeV2/antspy/docs/source/setup.rst

@@ -0,0 +1,7 @@
+setup module
+============
+
+.. automodule:: setup
+   :members:
+   :undoc-members:
+   :show-inheritance:

MindEyeV2/antspy/docs/source/vis.rst

@@ -0,0 +1,8 @@
+Visualization
+===================================
+.. automodule:: ants
+
+.. autofunction:: plot
+.. autofunction:: surf
+.. autofunction:: vol
+.. autofunction:: render_surface_function

MindEyeV2/antspy/src/WRAP_KellyKapowski.cxx

@@ -0,0 +1,19 @@
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/vector.h>
+#include <nanobind/stl/string.h>
+
+#include "antscore/KellyKapowski.h"
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+using StrVector = std::vector<std::string>;
+
+int KellyKapowski( StrVector instring )
+{
+    return ants::KellyKapowski(instring, NULL);
+}
+
+void wrap_KellyKapowski(nb::module_ &m) {
+  m.def("KellyKapowski", &KellyKapowski);
+}

MindEyeV2/antspy/src/WRAP_N4BiasFieldCorrection.cxx

@@ -0,0 +1,19 @@
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/vector.h>
+#include <nanobind/stl/string.h>
+
+#include "antscore/N4BiasFieldCorrection.h"
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+using StrVector = std::vector<std::string>;
+
+int N4BiasFieldCorrection( StrVector instring )
+{
+    return ants::N4BiasFieldCorrection(instring, NULL);
+}
+
+void wrap_N4BiasFieldCorrection(nb::module_ &m) {
+  m.def("N4BiasFieldCorrection", &N4BiasFieldCorrection);
+}

MindEyeV2/antspy/src/WRAP_ResampleImage.cxx

@@ -0,0 +1,19 @@
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/vector.h>
+#include <nanobind/stl/string.h>
+
+#include "antscore/ResampleImage.h"
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+using StrVector = std::vector<std::string>;
+
+int ResampleImage( StrVector instring )
+{
+    return ants::ResampleImage(instring, NULL);
+}
+
+void wrap_ResampleImage(nb::module_ &m) {
+  m.def("ResampleImage", &ResampleImage);
+}

MindEyeV2/antspy/src/antsImage.h

@@ -0,0 +1,233 @@
+#ifndef __ANTSPYIMAGE_H
+#define __ANTSPYIMAGE_H
+
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/vector.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/tuple.h>
+#include <nanobind/stl/list.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/stl/shared_ptr.h>
+
+#include "itkImageIOBase.h"
+
+#include "itkImage.h"
+#include "itkImageFileReader.h"
+#include "itkImageFileWriter.h"
+#include "itkPyBuffer.h"
+#include "itkVectorImage.h"
+#include "itkChangeInformationImageFilter.h"
+
+#include "itkMath.h"
+#include "itkPyVnl.h"
+#include "itkMatrix.h"
+#include "vnl/vnl_matrix_fixed.hxx"
+#include "vnl/vnl_transpose.h"
+#include "vnl/algo/vnl_matrix_inverse.h"
+#include "vnl/vnl_matrix.h"
+#include "vnl/algo/vnl_determinant.h"
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+
+template <typename ImageType>
+typename ImageType::Pointer as( void * ptr )
+{
+    typename ImageType::Pointer * real  = static_cast<typename ImageType::Pointer *>(ptr); // static_cast or reinterpret_cast ??
+    return *real;
+}
+
+template <typename ImageType>
+void * wrap( const typename ImageType::Pointer &image )
+{
+    typedef typename ImageType::Pointer ImagePointerType;
+    ImagePointerType * ptr = new ImagePointerType( image );
+    return ptr;
+}
+
+template <typename ImageType>
+typename ImageType::Pointer asImage( void * ptr ) {
+    typename ImageType::Pointer itkImage = ImageType::New();
+    itkImage = as<ImageType>( ptr );
+    return itkImage;
+}
+
+
+template <typename ImageType> 
+struct AntsImage {
+    typename ImageType::Pointer ptr;
+};
+
+
+template <typename ImageType>
+void toFile( AntsImage<ImageType> & myPointer, std::string filename )
+{
+    typename ImageType::Pointer image = myPointer.ptr;
+
+    typedef itk::ImageFileWriter< ImageType > ImageWriterType ;
+    typename ImageWriterType::Pointer image_writer = ImageWriterType::New() ;
+    image_writer->SetFileName( filename.c_str() ) ;
+    image_writer->SetInput( image );
+    image_writer->Update();
+}
+
+
+template <typename ImageType>
+std::list<int> getShape( AntsImage<ImageType> & myPointer )
+{
+    typename ImageType::Pointer image = myPointer.ptr;
+    unsigned int ndim = ImageType::GetImageDimension();
+    image->UpdateOutputInformation();
+    typename ImageType::SizeType shape = image->GetBufferedRegion().GetSize();
+    std::list<int> shapelist;
+    for (int i = 0; i < ndim; i++)
+    {
+        shapelist.push_back( shape[i] );
+    }
+    return shapelist;
+}
+
+
+template <typename ImageType>
+int getComponents( AntsImage<ImageType> & myPointer )
+{
+    typename ImageType::Pointer image = myPointer.ptr;
+    return image->GetNumberOfComponentsPerPixel();
+}
+
+template <typename ImageType>
+std::vector<double> getOrigin( AntsImage<ImageType> & myPointer )
+{
+    typename ImageType::Pointer image = myPointer.ptr;
+    typename ImageType::PointType origin = image->GetOrigin();
+    unsigned int ndim = ImageType::GetImageDimension();
+
+    std::vector<double> originlist;
+    for (int i = 0; i < ndim; i++)
+    {
+        originlist.push_back( origin[i] );
+    }
+
+    return originlist;
+}
+
+template <typename ImageType>
+void setOrigin( AntsImage<ImageType> & myPointer, std::vector<double> new_origin)
+{
+    typename ImageType::Pointer itkImage = myPointer.ptr;
+    unsigned int nvals = new_origin.size();
+    typename ImageType::PointType origin = itkImage->GetOrigin();
+    for (int i = 0; i < nvals; i++)
+    {
+        origin[i] = new_origin[i];
+    }
+    itkImage->SetOrigin( origin );
+}
+
+
+template <typename ImageType>
+std::vector<double> getDirection( AntsImage<ImageType> & myPointer )
+{
+    typename ImageType::Pointer image = myPointer.ptr;
+    typedef typename ImageType::DirectionType ImageDirectionType;
+    ImageDirectionType direction = image->GetDirection();
+
+    typedef typename ImageDirectionType::InternalMatrixType DirectionInternalMatrixType;
+    DirectionInternalMatrixType fixed_matrix = direction.GetVnlMatrix();
+
+    vnl_matrix<double> vnlmat1 = fixed_matrix.as_matrix();
+
+    const unsigned int ndim = ImageType::SizeType::GetSizeDimension();
+
+    std::vector<double> dvec;
+
+    for (int i = 0; i < ndim; i++)
+    {
+        for (int j = 0; j < ndim; j++)
+        {
+            dvec.push_back(vnlmat1(i,j));
+        }
+    }
+    return dvec;
+
+}
+
+
+template <typename ImageType>
+void setDirection( AntsImage<ImageType> & myPointer, std::vector<std::vector<double>> new_direction)
+{
+
+    typename ImageType::Pointer itkImage = myPointer.ptr;
+
+    typename ImageType::DirectionType new_matrix2 = itkImage->GetDirection( );
+    for ( std::size_t i = 0; i < new_direction.size(); i++ )
+      for ( std::size_t j = 0; j < new_direction[0].size(); j++ ) {
+        new_matrix2(i,j) = new_direction[i][j];
+      }
+    itkImage->SetDirection( new_matrix2 );
+}
+
+template <typename ImageType>
+void setSpacing( AntsImage<ImageType> & myPointer, std::vector<double> new_spacing)
+{
+    typename ImageType::Pointer itkImage = myPointer.ptr;
+    unsigned int nvals = new_spacing.size();
+    typename ImageType::SpacingType spacing = itkImage->GetSpacing();
+
+    for (int i = 0; i < nvals; i++)
+    {
+        spacing[i] = new_spacing[i];
+    }
+    itkImage->SetSpacing( spacing );
+}
+
+template <typename ImageType>
+std::vector<double> getSpacing( AntsImage<ImageType> & myPointer )
+{
+    typename ImageType::Pointer image = myPointer.ptr;
+    typename ImageType::SpacingType spacing = image->GetSpacing();
+    unsigned int ndim = ImageType::GetImageDimension();
+
+    std::vector<double> spacinglist;
+    for (int i = 0; i < ndim; i++)
+    {
+        spacinglist.push_back( spacing[i] );
+    }
+
+    return spacinglist;
+}
+
+/*
+This function resets the region of an image to index from zero if needed. This
+keeps the voxel indices in the numpy matrix consistent with the ITK image, and
+also keeps the origin of physical space of the consistent with how it will be
+saved as NIFTI.
+*/
+template <typename ImageType>
+static void FixNonZeroIndex( typename ImageType::Pointer img )
+{
+    assert(img);
+
+    typename ImageType::RegionType r = img->GetLargestPossibleRegion();
+    typename ImageType::IndexType idx = r.GetIndex();
+
+    for (unsigned int i = 0; i < ImageType::ImageDimension; ++i)
+    {
+        // if any index is non-zero, reset the origin and region
+        if ( idx[i] != 0 )
+        {
+            typename ImageType::PointType o;
+            img->TransformIndexToPhysicalPoint( idx, o );
+            img->SetOrigin( o );
+
+            idx.Fill( 0 );
+            r.SetIndex( idx );
+            img->SetRegions( r );
+
+            return;
+        }
+    }
+}
+
+#endif

MindEyeV2/antspy/src/antsImageClone.cxx

@@ -0,0 +1,115 @@
+
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/vector.h>
+#include <nanobind/stl/string.h>
+
+#include <exception>
+#include <vector>
+#include <string>
+
+#include "itkImage.h"
+#include "itkImageFileWriter.h"
+
+#include "antsImage.h"
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+template<typename InImageType, typename OutImageType>
+AntsImage<OutImageType> antsImageClone( AntsImage<InImageType> & myPointer )
+{
+  typename InImageType::Pointer in_image = myPointer.ptr;
+
+  typename OutImageType::Pointer out_image = OutImageType::New() ;
+  out_image->SetRegions( in_image->GetLargestPossibleRegion() ) ;
+  out_image->SetSpacing( in_image->GetSpacing() ) ;
+  out_image->SetOrigin( in_image->GetOrigin() ) ;
+  out_image->SetDirection( in_image->GetDirection() );
+  //out_image->CopyInformation( in_image );
+  out_image->AllocateInitialized();
+
+  itk::ImageRegionConstIterator< InImageType > in_iterator( in_image , in_image->GetLargestPossibleRegion() ) ;
+  itk::ImageRegionIterator< OutImageType > out_iterator( out_image , out_image->GetLargestPossibleRegion() ) ;
+  for( in_iterator.GoToBegin() , out_iterator.GoToBegin() ; !in_iterator.IsAtEnd() ; ++in_iterator , ++out_iterator )
+    {
+    out_iterator.Set( static_cast< typename OutImageType::PixelType >( in_iterator.Get() ) ) ;
+    }
+    AntsImage<OutImageType> outImage = { out_image };
+    return outImage;
+}
+void local_antsImageClone(nb::module_ &m) {
+
+    // call the function based on the image type you are converting TO.
+    // the image type you are converting FROM should be automatically inferred by the template
+
+    // dim = 2
+    m.def("antsImageCloneUC2", &antsImageClone<itk::Image<unsigned char,2>,itk::Image<unsigned char,2>>);
+    m.def("antsImageCloneUC2", &antsImageClone<itk::Image<unsigned int,2>,itk::Image<unsigned char,2>>);
+    m.def("antsImageCloneUC2", &antsImageClone<itk::Image<float,2>,itk::Image<unsigned char,2>>);
+    m.def("antsImageCloneUC2", &antsImageClone<itk::Image<double,2>,itk::Image<unsigned char,2>>);
+
+    m.def("antsImageCloneUI2", &antsImageClone<itk::Image<unsigned char,2>,itk::Image<unsigned int,2>>);
+    m.def("antsImageCloneUI2", &antsImageClone<itk::Image<unsigned int,2>,itk::Image<unsigned int,2>>);
+    m.def("antsImageCloneUI2", &antsImageClone<itk::Image<float,2>,itk::Image<unsigned int,2>>);
+    m.def("antsImageCloneUI2", &antsImageClone<itk::Image<double,2>,itk::Image<unsigned int,2>>);
+
+    m.def("antsImageCloneF2", &antsImageClone<itk::Image<unsigned char,2>,itk::Image<float,2>>);
+    m.def("antsImageCloneF2", &antsImageClone<itk::Image<unsigned int,2>,itk::Image<float,2>>);
+    m.def("antsImageCloneF2", &antsImageClone<itk::Image<float,2>,itk::Image<float,2>>);
+    m.def("antsImageCloneF2", &antsImageClone<itk::Image<double,2>,itk::Image<float,2>>);
+
+    m.def("antsImageCloneD2", &antsImageClone<itk::Image<unsigned char,2>,itk::Image<double,2>>);
+    m.def("antsImageCloneD2", &antsImageClone<itk::Image<unsigned int,2>,itk::Image<double,2>>);
+    m.def("antsImageCloneD2", &antsImageClone<itk::Image<float,2>,itk::Image<double,2>>);
+    m.def("antsImageCloneD2", &antsImageClone<itk::Image<double,2>,itk::Image<double,2>>);
+
+    m.def("antsImageCloneRGBUC2", &antsImageClone<itk::Image<itk::RGBPixel<unsigned char>,2>,itk::Image<itk::RGBPixel<unsigned char>,2>>);
+
+    // dim = 3
+
+    m.def("antsImageCloneUC3", &antsImageClone<itk::Image<unsigned char,3>,itk::Image<unsigned char,3>>);
+    m.def("antsImageCloneUC3", &antsImageClone<itk::Image<unsigned int,3>,itk::Image<unsigned char,3>>);
+    m.def("antsImageCloneUC3", &antsImageClone<itk::Image<float,3>,itk::Image<unsigned char,3>>);
+    m.def("antsImageCloneUC3", &antsImageClone<itk::Image<double,3>,itk::Image<unsigned char,3>>);
+
+    m.def("antsImageCloneUI3", &antsImageClone<itk::Image<unsigned char,3>,itk::Image<unsigned int,3>>);
+    m.def("antsImageCloneUI3", &antsImageClone<itk::Image<unsigned int,3>,itk::Image<unsigned int,3>>);
+    m.def("antsImageCloneUI3", &antsImageClone<itk::Image<float,3>,itk::Image<unsigned int,3>>);
+    m.def("antsImageCloneUI3", &antsImageClone<itk::Image<double,3>,itk::Image<unsigned int,3>>);
+
+    m.def("antsImageCloneF3", &antsImageClone<itk::Image<unsigned char,3>,itk::Image<float,3>>);
+    m.def("antsImageCloneF3", &antsImageClone<itk::Image<unsigned int,3>,itk::Image<float,3>>);
+    m.def("antsImageCloneF3", &antsImageClone<itk::Image<float,3>,itk::Image<float,3>>);
+    m.def("antsImageCloneF3", &antsImageClone<itk::Image<double,3>,itk::Image<float,3>>);
+
+    m.def("antsImageCloneD3", &antsImageClone<itk::Image<unsigned char,3>,itk::Image<double,3>>);
+    m.def("antsImageCloneD3", &antsImageClone<itk::Image<unsigned int,3>,itk::Image<double,3>>);
+    m.def("antsImageCloneD3", &antsImageClone<itk::Image<float,3>,itk::Image<double,3>>);
+    m.def("antsImageCloneD3", &antsImageClone<itk::Image<double,3>,itk::Image<double,3>>);
+
+    m.def("antsImageCloneRGBUC3", &antsImageClone<itk::Image<itk::RGBPixel<unsigned char>,3>,itk::Image<itk::RGBPixel<unsigned char>,3>>);
+
+    // dim = 4
+
+    m.def("antsImageCloneUC4", &antsImageClone<itk::Image<unsigned char,4>,itk::Image<unsigned char,4>>);
+    m.def("antsImageCloneUC4", &antsImageClone<itk::Image<unsigned int,4>,itk::Image<unsigned char,4>>);
+    m.def("antsImageCloneUC4", &antsImageClone<itk::Image<float,4>,itk::Image<unsigned char,4>>);
+    m.def("antsImageCloneUC4", &antsImageClone<itk::Image<double,4>,itk::Image<unsigned char,4>>);
+
+    m.def("antsImageCloneUI4", &antsImageClone<itk::Image<unsigned char,4>,itk::Image<unsigned int,4>>);
+    m.def("antsImageCloneUI4", &antsImageClone<itk::Image<unsigned int,4>,itk::Image<unsigned int,4>>);
+    m.def("antsImageCloneUI4", &antsImageClone<itk::Image<float,4>,itk::Image<unsigned int,4>>);
+    m.def("antsImageCloneUI4", &antsImageClone<itk::Image<double,4>,itk::Image<unsigned int,4>>);
+
+    m.def("antsImageCloneF4", &antsImageClone<itk::Image<unsigned char,4>,itk::Image<float,4>>);
+    m.def("antsImageCloneF4", &antsImageClone<itk::Image<unsigned int,4>,itk::Image<float,4>>);
+    m.def("antsImageCloneF4", &antsImageClone<itk::Image<float,4>,itk::Image<float,4>>);
+    m.def("antsImageCloneF4", &antsImageClone<itk::Image<double,4>,itk::Image<float,4>>);
+
+    m.def("antsImageCloneD4", &antsImageClone<itk::Image<unsigned char,4>,itk::Image<double,4>>);
+    m.def("antsImageCloneD4", &antsImageClone<itk::Image<unsigned int,4>,itk::Image<double,4>>);
+    m.def("antsImageCloneD4", &antsImageClone<itk::Image<float,4>,itk::Image<double,4>>);
+    m.def("antsImageCloneD4", &antsImageClone<itk::Image<double,4>,itk::Image<double,4>>);
+
+    m.def("antsImageCloneRGBUC4", &antsImageClone<itk::Image<itk::RGBPixel<unsigned char>,4>,itk::Image<itk::RGBPixel<unsigned char>,4>>);
+}

MindEyeV2/antspy/src/antsTransform.cxx

@@ -0,0 +1,312 @@
+
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/vector.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/tuple.h>
+#include <nanobind/stl/list.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/stl/shared_ptr.h>
+
+#include <algorithm>
+#include <vector>
+#include <string>
+
+#include "itkMacro.h"
+#include "itkImage.h"
+#include "itkVectorImage.h"
+#include "itkVector.h"
+#include "itkImageRegionIteratorWithIndex.h"
+#include "vnl/vnl_vector_ref.h"
+#include "itkTransform.h"
+#include "itkAffineTransform.h"
+
+#include "itkAffineTransform.h"
+#include "itkAffineTransform.h"
+#include "itkCenteredAffineTransform.h"
+#include "itkEuler2DTransform.h"
+#include "itkEuler3DTransform.h"
+#include "itkRigid2DTransform.h"
+#include "itkRigid3DTransform.h"
+#include "itkCenteredRigid2DTransform.h"
+#include "itkCenteredEuler3DTransform.h"
+#include "itkSimilarity2DTransform.h"
+#include "itkCenteredSimilarity2DTransform.h"
+#include "itkSimilarity3DTransform.h"
+#include "itkQuaternionRigidTransform.h"
+#include "itkTranslationTransform.h"
+#include "itkResampleImageFilter.h"
+#include "itkTransformFileReader.h"
+#include "itkCompositeTransform.h"
+#include "itkMatrixOffsetTransformBase.h"
+#include "itkDisplacementFieldTransform.h"
+#include "itkConstantBoundaryCondition.h"
+
+#include "itkBSplineInterpolateImageFunction.h"
+#include "itkLinearInterpolateImageFunction.h"
+#include "itkGaussianInterpolateImageFunction.h"
+#include "itkInterpolateImageFunction.h"
+#include "itkNearestNeighborInterpolateImageFunction.h"
+#include "itkWindowedSincInterpolateImageFunction.h"
+#include "itkLabelImageGaussianInterpolateImageFunction.h"
+#include "itkTransformFileWriter.h"
+
+#include "itkMacro.h"
+#include "itkImage.h"
+#include "itkVectorImage.h"
+#include "itkVector.h"
+#include "itkImageRegionIteratorWithIndex.h"
+#include "vnl/vnl_vector_ref.h"
+#include "itkTransform.h"
+#include "itkAffineTransform.h"
+
+#include "antscore/antsUtilities.h"
+
+#include "antsTransform.h"
+#include "antsImage.h"
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+template <typename TransformType, typename VectorImageType, typename PrecisionType, unsigned int Dimension>
+AntsTransform<TransformType> antsTransformFromDisplacementField( AntsImage<VectorImageType> & field )
+{
+  //typedef itk::Transform<PrecisionType,Dimension,Dimension>                  TransformType;
+  typedef typename TransformType::Pointer                                    TransformPointerType;
+  typedef typename itk::DisplacementFieldTransform<PrecisionType, Dimension> DisplacementFieldTransformType;
+  typedef typename DisplacementFieldTransformType::DisplacementFieldType     DisplacementFieldType;
+  typedef typename DisplacementFieldType::PixelType                          VectorType;
+
+  // Displacement field is an itk::Image with vector pixels, while in ANTsR we use the
+  // itk::VectorImage class for multichannel data. So we must copy the field
+  // and pass it to the transform
+  //typedef itk::VectorImage<PrecisionType, Dimension> AntsrFieldType;
+  //typedef typename AntsrFieldType::Pointer           AntsrFieldPointerType;
+  typedef typename VectorImageType::Pointer VectorImagePointerType;
+  VectorImagePointerType antsrField = field.ptr;
+
+  typename DisplacementFieldType::Pointer itkField = DisplacementFieldType::New();
+  itkField->SetRegions( antsrField->GetLargestPossibleRegion() );
+  itkField->SetSpacing( antsrField->GetSpacing() );
+  itkField->SetOrigin( antsrField->GetOrigin() );
+  itkField->SetDirection( antsrField->GetDirection() );
+  itkField->AllocateInitialized();
+
+  typedef itk::ImageRegionIteratorWithIndex<DisplacementFieldType> IteratorType;
+  IteratorType it( itkField, itkField->GetLargestPossibleRegion() );
+  while ( !it.IsAtEnd() )
+  {
+    typename VectorImageType::PixelType vec = antsrField->GetPixel( it.GetIndex() );
+    VectorType dvec;
+    for ( unsigned int i=0; i<Dimension; i++)
+      {
+      dvec[i] = vec[i];
+      }
+    itkField->SetPixel(it.GetIndex(), dvec);
+    ++it;
+  }
+
+  typename DisplacementFieldTransformType::Pointer displacementTransform =
+    DisplacementFieldTransformType::New();
+  displacementTransform->SetDisplacementField( itkField );
+
+  /*
+  TransformPointerType transform = dynamic_cast<TransformType *>( displacementTransform.GetPointer() );
+
+  Rcpp::S4 antsrTransform( "antsrTransform" );
+  antsrTransform.slot("dimension") = Dimension;
+  antsrTransform.slot("precision") = precision;
+  std::string type = displacementTransform->GetNameOfClass();
+  antsrTransform.slot("type") = type;
+  TransformPointerType * rawPointer = new TransformPointerType( transform );
+  Rcpp::XPtr<TransformPointerType> xptr( rawPointer, true );
+  antsrTransform.slot("pointer") = xptr;
+
+  return antsrTransform;
+  */
+  AntsTransform<TransformType> outTransform = { displacementTransform.GetPointer() };
+  return outTransform;
+}
+
+template <typename TransformType, typename VectorImageType, typename PrecisionType, unsigned int Dimension>
+AntsImage<VectorImageType> antsTransformToDisplacementField( AntsTransform<TransformType> & xfrm,
+                                                             AntsImage<itk::Image<PrecisionType, Dimension>> & ref )
+{
+  //typedef itk::Transform<PrecisionType,Dimension,Dimension>                  TransformType;
+  using ImageType = typename itk::Image<PrecisionType, Dimension>;
+  using ImagePointerType = typename ImageType::Pointer;
+  using TransformPointerType = typename TransformType::Pointer;
+  using DisplacementFieldTransformType = typename itk::DisplacementFieldTransform<PrecisionType, VectorImageType::ImageDimension>;
+  using DisplacementFieldTransformPointerType = typename DisplacementFieldTransformType::Pointer;
+  using DisplacementFieldType = typename DisplacementFieldTransformType::DisplacementFieldType;
+  using VectorType = typename DisplacementFieldType::PixelType;
+
+  TransformPointerType itkTransform = xfrm.ptr;
+  DisplacementFieldTransformPointerType warp = dynamic_cast<DisplacementFieldTransformType *>( itkTransform.GetPointer() ) ;
+
+  ImagePointerType domainImage = ref.ptr;
+
+  typedef typename VectorImageType::Pointer VectorImagePointerType;
+  VectorImagePointerType antsrField = VectorImageType::New();
+  antsrField->CopyInformation( domainImage );
+  antsrField->SetRegions( domainImage->GetLargestPossibleRegion() );
+  antsrField->SetNumberOfComponentsPerPixel( Dimension );
+  antsrField->AllocateInitialized();
+
+  typedef itk::ImageRegionIteratorWithIndex<ImageType> IteratorType;
+  IteratorType it( domainImage, domainImage->GetLargestPossibleRegion() );
+  while ( !it.IsAtEnd() )
+    {
+    VectorType vec = warp->GetDisplacementField()->GetPixel( it.GetIndex() );
+    typename VectorImageType::PixelType dvec;
+    dvec.SetSize( Dimension );
+    for( unsigned int i = 0; i < Dimension; i++ )
+      {
+      dvec[i] = vec[i];
+      }
+    antsrField->SetPixel( it.GetIndex(), dvec );
+    ++it;
+    }
+
+  AntsImage<VectorImageType> outImage = { antsrField };
+  return outImage;
+}
+
+void local_antsTransform(nb::module_ &m) {
+
+    m.def("getTransformParameters", &getTransformParameters<itk::Transform<float, 2, 2>>);
+    m.def("getTransformParameters", &getTransformParameters<itk::Transform<float, 3, 3>>);
+    m.def("getTransformParameters", &getTransformParameters<itk::Transform<float, 4, 4>>);
+    m.def("getTransformParameters", &getTransformParameters<itk::Transform<double,2, 2>>);
+    m.def("getTransformParameters", &getTransformParameters<itk::Transform<double,3, 3>>);
+    m.def("getTransformParameters", &getTransformParameters<itk::Transform<double,4, 4>>);
+
+    m.def("setTransformParameters", &setTransformParameters<itk::Transform<float, 2, 2>>);
+    m.def("setTransformParameters", &setTransformParameters<itk::Transform<float, 3, 3>>);
+    m.def("setTransformParameters", &setTransformParameters<itk::Transform<float, 4, 4>>);
+    m.def("setTransformParameters", &setTransformParameters<itk::Transform<double,2, 2>>);
+    m.def("setTransformParameters", &setTransformParameters<itk::Transform<double,3, 3>>);
+    m.def("setTransformParameters", &setTransformParameters<itk::Transform<double,4, 4>>);
+
+    m.def("getTransformFixedParameters", &getTransformFixedParameters<itk::Transform<float, 2, 2>>);
+    m.def("getTransformFixedParameters", &getTransformFixedParameters<itk::Transform<float, 3, 3>>);
+    m.def("getTransformFixedParameters", &getTransformFixedParameters<itk::Transform<float, 4, 4>>);
+    m.def("getTransformFixedParameters", &getTransformFixedParameters<itk::Transform<double,2, 2>>);
+    m.def("getTransformFixedParameters", &getTransformFixedParameters<itk::Transform<double,3, 3>>);
+    m.def("getTransformFixedParameters", &getTransformFixedParameters<itk::Transform<double,4, 4>>);
+
+    m.def("setTransformFixedParameters", &setTransformFixedParameters<itk::Transform<float, 2, 2>>);
+    m.def("setTransformFixedParameters", &setTransformFixedParameters<itk::Transform<float, 3, 3>>);
+    m.def("setTransformFixedParameters", &setTransformFixedParameters<itk::Transform<float, 4, 4>>);
+    m.def("setTransformFixedParameters", &setTransformFixedParameters<itk::Transform<double,2, 2>>);
+    m.def("setTransformFixedParameters", &setTransformFixedParameters<itk::Transform<double,3, 3>>);
+    m.def("setTransformFixedParameters", &setTransformFixedParameters<itk::Transform<double,4, 4>>);
+
+
+    m.def("transformPoint", &transformPoint<itk::DisplacementFieldTransform<float, 2>>);
+    m.def("transformPoint", &transformPoint<itk::DisplacementFieldTransform<float, 3>>);
+    m.def("transformPoint", &transformPoint<itk::Transform<float, 2, 2>>);
+    m.def("transformPoint", &transformPoint<itk::Transform<float, 3, 3>>);
+    m.def("transformPoint", &transformPoint<itk::Transform<float, 4, 4>>);
+    m.def("transformPoint", &transformPoint<itk::Transform<double,2, 2>>);
+    m.def("transformPoint", &transformPoint<itk::Transform<double,3, 3>>);
+    m.def("transformPoint", &transformPoint<itk::Transform<double,4, 4>>);
+
+    m.def("transformVector", &transformVector<itk::Transform<float, 2, 2>>);
+    m.def("transformVector", &transformVector<itk::Transform<float, 3, 3>>);
+    m.def("transformVector", &transformVector<itk::Transform<float, 4, 4>>);
+    m.def("transformVector", &transformVector<itk::Transform<double,2, 2>>);
+    m.def("transformVector", &transformVector<itk::Transform<double,3, 3>>);
+    m.def("transformVector", &transformVector<itk::Transform<double,4, 4>>);
+
+    m.def("transformImage", &transformImage<itk::Transform<float, 2, 2>, itk::Image<unsigned char, 2>>);
+    m.def("transformImage", &transformImage<itk::Transform<float, 3, 3>, itk::Image<unsigned char, 3>>);
+    m.def("transformImage", &transformImage<itk::Transform<float, 4, 4>, itk::Image<unsigned char, 4>>);
+    m.def("transformImage", &transformImage<itk::Transform<double,2, 2>, itk::Image<unsigned char, 2>>);
+    m.def("transformImage", &transformImage<itk::Transform<double,3, 3>, itk::Image<unsigned char, 3>>);
+    m.def("transformImage", &transformImage<itk::Transform<double,4, 4>, itk::Image<unsigned char, 4>>);
+
+    m.def("transformImage", &transformImage<itk::Transform<float, 2, 2>, itk::Image<unsigned int, 2>>);
+    m.def("transformImage", &transformImage<itk::Transform<float, 3, 3>, itk::Image<unsigned int, 3>>);
+    m.def("transformImage", &transformImage<itk::Transform<float, 4, 4>, itk::Image<unsigned int, 4>>);
+    m.def("transformImage", &transformImage<itk::Transform<double,2, 2>, itk::Image<unsigned int, 2>>);
+    m.def("transformImage", &transformImage<itk::Transform<double,3, 3>, itk::Image<unsigned int, 3>>);
+    m.def("transformImage", &transformImage<itk::Transform<double,4, 4>, itk::Image<unsigned int, 4>>);
+
+    m.def("transformImage", &transformImage<itk::Transform<float, 2, 2>, itk::Image<float, 2>>);
+    m.def("transformImage", &transformImage<itk::Transform<float, 3, 3>, itk::Image<float, 3>>);
+    m.def("transformImage", &transformImage<itk::Transform<float, 4, 4>, itk::Image<float, 4>>);
+    m.def("transformImage", &transformImage<itk::Transform<double,2, 2>, itk::Image<float, 2>>);
+    m.def("transformImage", &transformImage<itk::Transform<double,3, 3>, itk::Image<float, 3>>);
+    m.def("transformImage", &transformImage<itk::Transform<double,4, 4>, itk::Image<float, 4>>);
+
+    m.def("transformImage", &transformImage<itk::Transform<float, 2, 2>, itk::Image<double, 2>>);
+    m.def("transformImage", &transformImage<itk::Transform<float, 3, 3>, itk::Image<double, 3>>);
+    m.def("transformImage", &transformImage<itk::Transform<float, 4, 4>, itk::Image<double, 4>>);
+    m.def("transformImage", &transformImage<itk::Transform<double,2, 2>, itk::Image<double, 2>>);
+    m.def("transformImage", &transformImage<itk::Transform<double,3, 3>, itk::Image<double, 3>>);
+    m.def("transformImage", &transformImage<itk::Transform<double,4, 4>, itk::Image<double, 4>>);
+
+    // displacement field transforms
+    m.def("transformImage", &transformImage<itk::DisplacementFieldTransform<float, 2>, itk::Image<unsigned char, 2>>);
+    m.def("transformImage", &transformImage<itk::DisplacementFieldTransform<float, 3>, itk::Image<unsigned char, 3>>);
+    m.def("transformImage", &transformImage<itk::DisplacementFieldTransform<float, 2>, itk::Image<unsigned int, 2>>);
+    m.def("transformImage", &transformImage<itk::DisplacementFieldTransform<float, 3>, itk::Image<unsigned int, 3>>);
+    m.def("transformImage", &transformImage<itk::DisplacementFieldTransform<float, 2>, itk::Image<float, 2>>);
+    m.def("transformImage", &transformImage<itk::DisplacementFieldTransform<float, 3>, itk::Image<float, 3>>);
+    m.def("transformImage", &transformImage<itk::DisplacementFieldTransform<float, 2>, itk::Image<double, 2>>);
+    m.def("transformImage", &transformImage<itk::DisplacementFieldTransform<float, 3>, itk::Image<double, 3>>);
+
+    m.def("inverseTransform", &inverseTransform<itk::Transform<float, 2, 2>, itk::Transform<float, 2, 2>>);
+    m.def("inverseTransform", &inverseTransform<itk::Transform<float, 3, 3>, itk::Transform<float, 3, 3>>);
+    m.def("inverseTransform", &inverseTransform<itk::Transform<float, 4, 4>, itk::Transform<float, 4, 4>>);
+    m.def("inverseTransform", &inverseTransform<itk::Transform<double,2, 2>, itk::Transform<double,2, 2>>);
+    m.def("inverseTransform", &inverseTransform<itk::Transform<double,3, 3>, itk::Transform<double,3, 3>>);
+    m.def("inverseTransform", &inverseTransform<itk::Transform<double,4, 4>, itk::Transform<double,4, 4>>);
+
+    m.def("composeTransformsF2", &composeTransforms<itk::Transform<float, 2, 2>, float, 2>);
+    m.def("composeTransformsF3", &composeTransforms<itk::Transform<float, 3, 3>, float, 3>);
+    m.def("composeTransformsF4", &composeTransforms<itk::Transform<float, 4, 4>, float, 4>);
+    m.def("composeTransformsD2", &composeTransforms<itk::Transform<double,2, 2>, double,2> );
+    m.def("composeTransformsD3", &composeTransforms<itk::Transform<double,3, 3>, double,3> );
+    m.def("composeTransformsD4", &composeTransforms<itk::Transform<double,4, 4>, double,4> );
+
+    m.def("readTransformF2", &readTransform<itk::Transform<float, 2, 2>, float, 2>);
+    m.def("readTransformF3", &readTransform<itk::Transform<float, 3, 3>, float, 3>);
+    m.def("readTransformF4", &readTransform<itk::Transform<float, 4, 4>, float, 4>);
+    m.def("readTransformD2", &readTransform<itk::Transform<double,2, 2>, double,2> );
+    m.def("readTransformD3", &readTransform<itk::Transform<double,3, 3>, double,3> );
+    m.def("readTransformD4", &readTransform<itk::Transform<double,4, 4>, double,4> );
+
+    m.def("writeTransform", &writeTransform<itk::Transform<float, 2, 2>>);
+    m.def("writeTransform", &writeTransform<itk::Transform<float, 3, 3>>);
+    m.def("writeTransform", &writeTransform<itk::Transform<float, 4, 4>>);
+    m.def("writeTransform", &writeTransform<itk::Transform<double,2, 2>>);
+    m.def("writeTransform", &writeTransform<itk::Transform<double,3, 3>>);
+    m.def("writeTransform", &writeTransform<itk::Transform<double,4, 4>>);
+
+    m.def("matrixOffsetF2", &matrixOffset<itk::Transform<float, 2, 2>, float, 2>);
+    m.def("matrixOffsetF3", &matrixOffset<itk::Transform<float, 3, 3>, float, 3>);
+    m.def("matrixOffsetF4", &matrixOffset<itk::Transform<float, 4, 4>, float, 4>);
+    m.def("matrixOffsetD2", &matrixOffset<itk::Transform<double,2, 2>, double,2>);
+    m.def("matrixOffsetD3", &matrixOffset<itk::Transform<double,3, 3>, double,3>);
+    m.def("matrixOffsetD4", &matrixOffset<itk::Transform<double,4, 4>, double,4>);
+
+    m.def("antsTransformFromDisplacementField", &antsTransformFromDisplacementField<itk::DisplacementFieldTransform<float,2>, itk::VectorImage<float,2>,float,2>);
+    m.def("antsTransformFromDisplacementField", &antsTransformFromDisplacementField<itk::DisplacementFieldTransform<float,3>, itk::VectorImage<float,3>,float,3>);
+    m.def("antsTransformToDisplacementField", &antsTransformToDisplacementField<itk::DisplacementFieldTransform<float,2>, itk::VectorImage<float,2>,float,2>);
+    m.def("antsTransformToDisplacementField", &antsTransformToDisplacementField<itk::DisplacementFieldTransform<float,3>, itk::VectorImage<float,3>,float,3>);
+
+
+    nb::class_<AntsTransform<itk::DisplacementFieldTransform<float,2>>>(m, "AntsTransformDF2");
+    nb::class_<AntsTransform<itk::DisplacementFieldTransform<float,3>>>(m, "AntsTransformDF3");
+    nb::class_<AntsTransform<itk::Transform<float, 2, 2>>>(m, "AntsTransformF22");
+    nb::class_<AntsTransform<itk::Transform<float, 3, 3>>>(m, "AntsTransformF33");
+    nb::class_<AntsTransform<itk::Transform<float, 4, 4>>>(m, "AntsTransformF44");
+    nb::class_<AntsTransform<itk::Transform<double,2, 2>>>(m, "AntsTransformD22");
+    nb::class_<AntsTransform<itk::Transform<double,3, 3>>>(m, "AntsTransformD33");
+    nb::class_<AntsTransform<itk::Transform<double,4, 4>>>(m, "AntsTransformD44");
+
+}
+
+
+

MindEyeV2/antspy/src/fsl2antstransform.cxx

@@ -0,0 +1,172 @@
+
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/vector.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/tuple.h>
+#include <nanobind/stl/list.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/stl/shared_ptr.h>
+
+#include <algorithm>
+#include <vector>
+#include <string>
+
+#include "itkImage.h"
+#include "itkMatrixOffsetTransformBase.h"
+#include "itkCastImageFilter.h"
+#include "vnl/vnl_matrix_fixed.h"
+#include "vnl/vnl_diag_matrix.h"
+#include "vnl/vnl_vector.h"
+#include "vnl/vnl_det.h"
+#include "vnl/vnl_inverse.h"
+#include "vnl/algo/vnl_real_eigensystem.h"
+#include "vnl/algo/vnl_qr.h"
+
+#include "antsTransform.h"
+#include "antsImage.h"
+
+#define RAS_TO_FSL 0
+#define FSL_TO_RAS 1
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+/**
+ * Get a matrix that maps points voxel coordinates to RAS coordinates
+ */
+template< class ImageType, class TransformMatrixType >
+TransformMatrixType GetVoxelSpaceToRASPhysicalSpaceMatrix(typename ImageType::Pointer image)
+  {
+  // Generate intermediate terms
+  vnl_matrix_fixed<double, 3U, 3U> m_dir, m_ras_matrix;
+  vnl_diag_matrix_fixed<double, 3U> m_scale, m_lps_to_ras;
+  vnl_vector_fixed<double, 3U> v_origin, v_ras_offset;
+
+  // Compute the matrix
+  m_dir = image->GetDirection().GetVnlMatrix();
+  m_scale.set(image->GetSpacing().GetVnlVector());
+  m_lps_to_ras.set(vnl_vector<double>(ImageType::ImageDimension, 1.0));
+  m_lps_to_ras[0] = -1;
+  m_lps_to_ras[1] = -1;
+  m_ras_matrix = m_lps_to_ras * m_dir * m_scale;
+
+  // Compute the vector
+  v_origin = image->GetOrigin().GetVnlVector();
+  v_ras_offset = m_lps_to_ras * v_origin;
+
+  // Create the larger matrix
+  TransformMatrixType mat;
+  vnl_vector<double> vcol(ImageType::ImageDimension+1, 1.0);
+  vcol.update(v_ras_offset);
+  mat.SetIdentity();
+  mat.GetVnlMatrix().update(m_ras_matrix);
+  mat.GetVnlMatrix().set_column(ImageType::ImageDimension, vcol);
+
+  return mat;
+  }
+
+
+template< class PixelType, unsigned int Dimension >
+AntsTransform<itk::Transform<double,3,3>> fsl2antstransform( std::vector<std::vector<float> > matrix,
+                AntsImage<itk::Image<PixelType, Dimension>> & ants_reference,
+                AntsImage<itk::Image<PixelType, Dimension>> & ants_moving,
+                int flag )
+{
+  typedef vnl_matrix_fixed<double, 4, 4>              MatrixType;
+  typedef itk::Image<PixelType, Dimension>            ImageType;
+  typedef itk::Matrix<double, 4,4>                    TransformMatrixType;
+
+  typedef itk::AffineTransform<double, 3> AffTran;
+
+  typedef typename ImageType::Pointer     ImagePointerType;
+
+  typedef itk::Transform<double,3,3>                    TransformBaseType;
+  typedef typename TransformBaseType::Pointer           TransformBasePointerType;
+
+  ImagePointerType ref = ants_reference.ptr;
+  ImagePointerType mov = ants_moving.ptr;
+
+  MatrixType m_fsl, m_spcref, m_spcmov, m_swpref, m_swpmov, mat, m_ref, m_mov;
+
+  //Rcpp::NumericMatrix matrix(r_matrix);
+  for ( unsigned int i=0; i<matrix.size(); i++)
+    for ( unsigned int j=0; j<matrix[0].size(); j++)
+      m_fsl(i,j) = matrix[i][j];
+
+  // Set the ref/mov matrices
+  m_ref = GetVoxelSpaceToRASPhysicalSpaceMatrix<ImageType, TransformMatrixType>( ref ).GetVnlMatrix();
+  m_mov = GetVoxelSpaceToRASPhysicalSpaceMatrix<ImageType, TransformMatrixType>( mov ).GetVnlMatrix();
+
+  // Set the swap matrices
+  m_swpref.set_identity();
+  if(vnl_det(m_ref) > 0)
+    {
+    m_swpref(0,0) = -1.0;
+    m_swpref(0,3) = (ref->GetBufferedRegion().GetSize(0) - 1) * ref->GetSpacing()[0];
+    }
+
+  m_swpmov.set_identity();
+  if(vnl_det(m_mov) > 0)
+    {
+    m_swpmov(0,0) = -1.0;
+    m_swpmov(0,3) = (mov->GetBufferedRegion().GetSize(0) - 1) * mov->GetSpacing()[0];
+    }
+
+  // Set the spacing matrices
+  m_spcref.set_identity();
+  m_spcmov.set_identity();
+  for(size_t i = 0; i < 3; i++)
+    {
+    m_spcref(i,i) = ref->GetSpacing()[i];
+    m_spcmov(i,i) = mov->GetSpacing()[i];
+    }
+
+  // Compute the output matrix
+  //if (flag == FSL_TO_RAS)
+    mat = m_mov * vnl_inverse(m_spcmov) * m_swpmov * vnl_inverse(m_fsl) * m_swpref * m_spcref * vnl_inverse(m_ref);
+
+  // Add access to this
+  // NOTE: m_fsl is really m_ras here
+  //if (flag == RAS_TO_FSL)
+  //  mat =
+  //   vnl_inverse(vnl_inverse(m_swpmov) * m_spcmov* vnl_inverse(m_mov) *
+  //  m_fsl *
+  //  m_ref*vnl_inverse(m_spcref)*vnl_inverse(m_swpref));
+
+  ///////////////
+
+  // Flip the entries that must be flipped
+  mat(2,0) *= -1; mat(2,1) *= -1;
+  mat(0,2) *= -1; mat(1,2) *= -1;
+  mat(0,3) *= -1; mat(1,3) *= -1;
+
+  // Create an ITK affine transform
+  AffTran::Pointer atran = AffTran::New();
+
+  // Populate its matrix
+  AffTran::MatrixType amat = atran->GetMatrix();
+  AffTran::OffsetType aoff = atran->GetOffset();
+
+  for(size_t r = 0; r < 3; r++)
+    {
+    for(size_t c = 0; c < 3; c++)
+      {
+      amat(r,c) = mat(r,c);
+      }
+    aoff[r] = mat(r,3);
+    }
+
+  atran->SetMatrix(amat);
+  atran->SetOffset(aoff);
+
+  TransformBasePointerType itkTransform = dynamic_cast<TransformBaseType*>( atran.GetPointer() );
+
+  AntsTransform<TransformBaseType> out_ants_tx = { itkTransform };
+  return out_ants_tx;
+}
+
+
+void local_fsl2antstransform(nb::module_ &m)
+{
+  m.def("fsl2antstransformF3", &fsl2antstransform<float,3>);
+}