Notes

#include "graphics.h"
#include <math.h>
#include <stdlib.h>
#include <dos.h>
#include <windows.h>
#include <iostream>

using namespace std;

#define pi 3.14
#define T - 6 * pi / 180
#define alpha pi / 8
//#define th pi / 180

int a, b, xmin, xmax, ymin, ymax;




int xe(float x) {
return ((int)floor((x - xmin) / (xmax - xmin)*a));
}

int ye(float y) {
return ((int)floor((ymax - y) / (ymax - ymin)*b));
}

void xoy() {
line(xe(xmin), ye(0), xe(xmax), ye(0));
line(xe(0), ye(ymin), xe(0), ye(xmax));
}

void triunghi() {
setcolor(GREEN);
line(xe(0), ye(-150), xe(-150), ye(80));
line(xe(-150), ye(80), xe(150), ye(80));
line(xe(150), ye(80), xe(0), ye(-150));
/*setcolor(RED);
outtextxy(xe(-5), ye(-170), "A");
outtextxy(xe(-160), ye(80), "B");
outtextxy(xe(150), ye(80), "C");*/
}



/*void trans() {
setcolor(YELLOW);
int xt = 100;
int yt = 100;
line(xe(0 + xt), ye(-150 + yt), xe(-150 + xt), ye(80 + yt));
line(xe(-150 + xt), ye(80 +yt), xe(150 + xt), ye(80 + yt));
line(xe(150 + xt), ye(80 + yt), xe(0 + xt), ye(-150 + yt));
setcolor(BLUE);
outtextxy(xe(-5 + xt), ye(-170 + yt), "A");
outtextxy(xe(-160 + xt), ye(80 + yt), "B");
outtextxy(xe(150 + xt), ye(80 + yt), "C");
}*/

/*void scale() {
setcolor(12);
int xs = 2, ys = 2;
line(xe(0 * xs), ye(-150 * ys), xe(-150 * xs), ye(80 * ys));
line(xe(-150 * xs), ye(80 * ys), xe(150 * xs), ye(80 * ys));
line(xe(150 * xs), ye(80 * ys), xe(0 * xs), ye(-150 * ys));
setcolor(14);
outtextxy(xe(-5 * xs), ye(-170 * ys), "A");
outtextxy(xe(-160 * xs), ye(80 * ys), "B");
outtextxy(xe(150 * xs), ye(80 * ys), "C");
}*/

/*void spin() {
float xa = 0;
float ya = -150;
float xb = -150;
float yb = 80;
float xc = 150;
float yc = 80;

float a1, a2, b1, b2, c1, c2;

for (int i = 0; i < 60; i++) {
cleardevice();

setcolor(YELLOW);

line(xe(xa), ye(ya), xe(xb), ye(yb));
line(xe(xb), ye(yb), xe(xc), ye(yc));
line(xe(xc), ye(yc), xe(xa), ye(ya));

delay(500);

xa = xa * cos(T) - ya * sin(T);
ya = xa * sin(T) + ya* cos(T);

xb = xb * cos(T) - yb * sin(T);
yb = xb * sin(T) + yb* cos(T);

xc = xc * cos(T) - yc * sin(T);
yc = xc * sin(T) + yc* cos(T);
}
}*/

/*void xoyoz() {
line(xe(0), ye(0), xe(0), ye(ymax));
line(xe(0), ye(0), xe(xmax), ye(0));
line(xe(0), ye(0), xe(xmin * cos(alpha)), ye(xmin * sin(alpha)));
}*/

struct Punct2D {
float x, y;
Punct2D(float x = 0, float y = 0) {
this->x = x;
this->y = y;
}
};
/*
struct Punct3D {
float x, y, z;
Punct3D(float x = 0, float y = 0, float z = 0) {
this->x = x;
this->y = y;
this->z = z;
}
};

Punct2D transfPunct(Punct3D punct) {
float xprim = xe(punct.x - punct.y * cos(alpha));
float yprim = ye(punct.z - punct.y * sin(alpha));

Punct2D punctNou = Punct2D();
punctNou.x = xprim;
punctNou.y = yprim;

return punctNou;
}

Punct3D piramida3d[5];
*/


void init() {
initwindow(800, 600);
a = getmaxx();
b = getmaxy();
xmin = (int)(-a / 2);
xmax = (int)(a / 2);
ymin = (int)(-b / 2);
ymax = (int)(b / 2);

/*piramida3d[0] = Punct3D(50, 50, 0);
piramida3d[1] = Punct3D(250, 50, 0);
piramida3d[2] = Punct3D(250, 250, 0);
piramida3d[3] = Punct3D(50, 250, 0);
piramida3d[4] = Punct3D(150, 150, 250);*/
}

