计算机图形学OpenGL-DDA直线绘制和Bresenham直线绘制-付老师的实验二

已于 2024-01-10 21:17:12 修改
阅读量444 收藏 4
点赞数 3
分类专栏： 计算机图形学 文章标签： 算法
于 2023-09-29 15:11:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59779173/article/details/133358771
版权

1、用OpenGL实现微分法(DDA)直线绘制算法绘制一条直线，并用鼠标写出自己的名字。

#include <GL/glut.h>
#include <math.h>

#define MAX_LINES 100  // lines数组能保存的最大直线数量
bool isDrawing = false;  // 是否正在进行绘制
int startX, startY;      // 起始点坐标
int currentX, currentY;              // 当前点坐标
int lines[MAX_LINES][4];             // 已绘制的直线，每条直线使用4个整数表示
int lineCount = 0;                   // 已绘制的直线数量

void DDALine(int x0,int y0,int x1,int y1)  //书本DDA算法绘制直线
{
    glLineWidth(5.0f);
    glBegin(GL_LINE_STRIP);
    int dx, dy, eps1, k;
    float x, y, xIncre, yIncre;
    dx = x1 - x0;
    dy = y1 - y0;
    x = x0;
    y = y0;
    if (abs(dx) > abs(dy))
        eps1 = abs(dx);
    else
        eps1 = abs(dy);
    xIncre = (float)dx / (float)eps1;
    yIncre = (float)dy / (float)eps1;
  
    for (k = 0; k <= eps1; k++)
    {
        glVertex2f(int(x + 0.5), int(y + 0.5));
        x += xIncre;
        y += yIncre;
    }
    
    glEnd();
}



void display()
{
    glClear(GL_COLOR_BUFFER_BIT);
    glColor3f(0.0f, 0.0f, 0.0f);
    // 绘制已保存的直线
    for (int i = 0; i < lineCount; i++)
    {
        DDALine(lines[i][0], lines[i][1], lines[i][2], lines[i][3]);
    }
    if (isDrawing)
        DDALine(startX, startY, currentX,currentY);

    glFlush();
}

void mouse(int button, int state, int x, int y)
{
	int height = glutGet(GLUT_WINDOW_HEIGHT);  // 获取窗口高度
	if (button == GLUT_LEFT_BUTTON)
	{
		if (state == GLUT_DOWN)
		{
			startX = x;
			startY = height - y - 1;
            currentX = startX;
            currentY = startY;
			isDrawing = true;
		}
		else if (state == GLUT_UP)
		{
            isDrawing = false;
            lines[lineCount][0] = startX;    //每次绘制完，将直线的两点保存到lines数组中
            lines[lineCount][1] = startY;
            lines[lineCount][2] = currentX;
            lines[lineCount][3] = currentY;
            lineCount++;
		}
	}

    glutPostRedisplay();
}

void motion(int x, int y)
{
    int height = glutGet(GLUT_WINDOW_HEIGHT);  // 获取窗口高度
    if (isDrawing)
    {
		currentX = x;
		currentY = height - y - 1;
    }

    glutPostRedisplay();
}


void reshape(int width, int height)
{
    glViewport(0, 0, width, height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(0, width, 0, height);
}

int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize(1280, 720);
    glutCreateWindow("DDALine算法绘制线段");
   

    glClearColor(1.0f, 1.0f, 1.0f, 0.0);

    glutDisplayFunc(display);
    glutMouseFunc(mouse);
    glutMotionFunc(motion);
    glutReshapeFunc(reshape);
    glutMainLoop();

    return 0;
}

第一道题目用DDA算法绘制直线，DDA算法实现实现的绘制并不难，只要把书本中的代码中的putpixel部分换成opengl库中绘制顶点的glVertex2f函数就行了。

