Laborator I. Graph.

h si Sistem cartezian

Pt toate functiile: https://home.cs.colorado.edu/~main/bgi/doc/

Introducere.
Originea ecranului este in stanga sus.
Originea ferestrei este tot in stanga sus.
Codurile culorilor sunt: BLACK, RED, YELLOW, GREEN etc.
Creeaza fereastra.
initwindow(int x, int y, char* nume, int x2, int y2) unde:
- (x,y) reprezinta dimensiunea ferestrei in pixeli; x reprezinta axa x (orizontal) iar y axa y (vertical
- Char* nume reprezinta numele ferestrei care apare pe bara de titlu; acesta e parametru facultativ
- (a,b) reprezinta offsetul ferestrei raportat la originea ecranului.
Coloreaza fereastra.
cleardevice() este o functie care coloreaza background-ul. Culoarea cu care va colora se seteaza cu
urmatoarea functie: setbkcolor(BLACK)
outtextxy(x,y, “text”) este functia cu care se afiseaza un text in fereastra la coordonatele (x,y)
Coordonate.
getmaxx() returneaza coordonata x maxima
getmaxy() returneaza coordonata y maxima
Spre exemplu, intr-o fereastra de 800x600: :
- (getmaxx(),0) este punctul de coordonate (800,0)
- (0,getmaxy()) este punctul de coordonate (0,600)
- (getmaxx(), getmaxy()) este punctul de coordonate (800,600)
getx() returneaza coordonata x a pixelului curent
gety() returneaza coordonata y a pixelului curent
setviewport(xx, xy, yx, yy) seteaza o noua origine unde (xx,xy) este punctul pentru axa x iar (yx,yy) estep
unctul pentru axa y).
Figuri.
setcolor(color) este functia cu care se seteaza culoarea cu care desenam figurile geometrice.
putpixel(x,y, color) este o functie care afiseaza un pixel in fereastra: (x,y) sunt coordonatele la care va fi
afisat iar char* color este culoarea cu care il va afisa, eg putpixel(1,1,BLACK).
line(xstart, ystart, xend, yend) este functia care traseaza o linie care pleaca din punctul (xstart,ystart) si se
termina in punctul (xend,yend).
circle(xcentru, ycentru, raza) este functia care deseneaza un cerc cu centrul (xcentru,ycentru).
rectangle(xss, yss, xdj, ydj) este functia care deseneaza un dreptunghi unde (xss,yss) sunt coordonatele
punctului din coltul din stanga sus iar (xdj,ydj) sunt coordonatele punctului din coltul dreapta jos.
Project 1. Deseanza o masina si fa-o sa se pe axa x.
#include "graphics.h"
#include <math.h>
#include <stdlib.h>
#include <dos.h>
#include <windows.h>
#include <iostream>
void main(){
initwindow(600, 450);

for (int z = 0; z < 450; z++) {

setbkcolor(BLACK);
cleardevice();
line(0, 400, getmaxx(), 400);
rectangle(20+z, 350, 80+z, 380);
circle(35+z, 390, 10);
circle(65+z, 390, 10);
Sleep(3);
}
getch();
closegraph();
}
Project 2. Sistem cartezian.
#include "graphics.h"
#include <math.h>
#include <stdlib.h>
#include <dos.h>
#include <windows.h>
#include <iostream>

using namespace std;

#define pi 3.14159265359
int gd, gm;
int n, i, j;
double r, x, y, xp, yp, fi;

float x_1, x_2, y_1, y_2;

int a, b;
int xe(float x)// normalizarea coordonatei x
{
return((int)((x - x_1) / (x_2 - x_1) * a));
}
int ye(float y)// normalizarea coordonatei y
{
return((int)((y_2 - y) / (y_2 - y_1) * b));
}
void axe() {
setcolor(WHITE);
outtextxy(xe(x_2) - 20, ye(0) - 20, "x");
outtextxy(xe(x_2) - 18, ye(0) - 8, ">");
outtextxy(xe(0) - 15, ye(y_2) + 15, "y");
outtextxy(xe(0) - 15, ye(0) - 15, "O");
outtextxy(xe(0) - 1, ye(y_2)-3, "^");
line(xe(x_1), ye(0), xe(x_2), ye(0));
line(xe(0), ye(y_1), xe(0), ye(y_2));
}

