2>2d and 3d transformation

3>COHEN SUTHERLAND and Liang-Barsky Line Clipping

4>SUTHERLAND-HODGMAN POLYGON CLIPPING

5>Character Generation

6>elipse by using mid-point

7>Bezier Curve using Midpoint and parametric

To Implement Bezier Curve using Midpoint approach*/

#include<stdio.h>

#include<graphics.h>

#include<conio.h>

int gd,gm,maxx,maxy;

float xxx[4][2];

void line1(float x2,float y2)

{

line(xxx[0][0],xxx[0][1],x2,y2);

xxx[0][0]=x2;

xxx[0][1]=y2;

}

bezier(float xb,float yb,float xc,float yc,float xd,float yd,int n)

{

float xab,yab,xbc,ybc,xcd,ycd;

float xabc,yabc,xbcd,ybcd;

float xabcd,yabcd;

if(n==0)

{

line1(xb,yb);

line1(xc,yc);

line1(xd,yd);

}

else

{

xab = (xxx[0][0]+xb)/2;

yab = (xxx[0][1]+yb)/2;

xbc = (xb+xc)/2;

ybc = (yb+yc)/2;

xcd = (xc+xd)/2;

ycd = (yc+yd)/2;

xabc = (xab+xbc)/2;

yabc = (yab+ybc)/2;

xbcd= (xbc+xcd)/2;

ybcd = (ybc+ycd)/2;

xabcd = (xabc+xbcd)/2;

yabcd = (yabc+ybcd)/2;

n=n-1;

bezier(xab,yab,xabc,yabc,xabcd,yabcd,n);

bezier(xbcd,ybcd,xcd,ycd,xd,yd,n);

}

}

void igraph()

{

detectgraph(&gd,&gm);

if(gd<0)

{

puts(“CANNOT DETECT A GRAPHICS CARD”);

exit(1);

}

initgraph(&gd,&gm,”c:\\tc\\bgi”);

}

main()

{

int i;

float temp1,temp2;

igraph();

for(i=0;i<4;i++)

{

printf(“Enter x coordinates of point %d: “,i+1);

scanf(“%f”,&temp1);

printf(“Enter the y coordinates of point %d:”,i+1);

scanf(“%f”,&temp2);

xxx[i][0] = temp1;

xxx[i][1] = temp2;

}

bezier(xxx[1][0],xxx[1][1],xxx[2][0],xxx[2][1],xxx[3][0],xxx[3][1],8);

getch();

closegraph();

return(0);

}

/////////////////////////

To Implement Bezier Curve*/

#include<stdio.h>

#include<graphics.h>

int x,y,z;

main()

{

float  u;

int    gd,gm,ymax,i,n,c[4][3];

for(i=0;i<4;i++)  { c[i][0]=0; c[i][1]=0; }

printf(“\n\n  Enter four points  :  \n\n”);

for(i=0; i<4; i++)

{

printf(“\t X%d   Y%d     :  “,i,i);

scanf(“%d %d”,&c[i][0],&c[i][1]);

}

c[4][0]=c[0][0];

c[4][1]=c[0][1];

detectgraph(&gd,&gm);

initgraph(&gd,&gm,” “);

ymax = 480;

setcolor(35);

for(i=0;i<3;i++)

{

line(c[i][0],ymax-c[i][1],c[i+1][0],ymax-c[i+1][1]);

}

setcolor(63);

n=3;

for(i=0;i<=40;i++)

{

u=(float)i/40.0;

bezier(u,n,c);

if(i==0)

{ moveto(x,ymax-y);}

else

{ lineto(x,ymax-y); }

getch();

}

getch();getch();

}/*-main()-*/

/*————————– CURVE.C ————————–*/

bezier(u,n,p)

float u;int n; int p[4][3];

{

int j;

float v,b;

float blend(int,int,float);

x=0;y=0;z=0;

for(j=0;j<=n;j++)

{

b=blend(j,n,u);

x=x+(p[j][0]*b);

y=y+(p[j][1]*b);

z=z+(p[j][2]*b);

}

}

float blend(int j,int n,float u)

{

int k;

float v,blend;

v=C(n,j);

for(k=0;k<j;k++)

{ v*=u; }

for(k=1;k<=(n-j);k++)

{ v *= (1-u); }

blend=v;

return(blend);

}

C(int n,int j)

{

int k,a,c;

a=1;

for(k=j+1;k<=n;k++)  { a*=k; }

for(k=1;k<=(n-j);k++)   { a=a/k; }

c=a;

return(c);

}

#include<iostream.h>

#include<dos.h>

#include<conio.h>

#include<math.h>

#include<graphics.h>

void display (int xs1, int ys1, int x, int y);

void ellips1(int xs1,int ys1,int rx, int ry)