由于是第一次绘制直线，难的在直线如何绘制？考虑鼠标的捕捉，如果鼠标左键按下就要记住当前的直线起点位置，需要注意的是，x轴的坐标与屏幕上的x轴坐标一致，但y轴的坐标需要通过openGL窗口的高度减去Windows窗口的鼠标光标的坐标，才能得出正确的y轴坐标。依次赋值给startX和startY。然后再把获取的坐标赋值给当前x、y的坐标currentX和currentY，然后在每次鼠标左键没有被按下的时候，需要将直线的起点和终点分别保存到一个lines数组中，这个数组是100行四列的数组，记载了最多能在窗口上绘制100条直线。数组作为记忆，以便绘制的时候，每绘制一条直线，它不会消失。在DDAline函数中，第一行我将绘制线条的线宽度设置为5.0f，用glLineWidth函数实现。

在鼠标移动motion函数记载中也是要获取当前x、y的坐标，赋值给currentX和currentY,也需要注意y轴的坐标需要通过窗口高度减去y轴坐标。

还要注意最后执行一个reshape函数调整下窗口进行矩阵投影，即窗口再整形回调函数reshape。

2.用OpenGL实现Bresenham直线绘制算法绘制一条直线，并用鼠标写出自己的名字。

#include <GL/glut.h>
#include <math.h>

#define MAX_LINES 100  // lines数组能保存的最大直线数量
bool isDrawing = false;  // 是否正在进行绘制
int startX, startY;      // 起始点坐标
int currentX, currentY;              // 当前点坐标
int lines[MAX_LINES][4];             // 已绘制的直线，每条直线使用4个整数表示
int lineCount = 0;                   // 已绘制的直线数量

void BresenhamLine0to1(int x0, int y0, int x1, int y1)
{
    glLineWidth(5.0f);
    glBegin(GL_LINE_STRIP);
    int dx = x1 - x0;
    int dy = y1 - y0;
    int e = -dx;
    int x = x0;
    int y = y0;
    if (dx >= 0)
    {
        for (; x <= x1; x++)
        {
            glVertex2f(x, y);

            e = e + 2 * dy;
            if (e > 0)
            {
                y++;
                e = e - 2 * dx;
            }
        }
    }
    else
    {
        for (; x >= x1; x--)
        {
            glVertex2f(x, y);

            e = e - 2 * dy;
            if (e > 0)
            {
                y--;
                e = e + 2 * dx;
            }
        }
    }
    glEnd();
}
void BresenhamLine1ToInfinity(int x0, int y0, int x1, int y1)
{
    glLineWidth(5.0f);
    glBegin(GL_LINE_STRIP);

    int dx = x1 - x0;
    int dy = y1 - y0;
    int e = -dy;
    int x = x0;
    int y = y0;
    if (dx >= 0)
    {
        for (; y <= y1; y++)
        {
            glVertex2f(x, y);

            e = e + 2 * dx;
            if (e > 0)
            {
                x++;
                e = e - 2 * dy;
            }
        }
    }
    else
    {
        for (; y >= y1; y--)
        {
            glVertex2f(x, y);

            e = e - 2 * dx;
            if (e > 0)
            {
                x--;
                e = e + 2 * dy;
            }
        }
    }
    glEnd();
}
void BresenhamLineMinus1to0(int x0, int y0, int x1, int y1)
{
    glLineWidth(5.0f);
    glBegin(GL_LINE_STRIP);
    int dx = x1 - x0;
    int dy = y1 - y0;
    int e = -dx;
    int x = x0;
    int y = y0;
    if (dx >= 0)
    {
        for (; x <= x1; x++)
        {
            glVertex2f(x, y);

            e = e - 2 * dy;
            if (e >= 0)
            {
                y--;
                e = e - 2 * dx;
            }
        }
    }
    else
    {
        for (; x >= x1; x--)
        {
            glVertex2f(x, y);

            e = e + 2 * dy;
            if (e >= 0)
            {
                y++;
                e = e + 2 * dx;
            }
        }
    }
    glEnd();
}
void BresenhamLineMinusInfinityToMinus1(int x0, int y0, int x1, int y1)
{
    glLineWidth(5.0f);
    glBegin(GL_LINE_STRIP);

    int dx = x1 - x0;
    int dy = y1 - y0;
    int e = -dy;
    int x = x0;
    int y = y0;
    if (dx >= 0)
    {
        for (; y >= y1; y--)
        {
            glVertex2f(x, y);

            e = e + 2 * dx;
            if (e > 0)
            {
                x++;
                e = e + 2 * dy;
            }
        }
    }
    else
    {
        for (; y <= y1; y++)
        {
            glVertex2f(x, y);

            e = e - 2 * dx;
            if (e >= 0)
            {
                x--;
                e = e - 2 * dy;
            }
        }
    }
    glEnd();
}
void display()
{
    glClear(GL_COLOR_BUFFER_BIT);
    glColor3f(0.0f, 0.0f, 0.0f);
    // 绘制已保存的直线
    int dx, dy;
    float k;
    for (int i = 0; i < lineCount; i++)
    {
        int x0 = lines[i][0];
        int y0 = lines[i][1];
        int x1 = lines[i][2];
        int y1 = lines[i][3];
        dx = x1 - x0;
        dy = y1 - y0;
        k = (float)dy / dx;
        if (k >= 0)
        {
            if (k <= 1)
                BresenhamLine0to1(x0, y0, x1, y1);
            else
                BresenhamLine1ToInfinity(x0, y0, x1, y1);

        }
        else
        {
            if (k >= -1)
                BresenhamLineMinus1to0(x0, y0, x1, y1);
            else
                BresenhamLineMinusInfinityToMinus1(x0, y0, x1, y1);
        }
    }
    if (isDrawing)
    {
        int x0 = startX;
        int y0 = startY;
        int x1 = currentX;
        int y1 = currentY;
        dx = x1 - x0;
        dy = y1 - y0;
        k = (float)dy / dx;
        if (k >= 0)
        {
            if (k <= 1)
                BresenhamLine0to1(x0, y0, x1, y1);
            else
                BresenhamLine1ToInfinity(x0, y0, x1, y1);

        }
        else
        {
            if (k >= -1)
                BresenhamLineMinus1to0(x0, y0, x1, y1);
            else
                BresenhamLineMinusInfinityToMinus1(x0, y0, x1, y1);
        }
    }
    glFlush();
}