int main()
{
printf("Limitele domeniului orizontal:\n");
 printf("Atentie, x_1<0<x_2 si y_1<0<y_2 \n");
printf("x_1="); scanf("%f", &x_1); //x_1<0<x_2
printf("x_2="); scanf("%f", &x_2);
printf("Limitele domeniului vertical:\n");
printf("y_1="); scanf("%f", &y_1); //y_1<0<y_2
printf("y_2="); scanf("%f", &y_2);
initwindow(800, 600, "AXE", 200, 200);
setbkcolor(BLACK);
cleardevice();
a = getmaxx(); //nr. maxim de pixeli pe coord. x
b = getmaxy();
axe();
getch();
closegraph();
return 0;
}
 Laborator II. Reprezentari 2D parametrice

I. Cartezian.
#include <math.h>
#include <stdlib.h>
#include <dos.h>
#include <windows.h>
#include <iostream>

using namespace std;

#define pi 3.14159265359
int gd, gm;
int n, i, j;
double r, x, y, xp, yp, fi;
float x_1, x_2, y_1, y_2;
int a, b;
int xe(float x)// normalizarea coordonatei x
{
return((int)((x - x_1) / (x_2 - x_1) * a));
}
int ye(float y)// normalizarea coordonatei y
{
return((int)((y_2 - y) / (y_2 - y_1) * b));
}
void axe() {
setcolor(WHITE);
outtextxy(xe(x_2) - 20, ye(0) - 20, "x");
outtextxy(xe(x_2) - 18, ye(0) - 8, ">");
outtextxy(xe(0) - 15, ye(y_2) + 15, "y");
outtextxy(xe(0) - 15, ye(0) - 15, "O");
outtextxy(xe(0) - 1, ye(y_2)-3, "^");
line(xe(x_1), ye(0), xe(x_2), ye(0));
line(xe(0), ye(y_1), xe(0), ye(y_2));
}
int main()
{
printf("Limitele domeniului orizontal:\n");
printf("Atentie, x_1<0<x_2 si y_1<0<y_2 \n");
printf("x_1="); scanf("%f", &x_1); //x_1<0<x_2
printf("x_2="); scanf("%f", &x_2);
printf("Limitele domeniului vertical:\n");
printf("y_1="); scanf("%f", &y_1); //y_1<0<y_2
printf("y_2="); scanf("%f", &y_2);
initwindow(800, 800, "AXE", 200, 200);
setbkcolor(BLACK);
cleardevice();
a = getmaxx(); //nr. maxim de pixeli pe coord. x
b = getmaxy();
axe();
getch();
closegraph();
return 0;
}
II. Reprezentare parametrica. In reprezentarea obisnuita, y depinde de x, astfel ca avem ceva
de genul: y = x. In reprezentarea parametrica, atat x cat si y depind de o a treia variabila: theta, astfel ca
vom avea ceva de genul: x = theta; y = theta. Spre exemplu, reprezentarea obisnuita a sinusului este
sin(x) iar reprezentarea parametrica este x = theta si y = sin(theta). Alt exemplu: f(x) sau y = 2x 2+5x este
in reprezentarea parametrica: x = theta; y = 2*theta*theta+5*theta. EXEMPLU COD:
Reprezentare obisnuita:
void sinus2() {
float x = -10; // Valoarea de la care pleaca
float y;
float pie = 3.1415;
float pas = 2 * pie / 4000; // Pas
while (x <= 10) { // Valoarea pana la care merge
y = sin(x);
putpixel(xe(x), ye(y), 14);
x = x + pas;
}
}
Reprezentare parametrica:
void sinus() {
float theta = -10;
float x, y;
float pie = 3.1415;
float pas = 2 * pie / 4000;
while (theta <= 10) {
x = theta;
y = sin(theta);
putpixel(xe(x), ye(y), 14);
theta = theta + pas;
}
}
III. Problema 1. Reprezentati grafic sinusul, cosinusul, tangenta, exponentiala si ecuatia de
grad2.
void sinus() { // sinusul se duce de la 0 la 2pi
// Fiind vorba de o functie parametrica, mai intai definim variabilele theta, x si y precum si pi.
float theta = -10; // Atentie: valoare data initiala lui theta reprezinta punctul din care
pleaca sinusoida. Daca theta = 0 inseamna ca sinusoida incepe din origine.
float x, y;
float pie = 3.1415;
// Stabilim pasul: plecam de la faptul ca sinusoida se duce de la 0 la 2pi. Pentru a stabili un
pas, impartim acest interval
float pas = 2 * pie / 4000;
// In acest while desenam sinusoida
while (theta <= 10) { // Atentie: valoarea pana la care merge while-ul reprezinta unde se
termina sinusoida.
x = theta;
y = theta*theta;
// Dupa ce stabilim valorile lui x si y in reprezentarea parametrica, folosim functia
putpixel pentru a desena punctul in sistemul cartezian
putpixel(xe(x), ye(y), 14);
// Apoi dam o noua valoare lui theta folosindu-ne de pasul stabilit mai sus
theta = theta + pas;
}
// Atentie: deobicei vrem sa desenam doar un segment al sinusoidei (segmentul care nu se repeta).
Pentru acest lucru, vom seta theta = 0 (pleaca din origine) si in while vom avea while theta <= 2pi
deoarece sinusoida nu se repeta pe un interval de la 0 la 2pi
}