{

int x,y;

float d1,d2,dx,dy;

x = 0;                  // take start position as (0,ry)

y = ry;             // finding decision parameter d1

d1 = pow(ry,2) – (pow(rx,2) * ry) + (0.25 * pow(rx,2));

dx = 2 * pow(ry,2) * x;

dy = 2 * pow(rx,2) * y;

do                         // region one

{

display(xs1,ys1,x,y);

if(d1<0)

{

x++;

dx = dx + (2 * (pow(ry,2)));

d1 = d1 + dx +(pow(ry,2));

}

else

{

x++;

y–;

dx = dx + (2 * (pow(ry,2)));

dy = dy – (2 * (pow(rx,2)));

d1 = d1 + dx – dy + (pow(ry,2));

}

}while(dx<dy);      // change over condition for region-2

do                       // region two

{

display(xs1,ys1,x,y);

if(d2>0)

{

x = x;

y–;

dy = dy – (2 * (pow(rx,2)));

d2 = d2 – dy + pow(rx,2);

}

else

{

x++;

y–;

dy = dy – (2 * (pow(rx,2)));

dx = dx + (2 * (pow(ry,2)));

d2 = d2 +dx – dy + pow(rx,2);

}

}while(y>0);

}

void display(int xs,int ys,int x,int y)

{

putpixel(xs+x,ys+y,WHITE); // plot points by using 4 point symmetry

putpixel(xs-x,ys-y,WHITE);

putpixel(xs+x,ys-y,WHITE);

putpixel(xs-x,ys+y,WHITE);

}

int main(void)

{

int xs1,ys1;

float rx1,ry1;

int gd = DETECT,gm;           // Initialise the graphics system

initgraph(&gd,&gm,”c:\\tc\\bgi”);

cout<<”\t\tMidpoint Ellipe Drawing Algorithm\n”;

cout<<”Enter the Center Co-ordinates\n”;

cout<<”xc = \t”;

cin>>xs1;

cout<<”yc = \t”;

cin>>ys1;

cout<<”Enter the X Radius\t”;

cin>>rx1;

cout<<”Enter the Y Radius\t”;

cin>>ry1;

ellips1(xs1,ys1,rx1,ry1);

getch();

closegraph();

}

#include<stdio.h>

#include<graphics.h>

main()

{

int gd,gm,i,j;

/* Save character map of letter A

————————————- */

int a[13][9] = {

{ 0, 0, 0, 0, 1, 0, 0, 0, 0},

{ 0, 0, 0, 1, 0, 1, 0, 0, 0},

{ 0, 0, 1, 0, 0, 0, 1, 0, 0},

{ 0, 1, 0, 0, 0, 0, 0, 1, 0},

{ 0, 1, 0, 0, 0, 0, 0, 1, 0},

{ 0, 1, 0, 0, 0, 0, 0, 1, 0},

{ 0, 1, 1, 1, 1, 1, 1, 1, 0},

{ 0, 1, 0, 0, 0, 0, 0, 1, 0},

{ 0, 1, 0, 0, 0, 0, 0, 1, 0},

{ 0, 1, 0, 0, 0, 0, 0, 1, 0},

{ 0, 1, 0, 0, 0, 0, 0, 1, 0},

{ 0, 1, 0, 0, 0, 0, 0, 1, 0},

{ 0, 1, 0, 0, 0, 0, 0, 1, 0},

};

/* Initialise graphics mode

———————————- */

detectgraph(&gd,&gm);

initgraph(&gd,&gm,”c:\\tc\\bgi”);

for(i=0;i<13;i++)

{

for(j=0;j<9;j++)

{

putpixel(200+j,200+i,30*a[i][j]);

}

}

getch();

closegraph();

}

#include <math.h>

#include <stdio.h>

#include <graphics.h>

int         n,p,x,y,i,j;

int         xwmin,ywmin,xwmax,ywmax;

int         x1,y1,x2,y2,xmax,ymax;

float      m;

char      flag;

float      dy,dx;

main()