void mouse(int button, int state, int x, int y)
{
    int height = glutGet(GLUT_WINDOW_HEIGHT);  // 获取窗口高度
    if (button == GLUT_LEFT_BUTTON)
    {
        if (state == GLUT_DOWN)
        {
            startX = x;
            startY = height - y - 1;
            currentX = startX;
            currentY = startY;
            isDrawing = true;
        }
        else if (state == GLUT_UP)
        {
            isDrawing = false;
            lines[lineCount][0] = startX;    //每次绘制完，将直线的两点保存到lines数组中
            lines[lineCount][1] = startY;
            lines[lineCount][2] = currentX;
            lines[lineCount][3] = currentY;
            lineCount++;
        }
    }
    glutPostRedisplay();
}
void motion(int x, int y)
{
    int height = glutGet(GLUT_WINDOW_HEIGHT);  // 获取窗口高度
    if (isDrawing)
    {
        currentX = x;
        currentY = height - y - 1;
    }
    glutPostRedisplay();
}
void reshape(int width, int height)
{
    glViewport(0, 0, width, height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(0, width, 0, height);
}
int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize(1280, 720);
    glutCreateWindow("Bresenham算法绘制线段");
    glClearColor(1.0f, 1.0f, 1.0f, 0.0);
    glutDisplayFunc(display);
    glutMouseFunc(mouse);
    glutMotionFunc(motion);
    glutReshapeFunc(reshape);
    glutMainLoop();
    return 0;
}

