[Graphics Lab Logo Image] Home  Up  Feedback  Contents  Search 

Lucrarea nr.5:

Transformari Grafice 2D

[ Prev ] Lucrarea 5 [ Next ]
[Under Construction]

Descriere

Implementare

Aplicatii

A.Descriere

1. Transformari liniare elementare

Transformarea unei figuri geometrice implica transformarea fiecarui punct din care este alcatuita. Ca urmare transformarea figurii va induce in ultima instanta, transformari la nivelul pixelilor care compun realizarea grafica a figurii geometrice. Transformarile vor fi realizate in coordonate utilizator iar efectele induse asupra pixelilor imaginii grafice vor fi realizate prin transformarea de vedere (fereastra -> port de vedere).

 Forma generala a unei transformari punctuale bidimensionale este:

	x’=f1(x, y)
	y’=f2(x, y)

f1, f2 – functii necesar liniare, sau in forma matriciala

	X’=F(X),
	 

Transformarile pot fi:

  • active – in acest caz X si X’ reprezinta puncte diferite in acelasi sistem de coordonate al utilizatorului
  • pasive – in acest caz X si X’ reprezinta acelasi punct in plan dar in sisteme de coordonate diferite.

In continuare, vom presupune ca transformarile sunt active. In lucrarile anterioare s-a prezentat modul in care fiecare element geometric de baza care este format dintr-un numar infinit de puncte, poate fi definit cu ajutorul unui set finit de puncte. Un element geometric va fi transformat prin aplicarea functiilor de transformare f1, f2 asupra tuturor punctelor din care este constituit, adica de un numar infinit de ori, ceea ce este practic imposibil. Ca urmare se vor aplica functiile f1 si f2 asupra punctelor multimii finite care defineste elementul grafic, iar noul set de puncte obtinute in urma transformarii se vor utiliza pentru generarea elementului transformat. Imaginea obtinuta poate sa nu fie identica cu imaginea reala a elementului transformat. Un element geometric este invariat sub un grup de transformari daca multimea de puncte obtinute prin aplicarea oricarei transformari asupra tuturor punctelor elementului geometric este aceeasi cu cea generata dupa aplicarea transformarii asupra setului de puncte care definesc elementul geometric. 

In forma matriciala avem:

	X’=A*X+B

sau

(1)	x’ = a11*x + a12*y + b1
	y’ = a21*x + a22*y + b2
	 

Vom considerea in continuare urmatoarele transformari grafice elementare:

  1. translatia
  2. rotatia
  3. scalarea

 

2. Coordonate omogene. Matrici de transformare

Un punct din plan P(x, y) poate fi reprezentat ca un vector coloana:

	H = (H1, H2, S)t

H1, H2, S se numesc coordonatele omogene ale punctului P. Coordonatele carteziene (x, y) ale punctului se obtin din coordonatele omogene astfel:

	x = H1 / S
	y = H2 / S

De obicei S = 1, deci x = H1, y=H2. Punctele de pe cercul de la infinit vor avea in coordonate omogene S = 0.

Utilizand coordonatele omogene este posibila tratarea unitara a transformarilor elementare, reprezentate ca matrici de 3x3. In acest caz, transformarile vor avea forma:

(2)	H’ = C * H
	H’ = (x’ y’ 1)t
	H = (x y 1)t

unde A, B sunt matricile din (1).

1. Translatia transforma punctul P(x, y) in punctul P’(x’, y’) dupa modelul:

	x’ = x + tx
	y’ = y + ty
	tx, ty – deplasarile pe directiile x si y

Matricea transformarii este:

2. Rotatia in jurul originii transforma punctul P(x, y) in punctul P(x’, y’) rotind vectorul de pozitie al punctului P, OP, in jurul originii cu un unghi t, in sens trigonometric:

	x’ = x*cos(t) - y*sin(t)
	y’ = x*sin(t) + y*cos(t)

Matricea transformarii este:

3. Scalarea transforma punctul P(x, y) in punctul P(x’, y’) dupa relatiile:

	x’ = x*sx
	y’ = y*sy
	sx, sy - factori de scara in directiile OX si OY

Transformarile succesive ale acestui punct pot fi compuse prin inmultirea succesiva la stanga a matricilor care definesc transformarile individuale. Se obtine o matrice rezultat care se aplica punctului initial conform relatiei (2). Ordinea in care se aplica transformarile nu este arbitrara, lucru ce reiese in mod evident din necomutativitatea produsului matricial.

 

B. Implementare

In cadrul lucrarii se vor implementa procedurile si functiile necesare pentru realizarea urmatoarelor operatii:

  • crearea matricilor de transformare
  • transformarea coordonatelor carteziene in coordonate omogene si reciproc
  • transformarea unui punct 2D
  • transformarea obiectelor grafice.

Aceste operatii se efectueaza in modulul G2Dtransformari. 

/*======================================================================*/
/* G2Dtransformari.h                                                    */
/*======================================================================*/


typedef double MAT2D[3][3];


/* Stabileste centrul curent al transformarilor grafice */
extern void centru (double cx, double cy);


/* Creeaza matricea de translatie cu parametrii tx, ty */
extern void tran_mat (double tx, double ty, MAT2D a);


/*
 * Creeaza matricea de rotatie cu unghiul theta (in radiani)
 * in jurul originii.
 */
extern void rot_mat_orig (double theta, MAT2D a);


/*
 * Creeaza matricea de scalare cu parametrii sx, sy
 * relativ la origine.
 */
extern void scal_mat_orig (double sx, double sy, MAT2D a);


/*
 * Creeaza matricea de rotatie cu unghiul theta (in radiani)
 * in jurul centrului curent al transformarilor.
 */
extern void rot_mat_centru (double theta, MAT2D a);


/*
 * Creeaza matricea de scalare cu parametrii sx, sy
 * relativ la centrul curent al transformarilor.
 */
extern void scal_mat_centru (double sx, double sy, MAT2D a);


/*
 * Aplica punctului P(xi,yi) transformarea activa avand
 * matricea de transformare m. Se obtine punctul P'(xt,yt).
 */
extern void transforma_punct (double xi, double yi, MAT2D m,
double *xt, double *yt);

/*======================================================================*/
/* End of G2Dtransformari.h                                             */
/*======================================================================*/

/*======================================================================*/
/* G2Dtransformari.c                                                    */
/*======================================================================*/

#include <math.h>


#include "G2Dtransformari.h"

/* Structuri de Date Private -------------------------------------------*/

typedef double OMOGEN[3];


static struct { double x, y; } centru_transf = { 0.0, 0.0 };

static MAT2D tmat;

/* Prototipuri Private -------------------------------------------------*/

/* Transforma coordonatele reale in coordonate omogene */
static void real_omogen (double x, double y, OMOGEN p);

/* Transforma coordonatele omogene in coordonate reale */
static void omogen_real (OMOGEN p, double *x, double *y);

/* Creeaza matricea nula */
static void nul (MAT2D m);

/* Creeaza matricea unitate */
static void identic (MAT2D m);

/* Calculeaza produsul matricial C=AxB */
static void produs_mat (MAT2D a, MAT2D b, MAT2D c);

/* Rutine Publice ------------------------------------------------------*/

/* Stabileste centrul curent al transformarilor grafice */
void
centru (double cx, double cy)
{
   centru_transf.x = cx;
   centru_transf.y = cy;
} /* centru */


/* Creeaza matricea de translatie cu parametrii tx, ty */
void
tran_mat (double tx, double ty, MAT2D a)
{
   identic (a);
   a[0][2] = tx;
   a[1][2] = ty;
} /* tran_mat */


/*
 * Creeaza matricea de rotatie cu unghiul theta (in radiani)
 * in jurul originii.
 */
void
rot_mat_orig (double theta, MAT2D a)
{
   identic (a);
   a[0][0] = cos (theta); a[0][1] = -sin (theta);
   a[1][0] = sin (theta); a[1][1] = cos (theta);
} /* rot_mat_orig */


/*
 * Creeaza matricea de scalare cu parametrii sx, sy
 * relativ la origine.
 */
void
scal_mat_orig (double sx, double sy, MAT2D a)
{
} /* scal_mat_orig */


/*
 * Creeaza matricea de rotatie cu unghiul theta (in radiani)
 * in jurul centrului curent al transformarilor.
 */
