• Author / Uploaded
• Joel Jacob Castellanos

Citation preview

UNIVERSIDAD POLITÉCNICA DE TAPACHULA

SISTEMA DE VISION ARTIFICAL ING. MECATRONICA

TRANSFORMACIONES GEOMETRICAS DE UNA IMAGEN.

JOEL JACOB CASTELLANOS 173138

ING. LUIS HIRAM ORDOÑEZ ALONSO.

TAPACHULA, CHIAPAS a 6 de marzo del 2020.

INDICE NTRODUCCION--------------------------------------------------------------------------------------------3 TRANSFORMACIONES GEOMETRICAS-----------------------------------------------------------4 REDIMENSIONALIZACION------------------------------------------------------------------------------------------4 TRANSLACION-----------------------------------------------------------------------------------------------------------5 ROTACION-----------------------------------------------------------------------------------------------------------------6 TRANSFORMACION A FIN-------------------------------------------------------------------------------------------7 TRANSFORMACION DE PERPESTIVA--------------------------------------------------------------------------8 INCLINACION CON OPENCV---------------------------------------------------------------------------------------9 CONCLUSION-------------------------------------------------------------------------------------------------------------11 BIBLIOGRAFIA-----------------------------------------------------------------------------------------------------------12

INTRODUCCION En el procesamiento de señales e imágenes se utilizan algunas técnicas sustentadas en el conocimiento de los operadores lineales y no lineales. El avance de las tecnologías de comunicación e información permiten hoy en día la aplicación de imágenes (matrices) y transformaciones del álgebra lineal a diversas áreas de las ciencias puras y aplicadas, así como de la ingeniería.

TRANSFORMACIONES GEOMÉTRICAS DE IMÁGENES CON OPENCV. Una transformación geométrica de una imagen es una transformación en su sistema de coordenadas.

OpenCV

proporciona

dos

funciones

de

transformación,

cv2.warpAffine y cv2.warpPerspective, con las que se pueden realizar todo tipo de transformaciones. Cv2.warpAffine toma

una

matriz

de

transformación

2×3

mientras cv2.warpPerspective toma una matriz de transformación 3×3 como entrada.

REDIMENSIONALIZACIÓN. Para cambiar el tamaño de una imagen, OpenCV viene con la función cv2.resize(). El tamaño deseado de la imagen final se puede especificar manualmente, o se puede indicar especificando un factor de escala. La función usa diferentes métodos de interpolación, siendo

los

más

usados: cv2.INTER_AREA,

para

contraer

la

imagen

y cv2.INTER_CUBIC (suave) & cv2.INTER_LINEAR, para acercar la imagen. El método de interpolación utilizado por defecto es cv2.INTER_LINEAR, que sirve para cualquier cambio de tamaño que se desee realizar. Cualquiera de los métodos mostrados a continuación, pueden ser utilizados para cambiar el tamaño de una imagen:

1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11.

import numpy as np import cv2 img = cv2.imread('MotherofDragons.jpg') #Indicando el factor de escala res = cv2.resize(img,None,fx=2, fy=2, interpolation = cv2.INTER_CUBIC) # Indicando manualmente el nuevo tamaño deseado de la iamgen height, width = img.shape[:2] res = cv2.resize(img,(2*width, 2*height), interpolation = cv2.INTER_CUBIC)

TRASLACIÓN. Una traslación es el desplazamiento de la posición de un objeto. Si se conoce la magnitud del desplazamiento 

 en las direcciones x e y, respectivamente, se puede escribir la

matriz de transformación M como:

La matriz M se puede crear utilizando la función np.float32 de la librería Numpy (ver curso introductorio).

Esta

matriz

luego

se

pasa

como

argumento

a

la

función cv2.warpAffine(). Observa el siguiente ejemplo para un desplazamiento de (210, 20). 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12.

import cv2 import numpy as np img = cv2.imread('MotherofDragons.jpg',0) rows,cols = img.shape M = np.float32([[1,0,210],[0,1,20]]) dst = cv2.warpAffine(img,M,(cols,rows)) cv2.imshow('img',dst) cv2.waitKey(0) cv2.destroyAllWindows()

Nota El tercer argumento de la función cv2.warpAffine () es el tamaño de la imagen de salida, que debe estar en forma de (anchura, altura). Recuerde, width = número de columnas y height = número de filas. A continuación, el siguiente resultado:

ROTACIÓN.

La rotación de una imagen, en un cierto ángulo θ, se logra aplicando la siguiente matriz de transformación:

Sin embargo, OpenCV permite además personalizar más la rotación multiplicando por un factor de escala. Por otra parte, también permite cambiar el centro de rotación. La matriz de transformación modificada, con estas dos nuevas opciones, tiene la forma:

donde

Para

encontrar

esta

matriz

de

transformación,

OpenCV

proporciona

la

función cv2.getRotationMatrix2D. Compruebe a continuación un ejemplo en el cual se gira la imagen 45 grados con respecto al centro sin aplicar ningún factor de escala.

1. 2. 3. 4. 5.

