cg - Paste text,images,html and share with anyone

#include <conio.h>
#include <iostream>
#include <graphics.h>
#include <stdlib.h>
using namespace std; class point
{
public:
int x,y;
}; class poly
{
private: point p[20];
int inter[20],x,y;
int v,xmin,ymin,xmax,ymax;
public:
int c; void read(); void calcs(); void display(); void ints(float); void sort(int);
}; void poly::read()
{
int i; cout<<“\n Scan Fill Algorithm “; cout<<“\n Enter Number Of Vertices Of Polygon: “; cin>>v;
if(v>2)
{
for(i=0;i<v; i++) //ACCEPT THE VERTICES
{
cout<<“\nEnter co-ordinate no. “<<i+1<<” : “; cout<<“\n\tx”<<(i+1)<<“=”; cin>>p[i].x; cout<<“\n\ty”<<(i+1)<<“=”; cin>>p[i].y;
}
p[i].x=p[0].x;
p[i].y=p[0].y; xmin=xmax=p[0].x;
ymin=ymax=p[0].y;
}
else
cout<<“\n Enter valid no. of vertices.”;
}void poly::calcs()
{for(int i=0;i<v;i++)
{ if(xmin>p[i].x) xmin=p[i].x;
if(xmax<p[i].x) xmax=p[i].x;
if(ymin>p[i].y)
ymin=p[i].y;
if(ymax<p[i].y)
ymax=p[i].y;}} void poly::display()
{ int ch1;
char ch=’y’;
float s,s2;
do
{ cout<<“\n\nMENU:”; cout<<“\n\n\t1 . Scan line Fill “; cout<<“\n\n\t2 . Exit “; cout<<“\n\nEnter your choice:”; cin>>ch1; switch(ch1)
{ case 1: s=ymin+0.01;
delay(100); cleardevice(); while(s<=ymax)
{ ints(s); sort(s); s++;}
break; case 2: exit(0); }
cout<<“Do you want to continue?: “; cin>>ch;
}while(ch==’y’ || ch==’Y’);} void poly::ints(float z)
{ int x1,x2,y1,y2,temp; c=0;
for(int i=0;i<v;i++)
{ x1=p[i].x;
y1=p[i].y; x2=p[i+1].x;
y2=p[i+1].y;
if(y2<y1)
{temp=x1; x1=x2; x2=temp;
temp=y1;
y1=y2;
y2=temp;}
if(z<=y2&&z>=y1)
{ if((y1-y2)==0) x=x1; else { x=((x2-x1)*(z-y1))/(y2-y1); x=x+x1; }
if(x<=xmax && x>=xmin)
inter[c++]=x;}}} void poly::sort(int z) // sorting
{ int temp,j,i;
for(i=0;i<v;i++)
{ line(p[i].x,p[i].y,p[i+1].x,p[i+1].y); }
delay(100);
for(i=0; i<c;i+=2)
{ delay(100);
line(inter[i],z,inter[i+1],z); }}
int main() //main
{ int cl;
initwindow(500,600); cleardevice();
poly x; x.read(); x.calcs(); cleardevice(); cout<<“\n\tEnter The Color You Want :(In Range 0 To 15 )->”; //selecting color cin>>cl; setcolor(cl); x.display(); closegraph(); //closing graph
getch(); return 0;
}

