MATLAB Escribe una función que gire una imagen usando una matriz de rotación. Si es correcto, obtén 100 puntos más.
i1=round(i*cos(a) - j*sin(a) + n * sin(a))+1;
j1=round(i*sin(a) + j*cos(a)) ;
Aparecerán valores cero en ambas ocasiones. La matriz F del índice MATLAB es incorrecta. Puede establecer un punto de interrupción y luego ejecutar un solo paso para ver en qué paso aparece el valor cero. Según el método de cálculo de la matriz de rotación, no debería haber ningún problema. que puede ocurrir un mapeo en escala de grises Para la posición cero, es mejor agregar una declaración de juicio para juzgar si aparecerá un valor cero cuando se calcule j1.
Lo que escribes así es rotación a lo largo del origen del eje de coordenadas. Dijiste que lo que escribí originalmente era rotación a lo largo de un punto fijo. La implementación es utilizar una matriz de rotación. Primero traduzco al origen y luego vuelvo a traducir. Específicamente, puedes echar un vistazo, no lo recuerdo claramente, jaja, ya no haré imágenes.
Escribí un programa para esto:
función im_final = imrotate_my(im_path,theta,options)
% implementa IM_ROTATE rotación de imagen bidimensional y líneas dobles Algoritmo de interpolación de escala de grises sexual
% im_path ruta de almacenamiento de imágenes
% ángulo de rotación theta, el número positivo significa rotación en el sentido de las agujas del reloj
% la opción puede ser circular (más allá del rango, expandida en ciclos)
% de recorte (fuera de rango, establecido en cero, es decir, "recortado". Es decir, todo negro)
% de referencia. Ingeniería de imágenes (Parte 1)--Procesamiento de imágenes.
Tsinghua University Press
% Autor: lskyp Fecha: 2009.08.12
% Versión: V1.2 Versión original: V1.0 im_bilinear.m;im_rotate.m
% Opciones de parámetros agregadas
% Opciones de parámetros agregadas
error(nargchk(2,3,nargin,'string'))
if nargin == 2
opciones = 'circular';
else
if ~ ( strcmp(opciones,'circular') || strcmp(opciones,' recortar') )
error('Método de salida incorrecto')
end
end
im_init = imread(im_path);
im_init = double(im_init);
im_height = size(im_init,1);
im_width = size(im_init,2);
% respectivamente Procesar escala de grises y Imágenes RGB
if ndims(im _init) == 3
im_final = zeros(im_height,im_width,3);
R = im_init (:
G = im_init(:,::2);
B = im_init(:,::3);
R_final = im_final(:, :,1);
G_final = im_final(:,:,2);
B_final = im_final(:,:3);
else
im_final = zeros(im_height ,im_width);
end
rot_matrix = [cos(theta) -sin(theta);sin(theta) cos(theta) ];
orig_h = (im_height + 1)/2;
orig_w = (im_width + 1)/2;
para h = 1: im_height
para w = 1: im_width
% Traducir al origen, rotar y luego traducir hacia atrás
new_position = rot_matrix*[h - orig_h;w - orig _w] + [orig_h;orig_w];
% control de expansión por ciclo fuera de rango, control de parámetros de opción
if strcmp(options,'circular')
nueva_posición(1) = mod(nueva_posición(1), altura_im);
nueva_posición(2) = mod(nueva_posición(2),ancho_im);
If nueva_posicion( 1) == 0
nueva_posicion(1) = im_height;
Fin
if nueva_posicion(2) == 0
new_position (2) = im_width;
end
end
end
% Si la nueva posición es un número entero, directamente cambiarlo
Se asigna a un valor de escala de grises o RGB; de lo contrario, se utiliza la interpolación bilineal.
% Usar mapeo hacia atrás
if new_position == round(new_position)
if new_position(1) == 0
new_position ( 1) = 1;
fin
si nueva _posición(2) == 0
nueva_posición(2) = 1;
end
% Control fuera de rango, las opciones son opciones de recorte, fuera de rango establecido en 0
if strcmp(options,'crop') && ( new_position(1) >= im_height | | ...
nueva_posición(2) >= im_width || nueva_posición(1) < 0 ||
Si ndims(im_init) == 3
R_final(h,w) = 0;
G_final(h,w) = 0;
B_final (h,w) = 0;
else
im_final(h,w) = 0;
end
else
p>
if ndims(im_init) == 3
R_final(h,w) = R(nueva_posición(1),nueva_posición(2));
G_final(h,w) = G(nueva_posición(1),nueva_posición(2));
B_final(h,w) = B(nueva_posición(1),nueva_posición( 2));
p>
else
im_ final(h,w) = im_init(nueva_posición(1),nueva_posición(2));
fin
fin
else
h_new = piso(nueva_posición(1));
w_ nuevo = piso(nueva_posición( 2));
si h_new == 0
h_new = 1;
Fin
si w_new == 0
w_new = 1;
Fin
% fuera de rango de control.
opciones es la opción de recorte, establecida en 0 fuera del rango
if strcmp(options,'crop') && (h_new >= im_height ||...
w_new >= im_width || h_nuevo < 0 | ...
w_nuevo < 0)
si ndims(im_init) == 3
R_final(h,w) = 0 ;
G_final(h,w) = 0;
B_final(h,w) = 0;
más
soy _final (h ,w) = 0;
fin
else
% control de límites
h1 = h_new + 1;
w1 = w_new + 1;
if h1 >= altura_im + 1
h1 = mod(h1,altura_im);
fin
if w1 >= im_width + 1
w1 = mod(w1,im_width);
end
if ndims(im_init) = = 3
% Implementación de interpolación bilineal
% Ref.p> % Referencias. Zhang Yujin. Ingeniería de imágenes (Parte 1)--Procesamiento de imágenes.
Prensa de la Universidad de Tsinghua
R_temp1 = R(h1,w_new)*(new_position(1) - h_new) + ...
R(h_new,w_new)*(h_new + 1 - nueva_posición(1));
R_temp2 = R(h1,w1)*(nueva_posición(1) - h_nueva) + ...
R(h_nueva,w1)*( h_nueva + 1 - nueva_posición(1));
R_final(h,w) = R_temp1*(w_nueva + 1 - nueva_posición(2))+ ...
R_temp2*( nueva_posición (2) - w_new);
G_temp1 = G(h1,w_new)*(new_position(1) - h_new) + ...
G(h_new,w_new)* ( h_new + 1 - nueva_posición(1));
G_temp2 = G(h1,w1)*(nueva_posición(1) - h_new) + ...
G(h_new, w1 )*(h_new + 1 - nueva_posición(1));
G_final(h,w) = G_temp1*(w_new + 1 - nueva_posición(2))+ ...
G_temp2*(nueva_posición(2) - w_nueva);
B_temp1 = B(h1,w_nueva)*(nueva_posición(1) - h_nueva) + ...
B(h_nueva , w_new)*(h_new + 1 - nueva_posición(1));
B_temp2 = B(h1,w1)*(nueva_posición(1) - h_new) + ...
B (h_new,w1)*(h_new + 1 - nueva_posición(1));
B_final(h,w) = B_temp1*(w_new + 1 - nueva_posición(2))+ ...
B_temp2*(nueva_posición(2) - w_nueva);
else
gray_temp1 = im_init(h1,w_new)*(nueva_posición(1) - h_nueva) + . .
im_init(h_new,w_new)*(h_new + 1 - nueva_posición(1));
gray_temp2 = im_init(h1,w1)*(nueva_posición(1) - h_new ) + ...
im_init(h_new,w1)*(h_new + 1 - nueva_posición(1));
im_final(h,w) = gray_temp1*(w_new + 1 - nueva_posición(2))+ ...
gray_temp2*(nueva_posición(2) - w_new);
fin
fin
fin
fin
fin
if ndims(im_init) == 3
im_final(:,:,1) = R_final ;
im_final(:,:,2) = G_final;
im_final(:,:, 3) = B_final;
Fin
im_final = im2uint8(mat2gray( im_ final));
La parte de implementación es principalmente donde se controla el límite. Utilicé la expansión del bucle. Si cero se considera el límite, puede ver la parte de implementación.
Eso es todo por los detalles, jaja, gracias por tu confianza.
Aviso legal, si algún amigo reenvía el contenido del programa por favor indíquelo.
Esta función sólo puede ayudar a comprender el algoritmo. Si realmente desea utilizarlo, utilice la función imrotate de IPT.