tuxing1.c

计算机图形学

#include"stdio.h";
#include"graphics.h"
#include"math.h"
#include"dos.h"
#include"time.h"

typedef struct Point      /*  点 */
{
   int x;
   int y;
}Point;

typedef struct Line       /*  线 */
{
    Point  A;/*起点*/
    Point  B;/*终点*/
    int color; /*颜色*/
}Line;



typedef struct Yuan       /*  圆 */
{
   Point  o; /*圆心*/
   int r;    /*半径*/
   int color;/*颜色*/
}Yuan;

typedef struct TuoYuan    /*椭 圆*/
{
   Point  o;/*中心*/
   int a;   /*长轴*/
   int b;   /*短轴*/
   int color;/*颜色*/
}TuoYuan;

typedef struct Qiu        /* 球 */
{
   Point  o;/*中心*/
   int r;
   int color; /*颜色*/
}Qiu;

typedef struct Rect       /* 矩形*/
{
  Point LeftTop;
  Point RightDown;
  int color;
}Rect;

typedef struct ZFT       /*正方体*/
{
  Point A;/*左上前点*/
  int r;
  int color;
}ZFT;

/***********************/
/*   直线的DDA 算法    */
/***********************/

void LineDDA(Point A,Point B,int color)
{
   int x0,y0,x1,y1,x;
   float dy,dx,y,m;

   x0 = A.x;
   y0 = A.y;
   x1 = B.x;
   y1 = B.y;

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

/***********************/
/*   直线的中点算法    */
/***********************/

void MidPointLine(Point A,Point B,int color)
{
  int dx,dy,incrE,incrNE,d,x,y,x0,y0,x1,y1;

   x0 = A.x;
   y0 = A.y;
   x1 = B.x;
   y1 = B.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 = d + incrE;
    else
      {
        d = d + incrNE;
        y++;
       
      }
      x++;
      putpixel(x,y,color);
  }
}



/*********************/
/*   圆的中点算法    */
/*********************/


/* 圆的8对称点的显示 */
void CirclePoints(int x0,int y0,int x,int y,int color)/* 圆心为（x0,y0);*/
{
  putpixel(x,y,color);                 /*(x,  y) */
  putpixel(x0-y0+y,y0-x0+x,color);     /*(y,  x) */
  putpixel(x0+y0-y,y0-x0+x,color);     /*(-y, x) */
  putpixel(2*x0-x,y,color);            /*(-x, y) */
  putpixel(x0-y0+y,y0+x0-x,color);     /*(y, -x) */
  putpixel(x,2*y0-y,color);            /*(x, -y) */
  putpixel(2*x0-x,2*y0-y,color);       /*(-x,-y) */
  putpixel(x0+y0-y,y0+x0-x,color);     /*(-y,-x) */
}


/* 算法 1：圆的中点算法 */
void MidPointCircle_1(Point Q,int radius,int color)/* 圆心为 Q */
{
  int x,y,x0,y0;
  float d;

  x0 = Q.x;
  y0 = Q.y;

  x = x0;
  y = y0+radius;
  d = 5.0/4.0 - radius;
  CirclePoints(x0,y0,x,y,color);
  while((y-y0)>(x-x0))
  {
    if(d<=0)
      d = d + 2.0*(x-x0) + 3;
    else
      {
        d = d + 2.0*((x-x0)-(y-y0)) + 5;
        y--;
      }
    x++;
    CirclePoints(x0,y0,x,y,color);
  }

}

/* 算法 2 ：消除了浮点运算的中点算法 */

void MidPointCircle_2(Point Q,int radius,int color)/* 圆心为（x0,y0);*/
{
  int x,y,d,x0,y0;

  x0 = Q.x;
  y0 = Q.y;

  x = x0;
  y = y0 + radius;
  d = 5 - 4*radius;
  CirclePoints(x0,y0,x,y,color);
  while((y-y0)>(x-x0))
  {
   if(d<=0)
      d = d + 8*(x-x0) + 12;
    else
      {
        d = d + 8*((x-x0)-(y-y0)) + 20;
        y--;
      }
    x++;
    CirclePoints(x0,y0,x,y,color);
  }
}

/* 算法 3 ：消除了乘法运算的中点算法 */
void MidPointCircle_3(Point Q,int radius,int color)/* 圆心为（x0,y0);*/
{
   int x,y,d,deltaE,deltaSE,x0,y0;

   x0 = Q.x;
   y0 = Q.y;

   x = x0;
   y = y0 + radius;
   d = 5 - 4*radius;
   deltaE = 12;
   deltaSE = 20 - 8*radius;
   CirclePoints(x0,y0,x,y,color);
   while((y-y0)>(x-x0))
   {
      if(d<=0)
      {
        d = d + deltaE;
        deltaSE=deltaSE + 8;
      }
      else
      {
         d = d + deltaSE;
         deltaSE=deltaSE + 16;
         y--;
      }
      deltaE=deltaE + 8;
      x++;
      CirclePoints(x0,y0,x,y,color);
   }

}



/***********************/
/*   椭圆的中点算法    */
/***********************/


/* 椭圆的4对称点的显示 */
void EllipsePoints(int x0,int y0,int x,int y,int color) /*椭圆的中心为:(x0,y0)*/
{
  putpixel(x,y,color);              /*(x,  y) */
  putpixel(2*x0-x,y,color);         /*(-x, y) */
  putpixel(2*x0-x,2*y0-y,color);    /*(-x,-y) */
  putpixel(x,2*y0-y,color);         /*(x, -y) */
}


/* 椭圆的中点算法 */
void MidPointEllipse(Point Q,int a,int b,int color)
{
  int x,y,xP,yP,x0,y0;
  float d,squrarea,squrareb;
   x0 = Q.x;
   y0 = Q.y;


  squrarea = a * a;
  squrareb = b * b;

  /*计算分解点P*/
  xP = (int)(0.5 + squrarea/sqrt(squrarea + squrareb));
  yP = (int)(0.5 + squrareb/sqrt(squrarea + squrareb));

 /* 生成上半部椭圆*/
  x = x0;
  y = y0 + b;
  d = 4 * (squrareb - squrarea * b) + squrarea;
  EllipsePoints(x0,y0,x,y,color);
  while((x - x0)<xP)
  {
    if(d<=0)
       d = d + 4 * squrareb * (2 * (x - x0) + 3);
    else
       {
         d = d + 4 * squrareb * (2 * (x - x0) + 3)-8 * squrarea * ((y - y0) - 1);
         y--;
       }
    x++;
    EllipsePoints(x0,y0,x,y,color);
  }

  /* 生成下半部椭圆*/
  x = x0 + a;
  y = y0;
  d = 4 * (squrarea - squrareb * a) + squrareb;
  EllipsePoints(x0,y0,x,y,color);
  while((y-y0) < yP)
  {
    if(d<=0)
       d = d + 4 * squrarea * (2 * (y - y0) + 3);
    else
       {
         d = d + 4 * squrarea * (2 * (y - y0) + 3)-8 * squrareb * ((x - x0) - 1);
         x--;
       }
     y++;
   EllipsePoints(x0,y0,x,y,color);
  }
}

/***********************/
/*     矩形的算法      */
/***********************/
void Rectangle(Point LeftTop,Point RightDown,int color)
{
  int x1,y1,x2,y2,x,y;
  x1 = LeftTop.x;
  x2 = RightDown.x;
  y1 = LeftTop.y;
  y2 = RightDown.y;
  x = x1;
  while(x<=x2)
  {
    putpixel(x,y1,color);
    putpixel(x,y2,color);
    x++;
  }

  y = y1;
  while(y<=y2)
  {
     putpixel(x1,y,color);
     putpixel(x2,y,color);
     y++;
  }

}

/***********************/
/*     正方体的算法    */
/***********************/
void Zft(Point A,int r,int color)
{
   Point B,C;
   int x,y;
   B.x = A.x;
   B.y = A.y;
   C.x = A.x + r;
   C.y = A.y + r;

   Rectangle(B,C,color);
     C.x--;
     C.y--;
   while(C.x>B.x)
   {
     x = B.x;
     while(x<=C.x)
     {
       putpixel(x,C.y,color);
       x++;
     }
     y = B.y;
     while(y<=C.y)
     {
        putpixel(C.x,y,color);
        y++;
     }
     C.x--;
     C.y--;

   }

   B.x = A.x + (sqrt(2)/2.0) * r;
   B.y = A.y - (sqrt(2)/2.0) * r;
   C.x = A.x + (sqrt(2)/2.0) * r + r;
   C.y = A.y - (sqrt(2)/2.0) * r + r;
     Rectangle(B,C,color);

   
   x = A.x;
   y = A.y;
   while(x<=A.x + (sqrt(2)/2.0) * r)
       {
        putpixel(x,y,color);
        putpixel(x,y+r,color);
        x++;
        y--;
       }

   x = A.x + r;
   y = A.y;
   while(y>=A.y - (sqrt(2)/2.0) * r)
      {
        putpixel(x,y,color);
        putpixel(x,y+r,color);
        x++;
        y--;
       }
}

/*************************/
/******   网格球     *****/
/*************************/

void QiuEC(Point o,int r,int color) /*  球心为(x,y) */
{
  float i,X,Y,ra,rb;
  int k,x,y;
  x = o.x;
  y = o.y;
  MidPointEllipse(o,r,15,color);
  MidPointCircle_1(o,r,color);
  for(i=1;i<=(r/5);i++)
  {

     MidPointEllipse(o,5*i,r,color);

  }
  k = (int)(r/4);
  for(i=1;i<4;i++)
  {
     o.y = y-(4-i)*k;
     MidPointEllipse(o,sqrt(2*r*(k*i)-k*i*k*i),i*4,color);
     o.y = y+(4-i)*k;
     MidPointEllipse(o,sqrt(2*r*(k*i)-k*i*k*i),i*4,color);
  }
}



/********************************/
/****     二维基本变换     ******/
/********************************/

/* 点的平移变换 */
void PinYi(int * x,int * y,int tx,int ty)
{
  *x = *x + tx;
  *y = *y + ty;

}



/* 点旋转变换 */

void XuanZhuan(int * x,int * y,float q)
{
  int m ;
  int n;
  m = (*x);
  n = (*y);
  *x = m * cos(q) - n * sin(q);
  *y = m * sin(q) + n * cos(q);
}

/* 绕任意点的旋转变换 */

void XuanZhuan_RY(int m,int n,int * x,int * y,float q)/* 绕(m,n)的旋转*/
{

  PinYi(x,y,-m,-n);
    XuanZhuan(x,y,q);
  PinYi(x,y,m,n);
}

/* 点放缩变换 */
void FangSuo(int * x,int * y,float sx,float sy)
{
   *x =*x * sx;
   *y =*y * sy;
}

/* 以任意点的放缩变换 */
void FangSuo_RY(int m,int n,int * x,int * y,float sx,float sy) /*以(m,n)为参考点*/
{
   PinYi(x,y,-m,-n);
     FangSuo(x,y,sx,sy);
   PinYi(x,y,m,n);
}



/* 点的错切变换 */
void CuoQie(int * x,int * y,float q,int flag)
{
  if(flag==0)/* y为依赖轴 */
  {
    *x = *x + tan(q)*(*y);
    *y = *y;
  }
  else
  {
    *y = *y + tan(q)*(*x);
    *x = *x;
  }

}

/* 以任意点的错切变换 */
void CuoQie_RY(int m,int n,int * x,int * y,float q,int flag) /* 以为(m,n)参考点*/
{


    PinYi(x,y,-m,-n);
    CuoQie(x,y,q,flag);
    PinYi(x,y,m,n);

}


/*****************************/
/**                         **/
/**     矩形的旋转          **/
/**                         **/
/*****************************/
void Rectangle_XuanZhuan(Rect R,float q)
{
  int x1,y1,x2,y2,x,y,color,X,Y;

  color = R.color;

  x1 = R.LeftTop.x;
  y1 = R.LeftTop.y;

  x2 = R.RightDown.x;
  y2 = R.RightDown.y;

  x = x1;
  while(x<=x2)
  {
    X = x;
    Y = y1;
    XuanZhuan(&X,&Y,q);
       putpixel(X,Y,color);

    X = x;
    Y = y2;
    XuanZhuan(&X,&Y,q);
       putpixel(X,Y,color);

    x++;
  }

  y = y1;
  while(y<=y2)
  {
     X = x1;
     Y = y;
     XuanZhuan(&X,&Y,q);
       putpixel(X,Y,color);

     X = x2;
     Y = y;
     XuanZhuan(&X,&Y,q);
       putpixel(X,Y,color);
     y++;
  }

}

/*****************************/
/**                         **/
/**     正方体的旋转        **/
/**                         **/
/*****************************/
void Zft_XuanZhuan(ZFT Z,float q)
{
   int x,y,X,Y,r,color;
   Point A,B,C;
   Rect R;

   A.x = Z.A.x;
   A.y = Z.A.y;
   r = Z.r;
   color = Z.color;

   R.LeftTop.x = A.x;
   R.LeftTop.y = A.y;
   R.RightDown.x = A.x + r;
   R.RightDown.y = A.y + r;
   R.color = color;
   Rectangle_XuanZhuan(R,q);

    C.x = R.RightDown.x;
    C.y = R.RightDown.y;

     C.x--;
     C.y--;
   while(C.x>A.x)
   {
     x = A.x;
     while(x<=C.x)
     {
       X = x;
       Y = C.y;
       XuanZhuan(&X,&Y,q);
       putpixel(X,Y,color);
       x++;
     }
     y = A.y;
     while(y<=C.y)
     {
        X = C.x;
        Y = y;

        XuanZhuan(&X,&Y,q);
           putpixel(X,Y,color);
        y++;
     }
     C.x--;
     C.y--;

   }

  R.LeftTop.x = A.x + (sqrt(2)/2.0) * r;
  R.LeftTop.y = A.y - (sqrt(2)/2.0) * r;
  R.RightDown.x = A.x + (sqrt(2)/2.0) * r + r;
  R.RightDown.y = A.y - (sqrt(2)/2.0) * r + r;
     Rectangle_XuanZhuan(R,q);

   
   x = A.x;
   y = A.y;