第二个题目是使用Bresenham算法实现鼠标的绘制。他比第一个题目难的在这个算法的实现需要用四个函数，每个函数要分两个区域。由于Bensenham算法是根据直线斜率进行判断的，需要分四个函数。斜率范围依次是0<=k<=1，-1<=k<=0，-∞<=k<-1，1<k<=+∞。而每个函数也要通过X轴变化的增量进行判断。根据书本只给出的0<=k<=1斜率变化的代码，书本只给出的是在这个斜率范围朝右向上角延伸的，并没有给出朝左下角延伸的这个区间。所以通过x轴变化的增量，用dx>0或者dx<0判断，而dx<0的部分，要对for循环中的一些正负号和变量进行变换，才能实现在这个斜率范围的直线绘制，后面每一个函数都按这样的套路来，如果正负号变量弄反了，直线是会绘制错误的，所以这部分特别耗时间。凡是以x轴的步长为循环的变量，e的初始值都为-dx，还是以y轴的部长为循环的变量e的初始值都为-dy。

在绘制完四个函数之后，再直线绘制显示的部分display函数需要将绘制的点的斜率计算出来，把每一个点的斜率计算出来，注意计算出斜率的部分k=dy/dx，需要用浮点数进行计算。根据它的斜率在负无穷~-1~0~1~正无穷，这四个区间判断该使用哪个函数。其余的步骤跟第一个题目的一样。