// Pentru urmatoarele functii, codul este la fel ca la sinus cu urmatoarea exceptie:

void cosinus(); // y=cos(theta)
void tangeta(); // y=tan(theta)
void grad2fct(); // y = theta*theta + C
void exponentiala(); // y = exp(theta)
void logaritm(); // y = log(theta)
II. Problema 2. Reprezentati grafic cercul.
void cerc() {
float theta = 0;
float x, y;
float pas = 0.001 ;
float raza = 1;
while (theta <= 2 * pi) {
x = raza * cos(theta);
y = raza * sin(theta);
putpixel(xe(x), ye(y), 14);
theta = theta + pas;
}
}
III. Tot codul:
#include "graphics.h"
#include <math.h>
#include <stdlib.h>
#include <dos.h>
#include <windows.h>
#include <iostream>

using namespace std;

#define pi 3.14159265359
int gd, gm;
int n, i, j;
double r, x, y, xp, yp, fi;

float x_1, x_2, y_1, y_2;

int a, b;
int xe(float x)// normalizarea coordonatei x
{
return((int)((x - x_1) / (x_2 - x_1) * a));
}
int ye(float y)// normalizarea coordonatei y
{
return((int)((y_2 - y) / (y_2 - y_1) * b));
}
void axe() {
setcolor(WHITE);
outtextxy(xe(x_2) - 20, ye(0) - 20, "x");
outtextxy(xe(x_2) - 18, ye(0) - 8, ">");
outtextxy(xe(0) - 15, ye(y_2) + 15, "y");
outtextxy(xe(0) - 15, ye(0) - 15, "O");
outtextxy(xe(0) - 1, ye(y_2)-3, "^");
line(xe(x_1), ye(0), xe(x_2), ye(0));
line(xe(0), ye(y_1), xe(0), ye(y_2));
}
void sinus() { // sinusul se duce de la 0 la 2pi
// Fiind vorba de o functie parametrica, mai intai definim variabilele theta, x si
y precum si pi.
float theta = -10; // Atentie: valoare data initiala lui theta reprezinta punctul
din care pleaca sinusoida. Daca theta = 0 inseamna ca sinusoida incepe din origine.
float x, y;
float pie = 3.1415;
// Stabilim pasul: plecam de la faptul ca sinusoida se duce de la 0 la 2pi. Pentru
a stabili un pas, impartim acest interval
float pas = 2 * pie / 4000;
// In acest while desenam sinusoida
while (theta <= 10) { // Atentie: valoarea pana la care merge while-ul reprezinta
unde se termina sinusoida.
x = theta;
y = theta * theta;
// Dupa ce stabilim valorile lui x si y in reprezentarea parametrica,
folosim functia putpixel pentru a desena punctul in sistemul cartezian
putpixel(xe(x), ye(y), 14);
// Apoi dam o noua valoare lui theta folosindu-ne de pasul stabilit mai sus
theta = theta + pas;
}
// Atentie: deobicei vrem sa desenam doar un segment al sinusoidei (segmentul care
nu se repeta). Pentru acest lucru, vom seta theta = 0 (pleaca din origine) si in while
vom avea while theta <= 2pi deoarece sinusoida nu se repeta pe un interval de la 0 la 2pi
}

// Pentru urmatoarele functii, codul este la fel ca la sinus cu urmatoarea exceptie:

void cosinus(); // y=cos(theta)
void tangeta(); // y=tan(theta)
void grad2fct(); // y = theta*theta + C
void exponentiala(); // y = exp(theta)
void logaritm(); // y = log(theta)

void cerc() {
float theta = 0;
float x, y;
float pas = 0.001 ;
float raza = 1;
while (theta <= 2 * pi) {
x = raza * cos(theta);
y = raza * sin(theta);
putpixel(xe(x), ye(y), 14);
theta = theta + pas;
}
}

int main()
{
printf("Limitele domeniului orizontal:\n");
printf("Atentie, x_1<0<x_2 si y_1<0<y_2 \n");
printf("x_1="); scanf("%f", &x_1); //x_1<0<x_2
printf("x_2="); scanf("%f", &x_2);
printf("Limitele domeniului vertical:\n");
printf("y_1="); scanf("%f", &y_1); //y_1<0<y_2
printf("y_2="); scanf("%f", &y_2);
initwindow(800, 800, "AXE", 200, 200);
setbkcolor(BLACK);
 cleardevice();
a = getmaxx(); //nr. maxim de pixeli pe coord. x
b = getmaxy();
axe();
getch();
closegraph();
return 0;
}
 Laborator III. Transformari ale unui punct in 2D.

I. Introducere. A transforma o figura geometrica inseamna a muta figura geometrica la alte

coordonate. Exemple de transformari: translatia, rotirea, simetria fata de o dreapta. In transformari se
folosesc matrici deoarece avem de-a face cu matematica in 2D. Mai in detaliu: in matematica 1D, spre
exemplu intr-o adunare, avem doi operanzi: stanga si dreapta. Atat operandul stanga cat si dreapta sunt 2
numere. In matematica 2D, operanzii unei adunari nu mai sunt 2 numere ci 2 vectori formati din 2
numere. Similar, in matematica 3D, operanzii unei adunari sunt 2 vectori formati din 3 numere. In acest
capitol suntem interesati sa transformam o figura geometrica. Spre exmeplu, daca vrem sa mutam un
punct mai la dreapta cu o unitate, suntem interesati in modificarea coordonatei x. Insa, avand in vedere ca
suntem in matematica 2D, nu putem opera doar cu coordonata x, lasand y-ul pe dinafara.
II. Transformarea plana a unui punct. Aici vorbim la modul general despre toate
transformarile. Sa consideram un punct P cu coordonate (x,y). Trecerea de la P la P’ cu coordonate
(x’,y’) se face prin aplicarea unei functii f vechilor coordonate x,y si o alta functie g tot vechilor
coordoante x, y. Deci, P’ va avea coordonate x’ = f(x,y) si y’ = g(x,y). Deci, P’ = (f(x,y), g(x,y)).
Daca consideram coordonatele unui punct ca o matrice 2x1, avem: [x’] = [A B] * [x] = [Ax +
By]
[y’] [C D] [y] [Cx + Dy]
Toate punctele inmultite cu o matrice 2x2 vor da noi puncte.
Exista insa tipuri de transformari care nu pot fi realizate prin inmultirea cu o matrice de 2x2, caz
in care, vom inmulti cu o matrice de 3x3 ceea ce inseamna ca vom mai adauga un 1 la coordonate (eg din
(2,3) vom avea (2,3,1)). In aceasta situatie, spunem ca vectorul cu trei componente este o reprezentare in
coordonate omogene (atentie, vectorul nu are trei coordonate; el are tot 2)
III. Translatia unui punct. Reprezinta deplasarea unei figuri parelel cu un vector v=(a,b). Este
reprezentata de ecuatiile: x’ = x+a si y’ = y+b.
Matricial: [1 0 a] [x] [x+a] [x’]
[0 1 b] * [y] = [y+b] = [y’]
[0 0 1] [1] [1 ] [1]
void translatie(float p, float q) {
xa = xa + p; ya = ya + q; // Am translatat punctul A cu un vector (2,3), adica am
adunat 2 la x si 3 la y
xb = xb + p; yb = yb + q;
xa = xc + p; yc = yc + q;
}
IV. Scalarea unui punct. Modifica o figura prin redimensionarea ei pe orizontala si verticala cu
un factor de multiplicatie S. Este reprezentata de ecuatiile: x’ = Sx * x si y’ = Sy * y.
Matricial: [Sx 0 0] [x] [Sxx] [x’]
[0 Sy 0] * [y] = [Syy] = [y ]
[0 0 1 ] [1] [1] [1]
void scalare(float p, float q) {
xa = xa * p; ya = ya * q; // Am translatat punctul A cu un vector (2,3), adica am
adunat 2 la x si 3 la y
xb = xb * p; yb = yb * q;
 xa = xc * p; yc = yc * q;
}
V. Simetria unui punct. Sunt cazuri particulare de scalari cu factori unitari negativi. Exista doua
tipuri de simetrii: fata de o dreapta sau fata de un punct. Cele mai simple sunt cele fata de axe sau origine.
a) Simetria in raport cu axa OX: Sx = [1 0 0 ] [x]
[0 -1 0] * [y]
[0 0 1] [1]
y
b) Simetria in raport cu axa OY: S = [-1 0 0] [x]
[0 1 0 ] * [y]
[0 0 1 ] [1]

c) Simetria in raport cu originea:SO = [-1 0 0] [x]

[0 -1 0] *[y]
[0 0 1 ] [1]
void simetrie(); // Pentru simetrie, dam ca input scalarii: -1,1 sau 1,-1 sau -1-1.
VI. Rotatia unui punct in jurul originii. Aici ne folosim de un unghi theta.
[cosθ -sinθ 0] [x] [xcosθ – ysinθ] [x’]
[sinθ cosθ 0] * [y] = [xsinθ + ycosθ] = [y’]
[0 0 1] [1] [ 1 ] [1]
void rotatie2D()
{
float xaa = xa;
float xbb = xb;
float xcc = xc;
xa = xa * cos(theta) - ya * sin(theta);
ya = xaa * sin(theta) + ya * cos(theta);
xb = xb * cos(theta) - yb * sin(theta);
yb = xbb * sin(theta) + yb * cos(theta);
xc = xc * cos(theta) - yc * sin(theta);
yc = xcc * sin(theta) + yc * cos(theta);
}
VII. Proiect. Desenati un triunghi si aplicati aceste functii pentru a-l deplasa, mari si roti.
#include "graphics.h"
#include <math.h>
#include <stdlib.h>
#include <dos.h>
#include <windows.h>
#include <iostream>

using namespace std;

#define pi 3.14159265359
int gd, gm;
int n, i, j;
double r, x, y, xp, yp, fi;

float x_1, x_2, y_1, y_2;

float xa, ya, xb, yb, xc, yc;//coord.
float theta = pi / 36.f;//unghiul de rotatie, in radiani

int a, b;
int xe(float x)// normalizarea coordonatei x
{
return((int)((x - x_1) / (x_2 - x_1) * a));
}
int ye(float y)// normalizarea coordonatei y
{
return((int)((y_2 - y) / (y_2 - y_1) * b));
}
void axe() {
setcolor(WHITE);
outtextxy(xe(x_2) - 20, ye(0) - 20, "x");
outtextxy(xe(x_2) - 18, ye(0) - 8, ">");
outtextxy(xe(0) - 15, ye(y_2) + 15, "y");
outtextxy(xe(0) - 15, ye(0) - 15, "O");
outtextxy(xe(0) - 1, ye(y_2)-3, "^");
line(xe(x_1), ye(0), xe(x_2), ye(0));
line(xe(0), ye(y_1), xe(0), ye(y_2));
}

