Graphics programming using c

Sunday, August 15, 2010

Sutherland-Hodgeman Polygon Clipping

#include<stdio.h>
#include<graphics.h>
struct point
{
 int x;
 int y;
}wmin,wmax,p1,p2,ipt,pin[50],pout[50];
int np=0,n,gd=DETECT,gm=VGAMAX;
void newpin();
void drawpolygon();
void showpoints();
void clippolygon()
{
 float m=0.0;
 np=0;
 int i,j;
 for(i=0,j=0;i<n;i++)
 {
  m=0.0;  
  p1=pin[i]; 
  p2=pin[(i+1)%n];
  if(p1.x>=wmin.x&&p2.x>=wmin.x)
  {
   pout[j]=p2;
   np++;
   j++;
  }
  else if(p2.x==wmin.x)
  {
   pout[j]=p2;
   np++;
   j++;
  }  
  else if(p1.x<wmin.x&&p2.x>wmin.x||p1.x>wmin.x&&p2.x<wmin.x)
  {
   if(p1.x!=p2.x)
    m=(float)(p1.y-p2.y)/(float)(p1.x-p2.x);
   ipt.x=wmin.x;
   ipt.y=p1.y+(wmin.x-p1.x)*m; 
   if(p1.x<wmin.x)
   {
    pout[j]=ipt;
    pout[j+1]=p2;
    np=np+2;
    j=j+2;
   }   
   else
   {
    p2=ipt;
    pout[j]=ipt;
    np++;
    j++;
   }
  }
 }
 newpin();
 outtextxy(220,10,"After left clip");
 drawpolygon();
 while (!kbhit());
 closegraph();
 initgraph(&gd,&gm,"NULL");
 np=0;
 for(i=0,j=0;i<n;i++)
 {
  m=0.0;  
  p1=pin[i]; 
  p2=pin[(i+1)%n];
  if(p1.x<=wmax.x&&p2.x<=wmax.x)
  {
   pout[j]=p2;
   np++;
   j++;
  }
  else if(p2.x==wmax.x)
  {
   pout[j]=p2;
   np++;
   j++;
  }
  else if(p1.x>wmax.x&&p2.x<wmax.x||p1.x<wmax.x&&p2.x>wmax.x)
  {
   if(p1.x!=p2.x)
    m=(float)(p1.y-p2.y)/(float)(p1.x-p2.x);
   ipt.x=wmax.x;
   ipt.y=p1.y+(wmax.x-p1.x)*m; 
   if(p1.x>wmax.x)
   {
    pout[j]=ipt;
    pout[j+1]=p2;
    np=np+2;
    j=j+2;
   }   
   else
   {
    p2=ipt;
    pout[j]=ipt;
    np++;
    j++;
   }
  }
 }
 newpin();
 outtextxy(220,10,"After right clip");
 drawpolygon();
 while (!kbhit());
 closegraph();
 initgraph(&gd,&gm,"NULL");
 np=0;
 for(i=0,j=0;i<n;i++)
 {
  m=0.0;  
  p1=pin[i]; 
  p2=pin[(i+1)%n];
  if(p1.y>=wmin.y&&p2.y>=wmin.y)
  {
   pout[j]=p2;
   np++;
   j++;
  }
  else if(p2.y==wmin.y)
  {
   pout[j]=p2;
   np++;
   j++;
  }
  else if(p1.y<wmin.y&&p2.y>wmin.y||p1.y>wmin.y&&p2.y<wmin.y)
  {
   if(p1.x!=p2.x)
    m=(float)(p1.y-p2.y)/(float)(p1.x-p2.x);
   ipt.y=wmin.y;
   if(m!=0)
    ipt.x=p1.x+(float)(wmin.y-p1.y)*(float)(1/m);
   else
    ipt.x=p1.x; 
   if(p1.y<wmin.y)
   {
    pout[j]=ipt;
    pout[j+1]=p2;
    np=np+2;
    j=j+2;
   }   
   else
   {
    p2=ipt;
    pout[j]=ipt;
    np++;
    j++;
   }
  }
 }
 newpin();
 outtextxy(220,10,"After bottom clip");
 drawpolygon();
 while (!kbhit());
 closegraph();
 initgraph(&gd,&gm,"NULL");
 np=0;
 for(i=0,j=0;i<n;i++)
 {
  m=0.0;  
  p1=pin[i]; 
  p2=pin[(i+1)%n];
  if(p1.y<=wmax.y&&p2.y<=wmax.y)
  {
   pout[j]=p2;
   np++;
   j++;
  }
  else if(p2.y==wmax.y)
  {
   pout[j]=p2;
   np++;
   j++;
  }
  else if(p1.y>wmax.y&&p2.y<wmax.y||p1.y<wmax.y&&p2.y>wmax.y)
  {
   if(p1.x!=p2.x)
    m=(float)(p1.y-p2.y)/(float)(p1.x-p2.x);
   ipt.y=wmax.y;
   if(m!=0)
    ipt.x=p1.x+(float)(wmax.y-p1.y)*(float)(1/m);
   else
    ipt.x=p1.x;
   if(p1.y>wmax.y)   
   {
    pout[j]=ipt;
    pout[j+1]=p2;
    np=np+2;
    j=j+2;
   }   
   else
   {
    p2=ipt;
    pout[j]=ipt;
    np++;
    j++;
   }
  }
 }
 newpin();
 outtextxy(220,10,"clipped Polygon");
 showpoints();
 drawpolygon();
}
void newpin()
{
 int i,j;
 for(j=0,i=0;j<np;j++,i++)
  pin[i]=pout[j];
 n=i;
}
void showpoints()
{
 int j;
 printf("Vertex");
 for(j=0;j<n;j++)
  printf("\n%d.(%d,%d)",j+1,pin[j].x,pin[j].y);
}
void drawpolygon()
{
 int j;
 setcolor(10);
 rectangle(wmin.x,wmin.y,wmax.x,wmax.y);
 setcolor(6);
 for(j=0;j<n;j++)
  line(pin[j].x,pin[j].y,pin[(j+1)%n].x,pin[(j+1)%n].y);
}
int main()
{
 int c,j;
 printf("Enter the window minimum coordinates");
 scanf("%d%d",&wmin.x,&wmin.y);
 printf("Enter the window max coordinates");
 scanf("%d%d",&wmax.x,&wmax.y);
 printf("Enter the no of sides in polygon:\n");
 scanf("%d",&n);
 printf("Enter the coordinates(x,y)\n");
 for(j=0;j<n;j++)
 {
  printf("Enter the coordinate %d\n",j+1);
  scanf("%d%d",&pin[j].x,&pin[j].y);
 }
 initgraph(&gd,&gm,"NULL");
 outtextxy(220,10,"Orginal Polygon");
 drawpolygon();
 while (!kbhit());
 closegraph();
 initgraph(&gd,&gm,"NULL");
 clippolygon();
 while (!kbhit());
 closegraph();
 return 0;
}