㱘郳
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
计算机图形学DDA画直线，中点画直线，Bresenham画直线java程序
01-07
计算机图形学DDA算法，中点画直线算法，Bresenham算法java源代码
OpenGL绘制直线
lixiaoguang20的博客
11-10 1万+
// main.c // opengl_ animationRect_0002 // // Created by ch_soft on 12-1-16. // Copyright (c) 2012年 __MyCompanyName__. All rights reserved. // #include #include #include #include //用于绘制窗口需要的
使用DDA算法画直线
12-04
是直接可以用的代码，阐释了DDA画直线的原理 希望高手点评
DDA算法画直线（计算机图形学）.zip
10-07
在 pycharm 加 pyqt5环境中开发，python实现 DDA算法 画直线。 有优美的 UI界面。
【OpenGL】使用DDA算法画线
lishichengyan的博客
09-26 1万+
DDA（数字微分分析仪...好高大上的样子）算法其实就是利用直线方程来生成直线的算法，给定起点(x0,y0)和终点(xEnd,yEnd)，这条直线就唯一确定了，它的斜率是k=（yEnd-y0）/（xEnd-x0）。对于x方向我们取增量为1，那么下一个x值，即xi+1=xi+1，这样一来，y方向的增量就是斜率k，那么yi+1=yi+k。利用这两个加粗的方程，我们就可以遍历这条直线，每到一个地方就把这
图形学曲线_dda直线_椭圆画法_圆画法_bresenham绘制直线_
10-04
在计算机图形学中，绘制直线、椭圆和圆是基础且重要的部分，这些技术广泛应用于游戏开发、图像处理、UI设计等领域。以下是关于标题和描述中提到的几个关键概念的详细解释： 1. DDA（Digital Differential Analyzer...
计算机图形学实验-DDA直线算法源码
04-04
这个实验主要是为了帮助学生理解和应用DDA算法，通过源码实践来加深对计算机图形学原理的理解。 DDA算法基于数字微分分析器的概念，通过逐像素的方式画出直线。以下是DDA算法的基本步骤： 1. **输入参数**：DDA...
计算机图形学--Bresenham完整算法-画直线、椭圆和圆.docx
07-08
计算机图形学--Bresenham完整算法-画直线、椭圆和圆 在计算机图形学中，绘制基本图形元素是非常重要的，直线、椭圆和圆等基本图形元素的绘制是图形学的基础。本文档主要介绍Bresenham完整算法，包括画直线、椭圆和...
计算机图形学实验一（DDA算法、中点算法、Bresenham算法、中点画圆算法）
10-04
3、编程实现利用DDA算法、中点算法和Bresenham算法生成直线，并显示。 同时要求：（1）实现可动态修改直线的起始点坐标和终点坐标 （2）实现可动态选择线的颜色和线宽。 4、编程实现利用1/8圆中点算法和Bresenham...
DDA画直线源代码 C语言代码
12-28
DDA画直线源代码！适合画稍微平一点的直线，用X的变化来控制y。这样的话得到的y的点相对多。 #include<graphics.h> void linedda(int x0,int y0,int x1,int y1,int color) { int x,dy,dx,y; float m; 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+=m; } } main() { int a,b,c,d,e; int graphdriver=DETECT; int graphmode=0; initgraph(&graphdriver,&graphmode," "); cleardevice(); a=0; b=0; c=200; d=300; e=2; linedda(a,b,c,d,e); getch(); closegraph(); } ########################################################################## 适合画稍微抖一点的直线，用y的变化来控制x。这样的话得到的X的点相对多。 #include<graphics.h> void linedda(int x0,int y0,int x1,int y1,int color) { int x,dy,dx,y; float m; dx=x1-x0; dy=y1-y0; m=dy/dx; x=x0; for (y=y0;y<=y1;y++) { putpixel(y,(int)(x+0.5),color); x+=1/m; } } main() { int a,b,c,d,e; int graphdriver=DETECT; int graphmode=0; initgraph(&graphdriver,&graphmode," "); cleardevice(); a=0; b=0; c=100; d=100; e=2; linedda(0,100,200,300,1); linedda(0,0,200,300,e); linedda(100,100,200,300,1); getch(); closegraph(); }
opengl基础上的DDA画线程序
05-21
DDA算法的实现。是一个完整的vs2010项目，可以编译执行，鼠标任意获取屏幕上2点，实现画线。（任意斜率都可以！）
【OpenGL】直线生成算法DDA+Bresenham
stormpang的博客
09-20 1万+
OpenGL 直线生成算法 DDA + Bresenham
第一课、OpenGL绘制直线等等
热门推荐
ch_soft的专栏
01-18 2万+
// //  main.c //  opengl_ animationRect_0002 // //  Created by  ch_soft on 12-1-16. //  Copyright (c) 2012年 __MyCompanyName__. All rights reserved. // #include #include #include  #includ
CG1-v1.0-OpenGL点和直线的绘制
weixin_52566391的博客
05-30 1005
进行编程，以OpenGL为开发平台设计程序，以能够在屏幕上生成三个坐标、颜色和尺寸一定的点。了解和使用OpenGL的生成直线的命令，来验证程序运行结果。利用 OpenGL 作为开发平台设计程序，生成一个光栅图。理解基本图形元素光栅化的基本原理；了解光栅图形显示器的特点；了解计算机绘图的特点；
【OpenGL从入门到精通（四）】绘制一条线
用可见的方式来记录和分享每一次收获
10-20 449
//draw scene glClear(GL_COLOR_BUFFER_BIT); glBegin(GL_LINE_STRIP);//start to draw something glColor4ub(255, 0, 0, 255); glVertex3f(0.0f, 0.0f, -10.0f); glColor4ub(0, 255, 0, 255); glVertex3f(-5.0f, 0.0f, -10.0f); glColor4ub(0, 0, 255, 255...
【计算机图形学】实验一 直线生成算法实现（实验报告分析+截图+源码）
m0_55931547的博客
06-28 5799
DDA、中点Brensenham（所有情况都囊括了）、Brensenham（仅有0
【计算机图形学】基于OpenGL的中点Bresenham算法画直线
m0_63448210的博客
10-12 4446
学习过三种画直线的方法（DDA、中点Bresenham算法、改进的中点Bresenham算法）后，想着实际操作一下如何能够实现，OpenGL无疑是很好的选择，在老师的推荐下，我尝试着用OpenGL来实现中点Bresenham算法画直线，最后也基本实现了这个功能。如果有不正确或者能更好改进的地方欢迎各位大神留言或私信指教。
C++模拟OpenGL库——图形光栅化理论及实现（二)：Brensenham直线算法
最不正经的计算机专业学生
11-13 1049
Brensenham直线算法
算法-KMP字符串匹配
最新发布
xx_xb的博客
07-23 231
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值