perfect.c

计算机图形学

   dy=y1-y0;
   m=dy/dx;
   y=y0;
   for(x=x0;x<=x1;x++)
   {
     putpixel(x,(int)(y+0.5),color);
     y+=m;
   }
 }

 void LineDDA3(int x0,int y0,int x1,int y1,int color)
 /*假定x0<x1,直线斜率m>1*/
 {
   int y;
   float dy,dx,x,m;
   dx=x1-x0;
   dy=y1-y0;
   m=dx/dy;
   x=x0;
   for(y=y0;y<=y1;y++)
   {
     putpixel((int)(x+0.5),y,color);
     x+=m;
   }
 }

/*----------------------------中点算法生成直线--------------------------------*/
 void MidPointLine1(int x0,int y0,int x1,int y1,int color)
{ /*假定x0<x1,直线斜率m<-1*/

int dx,dy,incrE,incrNE,d,x,y;
  dx=x1-x0;
  dy=y1-y0;
  d=-2*dx-dy;
  incrE=-2*dx;
  incrNE=-2*(dx+dy);
  x=x0;y=y0;
  putpixel(x,y,color);
  while(y>=y1)
  {if(d>0)
  d+=incrE;
  else
  { d+=incrNE;
   x++;
  }
  y--;
  putpixel(x,y,color);
  }
}
 void MidPointLine2(int x0,int y0,int x1,int y1,int color)
{ /*假定x0<x1,直线斜率-1<m<0*/

int dx,dy,incrE,incrNE,d,x,y;
  dx=x1-x0;
  dy=y1-y0;
  d=-(dx+2*dy);
  incrE=-2*dy;
  incrNE=-2*(dx+dy);
  x=x0;y=y0;
  putpixel(x,y,color);
  while(x<x1)
  {if(d<=0)
  d+=incrE;
  else
  { d+=incrNE;
  y--;
  }
  x++;
  putpixel(x,y,color);
  }
}
void MidPointLine3(int x0,int y0,int x1,int y1,int color)
{  /* 假定 x0<x1,直线斜率0<=m<=1  */
  int dx,dy,incrE,incrNE,d,x,y;
  dx=x1-x0;
  dy=y1-y0;
  d=dx-2*dy;
  incrE=-2*dy;
  incrNE=2*(dx-dy);
  x=x0;y=y0;
  putpixel(x,y,color);
  while(x<x1)
  {
      if(d>0) d+=incrE;
      else
      {d+=incrNE;
       y++;}
      x++;
  putpixel(x,y,color);
  }
 }
void MidPointLine4(int x0,int y0,int x1,int y1,int color)
{ /*假定x0<x1,直线斜率m>1*/

int dx,dy,incrE,incrNE,d,x,y;
  dx=x1-x0;
  dy=y1-y0;
  d=2*dx-dy;
  incrE=2*dx;
  incrNE=2*(dx-dy);
  x=x0;y=y0;
  putpixel(x,y,color);
  while(x<x1)
  {if(d<=0)
  d+=incrE;
  else
  { d+=incrNE;
  x++;
  }
  y++;
  putpixel(x,y,color);
  }
}
/*-------------------------Bresenham算法生成直线-----------------------------*/
 BresenhamLine(int x0,int y0,int x1,int y1,int color)
{

  int x,y,dx,dy,i;
  float m,d;
  dx=x1-x0;
  dy=y1-y0;
  m=dy/dx;
  d=0;x=x0;y=y0;
  putpixel(x,y,color);
  for(i=0;i<=dx;i++)
  {
    d+=m;
    if(d>=0.5)
     {y+=1;d-=1;}
     x++;
     putpixel(x,y,color);
  }
}
/*-------------------------------建立坐标系----------------------------------*/
void LineH(int x0,int x1,int y0,int color)
 {
   int x,y;
   x=x0; y=y0;
   while(x<x1)
   {putpixel(x,y,color);
    x++;}
 }
void LineV(int y0,int y1,int x0,int color)
 {
   int x,y;
   x=x0; y=y0;
   while(y<y1)
   {putpixel(x,y,color);
    y++;}
 }


 int x0,y0,x1,y1,color,dx1,dy1;
 float m;