cohen-sutherland Line clipping

#include<stdio.h>
#include<graphics.h>
#define left 1
#define right 2
#define top 8
#define bottom 4
int xa,ya,xb,yb;
int wxmax,wxmin,wymax,wymin;
int regioncode(int x,int y)
{
 int ret=0;
 if(x<wxmin)
  ret|=left;
 if(x>wxmax)
  ret|=right;
 if(y<wymin)
  ret|=bottom;
 if(y>wymax)
  ret|=top;
 return ret;
}
int clipline()
{
 int rcode1=regioncode(xa,ya);
 int rcode2=regioncode(xb,yb);
 int x=0,y=0;
 float m=0.0;
 if(xb!=xa) 
  m=(float)(yb-ya)/(float)(xb-xa);
 while(1)
 {
  if(rcode1==0&&rcode2==0)
   return 1;
  else if((rcode1&rcode2)!=0)
   return 0;
  else
  {
   int outcode=(rcode1==0)?rcode2:rcode1;
   if(outcode&top)
   {
    if(m!=0)
     x=xa+(float)(1/m)*(float)(wymax-ya);
    else
     x=xa;
    y=wymax;
   } 
   else if(outcode&bottom)
   {
    if(m!=0)
     x=xa+(float)(1/m)*(float)(wymin-ya);
    else
     x=xa;
    y=wymin;
   }
   else if(outcode&left)
   {
    x=wxmin;
    y=ya+(float)(m)*(float)(wxmin-xa);
   }
   else if(outcode&right)
   {
    x=wxmax;
    y=ya+(float)(m)*(float)(wxmax-xa);
   }
   if(rcode1==outcode)
   {
    xa=x;
    ya=y;
    rcode1=regioncode(xa,ya);
   }
   else
   {
    xb=x;
    yb=y;
    rcode2=regioncode(xb,yb);
   }
  }
 }
}
int main()
{
 int gd=DETECT,gm=VGAMAX;
 printf("\nEnter the diagonal of rectangle, wxmin,wymin,wxmax,wymax");
 scanf("%d%d%d%d",&wxmin,&wymin,&wxmax,&wymax); 
 printf("\nxmin ymin (%d,%d)\n xmax ymax (%d,%d)",wxmin,wymin,wxmax,wymax);
 printf("\nEnter the cordinates of line ");
 scanf("%d%d%d%d",&xa,&ya,&xb,&yb);
 initgraph(&gd,&gm,NULL);
 printf("Before Clipping ");
 rectangle(wxmin,wymin,wxmax,wymax);
 line(xa,ya,xb,yb);
 while(!kbhit());
 closegraph();
 initgraph(&gd,&gm,NULL);
 printf("After Clipping ");
 rectangle(wxmin,wymin,wxmax,wymax);
 if(clipline())
 line(xa,ya,xb,yb);
 while(!kbhit());
 closegraph();
 return 0;
}

Tuesday, August 3, 2010

Filling - recursive and non-recursive method

3. Write a program to implement following seed filling algorithms on polygon, circle and an ellipse.
a) floodfill b) boundary fill

Recursive and Non Recursive method

#include<stdio.h>
#include<graphics.h>
#define ROUND(a)((int)(a+0.5))
struct stack
{
 int x;
 int y;
 struct stack *next;
}*p,*temp,*head=NULL;
typedef struct stack t1;
void push(int,int);
void pop();
int gd=DETECT,gm=VGAMAX;
int xf,yf;
void plotcircle(int,int,int,int);
void plotellipse(int,int,int,int);
void floodfill4(int,int,int,int);
void floodfill4nonrec(int,int,int,int);
void boundaryfill4(int,int,int,int);
void boundaryfill4nonrec(int,int,int,int);
void midpointcircle(int,int,int);
void midpointellipse(int,int,int,int);
void lineDDA(int,int,int,int);
int main()
{
 int xc,yc,rx,ry,r,n,choice,ch,newcolor;
 int oldcolor=getbkcolor();
 printf("\nEnter the fill color ");
 scanf("%d",&newcolor);
 while(1)
 {
  printf("\nMENU\n-------\n1.FLOOD FILL\n2.BOUNDARY FILL\n3.FLOOD FILL NONRECURSIVE\n4.BOUNDARY FILL NONRECURSIVE\n5.EXIT");
  printf("\nEnter the choice ");
  scanf("%d",&ch);
  if(ch>4)
   exit(0);
  printf("\nMENU\n-------\n1.CIRCLE\n2.ELLIPSE\n3.POLYGON\n4.EXIT");
  printf("\nEnter the choice ");
  scanf("%d",&choice);
  switch(choice)
  {
   case 1: printf("\nEnter the center ");
    scanf("%d%d",&xc,&yc); 
    printf("\nEnter the radius ");
    scanf("%d",&r);
    printf("\nEnter the inner point ");
    scanf("%d%d",&xf,&yf);
    initgraph(&gd,&gm,NULL);
    midpoint(xc,yc,r);
    break;
   case 2: printf("\nEnter the center ");
    scanf("%d%d",&xc,&yc);
    printf("\nEnter the minor and major axes ");
    scanf("%d%d",&rx,&ry);
    printf("\nEnter the inner point ");
    scanf("%d%d",&xf,&yf);
    initgraph(&gd,&gm,NULL);
    midpointellipse(xc,yc,rx,ry);
    break;
   case 3: printf("\nEnter the no of sides ");
    scanf("%d",&n);
    int i,ax[10],ay[10];
    for(i=0;i<n;i++)
    {
     printf("\nEnter the %d co=ordinates ",i+1);
     scanf("%d%d",&ax[i],&ay[i]);
    }
    printf("\nEnter the inner point ");
    scanf("%d%d",&xf,&yf);
    initgraph(&gd,&gm,NULL);
    for(i=0;i<n;i++)
     lineDDA(ax[i],ay[i],ax[(i+1)%n],ay[(i+1)%n]);
    break;
   case 4: exit(0);
    break;
   default:printf("\nInvalid Choice");
  }
  if(ch==1)
   floodfill4(xf,yf,newcolor,oldcolor);
  else if(ch==2)
   boundaryfill4(xf,yf,newcolor,10);
  else if(ch==2)
   floodfill4nonrec(xf,yf,newcolor,oldcolor);
  else
   boundaryfill4nonrec(xf,yf,newcolor,10);
  while (!kbhit());
  closegraph();
 }
 return 0;
}
void midpoint(int xc,int yc,int r)
{
 int x=0;
 int y=r;
 int p=1-r;
 plot(xc,yc,x,y);
 while(x<y)
 {
  x++;
  if(p<0)
   p+=2*x+1;
  else
  {
   y--;   
   p+=2*(x-y)+1;
  }
  plot(xc,yc,x,y);
 }
}
void plot(int xc,int yc,int x,int y)
{
 putpixel(xc+x,yc+y,10);
 putpixel(xc-x,yc+y,10);
 putpixel(xc+x,yc-y,10);
 putpixel(xc-x,yc-y,10);
 putpixel(xc+y,yc+x,10);
 putpixel(xc-y,yc+x,10);
 putpixel(xc+y,yc-x,10);
 putpixel(xc-y,yc-x,10);
}
void floodfill4(int x,int y,int new,int old)
{
 if(getpixel(x,y)==old)
 {
  putpixel(x,y,new);
  floodfill4(x+1,y,new,old);
  floodfill4(x-1,y,new,old);
  floodfill4(x,y+1,new,old);
  floodfill4(x,y-1,new,old);
 }
}
void boundaryfill4(int x,int y,int new,int bdry)
{
 int current=getpixel(x,y);
 if((current!=bdry)&&(current!=new))
 {
  putpixel(x,y,new);
  boundaryfill4(x+1,y,new,bdry);
  boundaryfill4(x-1,y,new,bdry);
  boundaryfill4(x,y+1,new,bdry);
  boundaryfill4(x,y-1,new,bdry);
 }
}
void floodfill4nonrec(int x,int y,int new,int old)
{
  
 if(getpixel(x,y)==new)
  return;
 push(x,y);
 putpixel(x,y,new);
 
 while(head!=NULL)
 {
  pop();
  x=p->x;
  y=p->y; 
  if(getpixel(x+1,y)==old)
  {
   putpixel(x+1,y,new);
   push(x+1,y);
  }
  if(getpixel(x-1,y)==old)
  {
   putpixel(x-1,y,new);
   push(x-1,y);
  }
  if(getpixel(x,y+1)==old)
  {
   putpixel(x,y+1,new);
   push(x,y+1);
  }
  if(getpixel(x,y-1)==old)
  {
   putpixel(x,y-1,new);
   push(x,y-1);
  }
 }
}
void boundaryfill4nonrec(int x,int y,int new,int bdry)
{
 if(getpixel(x,y)==bdry)
  return;
 push(x,y);
 putpixel(x,y,new);
 while(head!=NULL)
 {
  pop();
  x=p->x;
  y=p->y; 
  if((getpixel(x+1,y)!=bdry)&&(getpixel(x+1,y)!=new))
  {
   putpixel(x+1,y,new);
   push(x+1,y);  
  }
  if((getpixel(x-1,y)!=bdry)&&(getpixel(x-1,y)!=new))
  {
   putpixel(x-1,y,new);
   push(x-1,y);
  }
  if((getpixel(x,y+1)!=bdry)&&(getpixel(x,y+1)!=new))
  {
   putpixel(x,y+1,new);
   push(x,y+1);
  }
  if((getpixel(x,y-1)!=bdry)&&(getpixel(x,y-1)!=new))
  {
   putpixel(x,y-1,new);
   push(x,y-1);
  }
 }
}
void midpointellipse(int xc,int yc,int rx,int ry)
{
 int rx2=rx*rx;
 int ry2=ry*ry;
 int tworx2=2*rx2;
 int twory2=2*ry2;
 int p,x=0,y=ry,px=0,py=tworx2*y;
 plotellipse(xc,yc,x,y);
 p=ROUND(ry2-(rx2*ry)+(0.25*rx2));
 while(px<py)
 {
  x++;
  px+=twory2;
  if(p<0)
   p+=ry2+px;
  else
  {
   y--;
   py-=tworx2;
   p+=ry2+px-py;
  }
  plotellipse(xc,yc,x,y);
 }
 p=ROUND(ry2*(x+.5)*(x+.5)+rx2*(y-1)*(y-1)-rx2*ry2);
 while(y>0)
 {
  y--;
  py-=tworx2;
  if(p>0)
   p+=rx2-py;
  else
  {
   x++;
   px+=twory2;
   p+=rx2-py+px;
  }
  plotellipse(xc,yc,x,y);
 }
}
void plotellipse(int xc,int yc,int x,int y)
{
 putpixel(xc+x,yc+y,10);
 putpixel(xc-x,yc+y,10);
 putpixel(xc+x,yc-y,10);
 putpixel(xc-x,yc-y,10);
}
void lineDDA(int xa,int ya,int xb,int yb)
{
 int dx,dy,steps,k;
 dx=xb-xa;
 dy=yb-ya;
 float x=xa,y=ya,xinc,yinc;
 if(abs(dx)>abs(dy))
  steps=abs(dx);
 else
  steps=abs(dy);
 xinc=dx/(float)steps;
 yinc=dy/(float)steps;
 putpixel(ROUND(x),ROUND(y),10);
 for(k=0;k<steps;k++)
 {
  x+=xinc;
  y+=yinc;
  putpixel(ROUND(x),ROUND(y),10);
 } 
}
void push(int x1,int y1)
{
 temp=(t1 *)malloc(sizeof(t1));
 temp->x=x1;
 temp->y=y1;
 if(head==NULL)
 {
  head=temp;
  temp->next=NULL;
 }
 else
 {
  temp->next=head;
  head=temp;
 }
}
void pop()
{
 p=head;
 head=head->next;
}

