AMRITA VISHWAVIDYAPEETHAM

Ș COALA DE INFORMATICĂ AMRITA, MYSORE

RECORD LAB – GRAFICA COMPUTERIZATĂ

DEPARTAMENTUL DE INFORMATICĂ

PROGRAM: MCA INTEGRAT

SEMESTER: Ⅵ
COURSE TITLE: COMPUTER GRAPHICS
CODUL CURSULUI: 18CSA383

SUBMISAȚI LA: SUBMIS DE

KAVYAT.G CHARISHMA.K. S
Lector universitar [Link].I5MCA20004
DEPARTAMENTUL DE INFORMATICĂ

SEMNĂTURĂ DATA:
 INDEX

Nr. crt. CONTENTS Pg. Nr.

1 afiș are grafică raster 2

2 primitivă geometrică 2D 2,3

3 Cercuri concentrice 3,4

4 Afiș ează pătratul umplut 4,5

5 Schimbă culoarea de fundal 5,6

6 Desenează emoji 6,7

7 Desenează o linie 7,8

8 Algoritmul lui Bresenham 8,9

9 Maș ină în miș care 9,10

10 Cerc folosind punctul mediu 11

11 Panta mai mică de 1 12

12 Translation 13,14

13 Rotatie 14,15,16

14 Scalare 16,17

15 Algoritmul de umplere a inundaț iei 17,18

16 Algoritmul de umplere a limitelor 18,19

17 Tăierea unei linii 18,19

18 Reflecț ie 19,20,21

19 Clippingul poligoanelor 21-24

20 Fereastră către viewport 24,25

21 Tăierea liniilor Cohen Sutherland 26,27,28

1. Trasează o linie 2D care se afi ș ează ca grafic raster

#include <stdio.h>
#include <conio.h>
#include <graphics.h>

int main()
{
int gd= DETECT, gm, x1, y1, x2, y2;
initgraph(&gd,&gm,"C:\TC\BGI");
clrscr();
introduceț i coordonata punctului de start
scanf("%d%d", &x1, &y1);
printf("Introduceț i coordonatele punctului final");
scanf("%d%d", &x2, &y2);
setbkcolor(GRI ÎNTUNECAT);
setează culoarea(ROȘ U);
linie(x1,y1,x2,y2);
Apăsaț i orice tastă pentru a continua
getch();
închide graficul();
return 0;
}

OUTPUT-

2. Primitives geometrice 2D
#include<stdio.h>
#include<conio.h>
#include<graphics.h>

void main()
{
int gd=DETECT, gm;
initgraph(&gd,&gm,"C:\TURBOC3\BGI");
setbkcolor(VERDE);
LINIE
linie (50,40,190,40);
RETANGHIU
dreptunghi(125,115,215,165);
ARC
arc(120,200,180,0,30);
CERC
cerc (120,270,30);
ECLIPSE
ellipse(120,350,0,360,30,20);
getch();
}

OUTPUT-

3. Cercuri concentrice

#include<stdio.h>
#include<graphics.h>
int main()
{
int gd=DETECT, gm;
int x,y;
initgraf(&gd,&gm,"C:\TURBOC3\BGI");
x=getmaxx()/2;
y=getmaxy()/2;
cercuri concentrice
setcolor(ROSU);
cerc(x,y,30);
setcolor (VERDE);
cerc(x,y,50);
setcolor(GALBEN);
cerc(x,y,70);
setcolor(ALBASTRU);
cerc(x,y,90);
getch();
închide graficul();
return 0;
}

OUTPUT-

4. Afi ș ează un pătrat umplut

#include<stdio.h>
#include<conio.h>
#include<graphics.h>

main()
{
int gd, gm, s;
gd=DETECT;
initgraf(&gd,&gm,"C:\TURBOC3\BGI");
Introduceti valoarea laturii patrului:
scanf("%d",&s);
setbkcolor(GRI DESCHIS);
setcolor(ROȘ U);
muta(50,50);
lineto (50+s,50),
lineto (50,50+s);
lineto (50+s,50+s);
lineto (50,50);
Apăsaț i orice tastă pentru a continua...
getch();
închidegraf();
}

IEȘ IRE-

5. Schimbă culoarea de fundal

#include<stdio.h>
#include<conio.h>
#include<graphics.h>

void main()
{
int gd=DETECT , gm;
initgraph(&gd,&gm,"C:\TURBOC3\BGI");
Apăsaț i orice tastă pentru a schimba culoarea de fundal în verde
getch();
setbkcolor(VERDE);
getch();
închide graficul();
}

OUTPUT-

6. Desenează emoji

#include<stdio.h>
#include<conio.h>
#include<graphics.h>