{

int gd,gm;

int a[10][10],b[10][10],c[10][10],d[10][10],e[10][10];

detectgraph(&gd,&gm);

initgraph(&gd,&gm,”");

printf(“\n\n\tEnter the no. of edges of polygon :  “);

scanf(“%d”,&n);

printf(“\n\n\tEnter the cordinates  of  polygon :\n\n\n “);

for(i=0;i<n;i++)

{

printf(“\tX%d  Y%d  :  “,i,i);

scanf(“%d %d”,&a[i][0],&a[i][1]);

}

a[n][0]=a[0][0];

a[n][1]=a[0][1];

printf(“\n\tEnter the co_ordinates of window  :\n “);

printf(“\n\txwmin , ywmin  : “);

scanf(“%d %d”,&xwmin,&ywmin);

printf(“\n\txwmax , ywmax  : “);

scanf(“%d %d”,&xwmax,&ywmax);

xmax = 640; ymax = 480;

cleardevice();

setcolor(35);

for(i=0;i<n;i++)

{

line(a[i][0],ymax-a[i][1],a[i+1][0],ymax-a[i+1][1]);

}

rectangle(xwmin,ymax-ywmin,xwmax,ymax-ywmax);

getch();

setcolor(35);

clip_left(a,b);

clip_right(b,c);

clip_bottom(c,d);

clip_top(d,e);

cleardevice();

setcolor(63);

for(i=0;i<p;i++)

{

line(e[i][0],ymax-e[i][1],e[i+1][0],ymax-e[i+1][1]);

}

getch();

}/*-main()-*/

clip_left(int a[10][10], int b[10][10])

{

p=0;flag=0;m=0;

for(i=0;i<n;i++)

{

dy=a[i+1][1]-a[i][1];

dx=a[i+1][0]-a[i][0];

if((dx!=0)&&(dy!=0))

{

m=(dy/dx);

}

if((a[i][0]<xwmin)&&(a[i+1][0]>=xwmin) )      flag=0;

if((a[i][0]>=xwmin)&&(a[i+1][0]>=xwmin))     flag=1;

if((a[i][0]>=xwmin)&&(a[i+1][0]<xwmin))       flag=2;

if((a[i][0]<xwmin)&&(a[i+1][0]<xwmin) )         flag=3;

switch(flag)

{

case 0 :

x=xwmin;

if(dy!=0)

y=(int)(a[i][1]+m*(x-a[i][0]));

else

y=a[i][1];

b[p][0]=x;

b[p][1]=y;

p++;

b[p][0]=a[i+1][0];

b[p][1]=a[i+1][1];

p++;

break;

case 1 :

b[p][0]=a[i+1][0];

b[p][1]=a[i+1][1];

p++;

break;

case 2 :

x=xwmin;

if(dy!=0)

y=(int)(a[i][1]+m*(x-a[i][0]));

else

y=a[i][1];

b[p][0]=x;

b[p][1]=y;

p++;

}

}/*-for()-*/

b[p][0]=b[0][0];

b[p][1]=b[0][1];

cleardevice();

setcolor(35);

rectangle(xwmin,ymax-ywmin,xwmax,ymax-ywmax);

setcolor(63);

for(i=0;i<p;i++)

{

line(b[i][0],ymax-b[i][1],b[i+1][0],ymax-b[i+1][1]);

getch();

}

getch();

}

clip_right(int b[10][10],int c[10][10])

{

n=p; p=0; m=0;

for(i=0;i<n;i++)

{

dy=b[i+1][1]-b[i][1];

dx=b[i+1][0]-b[i][0];

if((dx!=0)&&(dy!=0))

{

m=(dy/dx);

}

if((b[i][0]>xwmax)&&(b[i+1][0]<=xwmax) )  flag=0;

if((b[i][0]<=xwmax)&&(b[i+1][0]<=xwmax) ) flag=1;

if((b[i][0]<=xwmax)&&(b[i+1][0]>xwmax) )  flag=2;

if((b[i][0]>xwmax)&&(b[i+1][0]>xwmax) )   flag=3;

switch(flag)

{

case 0 :

x=xwmax;

if(dy!=0)

y=(int)(b[i][1]+m*(x-b[i][0]));

else

y=b[i][1];

c[p][0]=x;

c[p][1]=y;

p++;

c[p][0]=b[i+1][0];

c[p][1]=b[i+1][1];

p++;

break;

case 1 :

c[p][0]=b[i+1][0];

c[p][1]=b[i+1][1];

p++;

break;

case 2 :

x=xwmax;

if(dy!=0)

y=(int)(b[i][1]+m*(x-b[i][0]));

else

y=b[i][1];

c[p][0]=x;

c[p][1]=y;

p++;

}

}/*-for()-*/

c[p][0]=c[0][0];

c[p][1]=c[0][1];

cleardevice();

setcolor(35);

rectangle(xwmin,ymax-ywmin,xwmax,ymax-ywmax);

setcolor(63);

for(i=0;i<p;i++)

{

line(c[i][0],ymax-c[i][1],c[i+1][0],ymax-c[i+1][1]);

getch();

}

getch();

}

clip_bottom(int c[10][10],int d[10][10])

{

n=p; p=0; m=0;

for(i=0;i<n;i++)

{

dy=c[i+1][1]-c[i][1];

dx=c[i+1][0]-c[i][0];

if((dx!=0)&&(dy!=0))

{

m=(dy/dx);

}

if((c[i][1]<ywmin)&&(c[i+1][1]>=ywmin) )  flag=0;

if((c[i][1]>=ywmin)&&(c[i+1][1]>=ywmin) ) flag=1;

if((c[i][1]>=ywmin)&&(c[i+1][1]<ywmin) )  flag=2;

if((c[i][1]<ywmin)&&(c[i+1][1]<ywmin) )   flag=3;

switch(flag)

{

case 0 :

y=ywmin;

if(dx!=0)

x=abs((int)(c[i][0]+(1/m)*(y-c[i][1])));

else

x=c[i][0];

d[p][0]=x;

d[p][1]=y;

p++;

d[p][0]=c[i+1][0];

d[p][1]=c[i+1][1];

p++;

break;

case 1 :

d[p][0]=c[i+1][0];

d[p][1]=c[i+1][1];

p++;

break;

case 2 :

y=ywmin;

if(dx!=0)

x=abs((int)(c[i][0]+(1/m)*(y-c[i][1])));

else

x=c[i][0];

d[p][0]=x;

d[p][1]=y;

p++;

}

}/*-for()-*/

d[p][0]=d[0][0];

d[p][1]=d[0][1];

cleardevice();

setcolor(35);

rectangle(xwmin,ymax-ywmin,xwmax,ymax-ywmax);

setcolor(63);

for(i=0;i<p;i++)

{

line(d[i][0],ymax-d[i][1],d[i+1][0],ymax-d[i+1][1]);

getch();

}

getch();

}

clip_top(int d[10][10],int e[10][10])

{

n=p;

p=0;

for(i=0;i<n;i++)

{

dy=d[i+1][1]-d[i][1];

dx=d[i+1][0]-d[i][0];

if((dx!=0)&&(dy!=0))

{

m=(dy/dx);

}

if((d[i][1]>ywmax)&&(d[i+1][1]<=ywmax) )  flag=0;

if((d[i][1]<=ywmax)&&(d[i+1][1]<=ywmax) ) flag=1;

if((d[i][1]<=ywmax)&&(d[i+1][1]>ywmax) )  flag=2;

if((d[i][1]>ywmax)&&(d[i+1][1]>ywmax) )   flag=3;

switch(flag)

{

case 0 :

y=ywmax;

if(dx!=0)

x=abs((int)(d[i][0]+(1/m)*(y-d[i][1])));

else

x=d[i][0];

e[p][0]=x;

e[p][1]=y;

p++;

e[p][0]=d[i+1][0];

e[p][1]=d[i+1][1];

p++;

break;

case 1 :

e[p][0]=d[i+1][0];

e[p][1]=d[i+1][1];

p++;

break;

case 2 :

y=ywmax;

if(dx!=0)

x=abs((int)(d[i][0]+(1/m)*(y-d[i][1])));

else

x=d[i][0];

e[p][0]=x;

e[p][1]=y;

p++;

}

}/*-for()-*/

e[p][0]=e[0][0];

e[p][1]=e[0][1];

cleardevice();

setcolor(35);

rectangle(xwmin,ymax-ywmin,xwmax,ymax-ywmax);

setcolor(63);

for(i=0;i<p;i++)

{

line(e[i][0],ymax-e[i][1],e[i+1][0],ymax-e[i+1][1]);

getch();

}

getch(); getch();

}

#include<stdio.h>

#include<conio.h>

#include<graphics.h>

int xwmin=100,ywmin=100,xwmax=300,ywmax=300,x,y;

float dx,dy,m;

void main()

{

int gd=DETECT,gm,x1,y1,x2,y2,flag=0;

printf(“Enter the co-ordinates of line:”);

scanf(“%d %d %d %d”,&x1,&y1,&x2,&y2);

initgraph(&gd,&gm,”c:\\tc\\bgi “);

rectangle(xwmin,ywmin,xwmax,ywmax);

line(x1,y1,x2,y2);

getch();

cleardevice();

rectangle(xwmin,ywmin,xwmax,ywmax);

if((y1>ywmax)&&(y2>ywmax)) flag=1;

if((y1<ywmin)&&(y2<ywmin)) flag=1;

if((x1>xwmax)&&(x2>xwmax)) flag=1;

if((x1<xwmin)&&(x2<xwmin)) flag=1;

if(flag==0)

{

dy=y2-y1;

dx=x2-x1;

if(dx==0)

dx=1;

m=dy/dx;

x=x1;

y=y1;

encode();

moveto(x,y);

x=x2;

y=y2;

encode();

if(x>=xwmin&&x<=xwmax&&y>=ywmin&&y<=ywmax)

lineto(x,y);

}

getch();

closegraph();

}

encode()

{

if(x<xwmin)

{

y=y+(xwmin-x)*m;

x=xwmin;

}

if(x>xwmax)

{

y=y+(xwmax-x)*m;

x=xwmax;

}

if(y<ywmin)

{

if(m!=0) x=x+(ywmin-y)/m;

else x=x+(ywmin-y);

y=ywmin;

}

if(y>ywmax)

{

if(m!=0) x=x+(ywmax-y)/m;

else x=x+(ywmax-y);

y=ywmax;

}

}

///////////////////////////////////////////////////////////////

//Program for Liang-Barsky Line Clipping Algorithm

#include<stdio.h>

#include<conio.h>

#include<graphics.h>

#include<math.h>

void main()

{

int i,gd=DETECT,gm;

int x1,y1,x2,y2,xmin,xmax,ymin,ymax,xx1,xx2,yy1,yy2;

float t1,t2,p[4],q[4],temp;

printf(“Enter line co-ordinates : “);

scanf(“%d %d %d %d”,&x1,&y1,&x2,&y2);

initgraph(&gd,&gm,”c:\\tc\\bgi”);

/*x1=10;

y1=10;

x2=60;

y2=30;*/

xmin=100;

xmax=300;

ymin=100;

ymax=300;

line(x1,y1,x2,y2);

rectangle(xmin,ymin,xmax,ymax);

getch();

cleardevice();

rectangle(xmin,ymin,xmax,ymax);

p[0]=-(x2-x1);

p[1]=(x2-x1);

p[2]=-(y2-y1);

p[3]=(y2-y1);

q[0]=(x1-xmin);

q[1]=(xmax-x1);

q[2]=(y1-ymin);

q[3]=(ymax-y1);

for(i=0;i<4;i++)

{

if(p[i]==0)

{

printf(“Line is parallel to one of the clipping boundary”);

if(q[i]>=0)

{

if(i<2)

{

if(y1<ymin)

y1=ymin;

if(y2>ymax)

y2=ymax;

line(x1,y1,x2,y2);

}

if(i>1)

{

if(x1<xmin)

x1=xmin;

if(x2>xmax)

x2=xmax;

line(x1,y1,x2,y2);

}

}

getch();

return(0);

}

}

t1=0;

t2=1;

for(i=0;i<4;i++)

{

temp=q[i]/p[i];

if(p[i]<0)

{

if(t1<=temp)

t1=temp;

}

else

{

if(t2>temp)

t2=temp;

}

}

if(t1<t2)

{

xx1=x1+t1*p[1];

xx2=x1+t2*p[1];

yy1=y1+t1*p[3];

yy2=y1+t2*p[3];

line(xx1,yy1,xx2,yy2);

}

getch();

closegraph();

}

#include<stdio.h>

#include<conio.h>

#include<stdlib.h>

#include<graphics.h>

#include<math.h>

#define OX maxx/2

#define OY maxy/2

#define MAX 10

int num=0;

int maxx,maxy;

double result[3][MAX];

void drawobject(double[3][MAX]);

void translate(double[3][MAX]);

void scale(double[3][MAX]);

void rotate(double[3][MAX]);

void arrmult(double[3][MAX],double[3][3],double[3][MAX]);

void main()

{

double vertices[3][MAX];

int gd=DETECT,gm;

int i,choice;

char ch;

initgraph(&gd,&gm,”c:\\tc\\bgi”);

cleardevice();

maxx=getmaxx();

maxy=getmaxy();

setcolor(WHITE);

printf(“\n\tEnter the details of original object :”);

printf(“\n\tEnter the total number of vertices :\t”);

scanf(“%d”,&num);

for(i=0;i<num;i++)

{

printf(“\n\tEnter the co-ordinates of vertice[%d] :\t”,i+1);

scanf(“%lf %lf”,&vertices[0][i],&vertices[1][i]);

vertices[2][i]=1;

}

cleardevice();

drawobject(vertices);

getch();

cleardevice();

do

{

setlinestyle(DASHED_LINE,1,1);

printf(“\n\tEnter the choice : “);

printf(“\n\t1:TRANSLATION 2:ROTATION 3:SCALE”);

printf(“\n\tChoice :\t”);

scanf(“%d”,&choice);

switch(choice)

{

case 1: translate(vertices);

break;

case 2: rotate(vertices);

break;

case 3: scale(vertices);

break;

default:printf(“\n\tInvalid choice….”);

}

fflush(stdin);

cleardevice();

printf(“\n\tDo you wish to continue : (y/n)\n\tChoice :\t”);

scanf(“%c”,&ch);

}

while(ch!=’n'&&ch!=’N');

getch();

closegraph();

restorecrtmode();

}

void drawobject(double arr[3][MAX])

{

int i,j;

line(maxx/2,0,maxx/2,maxy);

line(0,maxy/2,maxx,maxy/2);

for(i=0;i<num;i++)

{

j=(i+1)%num;

line(OX+arr[0][i],OY-arr[1][i],OX+arr[0][j],OY-arr[1][j]);

}

}

void arrmult(double product[3][MAX],double arr1[3][3],double arr2[3][MAX])

{

int i,j,k;

for(i=0;i<3;i++)

for(j=0;j<MAX;j++)

{

product[i][j]=0;

for(k=0;k<3;k++)

product[i][j]+=arr1[i][k]*arr2[k][j];

}

}

void translate(double arr[3][MAX])

{

int tx,ty;

double tranx[3][3]={1,0,0,0,1,0,0,0,1};

printf(“\n\tEnter the translation distance along X-axis:\t”);

scanf(“%d”,&tx);

printf(“\n\tEnter the translation distance along Y-axis:\t”);

scanf(“%d”,&ty);

tranx[0][2]=tx;

tranx[1][2]=ty;

arrmult(result,tranx,arr);

cleardevice();

drawobject(arr);

setlinestyle(SOLID_LINE,1,1);

drawobject(result);

getch();

}

void scale(double arr[3][MAX])

{

int sx,sy,x,y;

double scale[3][3]={0,0,0,0,0,0,0,0,1};

printf(“\n\tEnter the scaling magnitude along X-axis:\t”);

scanf(“%d”,&sx);

printf(“\n\tEnter the scaling magnitude along Y-axis:\t”);

scanf(“%d”,&sy);

printf(“\n\tEnter the fixed point X & Y coordinates for scaling:\t”);

scanf(“%d%d”,&x,&y);

scale[0][0]=sx;

scale[0][2]=x*(1-sx);

scale[1][1]=sy;

scale[1][2]=y*(1-sy);

arrmult(result,scale,arr);

cleardevice();

drawobject(arr);

setlinestyle(SOLID_LINE,1,1);

drawobject(result);

getch();

}

void rotate(double arr[3][MAX])

{

int angle,choice,x,y;

double rad;

double rotate[3][3]={0,0,0,0,0,0,0,0,1};

printf(“\n\tEnter the angle of rotation in degrees:\t”);

scanf(“%d”,&angle);

printf(“\n\t1.Clockwise Rotation  2. Anti-Clockwise Rotation\n\tEnter Choice :\t”);

scanf(“%d”,&choice);

angle*=(choice==1?-1:1);

printf(“\n\tEnter the pivot point X & Y coordinates for rotation:\t”);

scanf(“%d%d”,&x,&y);

rad=3.14159*angle/180;

rotate[0][0]=cos(rad);

rotate[0][1]=-1*sin(rad);

rotate[1][0]=sin(rad);

rotate[1][1]=cos(rad);

rotate[0][2]=x*(1-cos(rad))+y*sin(rad);

rotate[1][2]=y*(1-cos(rad))-x*sin(rad);

arrmult(result,rotate,arr);

cleardevice();

drawobject(arr);

setlinestyle(SOLID_LINE,1,1);

drawobject(result);

getch();

}

A C++ program to implement different 3D transformations such as

* Scaling               * Translation      * Rotation*/

#include<stdio.h>

#include<conio.h>

#include<iostream.h>

#include<graphics.h>

#include<alloc.h>

#include<stdlib.h>

#include<math.h>

#include<dos.h>

int gd=0, gm;

class axes

{

private:                                // Initialiasing data members for axes

int xmx,ymx,yst,xst,zmx,zst;

float xsc,ysc,xstep,ystep,zsc,zstep;

public:

axes();

void display();

int actx(int tmx,int tmy,int tmz)

{

return 320+((xsc*tmx)-(zsc*tmz/2))+tmy-tmy;

}

int acty(int tmx,int tmy,int tmz)

{

return 255-((ysc*tmy)-(zsc*tmz/2))+tmx-tmx;

}

}cl;

axes::axes()

{

xmx=280;

ymx=200;

zmx=400;

xsc=280.0/xmx;

xstep=10.0*xmx/280.0;

xst=ceil(xstep);

ysc=200.0/ymx;

ystep=10.0*ymx/200.0;

yst=ceil(ystep);

zsc=400.0/zmx;

zstep=10.0*zmx/400.0;

zst=ceil(zstep);

}

/*Member Name            :               display().

Purpose                               :               To display the X,Y & Z-axis*/

void axes::display()

{

setcolor(CYAN);

line(25,255,615,255);

line(320,25,320,455);

line(actx(0,0,zmx),acty(0,0,zmx),actx(0,0,-zmx),acty(0,0,-zmx));

outtextxy(325,255,”0″);

settextstyle(3,0,1);

outtextxy(620,240,”X”);

outtextxy(323,20,”Y”);

outtextxy(actx(0,0,zmx)+3,acty(0,0,zmx)+3,”Z”);

settextstyle(0,0,0);

}

class polygon

{

private:                // Initialiasing data members

float cube[8][4];

public:                   // Declaring all transformation functions

void accept();

void display(int);

void scaling();

void scale(float,float,float);

void translation();

void trans(int,int,int);

void rotate();

void x_rotat(float);

void y_rotat(float);

void z_rotat(float);

int plotx(int i)

{

return cl.actx(cube[i][0],cube[i][1],cube[i][2]);

}

int ploty(int i)

{

return cl.acty(cube[i][0],cube[i][1],cube[i][2]);

}

polygon operator * (float [4][4]);

}p1;

/*Member Name            :               display(int).

Purpose                               :               To display a 3D cube with specified color*/

void polygon::display(int color)

{

setcolor(color);

line(plotx(0),ploty(0),plotx(1),ploty(1));

line(plotx(1),ploty(1),plotx(3),ploty(3));

line(plotx(3),ploty(3),plotx(2),ploty(2));

line(plotx(2),ploty(2),plotx(0),ploty(0));

line(plotx(4),ploty(4),plotx(5),ploty(5));

line(plotx(5),ploty(5),plotx(7),ploty(7));

line(plotx(7),ploty(7),plotx(6),ploty(6));

line(plotx(6),ploty(6),plotx(4),ploty(4));

line(plotx(0),ploty(0),plotx(4),ploty(4));

line(plotx(1),ploty(1),plotx(5),ploty(5));

line(plotx(2),ploty(2),plotx(6),ploty(6));

line(plotx(3),ploty(3),plotx(7),ploty(7));

}

/*Member Name            :               accept().

Purpose                               :               To accept the 3D only one corner point of an object from the user and generate all point of object to display on the screen.*/

void polygon::accept()

{

int xc,yc,zc;

cout<<”\n\t\t 3-D TRANSFORMATIONS”;

cout<<”\n\tenter the co-ordinates of the corner of the cube…”;

cout<<”\n\n\tx :              “;

cin>>xc;

cout<<”\n\ty :   “;

cin>>yc;

cout<<”\n\tz :   “;

cin>>zc;

int sd;

cout<<”\n\tEnter the length of each side : “;

cin>>sd;

for(int i=0;i<8;i++)

{

cube[i][3] =1;

}

cube[0][0] = xc;

cube[0][1] = yc;

cube[0][2] = zc;

cube[1][0] = xc;

cube[1][1] = yc;

cube[1][2] = zc+sd;

cube[2][0] = xc;

cube[2][1] = yc+sd;

cube[2][2] = zc;

cube[3][0] = xc;

cube[3][1] = yc+sd;

cube[3][2] = zc+sd;

cube[4][0] = xc+sd;

cube[4][1] = yc;

cube[4][2] = zc;

cube[5][0] = xc+sd;

cube[5][1] = yc;

cube[5][2] = zc+sd;

cube[6][0] = xc+sd;

cube[6][1] = yc+sd;

cube[6][2] = zc;

cube[7][0] = xc+sd;

cube[7][1] = yc+sd;

cube[7][2] = zc+sd;

}

/*Member Name            :               operator* (float).

Purpose                               :               To multiply two matrices by using operator overloading concept*/

polygon polygon::operator* (float b[4][4])

{

polygon c;

for(int i=0;i<8;i++)

for(int j=0;j<4;j++)

{

c.cube[i][j]=0;

for(int k=0;k<4;k++)

c.cube[i][j]+=cube[i][k]*b[k][j];

delay(1);

}

return c;

}

/*Member Name            :               scaling().

Purpose                               :               To accept the scaling factors to perform scaling transformation.*/

void polygon::scaling()

{

float sx,sy,sz;

gotoxy(1,1);

cout<<”                                                                                                                                                “

“                                                                                                                                              “;

gotoxy(1,1);

cout<<” X scaling factor :”;

cin>>sx;

gotoxy(1,1);

cout<<”                                                                                                                                                “

“                                                                                                                                              “;

gotoxy(1,1);

cout<<” Y scaling factor :”;

cin>>sy;

gotoxy(1,1);

cout<<”                                                                                                                                                “

“                                                                                                                                              “;

gotoxy(1,1);

cout<<” Z scaling factor :”;

cin>>sz;

scale(sx,sy,sz);

getch();

gotoxy(1,3);

cout<<”                                                                                                                “;

gotoxy(1,4);

cout<<”                                                                                                                “;

gotoxy(1,5);

cout<<”                                                                                                                “;

}

/*Member Name            :               scale().

Purpose                               :               To create scaling matrix and multiply it with object to perform scaling     transformation.*/

void polygon::scale(float sx,float sy, float sz)

{

float sclmt[4][4];

sclmt[0][0]=sx;

sclmt[0][1]=0;

sclmt[0][2]=0;

sclmt[0][3]=0;

sclmt[1][0]=0;

sclmt[1][1]=sy;

sclmt[1][2]=0;

sclmt[1][3]=0;

sclmt[2][0]=0;

sclmt[2][1]=0;

sclmt[2][2]=sz;

sclmt[2][3]=0;

sclmt[3][0]=0;

sclmt[3][1]=0;

sclmt[3][2]=0;

sclmt[3][3]=1;

cleardevice();

gotoxy(1,1);

cout<<”scaling results….”;

cl.display();

p1=p1*sclmt;

display(2);

gotoxy(1,3);

cout<<”sx =  “<<sx;

gotoxy(1,4);

cout<<”sy =  “<<sy;

gotoxy(1,5);

cout<<”sz =  “<<sz;

}

/*Member Name            :               translation().

Purpose                               :               To accept the translation factors to perform translation.*/

void polygon::translation()

{

float tx,ty,tz;

gotoxy(1,1);

cout<<”                                                                                                                                                “

“                                                                                                                                              “;

gotoxy(1,1);

cout<<” X Translation factor        :”;

cin>>tx;

gotoxy(1,1);

cout<<”                                                                                                                                                “

“                                                                                                                                              “;

gotoxy(1,1);

cout<<” Y translation factor         :”;

cin>>ty;

gotoxy(1,1);

cout<<”                                                                                                                                                “

“                                                                                                                                              “;

gotoxy(1,1);

cout<<” Z Translation factor        :”;

cin>>tz;

trans(tx,ty,tz);

getch();

gotoxy(1,3);

cout<<”                                                                                                                “;

gotoxy(1,4);

cout<<”                                                                                                                “;

gotoxy(1,5);

cout<<”                                                                                                                “;

}

/*Member Name            :               trans(int,int,int).

Purpose                               :               To create translation matrix and multiply it

with object to perform translation.*/

void polygon::trans(int tx,int ty, int tz)

{

float tr[4][4];

tr[0][0]=1;

tr[0][1]=0;

tr[0][2]=0;

tr[0][3]=0;

tr[1][0]=0;

tr[1][1]=1;

tr[1][2]=0;

tr[1][3]=0;

tr[2][0]=0;

tr[2][1]=0;

tr[2][2]=1;

tr[2][3]=0;

tr[3][0]=tx;

tr[3][1]=ty;

tr[3][2]=tz;

tr[3][3]=1;

cleardevice();

gotoxy(1,1);

cout<<”Translation results….”;

cl.display();

p1=p1*tr;

display(4);

gotoxy(1,3);

cout<<”tx =  “<<tx;

gotoxy(1,4);

cout<<”ty =  “<<ty;

gotoxy(1,5);

cout<<”tz =  “<<tz;

}

/*Member Name            :               rotate().

Purpose                               :               To select rotation about a either X,Y or Z-axis                                                                      with specified angle.*/

void polygon::rotate()

{

int ch;

gotoxy(1,1);

cout<<”                                                                                                                                “

“                                                                                                                              “;

gotoxy(1,1);

cout<<”                1=> X                                     2=> Y                                     3=> Z     :”;

cin>>ch;

float angle;

gotoxy(1,1);

cout<<”                                                                                                                                “

“                                                                                                                              “;

gotoxy(1,1);

cout<<”                Rotation angle : “;

cin>>angle;

angle*=M_PI/180;

switch(ch)

{

case 1 : x_rotat(angle);

break;

case 2 : y_rotat(angle);

break;

case 3 : z_rotat(angle);

break;

}

}

/*Member Name            :               x_rotat(float).

Purpose                               :               To perform rotation about X-axis withspecified angle.*/

void polygon::x_rotat(float angle)

{

float rt[4][4];

rt[0][0]=1;

rt[0][1]=0;

rt[0][2]=0;

rt[0][3]=0;

rt[1][0]=0;

rt[1][1]=cos(angle);

rt[1][2]=-sin(angle);

rt[1][3]=0;

rt[2][0]=0;

rt[2][1]=sin(angle);

rt[2][2]=cos(angle);

rt[2][3]=0;

rt[3][0]=0;

rt[3][1]=0;

rt[3][2]=0;

rt[3][3]=1;

cleardevice();

p1=p1*rt;

cleardevice();

gotoxy(1,1);

cout<<”Rotating about X-axis….”;

cl.display();

display(2);

delay(5000);

}

/*Member Name            :               y_rotat(float).

Purpose                               :               To perform rotation about Y-axis withspecified angle.*/

void polygon::y_rotat(float angle)

{

float rt[4][4];

rt[0][0]=cos(angle);

rt[0][1]=0;

rt[0][2]=sin(angle);

rt[0][3]=0;

rt[1][0]=0;

rt[1][1]=1;

rt[1][2]=0;

rt[1][3]=0;

rt[2][0]=-sin(angle);

rt[2][1]=0;

rt[2][2]=cos(angle);

rt[2][3]=0;

rt[3][0]=0;

rt[3][1]=0;

rt[3][2]=0;

rt[3][3]=1;

cleardevice();

gotoxy(1,1);

cout<<”Rotating about Y-axis….”;

cl.display();

p1=p1*rt;

display(2);

delay(5000);

}

/*Member Name            :               z_rotat(float).

Purpose                               :               To perform rotation about Z-axis with specified angle.*/

void polygon::z_rotat(float angle)

{

float rt[4][4];

rt[0][0]=cos(angle);

rt[0][1]=-sin(angle);

rt[0][2]=0;

rt[0][3]=0;

rt[1][0]=sin(angle);

rt[1][1]=cos(angle);

rt[1][2]=0;

rt[1][3]=0;

rt[2][0]=0;

rt[2][1]=0;

rt[2][2]=1;

rt[2][3]=0;

rt[3][0]=0;

rt[3][1]=0;

rt[3][2]=0;

rt[3][3]=1;

cleardevice();

gotoxy(1,1);

cout<<”Rotating about Z-axis….”;

cl.display();

p1=p1*rt;

display(2);

delay(5000);

}

main()

{

initgraph(&gd,&gm,”c:\\tcplus\\bgi”);

p1.accept();

cleardevice();

cl.display();

p1.display(2);

int choice;

while(1)

{

gotoxy(1,1);

cout<<”                                “                              “                              “;

gotoxy(1,1);

cout<<”1.scaling               2.translation       3. Rotation  4.exit : “;

cin>>choice;

switch(choice)

{

case 1 : p1.scaling();

break;

case 2 : p1.translation();

break;

case 3 : p1.rotate();

break;

case 4 : getch();

closegraph();

exit (0);

}

}

}

/* End of program */

#include<stdio.h>

#include<graphics.h>

#include<conio.h>

#include<math.h>

void main()

{

float x,y,x1,x2,y1,y2,dx,dy,length;

int i,gd,gm;

clrscr();

printf(“Enter the value of x1=”);

scanf(“%f”,&x1);

printf(“Enter the value of y1=”);

scanf(“%f”,&y1);

printf(“Enter the value of x2=”);

scanf(“%f”,&x2);

printf(“Enter the value of y2=”);

scanf(“%f”,&y2);

detectgraph (&gd,&gm);

initgraph(&gd,&gm,”c:\\tc\\bgi”);

dx=abs(x2-x1);

dy=abs(y2-y1);

if (dx>=dy)

{

length = dx;

}

else

{

length = dy;

}

dx= (x2-x1)/length;

dy= (y2-y1)/length;

x=x1+0.5;

y=y1+0.5;

i=1;

while (i<=length)

{

putpixel(x,y,15);

x=x+dx;

y=y+dy;

i=i+1;

delay(10);

}

getch();

}

/*Problem Def :- To Implement Bresenham Line Algorithm*/

#include<stdio.h>

#include<graphics.h>

#include<conio.h>

#include<math.h>

void main()

{

float x,y,x1,x2,y1,y2,dx,dy,e;

int i,gd,gm;

clrscr();

printf(“Enter x1:”);

scanf(“%f”,&x1);

printf(“Enter y1:”);

scanf(“%f”,&y1);

printf(“Enter x2:”);

scanf(“%f”,&x2);

printf(“Enter y2:”);

scanf(“%f”,&y2);

detectgraph (&gd,&gm);

initgraph(&gd,&gm,”c:\\tc\\bgi”);

dx=abs(x2-x1);

dy=abs(y2-y1);

x=x1;

y=y1;

e=2*dy-dx;

i=1;

do

{

putpixel(x,y,15);

while(e>=0)

{

y=y+1;

e=e-2*dx;

}

x=x+1;

e=e+2*dy;

i=i+1;

}

while(i<=dx);

delay(50);

getch();

closegraph();

}