计算机图形学 实验二 DAA与Bresham以及中点圆

实验二：直线与画圆算法

实验目的： 理解光栅化，掌握几何数据如何经过一系列变换后转化为像素从而呈现在显示 设备上。

基本要求：

 实现 DDA 和 Bresenham 画线算法

 实现画圆算法

 请勿直接调用 OpenGL 库中提供的绘制线段和圆的函数，需手动模拟如何通过绘 制像素来显示几何图形，效果可参考下图。（界面显示的是“虚拟的像素”）

 可通过交互操作来确定线段的起点和终点。

实现：

#include<GL/glut.h>
#define EXIT_SUCCESS 0
#include<stdio.h>
#include<math.h>
// later Edition
int MODE = 0;          // 模式代码：0-DAA算法，1-Bresenham算法，2-中点圆算法
bool mouseLeftDown;     // 实时记录鼠标左键状态
bool mouseRightDown;    // 实时记录鼠标左键状态
float mouseX, mouseY;   // 实时记录鼠标位置，与下一次鼠标位置之间形成微分

int startX=0, startY=0, endX=0, endY=0;
int start[2] = { 0 };
int end[2] = { 0 };
float red=1.0,green=1.0, blue=0.0;
float PI = 3.415926535;

int arr[500][500];

void init(void)
{
    //glClearColor(0.0, 0.0, 0.0, 0.0);/* select clearing color  */   // 设置背景颜色为黑色
    //glMatrixMode(GL_MODELVIEW);                   
    glClearColor(0.0, 0.0, 0.0, 0.0); /* white background */
    glColor3f(1.0, 0.0, 0.0); /* draw in red */

    /* set up viewing: */
    /* 500 x 500 window with origin lower left */

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(0.0, 500.0, 0.0, 500.0);
    glMatrixMode(GL_MODELVIEW);
}




#define RED 1233
#define BLUE 1234
#define GREEN 1235
#define WHITE 12366
#define YELLOW 12367
#define DAA_LINE 12368
#define BRES_LINE 12369
#define CIRCLE 12370
void processMenuEvents(int option) {
    //option，就是传递过来的value的值。
    switch (option) {
    case RED:
        red = 1.0;
        green = 0.0;
        blue = 0.0; break;
    case GREEN:
        red = 0.0;
        green = 1.0;
        blue = 0.0; break;
    case BLUE:
        red = 0.0;
        green = 0.0;
        blue = 1.0; break;
    case WHITE:
        red = 1.0;
        green = 1.0;
        blue = 1.0; break;
    case YELLOW:
        red = 1.0;
        green = 1.0;
        blue = 0.0;break;
    case DAA_LINE:
        MODE = 0;break;
    case BRES_LINE:
        MODE = 1;break;
    case CIRCLE:
        MODE = 2;break;
    }
}
void createGLUTMenus() {

    int menu;

    // 创建菜单并告诉GLUT，processMenuEvents处理菜单事件。
    menu = glutCreateMenu(processMenuEvents);

    //给菜单增加条目
    glutAddMenuEntry("红色", RED);
    glutAddMenuEntry("蓝色", BLUE);
    glutAddMenuEntry("绿色", GREEN);
    glutAddMenuEntry("白色", WHITE);
    glutAddMenuEntry("黄色", YELLOW);
    glutAddMenuEntry("DAA_LINE", DAA_LINE);
    glutAddMenuEntry("BRES_LINE", BRES_LINE);
    glutAddMenuEntry("CIRCLE_SCAN", CIRCLE);

    // 把菜单和鼠标右键关联起来。
    glutAttachMenu(GLUT_RIGHT_BUTTON);
}