void main()
{
int gd=DETECT, gm;
initgraf(&gd,&gm,"C:\TURBOC3\BGI");
cerc(300,180,80);
cerc(270,150,10);
cerc(320,150,10);
linie(300,170,300,200);
arc(300,180,240,300,50);
getch();
închidegrafic();
}

IEȘ IRE-
Desenează o linie

#include<stdio.h>
#include<conio.h>
#include<graphics.h>

void main()
{
int gd=DETECT, gm;
clrscr();
initgrafic(&gd,&gm,"C:\TURBOC3\BGI");
linie(100,100,500,300);
getch();
închidegrafic();
}

IEȘ IRE
Algoritmul lui Bresenham

#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#include<math.h>

void main(){
int gd=DETECT, gm;
int x1,y1,x2,y2,dx,dy,p,k,x,y;
clrscr();
introduceț i coordonatele punctului de start:
scanf("%d%d", &x1, &y1);
printf("Introduceț i coordonatele punctului final: ");
scanf("%d%d",&x2,&y2);
initgraph(&gd,&gm,"C:\TURBOC3\BGI");
dx=x2-x1;
dy=y2-y1;
p=2*dy-dx;
x=x1;
y=y1;
punteazăpixel(x,y,15);
pentru(k=1;k<=dx;k++)
{
dacă(p<0)
{
punepixel(x,y,15);
p=p+2*dy;
}
altfel
{
x=x+1;
y=y+1;
punepixel(x,y,15);
p=p+2*dy-2*dx;
}
}
ilustrarea algoritmului lui Barsenham
outtextxy(x1+5,y1-5,"(x1,y1)");
outtextxy(x2+5,y2+5,"(x2,y2)");
getch();
closegraph();
restorecrtmode();
}

IEȘ IRE-

9. Ma ș ină în mi ș care

#include<stdio.h>
#include<conio.h>
#include<graphics.h>

int main()
{
int gd=DETECT,gm,i, maxx, cy;
initgrafică(&gd,&gm,"C:\TURBOC3\BGI");
setbkcolor(ALB);
setează culoarea(ROȘ U);
maxx=getmaxx()/2;
cy=getmaxy()/2;
pentru(i=0;i<maxx-140;i++)
{
ș terge_dispozitiv();
linie(0+i,cy-20,0+i,cy+15);
linie(0+i,cy-20,25+i,cy-20);
linie(25+i,cy-20,40+i,cy-70);
linie(40+i,cy-70,100+i,cy-70);
linie(100+i,cy-70,115+i,cy-20);
linie(115+i,cy-20,140+i,cy-20);
linie(0+i,cy+15,18+i,cy+15);
cerc(28+i,cy+15,10);
linie (38+i,cy+15,102+i,cy+15);
cerc(112+i,cy+15,10);
linie(112+i,cy+15,140+i,cy+15);
linie(140+i,cy+15, 140+i,cy-20);
dreptunghi(50+i,cy-62,90+i,cy-30);

setfillstyle(1, ALBASTRU);
floodfill(5+i,cy-15,ROȘ U);
setfillstyle(1,ALBASTRU_LUMINOS);
umple_inundare (52+i,cy-60,ROȘ U);
întârziere(10);
}
getch();
închide graficul();
return 0;
}

IEȘ IRE-

10. Cerc folosind punctul mediu

#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#include<math.h>
void simetrie(int xc,int yc,int x,int y);
void main()
{
int gd=DETECT,gm;
int xc,yc,p,r,x,y;
clrscr();
introduceț i coordonatele:
scanf("%d%d", &xc, &yc);
printf("Introduceț i raza:");
scanf("%d",&r);
initgrafică(&gd,&gm,"C:\TURBOC3\BGI");
x=0;
y=r;
simetrie(xc,yc,x,y);
p=1-r;
în timp ce(x<=y)
{
dacă(p<0)
{
x=x+1;
p=p+2*x+1;
}
altfel {
x=x+1;
y=y-1;
p=p+2*x+1-2*y;
}
simetrie(xc,yc,x,y);
}
ilustrarea punctului de mijloc al cercului
(xc,yc)
getch();
închidegrafic();
restaurează mod crt();
}
void simetrie(int xc,int yc,int x,int y)
{
punctpixel(xc+x,yc+y,ALB);
punct_pixel(xc-x,yc+y,ALB);
punctpixel(xc+x,yc-y,ALB);
punteaza_pixel(xc-x,yc-y,ALB);
putpixel(xc+y,yc+x,ALB);
punctpixel(xc-y,yc+x,ALB);
putpixel(xc+y,yc-x,ALB);
punctpixel(xc-y,yc-x,ALB);
}

OUTPUT-
11. Panta mai mică de 1

#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#include<math.h>