Circle Drawing

2. Write a program to draw a circle using parametric and midpoint algorithm.

#include<stdio.h>
#include<graphics.h>
#include<math.h>
#define ROUND(a)((int)(a+0.5))
void parametric(int,int,int);
void midpoint(int,int,int);
void plot(int,int,int,int);
int main()
{
 int xc,yc,r,choice,gd=DETECT,gm=VGAMAX;
 printf("\nEnter the center ");
 scanf("%d%d",&xc,&yc); 
 printf("\nEnter the radius ");
 scanf("%d",&r);
 while(1)
 {
  printf("\nMENU\n-------\n1.PARAMETRIC\n2.MIDPOINT\n3.EXIT");
  printf("\nEnter the choice ");
  scanf("%d",&choice);
  initgraph(&gd,&gm,NULL);
  switch(choice)
  {
   case 1: parametric(xc,yc,r);
    break;
   case 2: midpoint(xc,yc,r);
    break;
   case 3: exit(0);
    break;
   default:printf("\nInvalid Choice");
  } 
  while (!kbhit());
  closegraph();
 }
 return 0;
}
void parametric(int xc,int yc,int r)
{
 int i,x,y;
 for(i=0;i<=90;i++)
 {
  x=r*cos(3.1412*i/180);
  y=r*sin(3.1412*i/180);
  plot(xc,yc,x,y);
 }
}
void midpoint(int xc,int yc,int r)
{
 int x=0;
 int y=r;
 int p=1-r;
 plot(xc,yc,x,y);
 while(x<y)
 {
  x++;
  if(p<0)
   p+=2*x+1;
  else
  {
   y--;   
   p+=2*(x-y)+1;
  }
  plot(xc,yc,x,y);
 }
}
void plot(int xc,int yc,int x,int y)
{
 putpixel(xc+x,yc+y,10);
 putpixel(xc-x,yc+y,10);
 putpixel(xc+x,yc-y,10);
 putpixel(xc-x,yc-y,10);
 putpixel(xc+y,yc+x,10);
 putpixel(xc-y,yc+x,10);
 putpixel(xc+y,yc-x,10);
 putpixel(xc-y,yc-x,10);
}