img = cv2.imread('MotherofDragons.jpg',0) rows,cols = img.shape M = cv2.getRotationMatrix2D((cols/2,rows/2),45,1) dst = cv2.warpAffine(img,M,(cols,rows))

 

TRANSFORMACIÓN A FÍN.

En una transformación afín todas las líneas paralelas en la imagen original seguirán siendo paralelas en la imagen de salida. Para encontrar la matriz de transformación, necesitamos tres puntos de la imagen de entrada y sus ubicaciones correspondientes en la imagen de salida.

Luego cv2.getAffineTransform creará

una

matriz

2×3

que

se

pasará

a cv2.warpAffine. Compruebe a continuación el ejemplo, y observe los puntos que he seleccionado (marcados en color verde):

1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17.

 

import numpy as np import matplotlib.pyplot as plt #carga la librería para graficar import cv2 img = cv2.imread('cuadricula.png') rows,cols,ch = img.shape pts1 = np.float32([[100,400],[400,100],[100,100]]) pts2 = np.float32([[50,300],[400,200],[80,150]])

M = cv2.getAffineTransform(pts1,pts2) dst = cv2.warpAffine(img,M,(cols,rows)) plt.subplot(121),plt.imshow(img),plt.title('Input') plt.subplot(122),plt.imshow(dst),plt.title('Output') plt.show()

TRANSFORMACIÓN DE PERSPECTIVA. Para realizar una transformación de perspectiva es necesario especificar una matriz de 3×3. Luego de aplicar este tipo de transformación, las líneas rectas permanecerán rectas. Para generar la matriz de 3×3 es necesario indicar cuatro puntos sobre la imagen de inicial y los correspondientes puntos sobre la imagen resultante. Tres de los cuatro puntos, tienen que ser no-colineales. De esta manera la matriz de transformación puede ser generada utilizando la función cv2.getPerspectiveTransform. Luego, para aplicar la transformación, se utiliza cv2.warpPerspective teniendo en cuenta la matriz de 3×3 generada con la función anterior. A continuación, un ejemplo:

1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17.

import numpy as np import matplotlib.pyplot as plt import cv2 img = cv2.imread('sudoku.png') rows,cols,ch = img.shape pts1 = np.float32([[56,65],[368,52],[28,387],[389,390]]) pts2 = np.float32([[0,0],[300,0],[0,300],[300,300]]) M = cv2.getPerspectiveTransform(pts1,pts2) dst = cv2.warpPerspective(img,M,(300,300)) plt.subplot(121),plt.imshow(img),plt.title('Input') plt.subplot(122),plt.imshow(dst),plt.title('Output') plt.show()

INCLINACIÓN CON OPENCV La inclinación se puede aplicar sobre el eje X, Y o ambos si lo deseamos así, al igual que las transformaciones previas debemos definir la siguiente matriz:

Nuestro ejemplo agrega una inclinación de 20 grados en el eje X y de 15 grados en el eje Y, si deseamos inclinar solamente en X establecemos Y a cero o viceversa. import cv2 import numpy as np import math src = cv2.imread('lena.jpg') rows, cols = src.shape[:2] ix = math.tan(20 * math.pi / 180) iy = math.tan(15 * math.pi / 180) M = np.float32([[1, ix, 0], [iy, 1, 0]]) dst = cv2.warpAffine(src, M, (cols + 256, rows + 256)) cv2.imshow('lena.jpg', src) cv2.imshow('Inclinar', dst) cv2.waitKey()

El resultado de la operación:

Debido la inclinación el tamaño de la imagen de destino debe ser mayor a la original para poder contener la imagen deformada. Una forma diferente de calcular la matriz de transformación correspondiente es utilizar la función OpenCV llamada  cv2.getAffineTransform()  para utilizarle debemos indicar dos conjuntos de 3 puntos, el primero define el triángulo que abarca la imagen original, el segundo define la ubicación a donde deben moverse cada uno de estos puntos.  

Por ejemplo, para generar una transformación similar a la anterior: pt1 = np.float32([[0, 0], [cols, 0], [0, rows]]) pt2 = np.float32([[20, 20], [cols - 120, rows / 4], [cols / 4, rows - 120]]) M = cv2.getAffineTransform(pt1, pt2)

Cada pixel ubicado dentro del paralelogramo definido por los puntos de origen será mapeado al paralelogramo definido por los puntos de destino.

CONCLUSION Como punto final, pude observar que hay muchas opciones sobre las imágenes, como el hecho de poder rotar la imagen a voluntad, de la misma manera con las dimensiones de la imagen y así mismo la ubicación de los pixeles de una imagen, pero para poder hacer esto, se deben tomar en cuenta las matrices para cada operación.

BIBLIOGRAFIA [1] Gonzalez, R. & Woods R. Digital Image Processing. Second Edition. Prentice Hall. New Jersey. 2002. [2]

Gonzalez, R. & Woods R. Digital Image Processing using MATLAB. 1a Edition. Prentice Hall. New Jersey. 2004.

[3]

Strang, Gilbert. Introduction to Linear Algebra. Wellesley-Cambridge Press. 3a Edition 2003.