void main()
{
int gd=DETECT,gm;
int x1=100,x2=200,y1=200,y2=400,dx,dy,p,k,x,y;
clrscr();
initgrafică(&gd,&gm,"C:\TURBOC3\BGI");
dx=x2-x1;
dy=y2-y1;
p=p+2*dy-dx;
x=x1;
y=y1;
while(y<y2)
{
putpixel(x,y,50);
dacă(p<0)
{
y=y+1;
p=p+2*dy;
}
altfel{
x=x+1;
y=y+1;
p=p+2*dx-2*dy;
}
}
outtextxy(200,20,"Panta mai mică decât 1");
getch();
închidegrafic();
restorecrtmode();
}

IEȘ IRE

12. Traducere

#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#include<math.h>
void main()
{
int gd=DETECT,gm;
int x1,y1,x2,y2,a,b;
initgraph(&gd,&gm,"C:\TURBOC3\BGI");
introduce valoarea coordonatelor:
scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
printf("Introduceț i factorul de translare x:");
scanf("%d", &a);
Introduceti factorul de translatie y:
scanf("%d", &b);
curatadispozitiv();
textpeex(200,20,"Linie înainte de traducere");
linie(x1,y1,x2,y2);
x1=x1+a;
y1=y1+b;
x2=x2+a;
y2=y2+b;
getch();
ș tergeDispozitiv();
outtextxy(200,20,"Line after translation");
linie(x1,y1,x2,y2);
getch();
închidegrafic();
restaurează modul crt();
}

IEȘ IRE

13. Rotatie

#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#include<math.h>

void main()
{
int gd=DETECT,gm,ch;
float x1,y1,x2,y2,a,x,y;
initgraph(&gd,&gm,"C:\TURBOC3\BGI");
fa{
printf("Meniu principal");
[Link] în jurul originii
[Link] în jurul unui punct fix
printf("\nIntroduceț i alegerea dvs.: 0 pentru ieș ire");
scanf("%d",&ch);
dacă(ch==0){
getch();
iesire(1);
}
printf("Introduceț i coordonatele liniei:");
scanf("%f%f%f%f", &x1, &y1, &x2, &y2);
introduce unghiul de rotaț ie
scanf("%f",&a);
switch(ch)
{
cazul 1:
cleardevice();
outtextxy(250,20,"Linie înainte de rotaț ie");
linie(x1,y1,x2,y2);
a=a*(3.14/180);
x1=x1*cos(a)-y1*sin(a);
y1=x1*sin(a)+y1*cos(a);
x2=x2*cos(a)-y2*sin(a);
y2=x2*sin(a)+y2*cos(a);
getch();
ș terge dispozitivul();
linea după rotaț ie
linie(x1,y1,x2,y2);
getch();
stergeDispozitiv();
break;

caz 2:
introduceț i punctul fix
scanf("%f", &x, &y);
cleardevice();
linia înainte de rotaț ie
linie(x1,y1,x2,y2);
a=a*(3.14/180);
x1=x1*cos(a)-y1*sin(a)-x*cos(a)+y*sin(a)+x;
y1=x1*sin(a)+y1*cos(a)-x*sin(a)-y*cos(a)+y;
x2=x2*cos(a)-y2*sin(a)-x*cos(a)+y*sin(a)+x;
y2=x2*sin(a)+y2*cos(a)-x*sin(a)-y*cos(a)+y;
getch();
ș tergedevice();
outtextxy(250,20,"Linie după rotaț ie");
linie(x1,y1,x2,y2);
getch();
ştergeDispozitiv();
pauză;

default:
printf("invalid");
curăț are dispozitiv();
}
}
while(ch!=0);
getch();
închidegrafic();
restorecrtmode();
}

IESIRE-
14. Scalare

#include<stdio.h>
#include<graphics.h>
#include<conio.h>
#include<math.h>
void main() {
int gd=DETECT,gm;
int x1,y1,x2,y2,a,b,h,k,ch;
initgraph(&gd,&gm,"C:\TURBOC3\BGI");
fă{
printf("Meniul principal");
1. scalare în jurul originii
2. scalare în jurul unui punct fix
printf(" Introduceti alegerea dvs.: 0 pentru a iesi");
scanf("%d",&ch);
dacă(ch==0){
getch();
iesire(1);
}
printf("Introduceti coordonatele:");
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
printf("factor x");
scanf("%d", &a);
printf("factor y");
scanf("%d",&b);

switch(ch)
{
cazul 1:
curăț are_dispozitiv();
outtextxy(200,20,"înainte de scalare");
linie(x1,y1,x2,y2);
x1=x1*a;
y1=y1*b;
x2=x2*a;
y2=y2*b;
getch();
îndepărteazăDispozitiv();
outtextxy(200,20,"după scalare");
linie(x1,y1,x2,y2);
getch();
stergeDispozitiv();
răspuns;

caz 2:
introduceț i punctul fix
scanf("%d%d",&h,&k);
cleardevice();
outtextxy(200,20,"înainte de scalare");
linie(x1,y1,x2,y2);
x1=x1*a-h*a+h;
y1=y1*b-k*b+k;
x2=x2*a-h*a+h;
y2=y2*b-k*b+k;
getch();
ș tergeDispozitiv();
outtextxy(200,20,"după scalare");
linie(x1,y1,x2,y2);
getch();
cleardevice();
ruptura;

default:
printf("Opț iune invalidă");
goleș teDispozitiv();

}
}
while(ch!=0);
getch();
închidegraf();
restaureazăModulCRT();
}