Line Drawing

1. Write a program to draw line using DDA algorithm and Bresenham's algorithm.

#include<stdio.h>
#include<graphics.h>
#include<math.h>
#define ROUND(a)((int)(a+0.5))
void DDA(int,int,int,int);
void Bresenham(int,int,int,int);
int main()
{
 int xa,ya,xb,yb,choice,gd=DETECT,gm=VGAMAX;
 printf("\nEnter first cordinates ");
 scanf("%d%d",&xa,&ya); 
 printf("\nEnter second cordinates ");
 scanf("%d%d",&xb,&yb);
 while(1)
 {
  printf("\nMENU\n-------\n1.DDA\n2.BRESENTHAM\n3.EXIT");
  printf("\nEnter the choice ");
  scanf("%d",&choice);
  initgraph(&gd,&gm,NULL);
  switch(choice)
  {
   case 1: DDA(xa,ya,xb,yb);
    break;
   case 2: Bresenham(xa,ya,xb,yb);
    break;
   case 3: exit(0);
    break;
   default:printf("\nInvalid Choice");
  } 
  while (!kbhit());
  closegraph();
 }
 return 0;
}
void DDA(int xa,int ya,int xb,int yb)
{
 int dx,dy,steps,k;
 dx=xb-xa;
 dy=yb-ya;
 float x=xa,y=ya,xinc,yinc;
 if(abs(dx)>abs(dy))
  steps=abs(dx);
 else
  steps=abs(dy);
 xinc=dx/(float)steps;
 yinc=dy/(float)steps;
 putpixel(ROUND(x),ROUND(y),10);
 for(k=0;k<steps;k++)
 {
  x+=xinc;
  y+=yinc;
  putpixel(ROUND(x),ROUND(y),10);
 } 
}
void Bresenham(int xa,int ya,int xb,int yb)
{
 int dx=abs(xa-xb),dy=abs(ya-yb),p,twody,twodydx,x,y,xEnd;
 p=2*dy-dx;
 twody=2*dy; 
 twodydx=2*(dy-dx);
 if(xa>xb)
 {
  x=xb;
  y=yb;
  xEnd=xa;
 }
 else
 {
  x=xa;
  y=ya;
  xEnd=xb;
 }
 putpixel(x,y,10);
 while(x<xEnd)
 {
  x++;
  if(p<0) 
   p+=twody;
  else
  {
   y++;
   p+=twodydx;
  }
  putpixel(x,y,10);
 }
}