// Functie folosita ca sa nu mai scriem line(xe(val)) ci line(val) direct

void linie2D(float xa, float ya, float xb, float yb)
{
line(xe(xa), ye(ya), xe(xb), ye(yb));
}
void deseneazatriunghi() //void grafic()
{
outtextxy(xe(xa) + 10, ye(ya) - 10, "A");
circle(xe(xa), ye(ya), 2);
outtextxy(xe(xb) + 10, ye(yb) - 10, "B");
circle(xe(xb), ye(yb), 2);
outtextxy(xe(xc) - 10, ye(yc) + 10, "C");
circle(xe(xc), ye(yc), 2);
linie2D(xa, ya, xb, yb);
linie2D(xb, yb, xc, yc);
linie2D(xa, ya, xc, yc);
}

void translatie(float p, float q) {

xa = xa + p; ya = ya + q; // Am translatat punctul A cu un vector (2,3), adica am
adunat 2 la x si 3 la y
xb = xb + p; yb = yb + q;
xa = xc + p; yc = yc + q;
}

void scalare(float p, float q) {

xa = xa * p; ya = ya * q; // Am translatat punctul A cu un vector (2,3), adica am
adunat 2 la x si 3 la y
xb = xb * p; yb = yb * q;
xa = xc * p; yc = yc * q;
}

void simetrie(); // Pentru simetrie, dam ca input scalarii: -1,1 sau 1,-1 sau -1-1.

void rotatie2D()
{
float xaa = xa;
float xbb = xb;
float xcc = xc;
xa = xa * cos(theta) - ya * sin(theta);
 ya = xaa * sin(theta) + ya * cos(theta);
xb = xb * cos(theta) - yb * sin(theta);
yb = xbb * sin(theta) + yb * cos(theta);
xc = xc * cos(theta) - yc * sin(theta);
yc = xcc * sin(theta) + yc * cos(theta);
}

int main()
{
/////////////////////////////////////////////
printf("Limitele domeniului orizontal:\n");
printf("Atentie, x_1<0<x_2 si y_1<0<y_2 \n");
printf("x_1="); scanf("%f", &x_1); //x_1<0<x_2
printf("x_2="); scanf("%f", &x_2);
printf("Limitele domeniului vertical:\n");
printf("y_1="); scanf("%f", &y_1); //y_1<0<y_2
printf("y_2="); scanf("%f", &y_2);
initwindow(800, 800, "AXE", 200, 200);
setbkcolor(BLACK);
cleardevice();
a = getmaxx(); //nr. maxim de pixeli pe coord. x
b = getmaxy();
axe();
//////////////////////////////////////////////
xa = 7; ya = 10;//initializare coord triunghi
xb = 10; yb = 4;
xc = 1; yb = 1;
float sum_t = 0.f;
///////////////////////////////////////////////
// Pentru translatie si scalare:
do
{
cleardevice();
axe();
deseneazatriunghi();
delay(500);
scalare(2,3);
sum_t = sum_t + theta;
} while (sum_t <= 2);
// Pentru rotatie:
//do
//{
// cleardevice();
// axe();
// deseneazatriunghi();
// delay(100);
// rotatie2D();
// sum_t = sum_t + theta;
//} while (sum_t <= 2 * pi);

getch();
closegraph();
return 0;
}
 Laborator III. Reprezentari 3D