OUTPUT-
Algoritmul de umplere a inundaț iilor

#include<stdio.h>
#include<graphics.h>

void umpleFlood(int x,int y, int umple, int nouaCuloare)

{
dacă(getpixel(x,y)!=newcol&&getpixel(x,y)!=fill)
{
punctpixel(x,y,umple);
umpleInundare(x+1,y,umple, nouaCuloare);
floodFill(x,y+1,fill, newcol);
floodFill(x-1,y,fill, newcol);
umpleIn(x,y-1,fill, newcol);
umple inundare(x-1,y-1,umple, newcol);
floodFill(x-1,y+1,fill, newcol);
umple inundare(x+1,y-1,umple, newcol);
umpleInundatie(x+1,y+1,umple, nouaCuloare);
}
}
int main()
{
int gd=DETECT,gm;
initgraph(&gd,&gm,"C:\TURBOC3\BGI");
dreptunghi(50,50,100,100);
umpleInundare(55,55,4,15);
întârziere(1000);
getch();
închidegrafic();
return 0;
}

IEȘ IRE-

16. Algoritmul de umplere a limitelor

#include<stdio.h>
#include<graphics.h>
void boundaryFill(int x, int y, int newcol, int oldcol)
{
dacă(getpixel(x,y)==vecheaculoare)
{
punepixeli(x,y,nouacol);
umplereLimită(x+1,y,newcol,oldcol);
umplereLimită(x-1,y,newcol,oldcol);
boundaryFill(x,y+1,newcol,oldcol);
boundaryFill(x,y-1,newcol,oldcol);
}
}
int main()
{
int gd=DETECT,gm;
initgrafică(&gd,&gm,"C:\TURBOC3\BGI");
dreptunghi(50,50,300,300);
boundaryFill(51,51,12,0);
getch();
închidegrafic();
return 0;
}

OUTPUT-

17. Decuparea unei linii

#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#include<math.h>

void main(){
int gd=DETECT,gm;
int x1, y1, x2, y2, a, b;
initgrafică(&gd,&gm,"C:\TURBOC3\BGI");
introduceț i coordonatele:
scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
introduceț i factorul x
scanf("%d", &a);
printf("Introduceti factorul y");
scanf("%d",&b);
clear dispozitiv();
outtextxy(200,20,"înainte de tăiere");
linie(x1,y1,x2,y2);
x1=x1+a*y1;
y1=y1+b*x1;
x2=x2+a*y2;
y2=y2+b*x2;
getch();
curăț ădispozitiv();
după tăiere
linie(x1,y1,x2,y2);
getch();
închidegrafic();
restaureazămodcrt();
}

OUTPUT-

18. Reflecț ie

#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#include<math.h>

void main(){
int gd=DETECT,gm;
float x1,y1,x2,y2,x3,y3,x4,y4,m,n,b;
int ch,x,y;
initgraf(&gd,&gm,"C:\TURBOC3\BGI");
facă{
printf("[Link] despre x");
[Link] despre y
[Link] despre arbitrar
printf("introduce alegerea ta: 0 pentru a ieș i");
scanf("%d", &ch);
dacă(ch==0){
getch();
iesire(1);
}
printf("Introduceț i coordonatele:");
scanf("%f%f%f%f", &x1, &y1, &x2, &y2);
switch(ch){
cazul 1:
sterge dispozitivul();
outtextxy(200,20,"înainte");
x = getmaxx();
y=getmaxy();
linie(0,y/2,x,y/2);
linie(x/2,0,x/2,y);
linie(x1+x/2,y1+y/2,x2+x/2,y2+y/2);
x1=x1+x/2;
y1=y1+y/2-2*y1;
x2=x2+x/2;
y2=y2+y/2-2*y2;
getch();
ș tergeDispozitiv();
outtextxy(200,20,"după");
linie(x1,y1,x2,y2);
linie(0,y/2,x,y/2);
linie(x/2,0,x/2,y);
getch();
ș terge dispozitivul();
ruptura;

caz 2:
şterge dispozitivul();
outtextxy(200,20,"înainte");
x=getmaxx();
y=getmaxy();
linie(0,y/2,x,y/2);
linie(x/2,0,x/2,y);
linie(x1+x/2,y1+y/2,x2+x/2,y2+y/2);
x1=x1+x/2-2*x1;
y1=y1+y/2;
x2=x2+x/2-2*x2;
y2=y2+y/2;
getch();
curăț are dispozitiv();
outtextxy(200,20,"după");
linie(x1,y1,x2,y2);
linie(0,y/2,x,y/2);
linie(x/2,0,x/2,y);
getch();
ș terge dispozitivul();
sparge;

cazul 3:
printf("introduceț i un arbitrar");
scanf("%f%f%f%f",&x3,&y3,&x4,&y4);
curataparate();
outtextxy(200,20,"înainte");
linie(x1,y1,x2,y2);
linie(x3,y3,x4,y4);
m=(y4-y3)/(x4-x3);
b=y3-m*x3;
n=m*m+1;
x1=(1-m*m)*x1/n+2*m*y1/n-2*b*m/n;
y1=(m*m-1)*y1/n+2*m*x1/n+2*b/n;
x2=(1-m*m)*x2/n+2*m*y2/n-2*b*m/n;
y2=(m*m-1)*y2/n+2*m*x2/n+2*b/n;
getch();
ș tergeDispozitiv();
after
linie(x1,y1,x2,y2);
linie(x3,y3,x4,y4);
getch();
stergedispozitiv();
rupe;

default:
printf("invalide");
ș terge_dispozitivul();

}
}
while(ch!=0);
getch();
closegraph();
restorescale();
}

IEș IREA-
19. Decuparea poligoanelor

#include<stdio.h>
#include<graphics.h>
#include<conio.h>
#include<math.h>
#include<process.h>

#define ADEVARAT 1
#define FALS 0
typedef unsigned int outcode;
outcode CompOutCode(float x,float y);

enum{
TOP= 0x1,
BOTTOM= 0x2,
DREPT=0x4,
LEFT=0x8
};

float xmin,xmax,ymin,ymax;
void clip(float x0,float y0,float x1,float y1)
{
codie codie0, codiel, codieIesire;
int accept = FALSE,done = FALSE;
outcode0 =CompOutCode(x0,y0);
outcodel= CompOutCode(x1,y1);

fa
{
dacă(!(outcode0|outcodel))
{
accept = TRUE;
done = TRUE;
}
altfel
dacă(outcode0&outcodel)
done = TRUE;
altfel
{
float x,y;
outcodeOut = outcode0?outcode0:outcodel;
daca(outcodeOut&TOP)
{
x=x0+(x1-x0)*(ymax-y0)/(y1-y0);
y=ymax;
}
altfel
dacă(outcodeOut&BOTTOM)
{
x = x0+(x1-x0)*(ymin-y0)/(y1-y0);
y=ymin;
}
altfel
dacă(outcodeOut&DREAPTA)
{
y=y0+(y1-y0)*(xmax-x0)/(x1-x0);
x = xmax;
}
altfel
{
y=y0+(y1-y0)*(xmin-x0)/(x1-x0);
x = xmin;
}

dacă(outcodeOut==outcode0)
{
x0 = x;
y0 = y;
outcode0 =CompOutCode(x0,y0);
}
altfel
{
x1 = x;
y1=y;
outcodel = CompOutCode(x1,y1);
}}
}
în timp ce (terminat == FALS);
dacă(acceptă)
linie(x0,y0,x1,y1);
afisare_text(150,20,"POLIGON DUPĂ TĂIERE");
dreptunghi(xmin,ymin, xmax,ymax);
}
outcode CompOutCode(float x,float y){
outcode code = 0;
dacă(y>ymax)
cod|=TOP;
altfel dacă(y<ymin)
code|=BOTTOM;
dacă(x>xmax)
code|=RIGHT;
altfel dacă(x<xmin)
cod|=STÂNGA;
returnează cod;
}
void main(){
float x1,y1,x2,y2;
int gdriver = DETECT, gmode, n,poly[14],i;
clrscr();
printf("Introdu numărul de laturi al poligonului:");
scanf("%d", &n);
printf(" Introduceti coordonatele poligonului ");
pentru(i=0;i<2*n;i++)
{
scanf("%d",&poly[i]);
}
poly[2*n]=poly[0];
poly[2*n+1]=poly[1];
Introduceț i coordonatele dreptunghiulare ale feroniei de decupare
scanf("%f%f%f%f",&xmin,&ymin, &xmax,&ymax);
initgraph(&gdriver, &gmode, "C:\TURBOC3\BGI");
outtextxy(150,20,"POLIGON ÎNAINTE DE TĂIERE");
desenarepoligon(n+1,poligon);
dreptunghi(xmin,ymin,xmax,ymax);
getch( );
stergereaparate();
pentru(i=0;i<n;i++)
clip(poly[2*i],poly[(2*i)+1],poly[(2*i)+2],poly[(2*i)+3]);
getch( );
restorecrtmode();
}

OUTPUT-

20. Fereastra către viewport

#include<stdio.h>
#include<conio.h>
#include<graphics.h>
void main(){
int gd=DETECT,gm,i,n,poly[14],poly1[14];
int wxmin,wymin,wxmax,wymax,vxmin,vymin,vxmax,vymax;
float sx, sy;
initgrafică(&gd,&gm,"C:\TURBOC3\BGI");
printf("Introduceti coordonatele: wxmin=");
scanf("%d",&wxmin);
wymin=
scanf("%d",&wymin);
wxmax=
scanf("%d",&wxmax);
printf(" wymax=");
scanf("%d",&wymax);
printf("Introduceț i coordonatele vizualizării: vxmin=");
scanf("%d",&vxmin);
printf("\nvymin=");
scanf("%d",&vymin);
printf("\nvxmax=");
scanf("%d",&vxmax);
printf(" vymax=");
scanf("%d",&vymax);
printf("Introduceti laturile:");
scanf("%d",&n);
Introduceti coordonatele:
pentru(i=0;i<2*n;i++){
scanf("%d",&poly[i]);
}
golestedevice();
poly[2*n]=poly[0];
poly[2*n+1]=poly[1];
deseneazapoligon(n+1,poligon);
dreptunghi(wxmin,wymin,wxmax,wymax);
sx=(vxmax-vxmin)/(wxmax-wxmin);
sy=(vymax-vymin)/(wymax-wymin);
pentru(i=0;i<n;i++){
poly1[2*i]=sx*(poly[2*i]-wxmin)+vxmin;
poly1[2*i+1]=sy*(poly[2*i+1]-wymin)+vymin;
}
poly1[2*n]=poly1[0];
poly1[2*n+1]=poly1[1];
dreptunghi(vxmin, vymin, vxmax, vymax);
fereastra către vport
deseneazăpoligon(n+1, poligon1);
getch();
închide graficul();
}

OUTPUT-
21. Tăierea liniei Cohen Sutherland

#include<stdio.h>
#include<graphics.h>
#include<conio.h>
#include<math.h>
#define ADEVARAT 1
#define FALS 0
typedef unsigned int outcode;
outcode CompOutCode(float x,float y);

enum{TOP=0x1,
BOTTOM=0x2,
RIGHT=0x4,
LEFT=0x8
};

float xmin,xmax,ymin,ymax;
void clip(float x0,float y0,float x1,float y1)
{
outcode outcode0, outcode1, outcodeOut;
int accept=FALS, finalizat=FALS;
outcode0=CompOutCode(x0,y0);
outcode1=CompOutCode(x1,y1);
fă
{
dacă(!(outcode0|outcode1))
{
accept=TRUE;
done=TRUE;
}
altfel
dacă(outcode0&outcode1)
done=TRUE;
altfel{
float x,y;
outcodeOut=outcode0?outcode0:outcode1;
dacă(outcodeOut&TOP){
x=x0+(x1-x0)*(ymax-y0)/(y1-y0);
y=ymax;
}
altfel dacă(outcodeOut&BOTTOM){
x=x0+(x1-x0)*(ymin-y0)/(y1-y0);
y=ymin;
}
altfel dacă(outcodeOut&RIGHT){
y=y0+(y1-y0)*(xmax-x0)/(x1-x0);
x=xmax;
}
altfel{
y=y0+(y1-y0)*(xmin-x0)/(x1-x0);
x=xmin;
}
if(outcodeOut==outcode0)
{
x0=x;
y0=y;
outcode0=CompOutCode(x0,y0);
}
altfel{
x1=x;
y1=y;
outcode1=CompOutCode(x1,y1);

}
}
}
while(done==FALSE);
dacă(accept)
linie(x0,y0,x1,y1);
outtextxy(200,20,"Singur după decupare");
dreptunghi(xmin,ymin,xmax,ymax);
}
outcode CompOutCode(float x,float y)
{
outcode cod=0;
dacă(y>ymax)
cod|=TOP;
altfel dacă(y<ymin)
cod|=FUND;
altfel dacă(x>xmax)
code|=RIGHT;
altfel dacă(x<xmin)
cod|=STÂNGA;
returnează codul;
}
void main()
{
float x1,y1,x2,y2;
int gd=DETECT,gm;
printf("Introduceț i punctul final:");
scanf("%f%f%f%f", &x1, &y1, &x2, &y2);
Introduceti coordonatele rectangulare:
scanf("%f%f%f%f",&xmin,&ymin,&xmax,&ymax);
initgrafic(&gd,&gm,"C:\TURBOC3\BGI");
outtextxy(200,20,"Înainte de a decupa");
linie(x1,y1,x2,y2);
drepte(xmin,ymin,xmax,ymax);
getch();
ș terge dispozitivul();
clip(x1,y1,x2,y2);
getch();
restorecrtmode();
}

OUTPUT-
 DESEN ANIMAT DORAEMON

Declaraț ie de problemă:
Problema este să creăm o desen animat cu personajul popular Doraemon folosind
bibliotecă grafică în C. Obiectivul este de a dezvolta un program care poate genera un vizual
reprezentare atrăgătoare ș i recognoscibilă a lui Doraemon pe ecran printr-o serie de
iteraț ii animate. Programul ar trebui să utilizeze diverse funcț ii grafice pentru a desena diferitele
părț i ale corpului lui Doraemon, aplică setări de culoare pentru a crea variaț ii vizuale ș i introducerea unei tranziț ii graduale
efect de animaț ie pentru a aduce personajul la viaț ă. Rezultatul final ar trebui să semene cu Doraemon ș i
capturează trăsăturile sale caracteristice, cum ar fi faț a rotundă, corpul albastru, clopotul ș i alte elemente recognoscibile
elemente.

Introducere:
Codul dat este un program C care foloseș te biblioteca graphics.h pentru a desena un personaj numit
Doraemon pe ecran. Doraemon este un personaj popular din manga ș i anime japoneză.
utilizează diverse funcț ii grafice pentru a crea forma ș i caracteristicile personajului. Foloseș te forme
cum ar fi elipse, cercuri ș i linii pentru a reprezenta diferite părț i ale corpului lui Doraemon, inclusiv capul,
corp, mâini, picioare, coadă ș i trăsături faciale. Programul începe prin includerea header-ului necesar
fiș iere, cum ar fi `stdio.h`, `conio.h`, `dos.h`, `stdlib.h` ș i `graphics.h`. Aceste fiș iere header oferă
funcț iile ș i bibliotecile necesare pentru realizarea operaț iunilor de intrare/ieș ire, operaț iunilor cu consola,
Funcț ii legate de DOS, funcț ii din biblioteca standard ș i funcț ii grafice, respectiv.
Funcț ia `main` este punctul de intrare al programului. Aceasta iniț ializează modul grafic folosind
`initgraph` funcț ia. Funcț ia primeș te driverul grafic, modul grafic ș i calea către
Directorul BGI (Borland Graphics Interface) ca parametrii. Această funcț ie configurează graficile
un mediu pentru desen pe ecran. În interiorul funcț iei principale, există un ciclu care iterează 50
timpuri. În cadrul fiecărei iteraț ii a buclei, sunt folosite diverse funcț ii grafice pentru a desena diferite
body parts of the Doraemon character.
Codul utilizează funcț ii precum `setcolor` pentru a seta culoarea pentru desenare, `ellipse` pentru a desena
ellipsă, `linie` pentru a desena linii, ș i `cerc` pentru a desena cercuri. Fiecare parte a corpului este poziț ionată, modelată,
ș i dimensionate folosind coordonate ș i parametri specifici. Programul foloseș te culori diferite pentru a reda
personajul. Acesta setează culoarea folosind funcț ia `setcolor` cu coduri numerice. Schimbând
culoarea în cadrul fiecărei iteraț ii a buclei, aspectul personajului se schimbă în timp.
La sfârș itul fiecărei iteraț ii, programul introduce o întârziere de 350 de milisecunde folosind `delay`
funcț ie. Aceasta creează un efect de animaț ie pe măsură ce personajul apare treptat pe ecran.
În cele din urmă, programul aș teaptă o apăsare de tastă folosind funcț ia `getch`, iar apoi închide grafica.
modul folosind funcț ia `closegraph`. În general, codul combină utilizarea funcț iilor grafice,
bucle ș i manipularea culorilor pentru a crea o desen animat cu personajul Doraemon.
Cerinț e hardware:
1. Computer sau laptop
2. RAM suficientă pentru a rula funcț iile grafice fără probleme

3. Monitor sau ecran pentru a vizualiza ieș irea