void
rot_mat_centru (double theta, MAT2D a)
{
   MAT2D b, c, d, e;

   /* aduce centrul transformarii in origine */
   tran_mat (-centru_transf.x, -centru_transf.y, e);

   /* roteste in jurul originii */
   rot_mat_orig (theta, b);

   /* aduce centrul transformarii in pozitia initiala */
   tran_mat (centru_transf.x, centru_transf.y, c);

   produs_mat (b, e, d);
   produs_mat (c, d, a);
} /* rot_mat_centru */


/*
 * Creeaza matricea de scalare cu parametrii sx, sy
 * relativ la centrul curent al transformarilor.
 */
void
scal_mat_centru (double sx, double sy, MAT2D a)
{
} /* scal_mat_centru */


/*
 * Aplica punctului P(xi,yi) transformarea activa avand
 * matricea de transformare m. Se obtine punctul P'(xt,yt).
 */
void
transforma_punct (double xi, double yi, MAT2D m, double *xt, double *yt)
{
   int lin, col;
   double sum;
   OMOGEN pi, pt;

   real_omogen (xi, yi, pi);
   for (lin = 0; lin < 3; lin++)
   {
      sum = 0.0;
      for (col = 0; col < 3; col++)
      {
         sum += m[lin][col] * pi[col];
      }
      pt[lin] = sum;
   }
   omogen_real (pt, xt, yt);
} /* transforma_punct */


/* Rutine Private ------------------------------------------------------*/

/* Transforma coordonatele reale in coordonate omogene */
static void
real_omogen (double x, double y, OMOGEN p)
{
} /* real_omogen */


/* Transforma coordonatele omogene in coordonate reale */
static void
omogen_real (OMOGEN p, double *x, double *y)
{
} /* omogen_real */


/* Creeaza matricea nula */
static void
nul (MAT2D m)
{
} /* nul */


/* Creeaza matricea unitate */
static void
identic (MAT2D m)
{
} /* identic */


/* Calculeaza produsul matricial C=AxB */
static void
produs_mat (MAT2D a, MAT2D b, MAT2D c)
{
} /* produs_mat */


/*======================================================================*/
/* End of G2Dtransformari.c                                             */
/*======================================================================*/

Download G2Dtransformari.h, G2Dtransformari.c.

C. Aplicatii

1. Sa se construiasca si sa se implementeze unitatea G2Dtransformari.

2. Se considera un segment de drepta determinat de punctele P1(0,0) si P2(50,50). Scrieti un program de aplicatie care realizeaza urmatoarele:

  • roteste segmentul in jurul originii cu 45 de grade si apoi il translateaza cu 30 de unitai pe cele doua directii OX respectiv OY
  • translateaza segmentul cu 30 de unitati pe cele doua directii OX si OY si apoi il roteste cu 45 de grade in jurul originii. Observati diferenta fata de primul caz.

3. Scrieti cate un program de aplicatie care care genereaza o imagine in care segmentul P1(10, 10), P2(50, 50) apare in 60 de pozitii in urmatoarele conditii:

  • fiecare pozitie a segmentului se obtine din precedenta dupa o rotatie in jurul originii cu acelasi unghi de 6 grade
  • fiecare pozitie a segmentului se obtine din precedenta dupa o rotatie in jurul mijlocului segmentului cu acelasi unghi de 6 grade
  • fiecare pozitie a segmentului se obtine din precedenta dupa o rotatie in jurul punctului C(0, 45) cu acelasi unghi de 6 grade
  • fiecare pozitie a segmentului se obtine din precedenta dupa o rotatie in jurul originii a punctului P2 cu acelasi unghi de 6 grade si dupa rotatia punctului P1 in jurul originii cu un unghi de 9 grade
  • fiecare pozitie a segmentului se obtine din precedenta dupa o rotatie in jurul originii cu acelasi unghi de 6 grade urmata de o scalare cu factorul 0.9 pe ambele directii, relativa la centrul segmentului
  • fiecare pozitie a segmentului se obtine stiind ca punctul P1 se misca pe cercul cu centrul in origine, avand raza 20 unitati, in sens trigonometric, iar P2 se misca pe cercul cu centrul in origine avand raza de 50 unitati, in sens invers trigonometric.

 

 

[ Home ][ Up ][ Previous ][ Next ]

Send mail to sorin@aspc.cs.utt.ro with questions or comments about this web site.
Copyright © 2000 Graphics Laboratory
Last modified: