transformaciones geomÉtricas

TRANSFORMACIONES GEOMÉTRICAS

GRAFICACIÓN I

Transformaciones en dos dimensiones

Los objetos se definen mediante un conjunto de puntos. Las transformaciones son procedimientos para calcular nuevas posiciones de estos puntos, cambiado el tamaño y orientación del objeto.

Las operaciones básicas de transformación son

Traslación

Escalamiento

Rotación.

TraslaciónLas coordenadas (x, y) de un objeto se transforman a (x', y') de acuerdo a las fórmulas:

x x T y y Tx y' , '

El par (Tx, Ty) se conoce como vector de traslación.

y

x

(a)

Ejemplo traslación

Vector de desplazamiento

Vector de desplazamiento T = (–3, –2)

(x1, y1) = (2, 3)

(x3, y3) = (3, 1)

(x2, y2) = (1, 1)(x1, y1)

(x2, y2)(x3, y3)

(x1’, y1’) = (2, 3) + (–3, –2) = (–1, 1)

(x2’, y2’) = (1, 1) + (–3, –2) = (–2, –1)

(x3’, y3’) = (3, 1) + (–3, –2) = (0, –1)

(x1’, y1’)

(x2’, y2’) (x3’, y3’)

EscalamientoEl escalamiento modifica el tamaño de un polígono. Para obtener este efecto, se multiplica cada par coordenado (x, y) por un factor de escala en la dirección x y en la dirección y para obtener el par (x', y').

Las fórmulas son

x x S y y Sx y' ' y

x

y

x

(a)(b)

Ejemplo escalamientoFactores de escalamiento S = (2, –1)

(x1, y1) = (2, 3)

(x3, y3) = (3, 1)

(x2, y2) = (1, 1)(x1, y1)

(x2, y2)(x3, y3)

(x1’, y1’) = (2*2, (–1)3) = (4, –3)

(x2’, y2’) = (2*1, (–1)1) = (2, –1)

(x3’, y3’) = (2*3, (–1)1) = (6, –1)(x1’, y1’)

(x2’, y2’)(x3’, y3’)

RotaciónLa rotación gira los puntos de una figura alrededor de un punto fijo. De la figura se obtiene

y

x

r

r(x, y)

(x', y')

x r r r

y r r r

' cos cos cos sen sen

' sen sen cos cos sen

x x y

y y x

' cos sen

' cos sen

Simplificando

Ejemplo rotaciónÁngulo de rotación = 45°

(x1, y1) = (2, 3)

(x3, y3) = (3, 1)

(x2, y2) = (1, 1)(x1, y1)

(x2, y2)(x3, y3)

(x1’, y1’) = (2cos(45°) – 3sen(45°), 3cos(45°) + 2sen(45°))

= (2*0.707–3*0.707, 3*0.707+2*0.707) = (–0.707, 3,54)

(x2’, y2’) = (3cos(45°) –sen(45°), cos(45°) + 3sen(45°))

= (3*0.707–0.707, 0.707+3*0.707) = (1.414, 2.828)

(x3’, y3’) = (cos(45°) – sen(45°), cos(45°) + sen(45°))

= (0.707–0.707, 0.707+0.707) = (0, 1.414)

(x1’, y1’)

(x2’, y2’)

(x3’, y3’)

Escalamiento respecto a un punto fijo

Se puede llevar a cabo un escalamiento respecto a un punto fijo trasladando primero ese punto al origen, después escalando y luego regresando el objeto a la posición original.

Las ecuaciones son

x x x x S y y y y Sx y' , ' F F F F

y

x

y

x

(a)(b)

(x ,y )F F

F

F

1'

1'

ySSyy

xSSxx

yy

xx

Reacomodando

Rotación respecto a un punto arbitrario

La rotación respecto a un punto arbitrario es

x x x x y y

y y y y x x

' cos sen

' cos sen

R R R

R R R

y

x

(x , y )R R

Ejemplo rotación 2Ángulo de rotación = –90°

Centro de rotación (3,1)

(x1, y1) = (2, 3)

(x3, y3) = (3, 1)

(x2, y2) = (1, 1)

(x1, y1)

(x2, y2)(x3, y3)

(x1’, y1’)

(x2’, y2’)

= (x3’, y3’)

x1’ = 3 + (2 – 3)cos(–90°) – (3 – 1) sen(–90°)= 3 + 2 = 5

y1’ = 1 + (3 – 1)cos(–90°) + (2 – 3) sen(–90°)= 1 + 1 = 2

x2’ = 3 + (1 – 3)cos(–90°) – (1 – 1) sen(–90°)= 3

y2’ = 1 + (1 – 1)cos(–90°) + (1 – 3) sen(–90°)= 1 + 2 = 3

x3’ = 3 + (3 – 3)cos(–90°) – (1 – 1) sen(–90°)= 3

y3’ = 1 + (1 – 1)cos(–90°) + (3 – 3) sen(–90°)= 1

Código en Cstruct point{ float x,y;};void translate(point &p, float tx, float ty){ p.x = p.x + tx; p.y = p.y + ty;}void scale(point &p, float sx, float sy){ p.x = sx*p.x; p.y = sy*p.y;}void rotate(point &p, float a){ float sn = sin(a*PI/180); float cs = cos(a*PI/180); p.x = cs*p.x - sn*p.y; p.y = cs*p.y + sn*p.x;}

void rotateFix(point &p, float a,float xr, float yr){ translate(p,-xr,-yr); rotate(p,a); translate(p,xr,yr);}

void scaleFix(point &p, float sx, float sy,float xf, float yf){ translate(p,-xf,-yf); scale(p,sx,sy); translate(p,xf,yf);}

void translatePoly(point *p,int n, float tx, float ty){ for(int i=0; i<n ; i++) translate(p[i],tx,ty);}

TareaEscriba una función que dibuje un polígono relleno. Haciendo uso de esa función, escriba un programa en C que dibuje la figura que se muestra transformada mediante traslaciones, escalamientos y rotaciones para crear la imagen que se muestra.

Coordenadas homogéneasPara poder representar las tres transformaciones en forma matricial como producto de matrices, es necesario representar los puntos en coordenadas homogéneas.

Estas coordenadas agregan una tercer componente a las coordenadas bidimensionales. De tal forma que, un punto (x, y) pasa a ser (x, y, W). El punto en coordenadas Cartesianas representado por esta tríada es el (x/W, y/W). El valor de W es generalmente 1.

Representación matricial de traslaciones

Haciendo uso de coordenadas homogéneas la traslación puede representarse como:

x y x y

T Tx y

' ' 1 1

1 0 0

0 1 0

1

En forma abreviada la transformación se representará por T(Tx, Ty)

T T T

T Tx y

x y

,

1 0 0

0 1 0

1

P P T T Tx y' ,

Haciendo uso de coordenadas homogéneas el escalamiento puede representarse como:

En forma abreviada la transformación se representará por S(Sx, Sy)

x y x y

S

Sx

y' ' 1 1

0 0

0 0

0 0 1

P P S S Sx y' , S S S

S

Sx y

x

y,

0 0

0 0

0 0 1

Representación matricial de escalamientos

Representación matricial de rotaciones

Haciendo uso de coordenadas homogéneas la rotación puede representarse como:

En forma abreviada la transformación se representará por R()

x y x y' '

cos sen

sen cos1 1

0

0

0 0 1

P P R' R

cos sen

sen cos

0

0

0 0 1

Composición de transformaciones

Para aplicar varias transformaciones a un conjunto de puntos basta con combinar las matrices de transformación en una sola, mediante multiplicación matricial. En caso de tener solo transformaciones del mismo tipo, la combinación sigue reglas muy simples.

T T T T T T T T T T Tx y x y x x y y1 1 2 2 1 2 1 2, , , Traslación:

Escalamiento:

Rotación:

S S S S S S S S S S Sx y x y x x y x1 1 2 2 1 2 1 2, , ,

R R R 1 2 1 2

Escalamiento respecto a un punto fijo en forma matricial

Para llevar a cabo un escalamiento respecto a un punto fijo, se procede multiplicando una matriz de traslación para llevar el punto fijo al origen por una de escalamiento y posteriormente por otra de traslación para llevar al punto fijo a su posición original.

1 0 0

0 1 0

1

0 0

0 0

0 0 1

1 0 0

0 1 0

1

0 0

0 0

1 1 1

x y

S

S

x y

S

S

S x S y

x

y

x

y

x y

F F F F

F F

(a)

(x ,y )F F

Objeto original y punto fijo

(b)Traslada de manera que elpunto fijo quede en el origen

(c)Escala el objeto respecto al origen

(d)

(x ,y )F F

Traslada de manera que elpunto fijo quede en la posiciónoriginal

Rotación respecto a un punto fijo en forma matricial

Para llavar a cabo una rotación respecto a un punto fijo, se procede multiplicando una matriz de traslación para llevar el punto fijo al origen por una de rotación y posteriormente por otra de traslación para llevar al punto fijo a su posición original.

1cos1cos1

0cos

0cos

1

010

001

100

0cos

0cos

1

010

001

RRRR

RRRR

senxysenyx

sen

sen

yx

sen

sen

yx

(a)

(x ,y )R R

Objeto original y punto fijo

(b)Traslada de manera que elpunto fijo quede en el origen

(c)Rota el objeto respecto al origen

(d)

(x ,y )R R

Traslada de manera que elpunto fijo quede en la posiciónoriginal

Forma general

En general una transformación que utilice traslaciones, escalamientos y rotaciones tendrá la forma:

x y x y

a d

b e

c f

' ' 1 1

0

0

1

Por tanto, el cálculo de las coordenadas transformadas se podrá hacer con las siguientes ecuaciones

feydxy

cbyaxx

'

'

Otras transformaciones

Otras transformaciones que permiten llevar a cabo operaciones muy útiles, estas son:

Reflexiones

Corte.

Reflexiones en x y yLas reflexiones respecto al eje x y y se obtienen con las matrices siguientes:

1 0 0

0 1 0

0 0 1

1 0 0

0 1 0

0 0 1

(a) (b)

Posición original

Posición reflejada

Posición reflejadaPosición original

Reflexión respecto al origen

1 0 0

0 1 0

0 0 1

(a)

Posición original

Posición reflejada

La reflexión respecto al origen se obtiene con :

Reflexión respecto a la recta y = x

Una reflexión respecto a la recta y = x, puede obtenerse en tres pasos: girar un ángulo de 45 en el sentido de las manecillas del reloj, una reflexión respecto al eje x, y una rotación de 45 grados en contra del sentido del reloj.

0 1 0

1 0 0

0 0 1

Posición original

(a) Rotación de -45 grados (b) Reflexión respecto a x. (a) Rotación de 45 grados

Posición original

Posición reflejada

Corte en xEl corte produce una deformación similar al deslizamiento de una capa sobre otra. El corte en x se produce por la matriz:

1 0 0

1 0

0 0 1

SH x

(a) (b)

(1,1)(2,1) (3,1)

(1,0)

(0,1)

(0,0) (0,0) (1,0)x x

y y

yshxxx '

xshyyy '

Corte en yEl corte en y se produce por la matriz

1 0

0 1 0

0 0 1

SH y

(a) (b)

(1,1)

(1,2)

(1,3)

(1,0)

(0,1)

(0,0) (0,0)

(0,1)

x x

y y

Implementación de transformaciones con matrices

Para la implementación de matrices es conveniente definir tipos para punto y matriz.

Luego funciones para crear las matrices de las transformaciones básicas.

Lo primero es crear una matriz unitaria y a partir de está crear las demás funciones.

Es necesaria definir una función para multiplicar matrices y poder acumular las transformaciones.

Otra función debe aplicar una matriz de transformación a un punto y regresar el punto transformado.

Finalmente aplicar la matriz a un ppolígono.

Tipos básicos

Los tipos básicos para punto, matriz y polígono son los siguientes:

typedef double Point[3];typedef double Matrix[3][3];typedef Point poligono[10];

El punto p(1, -4) se define como

Point p = {1,-4,1};

Crear matriz identidad

La matriz identidad es la base para las demás funciones

void set_identity(Matrix m){ int i,j; for(i = 0; i<3 ; i++) for(j = 0; j<3 ; j++) m[i][j] = (i==j);}