I. Axe. In primul rand, avem 3 axe in loc de 2. In loc de axa Y vom avea axa Z (z-ul va fi cel
vertical). Atentie, in cod vom defini doar axa x si z iar y-ul il vom desena in functie de x si z.
#include "graphics.h"
#include <math.h>
#include <stdlib.h>
#include <dos.h>
#include <windows.h>
#include <iostream>
using namespace std;
#define pi 3.14159265359
float x_1, x_2, y_1, y_2, alfa = 3.1415 / 8;
int xemax, yemax;
///////////////////////////////////////////////////////////
int xe(float x)
// normalizarea coordonatei x
{
return((int)floor((x - x_1) / (x_2 - x_1) * xemax)); // Aici definim cele doua
axe X si Z
}
int ze(float z)
// normalizarea coordonatei y
{
return((int)floor((y_2 - z) / (y_2 - y_1) * yemax));
}
///////////////////////////////////////////////////////////
void axe()
{
setcolor(0);
line(xe(x_1 / 2), ze(0), xe(x_2), ze(0));
line(xe(0), ze(0), xe(0), ze(y_2));
line(xe(0), ze(0), xe(0 + x_1 * cos(alfa)), ze(0 + x_1 * sin(alfa))); // Aici
desenam axele. Axa Y va fi desenata folsindu-ne de un unghi
outtextxy(xe(0) - 15, ze(0) - 15, "O");

outtextxy(xe(x_2) - 20, ze(0) - 20, "x");

outtextxy(xe(x_2) - 6, ze(0) - 7, ">");
outtextxy(xe(0) + 15, ze(y_2) + 5, "z");
outtextxy(xe(0) - 1, ze(y_2) + 1, "^");
outtextxy(xe(x_1 * cos(alfa)), ze(x_1 * sin(alfa)), "y");
}
///////////////////////////////////////////////////////////
int main()
{
int gd, gm;
printf("Limitele domeniului orizontal:\n");
printf("x_1="); scanf("%f", &x_1);
printf("x_2="); scanf("%f", &x_2);
y_1 = x_1; y_2 = x_2;
initwindow(800, 800, "Elice conica", 200, 200);
setbkcolor(15);
cleardevice();
 xemax = getmaxx(); yemax = getmaxy();
axe();
setcolor(2);
getch();
closegraph();
return 0;
}
II. Desenare. Deoarece monitorul este bidimensional, pentru a putea afisa obiecte 3D intr-un
ecran 2D trebuie sa facem o proiectie a obiectelor 3D in 2D. Ne folosim de urmatoarea formula: Pentru
un punct tridimensional P3(x,y,z) avem punctul bidimensionalP2(x-cos(alfa)*y, z-sin(alfa)*y)
Atentie! Spre exemplu, daca x = cos(t), y = sin(t) si z = kt, cand folosim functia putpixel vom
scrie formula de mai sus (x-cos(alfa)*y, z-sin(alfa)*y). Spre exemplu, pentru a desena o elice cu functia
f(x,y,z) = cos(t), sin(t), 0.3k, avem
float f(float theta) {
return (2 * 0.7 * sin(theta) * tan(theta));
}
void grafic() {
float t, h;
float x, y, z;
float pie = 3.1415;
t = 0; h = pie / 800;
while (t <= +15)
{
x = 0.2 * t * cos(3 * t); //ecuatiile elicei conice
y = 0.2 * t * sin(3 * t);
z = 0.4 * t;
putpixel(xe(x - y * cos(alfa)), ze(z - y * sin(alfa)), 3);
t = t + h;
}
t = 0;
}
 Laborator III. Transformari 3D

Translatie.
[1 0 0 xtr] [x]
[0 1 0 ytr]*[y]
[0 0 1 ztr] [z]
[0 0 0 1] [1]
Scalare.
[xsc 0 0 0] [x]
[0 ysc 0 0]*[y]
[0 0 zsc 0] [z]
[0 0 0 1] [1]
Rotatie.
a) In raport cu axa Z: [cosθ sinθ 0 0] [x]
[-sinθ cosθ 0 0] * [y]
[0 0 1 0] [z]
[0 0 0 1] [1]

b) In raport cu axa X: [1 0 0 0] [x]

[cos() sin() 0 0]*[y]
[-sin() cos() 0 0] [z]
[0 0 0 1] [1]

b) In raport cu axa Y: [cos(β) 0 -sin(β) 0] [x]

[0 1 0 0]*[y]
[sin(β) 0 cos(β) 0] [z]
[0 0 0 1] [1]