void Line(void)
{
 /*-------------------------显示各种斜率的直线--------------------------------*/
  setbkcolor(BLACK);
  setcolor(BLUE);
 outtextxy(250,10,menuStr[0]);
  MidPointLine1(300,400,340,240,125);
  MidPointLine2(240,340,400,300,255);
  MidPointLine3(240,300,400,340,255);
  MidPointLine4(300,240,340,400,255);
  LineH(240,400,320,255);
  LineV(240,400,320,255);
  outtextxy(398,318,">");
  outtextxy(280,420,"MidPointLine");
  LineDDA1(180,280,220,120,125);
  LineDDA2(120,220,280,180,255);
  LineDDA2(120,180,280,220,255);
  LineDDA3(180,120,220,280,255);
  LineH(120,280,200,255);
  LineV(120,280,200,255);
  outtextxy(180,300,"LineDDA");

  BresenhamLine(322,53,430,182,255);
  outtextxy(330,160,"Bresenham");
/*----------------------------程序输入部分-----------------------------------*/
  printf("firstpoint x0,y0:\n");
  scanf("%d,%d",&x0,&y0);
  printf("lastpoint x1,y1:\n");
  scanf("%d,%d",&x1,&y1);
  printf("color:\n");
  scanf("%d",&color);
  dx1=x1-x0;
  dy1=y1-y0;
  m=dy1/dx1;
  if(m<-1)
      MidPointLine1(x0,y0,x1,y1,color);
  else if(m>=-1&&m<0)
      MidPointLine2(x0,y0,x1,y1,color) ;
   else if(m>=0&&m<=1)
         MidPointLine3(x0,y0,x1,y1,color) ;
         else
          MidPointLine4(x0,y0,x1,y1,color) ;

  Pause();
}

/*------------------------------圆的生成算法-----------------------------*/
 void CirclePoints(int x,int y,int t,int s,int color)
{
  putpixel(t+x,s+y,color);
  putpixel(s+y,t+x,color);
  putpixel(s-y,t+x,color);
  putpixel(t-x,s+y,color);
  putpixel(s+y,t-x,color);
  putpixel(t+x,s-y,color);
  putpixel(t-x,s-y,color);
  putpixel(s-y,t-x,color);
}
  void EllipsePoints(int x,int y,int t,int s,int color)
{
  putpixel(t+x,s+y,color);
  putpixel(t-x,s+y,color);
  putpixel(t+x,s-y,color);
  putpixel(t-x,s-y,color);

}


/*-----------------------------开平方法生成圆-----------------------------*/
void sqrtCircle(int radius,int color)
{
  float x,y;
  x=0;y=radius;
  CirclePoints(x,y,100,100,color);
  while(y>=x)
   {
     x++;
     y=sqrt(radius*radius-x*x);
     CirclePoints((int)(x+0.5),(int)(y+0.5),100,100,color);
   }
   outtextxy(50,170,"sqrtCircle");
}

/*----------------------------参数法生成圆---------------------------------*/
void funCircle(int radius,int color)
{
  float x,y,afla;
  x=radius;y=0;afla=0;
  CirclePoints(x,y,200,200,color);
  while (afla<=PI/4)
  {
    afla+=PI/400;
    x=radius*cos(afla);
    y=radius*sin(afla);
    CirclePoints((int)(x+0.5),(int)(y+0.5),200,200,color);
     outtextxy(100,250,"funCircle");
  }
}

/*----------------------------Bresenham算法生成圆-----------------------------*/
BresenhamCircle(int R,int color)
{
  int x,y,dD,dHD,dDV,next;
  x=0;y=R;dD=2*(1-R);
  while(y>=0)
  {
    CirclePoints(x,y,300,300,color);
    if(dD<0)
    {
      dHD=2*(dD+y)-1;
      if(dHD<=0) next=0;
      else next=1;
    }
    else if(dD>0)
    {
      dDV=2*(dD-x)-1;
      if(dDV<=0) next=1;
      else next=2;
    }
    else next=1;
    switch(next)
    {
     case 0:x++;
            dD+=2*x+1;
            break;
     case 1:x++;
            y--;
            dD+=2*(x-y+1);
            break;
     case 2:y--;
            dD+=-2*y+1;
            break;
    } /*switch*/
  }  /*while*/
  outtextxy(150,350,"BresenhamCircle");
}

/*----------------------------中点算法生成圆--------------------------------*/
void MidPointCircle(int radius,int color)
{
  int x,y,d,deltaE,deltaSE;
  x=0;
  y=radius;
  d=5-4*radius;
  deltaE=12;
  deltaSE=20-8*radius;
  CirclePoints(x,y,400,400,color);
  while(y>x)
  {
    if(d<=0)
      {d+=deltaE;
        deltaSE+=8;}
     else
      {
        d+=deltaSE;
        deltaSE+=16;
        y--;
      }
      deltaE+=8;
      x++;
      CirclePoints(x,y,400,400,color);
  }
  outtextxy(250,450,"MidPointCircle");
}

/*---------------------------开平方法生成椭圆---------------------------------*/
 void sqrtEllipse(int a,int b,int color)
{
 float x,y;
   x=0;y=b;
   EllipsePoints(x,y,300,100,color);
   while(x<a)
   {
     x++;
     y=sqrt(b*b-(x*x*b*b)/(a*a));
     EllipsePoints((int)(x+0.5),(int)(y+0.5),300,100,color);

   }
   outtextxy(350,100,"sqrtEllipse");
}
/*---------------------------参数法生成椭圆-----------------------------------*/
void funEllipse(int a,int b,int color)
{
  float x,y,afla;
  x=a;y=0;afla=0;
  EllipsePoints(x,y,400,200,color);
  while(afla<=PI/2)
  {
    afla+=PI/400;
    x=a*cos(afla);
    y=b*sin(afla);
     EllipsePoints((int)(x+0.5),(int)(y+0.5),400,200,color);
  }
  outtextxy(450,200,"funEllipse");
}
/*---------------------------中点算法生成椭圆---------------------------------*/
 void MidPointEllipse(double a,double b,int color)
  {
    double x,y,d,xP,yP,squarea,squareb;
    squarea=a*a;
    squareb=b*b;
    xP=(int)(0.5+(double)squarea/sqrt((double)(squarea+squareb)));
    yP=(int)(0.5+(double)squareb/sqrt((double)(squarea+squareb)));
    x=0;
    y=b;
    d=4*(squareb-squarea*b)+squarea;
    EllipsePoints(x,y,500,300,color);
    while(x<=xP)
    {
      if(d<=0)  d+=4*squareb*(2*x+3);
      else
        {d+=4*squareb*(2*x+3)-8*squarea*(y-1);
          y--;}
      x++;
      EllipsePoints(x,y,500,300,color);
     }
    x=a;
    y=0;
    d=4*(squarea-a*squareb)+squareb;
    EllipsePoints(x,y,500,300,color) ;
    while(y<yP)
     {
       if(d<=0)  d+=4*squarea*(2*y+3);
       else
         {
           d+=4*squarea*(2*y+3)-8*squareb*(x-1);
            x--;
         }
         y++;
         EllipsePoints(x,y,500,300,color);

     }
     outtextxy(480,380,"MidPointsEllipse");
  }

void Circle()
{
     setbkcolor(BLACK);
      setcolor(BLUE);
     outtextxy(250,10,menuStr[1]);
     setcolor(WHITE);
     sqrtCircle(50,105);
     funCircle(50,5);
     BresenhamCircle(50,35);
     MidPointCircle(50,255);
     sqrtEllipse(50,80,220);
     funEllipse(50,80,180);
     MidPointEllipse(50,80,150);
  Pause();
}

/*-------------------三次Bezier曲线的矩阵表示及生成-----------------------*/

void DisplayCubicBezierCurve(Vector P[4],int count)
{
  float C[2][4],t,deltat;
  Vector V,newV;
  int i,j;
  for(j=0;j<2;j++)
  {
   C[j][0]=P[0][j];
   C[j][1]=-3*P[0][j]+3*P[1][j];
   C[j][2]=3*P[0][j]-6*P[1][j]+3*P[2][j];