#include<iostream>
#include<stdlib.h>
#include<math.h>
#include<graphics.h>
#include<dos.h>
using namespace std; class Coordinate {
public:
int x,y; char code[4];
}; class Lineclip
{
public: Coordinate PT; void drawwindow(); void drawline(Coordinate p1,Coordinate p2);
Coordinate setcode(Coordinate p);
int visibility(Coordinate p1,Coordinate p2);
Coordinate resetendpt(Coordinate p1,Coordinate p2);
};
int main()
{
Lineclip lc;
int gd = DETECT,v,gm;
Coordinate p1,p2,p3,p4,ptemp; cout<<“\n Enter x1 and y1\n”; cin>>p1.x>>p1.y; cout<<“\n Enter x2 and y2\n”; cin>>p2.x>>p2.y;
initgraph(&gd,&gm,””);
lc.drawwindow();
delay(2000);
lc.drawline (p1,p2);
delay(2000); cleardevice();
delay(2000);
p1=lc.setcode(p1);
p2=lc.setcode(p2); v=lc.visibility(p1,p2);
delay(2000); switch(v)
{
case 0: lc.drawwindow();
delay(2000);
lc.drawline(p1,p2);
break; case 1:lc.drawwindow();
delay(2000);
break; case 2:p3=lc.resetendpt(p1,p2);
p4=lc.resetendpt(p2,p1);
lc.drawwindow();
delay(2000);
lc.drawline(p3,p4);
break;
}
delay(2000);
closegraph();
}void Lineclip::drawwindow()
{
line(150,100,450,100);
line(450,100,450,350);
line(450,350,150,350);
line(150,350,150,100);
}void Lineclip::drawline(Coordinate p1,Coordinate p2)
{
line(p1.x,p1.y,p2.x,p2.y);
}
Coordinate Lineclip::setcode(Coordinate p)
{
Coordinate ptemp;
if(p.y<100)
ptemp.code[0]=’1′; else ptemp.code[0]=’0′;
if(p.y>350)
ptemp.code[1]=’1′; else ptemp.code[1]=’0′;
if(p.x>450)
ptemp.code[2]=’1′; else ptemp.code[2]=’0′;
if(p.x<150)
ptemp.code[3]=’1′; else ptemp.code[3]=’0′;
ptemp.x=p.x;
ptemp.y=p.y; return(ptemp);
};
int Lineclip:: visibility(Coordinate p1,Coordinate p2)
{
int i,flag=0;
for(i=0;i<4;i++)
{
if(p1.code[i]!=’0′ || (p2.code[i]==’1′))
flag=’0′;
}
if(flag==0)
return(0);
for(i=0;i<4;i++)
{
if(p1.code[i]==p2.code[i] && (p2.code[i]==’1′))
flag=’0′;
}
if(flag==0)
return(1); return(2);
}
Coordinate Lineclip::resetendpt(Coordinate p1,Coordinate p2)
{
Coordinate temp;
int x,y,i;
float m,k;
if(p1.code[3]==’1′) x=150;
if(p1.code[2]==’1′)
x=450;
if((p1.code[3]==’1′) || (p1.code[2])==’1′)
{m=(float)(p2.y-p1.y)/(p2.x-p1.x);
k=(p1.y+(m*(x-p1.x)));
temp.y=k;
temp.x=x;
for(i=0;i<4;i++)
temp.code[i]=p1.code[i];
if(temp.y<=350 && temp.y>=100)
return (temp);
}
if(p1.code[0]==’1′)
y=100;
if(p1.code[1]==’1′)
y=350;
if((p1.code[1]==’1′) || (p1.code[1]==’1′))
{m=(float)(p2.y-p1.y)/(p2.x-p1.x);
k=(float)p1.x+(float)(y-p1.y)/m;
temp.x=k;
temp.y=y;
for(i=0;i<4;i++)
temp.code[i]=p1.code[i]; return(temp);
}
else
return(p1);
}

#include<iostream>
#include<graphics.h>
#include<math.h>
using namespace std; class transform
{
public:
int m,a[20][20],c[20][20];
int i,j,k;
public: void object(); void accept(); void operator *(float b[20][20])
{
for(int i=0;i<m;i++)
{
for(int j=0;j<m;j++)
{
c[i][j]=0;
for(int k=0;k<m;k++)
{
c[i][j]=c[i][j]+(a[i][k]*b[k][j]);
}
}
}
}
}; void transform::object()
{
int gd,gm;
gd=DETECT;
initgraph(&gd,&gm,NULL);
line(300,0,300,600);
line(0,300,600,300);
for( i=0;i<m-1;i++)
{
line(300+a[i][0],300-a[i][1],300+a[i+1][0],300-a[i+1][1]);
}
line(300+a[0][0],300-a[0][1],300+a[i][0],300-a[i][1]);
for( i=0;i<m-1;i++)
{
line(300+c[i][0],300-c[i][1],300+c[i+1][0],300-c[i+1][1]);
}
line(300+c[0][0],300-c[0][1],300+c[i][0],300-c[i][1]);
int temp; cout <<“Press 1 to continue”; cin >> temp; closegraph();
}void transform::accept()
{
cout<<“\n”; cout<<“Enter the Number Of Edges:”; cin>>m; cout<<“\nEnter The Coordinates :”;
for(int i=0;i<m;i++)
{
for(int j=0;j<3;j++)
{
if(j>=2)
a[i][j]=1; else
cin>>a[i][j];
}
}
}
int main()
{
int ch,tx,ty,sx,sy;
float deg,theta,b[20][20];
transform t;
t.accept(); cout<<“\nEnter your choice”; cout<<“\n1.Translation”
“\n2.Scaling”
“\n3.Rotation”; cin>>ch; switch(ch)
{
case 1: cout<<“\nTRANSLATION OPERATION\n”; cout<<“Enter value for tx and ty:”; cin>>tx>>ty;
b[0][0]=b[2][2]=b[1][1]=1;
b[0][1]=b[0][2]=b[1][0]=b[1][2]=0;
b[2][0]=tx;
b[2][1]=ty;
t * b;
t.object();
break; case 2: cout<<“\nSCALING OPERATION\n”; cout<<“Enter value for sx,sy:”; cin>>sx>>sy;
b[0][0]=sx;
b[1][1]=sy;
b[0][1]=b[0][2]=b[1][0]=b[1][2]=0;
b[2][0]=b[2][1]=0;
b[2][2] = 1;
t * b;
t.object();
break; case 3: cout<<“\nROTATION OPERATION\n”; cout<<“Enter value for angle:”; cin>>deg;
theta=deg*(3.14/100);
b[0][0]=b[1][1]=cos(theta);
b[0][1]=sin(theta);
b[1][0]=sin(-theta);
b[0][2]=b[1][2]=b[2][0]=b[2][1]=0;
b[2][2]=1;
t * b;
t.object();
break;
default: cout<<“\nInvalid choice”;
}
getch(); return 0;
}