/*
void deseneazaPiramida() {

Punct2D piramida2d[5];

for (int i = 0; i < 5; i++) {
piramida2d[i] = transfPunct(piramida3d[i]);
}

setcolor(RED);
line(piramida2d[0].x, piramida2d[0].y, piramida2d[1].x, piramida2d[1].y);
line(piramida2d[1].x, piramida2d[1].y, piramida2d[2].x, piramida2d[2].y);
line(piramida2d[2].x, piramida2d[2].y, piramida2d[3].x, piramida2d[3].y);
line(piramida2d[3].x, piramida2d[3].y, piramida2d[0].x, piramida2d[0].y);
line(piramida2d[4].x, piramida2d[4].y, piramida2d[0].x, piramida2d[0].y);
line(piramida2d[4].x, piramida2d[4].y, piramida2d[1].x, piramida2d[1].y);
line(piramida2d[4].x, piramida2d[4].y, piramida2d[2].x, piramida2d[2].y);
line(piramida2d[4].x, piramida2d[4].y, piramida2d[3].x, piramida2d[3].y);
}

void transPiramida() {

Punct2D piramida2d[5];

for (int i = 0; i < 5; i++) {
piramida2d[i] = transfPunct(piramida3d[i]);
}

setcolor(YELLOW);
line(piramida2d[0].x + 100, piramida2d[0].y + 100, piramida2d[1].x + 100, piramida2d[1].y + 100);
line(piramida2d[1].x + 100, piramida2d[1].y + 100, piramida2d[2].x + 100, piramida2d[2].y + 100);
line(piramida2d[2].x + 100, piramida2d[2].y + 100, piramida2d[3].x + 100, piramida2d[3].y + 100);
line(piramida2d[3].x + 100, piramida2d[3].y + 100, piramida2d[0].x + 100, piramida2d[0].y + 100);
line(piramida2d[4].x + 100, piramida2d[4].y + 100, piramida2d[0].x + 100, piramida2d[0].y + 100);
line(piramida2d[4].x + 100, piramida2d[4].y + 100, piramida2d[1].x + 100, piramida2d[1].y + 100);
line(piramida2d[4].x + 100, piramida2d[4].y + 100, piramida2d[2].x + 100, piramida2d[2].y + 100);
line(piramida2d[4].x + 100, piramida2d[4].y + 100, piramida2d[3].x + 100, piramida2d[3].y + 100);
}

void zoomInPiramida() {

Punct2D piramida2d[5];

for (int i = 0; i < 5; i++) {
piramida2d[i] = transfPunct(piramida3d[i]);
}

setcolor(BLUE);
line(piramida2d[0].x * 1.2, piramida2d[0].y * 1.2, piramida2d[1].x * 1.2, piramida2d[1].y * 1.2);
line(piramida2d[1].x * 1.2, piramida2d[1].y * 1.2, piramida2d[2].x * 1.2, piramida2d[2].y * 1.2);
line(piramida2d[2].x * 1.2, piramida2d[2].y * 1.2, piramida2d[3].x * 1.2, piramida2d[3].y * 1.2);
line(piramida2d[3].x * 1.2, piramida2d[3].y * 1.2, piramida2d[0].x * 1.2, piramida2d[0].y * 1.2);
line(piramida2d[4].x * 1.2, piramida2d[4].y * 1.2, piramida2d[0].x * 1.2, piramida2d[0].y * 1.2);
line(piramida2d[4].x * 1.2, piramida2d[4].y * 1.2, piramida2d[1].x * 1.2, piramida2d[1].y * 1.2);
line(piramida2d[4].x * 1.2, piramida2d[4].y * 1.2, piramida2d[2].x * 1.2, piramida2d[2].y * 1.2);
line(piramida2d[4].x * 1.2, piramida2d[4].y * 1.2, piramida2d[3].x * 1.2, piramida2d[3].y * 1.2);
}

void zoomOutPiramida() {

Punct2D piramida2d[5];

for (int i = 0; i < 5; i++) {
piramida2d[i] = transfPunct(piramida3d[i]);
}

setcolor(GREEN);
line(piramida2d[0].x * 0.75, piramida2d[0].y * 0.75, piramida2d[1].x * 0.75, piramida2d[1].y * 0.75);
line(piramida2d[1].x * 0.75, piramida2d[1].y * 0.75, piramida2d[2].x * 0.75, piramida2d[2].y * 0.75);
line(piramida2d[2].x * 0.75, piramida2d[2].y * 0.75, piramida2d[3].x * 0.75, piramida2d[3].y * 0.75);
line(piramida2d[3].x * 0.75, piramida2d[3].y * 0.75, piramida2d[0].x * 0.75, piramida2d[0].y * 0.75);
line(piramida2d[4].x * 0.75, piramida2d[4].y * 0.75, piramida2d[0].x * 0.75, piramida2d[0].y * 0.75);
line(piramida2d[4].x * 0.75, piramida2d[4].y * 0.75, piramida2d[1].x * 0.75, piramida2d[1].y * 0.75);
line(piramida2d[4].x * 0.75, piramida2d[4].y * 0.75, piramida2d[2].x * 0.75, piramida2d[2].y * 0.75);
line(piramida2d[4].x * 0.75, piramida2d[4].y * 0.75, piramida2d[3].x * 0.75, piramida2d[3].y * 0.75);

}



void spinPiramida() {
float th = 3.14 / 180;
int tip_rotatie = 2;
for (int i = 0; i < 360; i++) {
for (int j = 0; j < 5; j++) {
switch (tip_rotatie) {
case 1:
piramida3d[j].x = piramida3d[j].x;
piramida3d[j].y = piramida3d[j].y * cos(th) - piramida3d[j].z * sin(th);
piramida3d[j].z = piramida3d[j].y * sin(th) + piramida3d[j].z * cos(th);
break;
case 2:
piramida3d[j].x = piramida3d[j].x * cos(th) - piramida3d[j].y * sin(th);
piramida3d[j].y = piramida3d[j].x * sin(th) + piramida3d[j].y * cos(th);
piramida3d[j].z = piramida3d[j].z;
break;
default:
piramida3d[j].x = piramida3d[j].x * cos(th) - piramida3d[j].z * sin(th);
piramida3d[j].y = piramida3d[j].y;
piramida3d[j].z = piramida3d[j].x * sin(th) + piramida3d[j].z * cos(th);
}
cleardevice();
xoyoz();
deseneazaPiramida();
delay(100);
}
}
}

Punct3D punct[3000];


void deseneazaSpirala() {
float t = 0;
int index = 0;
float h = pi / 10, x, y, z;
while (t <= 100) {
x = t * cos(t / 4);
y = t * sin(t / 4);
z = t;
punct[index] = Punct3D(x, y, z);
index++;
t += h;
}
Punct2D punct2d[3000];
for (int i = 0; i < index; i++) {
punct2d[i] = transfPunct(punct[i]);
putpixel(punct2d[i].x, punct2d[i].y, YELLOW);
}
}

void spinSpirala() {
float th = -2 * 3.14 / 180;
int tip_rotatie = 2;
for (int i = 0; i < 160; i++) {
for (int j = 0; j < 5; j++) {
switch (tip_rotatie) {
case 1:
punct[j].x = punct[j].x;
punct[j].y = punct[j].y * cos(th) - punct[j].z * sin(th);
punct[j].z = punct[j].y * sin(th) + punct[j].z * cos(th);
break;
case 2:
punct[j].x = punct[j].x * cos(th) - punct[j].y * sin(th);
punct[j].y = punct[j].x * sin(th) + punct[j].y * cos(th);
punct[j].z = piramida3d[j].z;
break;
default:
punct[j].x = punct[j].x * cos(th) - punct[j].z * sin(th);
punct[j].y = punct[j].y;
punct[j].z = punct[j].x * sin(th) + punct[j].z * cos(th);
}
cleardevice();
xoyoz();
deseneazaSpirala();
delay(10);
}
}
}
*/

void colineare(Punct2D p, Punct2D q, Punct2D r) {
if ((q.y - p.y)*(r.x - q.x) - (q.x - p.x)*(r.y - q.y) == 0)
cout << "Coliniare!";
else
cout << "Necoliniare!";
}

void triunghi_coliniar(Punct2D p, Punct2D q, Punct2D r) {
setcolor(GREEN);
line(xe(p.x), ye(p.y), xe(q.x), ye(q.y));
line(xe(r.x), ye(r.y), xe(q.x), ye(q.y));
line(xe(p.x), ye(p.y), xe(r.x), ye(r.y));

colineare(p, q, r);
}

void main() {
init();
xoy();

/*Punct3D p;
p.x = 100, p.y = 92, p.z = 40;
Punct2D pt;
pt = transfPunct(p);
putpixel(pt.x, pt.y, RED);

deseneazaPiramida();
transPiramida();
zoomInPiramida();
zoomOutPiramida();

spinPiramida();

deseneazaSpirala();
spinSpirala();*/


Punct2D p(10, 20),q(20, 40),r(300,60);

triunghi_coliniar(p,q,r);

getch();
closegraph();
}