Matrices de traslación y escalamiento

Matriz de traslación.

void create_traslation_matrix(double tx, double ty,Matrix t){ set_identity(t); t[2][0] = tx; t[2][1] = ty;}

Matriz de escalamiento:

void create_scale_matrix(double sx, double sy,Matrix t){ set_identity(t); t[0][0] = sx; t[1][1] = sy;}

Matriz de rotación

El ángulo se especifica en grados.

void create_rotation_matrix(double a,Matrix t){ set_identity(t); double sn = sin(a*PI/180); double cs = cos(a*PI/180); t[0][0] = cs; t[0][1] = sn; t[1][0] = -sn;t[1][1] = cs;}

Matriz de corte

Solo es necesario definir una matriz de corte. Si se hace solo corte en x, shy = 0 y si se hace solo corte en y, shx = 0.

void create_shear_matrix(double shx, double shy,Matrix t){ set_identity(t); t[0][1] = shy; t[1][0] = shx;}

Acumula dos transformacionesLos parámetros m1 y m2 son de entrada, el resultado se almacena en m.

void accumulate_matrices(Matrix m1,Matrix m2,Matrix m){ int i,j,k; double s; for(i = 0; i<3 ; i++) for(j = 0; j<3 ; j++){ s = 0; for(k = 0; k<3 ; k++) s = s+m1[i][k]*m2[k][j]; m[i][j] = s; }}

Transformar un punto y un polígonoEl punto de entrada es p1 y el de salida p2.

void transformPoint(Point p1,Matrix m,Point p2){ p2[0] = m[0][0]*p1[0]+m[1][0]*p1[1]+m[2][0]*p1[2]; p2[1] = m[0][1]*p1[0]+m[1][1]*p1[1]+m[2][1]*p1[2]; p2[2] = m[0][2]*p1[0]+m[1][2]*p1[1]+m[2][2]*p1[2];}

El polígono de entrada es p1 y el de salida p2. n es el número de puntos del polígono.

void transformPoly(poligono p1,int n,Matrix m,poligono p2){ for(int i = 0;i<n;i++) transformPoint(p1[i],m,p2[i]);}

Dibujar polígono

Dibuja un polígono. Note que la tercer coordenada no se usa.

void draw(poligono p,int n){ moveto((int)p[0][0],(int)p[0][1]); for(int i=1;i<n;i++){ lineto((int)p[i][0],(int)p[i][1]); } }

Transformaciones Ventana-Puerto de visión

Las transformaciones ventana-puerto de visión, mapean puntos en el mundo real a puntos en la pantalla.

Coordenadas mundiales Coordenadas de pantalla

Ventana

Puerto de visión 1

Puerto de visión 2

Transformaciones de visión

Ventana en coordenadas mundiales

(xmin, ymin)

(xmax, ymax)

Ventana trasladada al origen

Ventana escalada al tamaño del área de visión.

Traslación hasta la posición final.

(umin, vmin)

(umax, vmax)

Transformaciones de visión (continuación)

minminminmax

minmax

minmax

minmaxminmin ,,, vuT

yyvv

xxuu

SyxTMWV

1

010

001

100

00

00

1

010

001

minminminmax

minmax

minmax

minmax

minmin vuyyvv

xxuu

yx

Transformaciones de visión (continuación)

1

00

00

minminmax

minmaxminmin

minmax

minmaxmin

minmax

minmax

minmax

minmax

vyyvv

yuxxuu

x

yyvv

xxuu

MWV

Implementación en C

void crate_window_view_matrix( double xmin,double ymin, double xmax, double ymax, int umin, int vmin, int umax, int vmax, Matrix m){ Matrix m1,m2,m3,m4; create_traslation_matrix(-xmin,-ymin,m1); create_scale_matrix((umax-umin)/(xmax-xmin), (vmax-vmin)/(ymax-ymin),m2); create_traslation_matrix(umin,vmin,m3); accumulate_matrices(m1,m2,m4); accumulate_matrices(m4,m3,m);}

