Tengo una imagen de origen ( src ) que deseo alinear con una imagen de destino ( dst ) mediante una transformación afín mientras retengo la extensión total de ambas imágenes durante la alineación (incluso las áreas que no se superponen).

Ya puedo calcular la matriz de desplazamiento y rotación de Affine Transformation, que envío a scipy.ndimage.interpolate.affine_transform para recuperar la imagen src alineada con dst .

El problema es que, cuando las imágenes no se superponen por completo, la imagen resultante se recorta solo en la huella común de las dos imágenes. Lo que necesito es la extensión completa de ambas imágenes, colocadas en el mismo sistema de coordenadas de píxeles. Esta pregunta es casi un duplicado de esta , y la excelente respuesta y el repositorio allí brindan esta funcionalidad para las transformaciones de OpenCV. Desafortunadamente, necesito esto para la implementación de scipy .

Demasiado tarde, después de golpear repetidamente una pared de ladrillos tratando de traducir la respuesta de la pregunta anterior a scipy , encontré este problema y luego seguí esta pregunta . La última pregunta me dio una idea del maravilloso mundo de la transformación afín de scipy , pero hasta ahora no he podido resolver mis necesidades particulares.

Las transformaciones de src a dst pueden tener traslaciones y rotaciones. Puedo hacer que solo funcionen las traducciones (a continuación se muestra un ejemplo) y solo puedo hacer que las rotaciones funcionen (en gran parte pirateando lo siguiente e inspirándome en el uso del argumento reshape en scipy.ndimage.interpolation.rotate ). Sin embargo, me estoy perdiendo completamente combinando los dos. He intentado calcular cuál debería ser el offset correcto (consulte las respuestas de esta pregunta nuevamente), pero no puedo hacerlo funcionar en todos los escenarios.

Ejemplo de trabajo de solo traducción de transformación afín acolchada, que sigue en gran medida este repositorio , explicado en esta respuesta :

 from scipy.ndimage import rotate, affine_transform import numpy as np import matplotlib.pyplot as plt nblob = 50 shape = (200, 100) buffered_shape = (300, 200) # buffer for rotation and translation def affine_test(angle=0, translate=(0, 0)): np.random.seed(42) # Maxiumum translation allowed is half difference between shape and buffered_shape # Generate a buffered_shape-sized base image with random blobs base = np.zeros(buffered_shape, dtype=np.float32) random_locs = np.random.choice(np.arange(2, buffered_shape[0] - 2), nblob * 2, replace=False) i = random_locs[:nblob] j = random_locs[nblob:] for k, (_i, _j) in enumerate(zip(i, j)): # Use different values, just to make it easier to distinguish blobs base[_i - 2 : _i + 2, _j - 2 : _j + 2] = k + 10 # Impose a rotation and translation on source src = rotate(base, angle, reshape=False, order=1, mode="constant") bsc = (np.array(buffered_shape) / 2).astype(int) sc = (np.array(shape) / 2).astype(int) src = src[ bsc[0] - sc[0] + translate[0] : bsc[0] + sc[0] + translate[0], bsc[1] - sc[1] + translate[1] : bsc[1] + sc[1] + translate[1], ] # Cut-out destination from the centre of the base image dst = base[bsc[0] - sc[0] : bsc[0] + sc[0], bsc[1] - sc[1] : bsc[1] + sc[1]] src_y, src_x = src.shape def get_matrix_offset(centre, angle, scale): """Follows OpenCV.getRotationMatrix2D""" angle = angle * np.pi / 180 alpha = scale * np.cos(angle) beta = scale * np.sin(angle) return ( np.array([[alpha, beta], [-beta, alpha]]), np.array( [ (1 - alpha) * centre[0] - beta * centre[1], beta * centre[0] + (1 - alpha) * centre[1], ] ), ) # Obtain the rotation matrix and offset that describes the transformation # between src and dst matrix, offset = get_matrix_offset(np.array([src_y / 2, src_x / 2]), angle, 1) offset = offset - translate # Determine the outer bounds of the new image lin_pts = np.array([[0, src_x, src_x, 0], [0, 0, src_y, src_y]]) transf_lin_pts = np.dot(matrix.T, lin_pts) - offset[::-1].reshape(2, 1) # Find min and max bounds of the transformed image min_x = np.floor(np.min(transf_lin_pts[0])).astype(int) min_y = np.floor(np.min(transf_lin_pts[1])).astype(int) max_x = np.ceil(np.max(transf_lin_pts[0])).astype(int) max_y = np.ceil(np.max(transf_lin_pts[1])).astype(int) # Add translation to the transformation matrix to shift to positive values anchor_x, anchor_y = 0, 0 if min_x < 0: anchor_x = -min_x if min_y < 0: anchor_y = -min_y shifted_offset = offset - np.dot(matrix, [anchor_y, anchor_x]) # Create padded destination image dst_h, dst_w = dst.shape[:2] pad_widths = [anchor_y, max(max_y, dst_h) - dst_h, anchor_x, max(max_x, dst_w) - dst_w] dst_padded = np.pad( dst, ((pad_widths[0], pad_widths[1]), (pad_widths[2], pad_widths[3])), "constant", constant_values=-1, ) dst_pad_h, dst_pad_w = dst_padded.shape # Create the aligned and padded source image source_aligned = affine_transform( src, matrix.T, offset=shifted_offset, output_shape=(dst_pad_h, dst_pad_w), order=3, mode="constant", cval=-1, ) # Plot the images fig, axes = plt.subplots(1, 4, figsize=(10, 5), sharex=True, sharey=True) axes[0].imshow(src, cmap="viridis", vmin=-1, vmax=nblob) axes[0].set_title("Source") axes[1].imshow(dst, cmap="viridis", vmin=-1, vmax=nblob) axes[1].set_title("Dest") axes[2].imshow(source_aligned, cmap="viridis", vmin=-1, vmax=nblob) axes[2].set_title("Source aligned to Dest padded") axes[3].imshow(dst_padded, cmap="viridis", vmin=-1, vmax=nblob) axes[3].set_title("Dest padded") plt.show()

p.ej:

 affine_test(0, (-20, 40))

da:

Con un zoom que muestra lo alineado en las imágenes rellenadas:

Necesito la extensión completa de las imágenes src y dst alineadas en las mismas coordenadas de píxeles, con rotaciones y traslaciones.

¡Cualquier ayuda es muy apreciada!