#include<iostream>
#include<graphics.h>
#include<math.h>
#include<cstdlib>
using namespace std; void move(int j, int h, int &x,int &y){
if(j==1)
y-=h; else
if(j==2) x+=h; else if(j==3)
y+=h; else if(j==4) x-=h;
lineto(x,y);} void hilbert(int r,int d,int l ,int u,int i,int h,int &x,int &y){
if(i>0){
i–;
hilbert(d,r,u,l,i,h,x,y); move(r,h,x,y);
hilbert(r,d,l,u,i,h,x,y); move(d,h,x,y);
hilbert(r,d,l,u,i,h,x,y); move(l,h,x,y);
hilbert(u,l,d,r,i,h,x,y);}}
int main(){
int n,x1,y1;
int x0=50,y0=150,x,y,h=10,r=2,d=3,l=4,u=1; cout<<“Give the value of n=”; cin>>n; x=x0;
y=y0;
int driver=DETECT,mode=0;
initgraph(&driver,&mode,NULL); moveto(x,y);
hilbert(r,d,l,u,n,h,x,y);
delay(10000); closegraph(); return 0;}

// C program to demonstrate

// drawing a circle using

// OpenGL

#include<stdio.h>

#include<GL/glut.h>

#include<math.h>

#define pi 3.142857

// function to initialize

void myInit (void)

{

// making background color black as first

// 3 arguments all are 0.0

glClearColor(0.0, 0.0, 0.0, 1.0);

// making picture color green (in RGB mode), as middle argument is 1.0

glColor3f(0.0, 1.0, 0.0);

// breadth of picture boundary is 1 pixel

glPointSize(1.0);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

// setting window dimension in X- and Y- direction

gluOrtho2D(-780, 780, -420, 420);

}

void display (void)

{

glClear(GL_COLOR_BUFFER_BIT);

glBegin(GL_POINTS);

float x, y, i;

// iterate y up to 2*pi, i.e., 360 degree

// with small increment in angle as

// glVertex2i just draws a point on specified co-ordinate

for ( i = 0; i < (2 * pi); i += 0.001)

{

// let 200 is radius of circle and as,

// circle is defined as x=r*cos(i) and y=r*sin(i)

x = 200 * cos(i);

y = 200 * sin(i);

glVertex2i(x, y);

}

glEnd();

glFlush();

}

int main (int argc, char** argv)

{

glutInit(&argc, argv);

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);

// giving window size in X- and Y- direction

glutInitWindowSize(1366, 768);

glutInitWindowPosition(0, 0);

// Giving name to window

glutCreateWindow(“Circle Drawing”);

myInit();

glutDisplayFunc(display);

glutMainLoop();

}

#include<iostream>
#include<conio.h>
#include<graphics.h>
#include<stdlib.h>
#include<dos.h>
using namespace std; class walkingman
{
int rhx,rhy;
public: void draw(int,int); void draw(int);
}; void walkingman::draw(int i)
{
line(20,380,580,380);
if(i%2)
{
line(25+i,380,35+i,340);
line(45+i,380,35+i,340);
line(35+i,310,25+i,330);
delay(20);
}
else {
line(35+i,340,35+i,310);
line(35+i,310,40+i,330);
delay(20);
}
line(35+i,340,35+i,310); circle(35+i,300,10);
line(35+i,310,50+i,330);
line(50+i,330,50+i,280);
line(15+i,280,85+i,280); arc(50+i,280,0,180,35); arc(55+i,330,180,360,5);
}void walkingman::draw(int x,int y)
{
int j; rhx=x; rhy=y;
for
(j=0;j<100;j++)
{outtextxy(rand()%rhx,rand()%(rhy-50),”|”); setcolor(WHITE);
}
}
int main()
{
int gd=DETECT,gm;
int rhx,rhy,j,i; walkingman obj;
initgraph(&gd,&gm,””);
for(i=0;i<500;i++)
{obj.draw(i);
rhx=getmaxx(); rhy=getmaxy(); obj.draw(rhx,rhy);
delay(150); cleardevice();
}
getch();
}

Download as PDF

Please follow and like us: