def rescale(self, scale, interpolator='scipy', round='ceil', **kwargs):
r"""
Return a copy of this image, rescaled by a given factor.
All image information (landmarks) are rescaled appropriately.
Parameters
----------
scale : float or tuple
The scale factor. If a tuple, the scale to apply to each dimension.
If a single float, the scale will be applied uniformly across
each dimension.
interpolator : 'scipy' or 'c', optional
The interpolator that should be used to perform the warp.
Default: 'scipy'
round: {'ceil', 'floor', 'round'}
Rounding function to be applied to floating point shapes.
Default: 'ceil'
kwargs : dict
Passed through to the interpolator. See `menpo.interpolation`
for details.
Returns
-------
rescaled_image : type(self)
A copy of this image, rescaled.
Raises
------
ValueError:
If less scales than dimensions are provided.
If any scale is less than or equal to 0.
"""
# Pythonic way of converting to list if we are passed a single float
try:
if len(scale) < self.n_dims:
raise ValueError(
'Must provide a scale per dimension.'
'{} scales were provided, {} were expected.'.format(
len(scale), self.n_dims
)
)
except TypeError: # Thrown when len() is called on a float
scale = [scale] * self.n_dims
# Make sure we have a numpy array
scale = np.asarray(scale)
for s in scale:
if s <= 0:
raise ValueError('Scales must be positive floats.')
transform = NonUniformScale(scale)
from menpo.image.boolean import BooleanImage
# use the scale factor to make the template mask bigger
template_mask = BooleanImage.blank(transform.apply(self.shape),
round=round)
# due to image indexing, we can't just apply the pseduoinverse
# transform to achieve the scaling we want though!
# Consider a 3x rescale on a 2x4 image. Looking at each dimension:
# H 2 -> 6 so [0-1] -> [0-5] = 5/1 = 5x
# W 4 -> 12 [0-3] -> [0-11] = 11/3 = 3.67x
# => need to make the correct scale per dimension!
shape = np.array(self.shape, dtype=np.float)
# scale factors = max_index_after / current_max_index
# (note that max_index = length - 1, as 0 based)
scale_factors = (scale * shape - 1) / (shape - 1)
inverse_transform = NonUniformScale(scale_factors).pseudoinverse
# Note here we pass warp_mask to warp_to. In the case of
# Images that aren't MaskedImages this kwarg will
# harmlessly fall through so we are fine.
return self.warp_to(template_mask, inverse_transform,
warp_landmarks=True,
interpolator=interpolator, **kwargs)