def test_zero_image_size(): with pytest.raises(ValueError): warp(np.zeros(0), SimilarityTransform()) with pytest.raises(ValueError): warp(np.zeros((0, 10)), SimilarityTransform()) with pytest.raises(ValueError): warp(np.zeros((10, 0)), SimilarityTransform()) with pytest.raises(ValueError): warp(np.zeros((10, 10, 0)), SimilarityTransform())
def test_warp_tform(): x = np.zeros((5, 5), dtype=np.double) x[2, 2] = 1 theta = -np.pi / 2 tform = SimilarityTransform(scale=1, rotation=theta, translation=(0, 4)) x90 = warp(x, tform, order=1) assert_array_almost_equal(x90, np.rot90(x)) x90 = warp(x, tform.inverse, order=1) assert_array_almost_equal(x90, np.rot90(x))
def run(self, stack: ImageStack, verbose: bool = False, *args) -> TransformsList: """ Iterate over the given axes of an ImageStack and learn the Similarity transform based off the reference_stack passed into :py:class:`Translation`'s constructor. Only supports 2d data. Parameters ---------- stack : ImageStack Stack to calculate the transforms on. verbose : bool if True, report on transformation progress (default = False) Returns ------- List[Tuple[Mapping[Axes, int], SimilarityTransform]] : A list of tuples containing axes of the Imagestack and associated transform to apply. """ transforms = TransformsList() reference_image = np.squeeze(self.reference_stack.xarray) for a in stack.axis_labels(self.axes): target_image = np.squeeze(stack.sel({self.axes: a}).xarray) if len(target_image.shape) != 2: raise ValueError( f"Only axes: {self.axes.value} can have a length > 1, " f"please use the MaxProj filter.") shift, error, phasediff = register_translation( src_image=target_image, target_image=reference_image, upsample_factor=self.upsampling) if verbose: print(f"For {self.axes}: {a}, Shift: {shift}, Error: {error}") selectors = {self.axes: a} # reverse shift because SimilarityTransform stores in y,x format shift = shift[::-1] transforms.append(selectors, TransformType.SIMILARITY, SimilarityTransform(translation=shift)) return transforms
def _align_transform(image_ref: ndarray, image: ndarray, **kwargs) -> Tuple[ndarray, SimilarityTransform]: """ Calculate the transformation needed to align the image with the a reference image :param image_ref: a refernce image to align with :param image: an image to align with image_ref :param kwargs: keyword arguments passed to imreg_dft.imreg.similarity :returns: a transformation that will align the image with image_ref, and the aligned greyscale image """ from imreg_dft import similarity from skimage.color import rgb2gray from ..imaging import image_as_rgb # imreg_dft.similarity can't handle colour images image_ref_gray = rgb2gray(image_as_rgb(image_ref)) image_gray = rgb2gray(image_as_rgb(image)) transform_params = similarity(image_ref_gray, image_gray, **kwargs) transform = SimilarityTransform(scale=transform_params["scale"], rotation=transform_params["angle"], translation=transform_params["tvec"]) return transform_params["timg"], transform
def rotate(image, angle, resize=False, order=1, mode='constant', cval=0.): """Rotate image by a certain angle around its center. Parameters ---------- image : ndarray Input image. angle : float Rotation angle in degrees in counter-clockwise direction. resize : bool, optional Determine whether the shape of the output image will be automatically calculated, so the complete rotated image exactly fits. Default is False. Returns ------- rotated : ndarray Rotated version of the input. Other parameters ---------------- order : int, optional The order of the spline interpolation, default is 1. The order has to be in the range 0-5. See `skimage.transform.warp` for detail. mode : string, optional Points outside the boundaries of the input are filled according to the given mode ('constant', 'nearest', 'reflect' or 'wrap'). cval : float, optional Used in conjunction with mode 'constant', the value outside the image boundaries. Examples -------- >>> from skimage import data >>> from skimage.transform import rotate >>> image = data.camera() >>> rotate(image, 2).shape (512, 512) >>> rotate(image, 2, resize=True).shape (530, 530) >>> rotate(image, 90, resize=True).shape (512, 512) """ rows, cols = image.shape[0], image.shape[1] # rotation around center translation = np.array((cols, rows)) / 2. - 0.5 tform1 = SimilarityTransform(translation=-translation) tform2 = SimilarityTransform(rotation=np.deg2rad(angle)) tform3 = SimilarityTransform(translation=translation) tform = tform1 + tform2 + tform3 output_shape = None if resize: # determine shape of output image corners = np.array([[1, 1], [1, rows], [cols, rows], [cols, 1]]) corners = tform(corners - 1) minc = corners[:, 0].min() minr = corners[:, 1].min() maxc = corners[:, 0].max() maxr = corners[:, 1].max() out_rows = maxr - minr + 1 out_cols = maxc - minc + 1 output_shape = np.ceil((out_rows, out_cols)) # fit output image in new shape translation = ((cols - out_cols) / 2., (rows - out_rows) / 2.) tform4 = SimilarityTransform(translation=translation) tform = tform4 + tform return warp(image, tform, output_shape=output_shape, order=order, mode=mode, cval=cval)
def test_inverse(): tform = SimilarityTransform(scale=0.5, rotation=0.1) inverse_tform = SimilarityTransform(matrix=np.linalg.inv(tform.params)) image = np.arange(10 * 10).reshape(10, 10).astype(np.double) assert_array_equal(warp(image, inverse_tform), warp(image, tform.inverse))
def test_invalid(): with pytest.raises(ValueError): warp(np.ones((4, 3, 3, 3)), SimilarityTransform())
def test_warp_coords_example(): image = astronaut().astype(np.float32) assert 3 == image.shape[2] tform = SimilarityTransform(translation=(0, -10)) coords = warp_coords(tform, (30, 30, 3)) map_coordinates(image[:, :, 0], coords[:2])