class StreamlineDistanceMetric(with_metaclass(abc.ABCMeta, object)):
def __init__(self, num_threads=None):
""" An abstract class for the metric used for streamline registration
If the two sets of streamlines match exactly then method ``distance``
of this object should be minimum.
Parameters
----------
num_threads : int
Number of threads. If None (default) then all available threads
will be used. Only metrics using OpenMP will use this variable.
"""
self.static = None
self.moving = None
self.num_threads = num_threads
@abc.abstractmethod
def setup(self, static, moving):
pass
@abc.abstractmethod
def distance(self, xopt):
""" calculate distance for current set of parameters
"""
pass
class SKLearnLinearSolver(with_metaclass(abc.ABCMeta, object)):
"""
Provide a sklearn-like uniform interface to algorithms that solve problems
of the form: $y = Ax$ for $x$
Sub-classes of SKLearnLinearSolver should provide a 'fit' method that have
the following signature: `SKLearnLinearSolver.fit(X, y)`, which would set
an attribute `SKLearnLinearSolver.coef_`, with the shape (X.shape[1],),
such that an estimate of y can be calculated as:
`y_hat = np.dot(X, SKLearnLinearSolver.coef_.T)`
"""
def __init__(self, *args, **kwargs):
self._args = args
self._kwargs = kwargs
@abc.abstractmethod
def fit(self, X, y):
"""Implement for all derived classes """
def predict(self, X):
"""
Predict using the result of the model
Parameters
----------
X : array-like (n_samples, n_features)
Samples.
Returns
-------
C : array, shape = (n_samples,)
Predicted values.
"""
X = np.asarray(X)
return np.dot(X, self.coef_.T)
class StreamlineDistanceMetric(with_metaclass(abc.ABCMeta, object)):
def __init__(self):
""" An abstract class for the metric used for streamline registration
If the two sets of streamlines match exactly then method ``distance``
of this object should be minimum.
"""
self.static = None
self.moving = None
@abc.abstractmethod
def setup(self, static, moving):
pass
@abc.abstractmethod
def distance(self, xopt):
""" calculate distance for current set of parameters
"""
pass
class SimilarityMetric(with_metaclass(abc.ABCMeta, object)):
def __init__(self, dim):
r""" Similarity Metric abstract class
A similarity metric is in charge of keeping track of the numerical
value of the similarity (or distance) between the two given images. It
also computes the update field for the forward and inverse displacement
fields to be used in a gradient-based optimization algorithm. Note that
this metric does not depend on any transformation (affine or
non-linear) so it assumes the static and moving images are already
warped
Parameters
----------
dim : int (either 2 or 3)
the dimension of the image domain
"""
self.dim = dim
self.levels_above = None
self.levels_below = None
self.static_image = None
self.static_affine = None
self.static_spacing = None
self.static_direction = None
self.moving_image = None
self.moving_affine = None
self.moving_spacing = None
self.moving_direction = None
self.mask0 = False
def set_levels_below(self, levels):
r"""Informs the metric how many pyramid levels are below the current one
Informs this metric the number of pyramid levels below the current one.
The metric may change its behavior (e.g. number of inner iterations)
accordingly
Parameters
----------
levels : int
the number of levels below the current Gaussian Pyramid level
"""
self.levels_below = levels
def set_levels_above(self, levels):
r"""Informs the metric how many pyramid levels are above the current one
Informs this metric the number of pyramid levels above the current one.
The metric may change its behavior (e.g. number of inner iterations)
accordingly
Parameters
----------
levels : int
the number of levels above the current Gaussian Pyramid level
"""
self.levels_above = levels
def set_static_image(self, static_image, static_affine, static_spacing,
static_direction):
r"""Sets the static image being compared against the moving one.
Sets the static image. The default behavior (of this abstract class) is
simply to assign the reference to an attribute, but
generalizations of the metric may need to perform other operations
Parameters
----------
static_image : array, shape (R, C) or (S, R, C)
the static image
"""
self.static_image = static_image
self.static_affine = static_affine
self.static_spacing = static_spacing
self.static_direction = static_direction
def use_static_image_dynamics(self, original_static_image, transformation):
r"""This is called by the optimizer just after setting the static image.
This method allows the metric to compute any useful
information from knowing how the current static image was generated
(as the transformation of an original static image). This method is
called by the optimizer just after it sets the static image.
Transformation will be an instance of DiffeomorficMap or None
if the original_static_image equals self.moving_image.
Parameters
----------
original_static_image : array, shape (R, C) or (S, R, C)
original image from which the current static image was generated
transformation : DiffeomorphicMap object
the transformation that was applied to original image to generate
the current static image
"""
pass
def set_moving_image(self, moving_image, moving_affine, moving_spacing,
moving_direction):
r"""Sets the moving image being compared against the static one.
Sets the moving image. The default behavior (of this abstract class) is
simply to assign the reference to an attribute, but
generalizations of the metric may need to perform other operations
Parameters
----------
moving_image : array, shape (R, C) or (S, R, C)
the moving image
"""
self.moving_image = moving_image
self.moving_affine = moving_affine
self.moving_spacing = moving_spacing
self.moving_direction = moving_direction
def use_moving_image_dynamics(self, original_moving_image, transformation):
r"""This is called by the optimizer just after setting the moving image
This method allows the metric to compute any useful
information from knowing how the current static image was generated
(as the transformation of an original static image). This method is
called by the optimizer just after it sets the static image.
Transformation will be an instance of DiffeomorficMap or None if
the original_moving_image equals self.moving_image.
Parameters
----------
original_moving_image : array, shape (R, C) or (S, R, C)
original image from which the current moving image was generated
transformation : DiffeomorphicMap object
the transformation that was applied to original image to generate
the current moving image
"""
pass
@abc.abstractmethod
def initialize_iteration(self):
r"""Prepares the metric to compute one displacement field iteration.
This method will be called before any compute_forward or
compute_backward call, this allows the Metric to pre-compute any useful
information for speeding up the update computations. This
initialization was needed in ANTS because the updates are called once
per voxel. In Python this is unpractical, though.
"""
@abc.abstractmethod
def free_iteration(self):
r"""Releases the resources no longer needed by the metric
This method is called by the RegistrationOptimizer after the required
iterations have been computed (forward and / or backward) so that the
SimilarityMetric can safely delete any data it computed as part of the
initialization
"""
@abc.abstractmethod
def compute_forward(self):
r"""Computes one step bringing the reference image towards the static.
Computes the forward update field to register the moving image towards
the static image in a gradient-based optimization algorithm
"""
@abc.abstractmethod
def compute_backward(self):
r"""Computes one step bringing the static image towards the moving.
Computes the backward update field to register the static image towards
the moving image in a gradient-based optimization algorithm
"""
@abc.abstractmethod
def get_energy(self):
r"""Numerical value assigned by this metric to the current image pair