Cerinț e software:
1. Compilator C (cum ar fi Turbo C++, Code::Blocks sau Visual Studio)
Biblioteca Graphics.h
3. Sistem de operare care suportă compilatorul C ales ș i biblioteca grafică (de exemplu, Windows,
Linux

Cod:
#include<stdio.h>
#include<conio.h>
#include<dos.h>
#include<stdlib.h>
#include<graphics.h>
void main()
{
int i;
int gd=DETECT,gm;
initgraf(&gd,&gm,"c:\turboc3\bgi");

pentru(i=0;i<50;i++)
{
//________PICIOARE______________//
setcolor(15);
elipsă(200,450,150,390,50,16);
linie(157,441,243,441);
elipsă(252,448,246,389,50,18);
linie(243,441,297,441);
setează culoarea(i);
ellipse(249,441,90,180,10,15);

//_______COADA
setcolor(12);
elipsă(155,410,80,280,8,8);

setcolor(i);
linie(157,441,157,370);
linie(297,441,297,350);

//_______mana stângă
setcolor(15);
cerc(147,357,16);
seteazăculoare(i);
elipsă(137,342,300,330,58,19);
elipsă(174,348,110,170,29,49);

//______mână dreaptă
setcolor(15);
cerc(327,275,16);
setcolor(i);
elipsă(265,260,299,340,74,90);
elipsă(323,285,110,170,25,19);

Gât
setcolor(12);
linie(163,302,285,302);
linie(163,298,285,298);
elipsă(163,301,90,270,3,3);
elipsă(285,300,280,80,4,3);

//_____geantă de burtă

setcolor(15);
ellipse(243,334,143,40,56,48);
elipsă(244,346,163,15,30,24);
linie(214,340,273,340);

//________clopot
setcolor(14);
cerc(244,310,8);
linie(238,306,251,306);
linie(236,309,251,309);

//______cap
setcolor(i);
ellipse(220,237,0,180,87,60);
ellipse(180,237,180,250,47,65);
ellipse(268,237,290,360,40,65);

//_______fa
setează culoare(15);
ellipse(263,277,15,90,45,60);
elipsă(245,210,0,360,19,23);
ellipse(207,210,0,360,19,23);
ellipse(202,237,190,243,47,69);
ellipse(187,254,90,170,32,35);
cerc(216,217,5);
cerc(237,218,5);

//_____nas
setează culoarea(12);
cerc(227,236,8);
ellipse(230,262,180,360,45,30);
ellipse(232,263,10,190,47,6);

setcolor(15);
ellipse(275,253,290,110,10,8);

linie(227,244,227,257);
linie(245,238,269,234);
linie(245,244,269,242);
linie(245,250,269,252);

linie(185,236,210,238);
linie(185,244,210,244);
linie(185,252,210,250);

//__________text
settextstyle(3,0,2);
setcolor(i);
outtextxy(100,50,"DORAEMON");
întârziere(350);
}
getch();
închidegrafic();
}
Output:

Future Enhancements:

1) Portarea codului la un compilator modern: Turbo C este un compilator învechit ș i este posibil să nu
lucrează pe sisteme moderne. Ia în considerare utilizarea unui compilator modern precum GCC sau Clang, ș i
actualizaț i codul pentru a fi compatibil cu noul compilator.

2) Utiliza ț i o bibliotecă grafică compatibilă cu compilatorul ales: Deoarece biblioteca graphics.h

este specific compilatorului Turbo C, s-ar putea să nu fie disponibil în alte compilatoare. Explorează
biblioteci grafice alternative, cum ar fi SDL, OpenGL sau SFML, care pot fi utilizate cu
compilatoare moderne.

3) Implementa ț i conceptele de modularizare ș i programare orientată pe obiect (OOP):

codul curent este scris într-un stil procedural. Pentru a îmbunătăț i menț inerea codului ș i
pentru lizibilitate, poț i să îl împarț i în funcț ii mai mici sau să implementezi un model orientat pe obiect
abordare prin crearea de clase pentru diferitele părț i ale animaț iei Doraemon.
4) Adăuga ț i interactivitate: Pute ț i introduce interac ț iune cu utilizatorul în anima ț ie răspunzând la
evenimente de tastatură sau mouse. De exemplu, ai putea adăuga funcț ionalitatea de a muta Doraemon
sau declanș ează animaț ii diferite în funcț ie de inputul utilizatorului.

5) Îmbunătă ț iț i efectele vizuale: Experimenta ț i cu diferite efecte grafice, cum ar fi umbrirea,

transparenț ă, sau efecte de particule, pentru a face animaț ia mai atrăgătoare din punct de vedere vizual.

6) Implementa ț i anima ț ii suplimentare: Extinde ț i programul adăugând mai multe anima ț ii sau
interacț iuni. De exemplu, ai putea crea miș cări suplimentare pentru Doraemon, a anima
alte personaje sau să creeze o scenă completă pentru ca Doraemon să interacț ioneze.