void DAA_alogrithm(int x0, int y0, int x1, int y1) {
    int x;
    float dx, dy, y, k;
    dx = x1 - x0,dy = y1 - y0; 
    k = dy / dx, y = y0;
    glPointSize(5.0);

    glBegin(GL_POINTS);
    
    for (x = x0;x <= x1;x++) {
        
        glVertex2d(x, int(y + 0.5));
        y = y + k;
    }
    glEnd();
}
void y_DAA_alogrithm(int x0, int y0, int x1, int y1) {
    int y;
    float dx, dy, x, k;
    dx = x1 - x0, dy = y1 - y0;
    k = dx / dy, x = x0;
    glPointSize(5.0);

    glBegin(GL_POINTS);

    for (y = y0;y <= y1;y++) {

        glVertex2d(int(x + 0.5),y );
        x = x + k;
    }
    glEnd();
}
void Bresenham(int x0, int y0, int x1, int y1) {
    bool is_nagetive_k = false;
    if ((y1 - y0) * (x1 - x0) < 0) {
        y1 *= -1, y0 *= -1;
        is_nagetive_k = true;
    }
    int x, y, dx, dy, e;
    dx = x1 - x0, dy = y1 - y0,e=-dx;
    x = x0;y = y0;
    glPointSize(5.0);

    glBegin(GL_POINTS);
    for (int i = 0;i < dx;i++) {
        if (!is_nagetive_k)glVertex2d(x, y);else {
            glVertex2d(x, -y);
        }
        x++, e = e + 2 * dy; 
        if (e >= 0)y++, e = e - 2 * dx;
    }
    glEnd();
}
void y_Bresenham(int x0, int y0, int x1, int y1) {
    bool is_nagetive_k = false;
    if ((y1 - y0) * (x1 - x0) < 0) {
        y1 *= -1;y0 *= -1;
        is_nagetive_k = true;
    }

    int x, y, dx, dy, e;
    dx = x1 - x0, dy = y1 - y0, e = -dy;
    x = x0;y = y0;
    glPointSize(5.0);

    glBegin(GL_POINTS);
    for (int i = 0;i < dy;i++) {
        if (!is_nagetive_k)glVertex2d(x, y);else {
            glVertex2d(x, -y);
        }
        y++, e = e + 2 * dx;
        if (e >= 0)x++, e = e - 2 * dy;
    }
    glEnd();
}
void circlePoints(int x,int y) {
    glPointSize(5.0);
    glBegin(GL_POINTS);
    glVertex2d(x,y);glVertex2d(y,x);
    glVertex2d(-x,y);glVertex2d(-y,x);
    glVertex2d(x,-y);glVertex2d(y,-x);
    glVertex2d(-x,-y);glVertex2d(-y,-x);
    glEnd();
}
void mindCircle(int r) {
    int x, y;
    float d;
    x = 0;y = r; d = 1.25 - r;
    circlePoints(x, y);
    while (x <= y) {
        if (d < 0) {
            d += 2 * x + 3;
        }
        else {
            d += 2 * (x - y) + 5;y--;
        }
        x++;
        circlePoints(x, y);
    }
}
void display(void)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glColor3f(red, green, blue);
    glLoadIdentity();


   

    if (MODE == 0) {
        if (abs(startY - endY) > abs(startX - endX)) {
            if (startY > endY) {
                y_DAA_alogrithm(endX, endY,startX, startY);
            }
            else {
                y_DAA_alogrithm(startX, startY, endX, endY);
            }
        }
        else {
            if (startX > endX) {
                DAA_alogrithm(endX, endY, startX, startY);
            }
            else {
                DAA_alogrithm(startX, startY, endX, endY);
            }
        }
    }
    else if (MODE == 1) {

        if (startX > endX) {
            if (abs(startY - endY) > abs(startX - endX))y_Bresenham(endX, endY, startX, startY);
            else Bresenham(endX, endY, startX, startY);
        }
        else {
            if(abs(startY - endY) > abs(startX - endX))y_Bresenham(startX, startY, endX, endY);
            else Bresenham(startX, startY, endX, endY);
        }
    
    }
    else if(MODE==2){
        glPushMatrix();
        glTranslated(startX, startY, 0);
        mindCircle(int(pow((startX - endX) * (startX - endX) + (startY - endY) * (startY - endY), 0.5)));
        glTranslated(-endX, -endY, 0);
        glPopMatrix();
    }
    
    
    
    
    /*
    glBegin(GL_LINES);

    glVertex2d(startX, startY);glVertex2d(endX, endY);

    glEnd();

    */
    /*
    glPointSize(10.0);
    for (int i = 0;i < 500;i++) {
        glVertex2d(100, i);
        glVertex2d(i, 100);
        glVertex2d(i, i);

    }
    glEnd();
    */
    
    glutSwapBuffers();
}
int saveStack = 0;
int firstSaveFlag = -1;
void keyboard(unsigned char key, int x, int y)

{
    switch (key) {
        case 'q':case 'Q':
            exit(EXIT_SUCCESS);
            break;
    }    
}
int ww, hh;

void mouse_process(int button, int state, int x, int y)
{
    mouseX = x;
    mouseY = y;
    printf("(%d,%d)
", x, y);
    printf("(%d,%d)", startX,startY);
    printf("(%d,%d)
", endX,endY);
    hh = glutGet(GLUT_WINDOW_HEIGHT);
    if (button == GLUT_LEFT_BUTTON)
    {
        if (state == GLUT_DOWN)
        {
            if (!mouseLeftDown) {
                startX = x;startY = hh-y;
            } 
            
            mouseLeftDown = true;
        }
        else if (state == GLUT_UP) {
            mouseLeftDown = false;
   
        }
            
    }

    else if (button == GLUT_RIGHT_BUTTON)
    {
        if (state == GLUT_DOWN)
        {
            mouseRightDown = true;
        }
        else if (state == GLUT_UP)
            mouseRightDown = false;
    }


    
}

void mouse_process_active(int x, int y)
{
    if (mouseLeftDown){
        endX = x;endY = hh - y;
        glutPostRedisplay();
    }
    if(mouseRightDown)
    {   

    }
    glutPostRedisplay();

}
void mouse_process_passtive(int x, int y) {}


int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
    glutInitWindowSize(500, 500);
    glutCreateWindow("19智能 右键开启菜单");

    init();

    glutDisplayFunc(display);
  
    // later Edition
    glutMouseFunc(mouse_process);
    glutMotionFunc(mouse_process_active);
    glutPassiveMotionFunc(mouse_process_passtive);
    createGLUTMenus();
    glutKeyboardFunc(keyboard);
    glutMainLoop();

    return 0;
}