Rutina de desplieguevoid show_polygon( double xmin,double ymin,double xmax,double ymax, int umin,int vmin,int umax,int vmax,poligono p){ Matrix m1,m2; poligono p2,p3; //poligonos transformados int xv1,xv2,yv1,yv2; //coordenadas del viewport //es necesario ordenar las coordenadaas del viewport if(umin>umax){ xv1 = umax; xv2 = umin; }else{ xv1 = umin; xv2 = umax; } if(vmin>vmax){ yv1 = vmax; yv2 = vmin; }else{ yv1 = vmin; yv2 = vmax; }

//dibuja un rectángulo para delimitar el viewport setlinestyle(DOTTED_LINE,0,NORM_WIDTH); rectangle(xv1,yv1,xv2,yv2);//es necesario trasladar al origen porque el viewport// define coordenadas con 0,0 en la esquina superior// izquierda create_traslation_matrix(-xv1,-yv1,m2); crate_window_view_matrix(xmin,ymin,xmax,ymax, umin,vmin,umax,vmax,m1);

//transforma a coordenadas de visión transformPoly(p,10,m1,p2);//traslada poígono al origen del viewport transformPoly(p2,10,m2,p3);//establece viewport setviewport(xv1,yv1,xv2,yv2,true); setlinestyle(SOLID_LINE,0,NORM_WIDTH); draw(p3,10); setviewport(0,0,getmaxx(),getmaxy(),false);}

Ejemplo de función main

main(){ poligono p,p2; Matrix m1,m2; initPol(p); initwindow(500,500); show_polygon(5,5,20,20,220,350,450,20,p); show_polygon(-1,-1,11,11,20,100,100,20,p); show_polygon(-10,-10,20,20,20,200,200,120,p); show_polygon(-1,-1,5,5,20,370,140,250,p); getch();}

Salida del ejemplo

Propiedades de las transformaciones

Los vectores fila de la submatriz superior 2x2 de rotación tienen tres propiedades:

1. Cada uno es un vector unidad

2. Cada uno es perpendicular al otro (su producto punto es cero)

3. El primer y segundo vector se rotarán por R() para que caigan sobre los ejes x y y positivos.

Una matriz que cumple esto se le llama ortogonal especial.

Una matriz de transformación de la forma:

1002221

1211

y

x

trr

trr

Donde la submatriz superior de 2x2 es ortogonal, conserva los ángulos y las longitudes.

Estas transformaciones se denominan de cuerpo rígido.

Una secuencia arbitraria de traslaciones, rotaciones y escalamientos conserva el paralelismo de las líneas, pero no la longitud ni los ángulos. Estas transformaciones se denominan transformaciones afines.

Operaciones de rastreoEl buffer de pantalla se puede manipular directamente para llevar a cabo algunas transformaciones. La más sencilla es la copia de un bloque de un lugar de la pantalla a otro.

Para girar una figura un ángulo múltiplo de 90 grados se pueden lograr invirtiendo renglones por columnas. La rotación por 180 grados se logra invirtiendo cada renglón y posteriormente invirtiendo los renglones.

Para otros ángulos cada área de pixel de destino se diagrama sobre la matriz que se gira y se calcula la cantidad de superposición con las áreas de pixel que se giran. Entonces se calcula una intensidad para el pixel al promediar las intensidades de los pixeles fuente superpuestos.

Rotación diferente de 90 grados

Escalamiento del mapa de bitsEscalamos las áreas de pixeles en el bloque original al emplear los valores de sx y sy y diagramar el rectángulo que se escala sobre un conjunto de pixeles destino. La intensidad de cada pixel destino se designa de acuerdo con el área de superposición con las áreas de pixel que se escalan.

TareaEscribir una biblioteca para realizar transformaciones de 2D utilizando matrices, defina lo siguiente:

- Tipo vector y tipo matriz en coordenadas homogéneas

- Rutinas para: trasladar, rotar, escalar, reflejar, cortar y transformación de puerto de visión.

Animación

Para lograr una animación mediante transformaciones es conveniente mantener una copia del los objetos sin transformar.

Para lograr la animación se copia el objeto original, luego se le aplican a esta copia las transformaciones a realizar y se dibuja el objeto transformado.

-Copiar objeto

- transformar

- dibujar

EjemploDefine un cruz:

void init(){ poly[0].x = 0;poly[0].y = 10; poly[1].x = 10;poly[1].y = 10; poly[2].x = 10;poly[2].y = 0; poly[3].x = 20;poly[3].y = 0; poly[4].x = 20;poly[4].y = 10; poly[5].x = 30;poly[5].y = 10; poly[6].x = 30;poly[6].y = 20; poly[7].x = 20;poly[7].y = 20; poly[8].x = 20;poly[8].y = 30; poly[9].x = 10;poly[9].y = 30; poly[10].x = 10;poly[10].y = 20; poly[11].x = 0;poly[11].y = 20;}

void play(){ char c; int i,p=0; unsigned int size; point p1[20]; float a=0,da = 0,vx=0,vy=0,x=0,y=0; setactivepage(1); for(i = 0; i< 1000; i++){ putpixel(rand()%400,rand()%400,rand()%15+1); } size = imagesize(0, 0, 400, 400); /* allocate memory to hold the image */ img = malloc(size); /* grab the image */ getimage(0,0,400,400,img);

while(true){ if(kbhit()){ c = (char)getch(); switch(c){ case 27:return; case 'i':vy--;break; case 'm':vy++;break; case 'j':vx--;break; case 'k':vx++;break; case 'r':da--;break; case 't':da++;break; case ‘e':s--;break; case ‘w':s++;break; } } x += vx; y += vy; a += da;

a=(a>360)?a-360:a; a=(a<-360)?a+360:a; if(x>400) x= 0; if(y>400) y= 0; if(x<0) x= 400; if(y<0) y= 400;

inicia

Lee teclado

//copia el polígono orignal for(i = 0; i<12 ; i++) p1[i] = poly[i]; setfillstyle(1,BLUE); setcolor(BLUE); rotatePoly(p1,12,a,15,15); scalePoly(p1,12,3+s,3+s); translatePoly(p1,12,x,y); setvisualpage(1-p); setactivepage(p); putimage(0,0,img,COPY_PUT); fillPoly(p1,12); delay(10); swapbuffers( ); p = 1-p; }

Doble búfer para animar

Objeto original

Gira a grados

Se escala 3+s veces

Traslada a x,y

Biblioteca de transformaciones//archivo: transform.hstruct point{ float x,y;};

void translate(point &p, float tx, float ty);void scale(point &p, float sx, float sy);void rotate(point &p, float a);void rotateFix(point &p, float a,float xr, float yr);void scaleFix(point &p, float sx, float sy,float xf, float yf);void translatePoly(point *p,int n, float tx, float ty);void dibujaPunto(point p);void dibujaPoly(point *p,int n);void transW2V(point *p,int n,float xmin,float ymin,float xmax,float ymax, int umin,int vmin,int umax, int vmax);void copia(point *p1,point *p2,int n);

//archivo: transform.cpp#include <graphics.h>#include <math.h>#include "transform.h"float PI = 3.14159265;void translate(point &p, float tx, float ty){...

void transW2V(point *p,int n,float xmin,float ymin,float xmax,float ymax,int umin,int vmin,int umax, int vmax){ int i; for(i=0; i<n ; i++){ translate(p[i],-xmin,-ymin); scale(p[i],(umax-umin)/(xmax-xmin),(vmax-vmin)/(ymax-ymin)); translate(p[i],umin,vmin); } rectangle(umin,vmin,umax,vmax);}void copia(point *p1,point *p2,int n){ int i; for(i=0; i<n; i++) p2[i] = p1[i];}

#include <graphics.h>#include "transform.h"

main(){ initwindow(400,400); point p[10],p1[10]; p[0].x = 0;p[0].y = 10; p[1].x = 10;p[1].y = 10; p[2].x = 10;p[2].y = 0; p[3].x = 20;p[3].y = 0; p[4].x = 20;p[4].y = 10; p[5].x = 30;p[5].y = 10; dibujaPoly(p,6); copia(p,p1,6); transW2V(p1,6,0,0,30,30,100,100,150,150); dibujaPoly(p1,6); copia(p,p1,6); transW2V(p1,6,0,0,30,20,200,100,350,300); dibujaPoly(p1,6);// setviewport(100,100,200,200,true);// dibujaPoly(p,6); getch();}