【OpenGL】使用DDA算法绘制直线，使用Bresenham算法绘制直线和圆

最新推荐文章于 2023-07-10 00:54:39 发布
最新推荐文章于 2023-07-10 00:54:39 发布
阅读量2k 收藏 38
点赞数 5
分类专栏： 计算机图形学 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/elford/article/details/120439935
版权 
//#include "stdafx.h"
#include <windows.h>
#include <GL/glu.h>
#include <GL/gl.h>
#include <GL/glut.h>
#include<stdlib.h>  
#include <iostream>
#include <algorithm>
using namespace std;

void display(void);
void myInit(void);
void DDA_Line(int x0, int y0, int xEnd, int yEnd);
void Bres_Line(int x1, int y1, int x2, int y2);
void Bres_Circle(int x0, int y0, double r);
void Cirpot(int x0, int y0, int x, int y);          // 八路对称


int main(int argc, char* argv[])
{
	glutInit(&argc, argv);                          // 初始化
	glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);    // 单缓冲窗口，RGB颜色模式
	glutInitWindowSize(1000, 800);                  // 创建窗口
	glutInitWindowPosition(500, 250);               // 窗口位置
	glutCreateWindow("Widget");                     // 窗口名词

	glutDisplayFunc(display);                       // 绘制方法

	myInit();                                       // 初始化
	glutMainLoop();                                 // 循环渲染
	return(0);
}


void display(void)
{
	glClear(GL_COLOR_BUFFER_BIT);  // 清除当前可写的颜色缓冲
	glViewport(0, 0, 1000, 800);   // 视口矩形的范围(x, y, width, height)
	DDA_Line(30, 30, 400, 400);
	Bres_Line(50, 100, 100, 400);
	Bres_Circle(250, 250, 100);
}

void myInit(void)
{
	glClearColor(0.2f, 0.2f, 0.2f, 1.0f);           // 设置背景颜色
	glColor3f(1.0, 1.0, 1.0);                       // 设置点颜色
	gluOrtho2D(0.0, 500.0, 0.0, 500.0);             // 用来指定屏幕区域对应的模型坐标范围(left, right, bottom, top)
	glMatrixMode(GL_MODELVIEW);                     // 在进行变换前把当前矩阵设置为单位矩阵
}

void DDA_Line(int x0, int y0, int xEnd, int yEnd)
{
	int dx = xEnd - x0;			
	int dy = yEnd - y0;			
	int steps;
	float xIncrement, yIncrement, x = x0, y = y0;
	if (abs(dx) > abs(dy))	 // k < 1
		steps = abs(dx);
	else                     // k > 1
		steps = abs(dy);

	xIncrement = float(dx) / float(steps);         
	yIncrement = float(dy) / float(steps);			

	glBegin(GL_POINTS);            // 画点
	glVertex3f(x0, y0, 0);		   // 画起点
	for (int k = 0; k <= steps; k++)
	{
		x += xIncrement;		   // x点 + 增量
		y += yIncrement;		   // y点 + 增量
		glVertex3f(x, y, 0);       // 画点
	}
	glVertex3f(xEnd, yEnd, 0);	   // 画终点
	glEnd();
	glFlush();
}

void Bres_Line(int x1, int y1, int x2, int y2)
{
	glBegin(GL_POINTS);            // 画点
	glColor3f(0.7, 0.0, 0.6);
	glVertex3f(x1, y1, 0);		   // 画起点
	int dx = abs(x2 - x1), dy = abs(y2 - y1);
	if (dx == 0 && dy == 0)
		return;
	int flag = 0;
	if (dx < dy)    // k > 1
	{
		flag = 1;
		swap(x1, y1);
		swap(x2, y2);
		swap(dx, dy);
	}
	int tx = (x2 - x1 > 0 ? 1 : -1);
	int ty = (y2 - y1 > 0 ? 1 : -1);
	int curx = x1, cury = y1;
	int dS = 2 * dy, dT = 2 * (dy - dx);
	int d = dS - dT;               // 判别式
	while (curx != x2)
	{
		if (d < 0)
			d += dS;
		else
		{
			cury += ty;
			d += dT;
		}
		if (flag)  // k > 1
			glVertex3f(cury, curx, 0);
		else       // k <= 1
			glVertex3f(curx, cury, 0);
		curx += tx;
	}
	glEnd();
	glFlush();
}

void Cirpot(int x0, int y0, int x, int y)
{
	glVertex3f(x0 + x, y0 + y, 0);
	glVertex3f(x0 + y, y0 + x, 0);
	glVertex3f(x0 + y, y0 - x, 0);
	glVertex3f(x0 + x, y0 - y, 0);
	glVertex3f(x0 - x, y0 - y, 0);
	glVertex3f(x0 - y, y0 - x, 0);
	glVertex3f(x0 - y, y0 - x, 0);
	glVertex3f(x0 - y, y0 + x, 0);
	glVertex3f(x0 - x, y0 + y, 0);
}

void Bres_Circle(int x0, int y0, double r)
{
	int x = 0, y = (int)r;
	int d = int(3 - 2 * r);   // 判别式初始值
	glBegin(GL_POINTS);            // 画点
	glColor3f(1.0, 0.1, 0.0);
	while (x < y)
	{
		Cirpot(x0, y0, x, y);
		if (d < 0)
			d += (4 * x + 6);
		else
		{
			d += (4 * (x - y) + 10);
			y--;
		}
		x++;
	}
	if (x == y)
		Cirpot(x0, y0, x, y);
	glEnd();
	glFlush();
}

成品图：
在这里插入图片描述

使用鼠标交互

//#include "stdafx.h"
#include <windows.h>
#include <GL/glu.h>
#include <GL/gl.h>
#include <GL/glut.h>
#include<stdlib.h>  
#include <iostream>
#include <algorithm>
using namespace std;

void display(void);
void myInit(void);
void DDA_Line(int x0, int y0, int xEnd, int yEnd);
void Bres_Line(int x1, int y1, int x2, int y2);
void Bres_Circle(int x0, int y0, double r);
void Cirpot(int x0, int y0, int x, int y);          // 八路对称
void Mouse0(int button, int state, int x, int y);    // 鼠标单击事件
void Mouse1(int button, int state, int x, int y);
int GLOBALx0 = 30, GLOBALy0 = 30;
int GLOBALx1 = 400, GLOBALy1 = 400;
int f = 0;

int main(int argc, char* argv[])
{
	glutInit(&argc, argv);                          // 初始化
	glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);    // 单缓冲窗口，RGB颜色模式
	glutInitWindowSize(1000, 800);                  // 创建窗口
	glutInitWindowPosition(0, 0);                   // 窗口位置
	glutCreateWindow("Widget");                     // 窗口名词

	glutDisplayFunc(display);                       // 绘制方法

	myInit();                                       // 初始化
	glutMainLoop();                                 // 循环渲染
	return(0);
}

void Mouse0(int button, int state, int x, int y)
{
	if (state == GLUT_DOWN)
	{
		f++;
		if (f % 2 == 1)
		{
			GLOBALx0 = x;
			GLOBALy0 = y;
		}
		else
		{
			GLOBALx1 = x;
			GLOBALy1 = y;
			DDA_Line(GLOBALx0, GLOBALy0, GLOBALx1, GLOBALy1);
		}
	}
	cout << "(" << GLOBALx0 << ", " << GLOBALy0 << ")  (" << GLOBALx1 << ", " << GLOBALy1 << ") \n";
}

void Mouse1(int button, int state, int x, int y)
{
	
}

void display(void)
{
	glClear(GL_COLOR_BUFFER_BIT);  // 清除当前可写的颜色缓冲
	glViewport(0, 0, 1000, 800);   // 视口矩形的范围(x, y, width, height)
	glutMouseFunc(Mouse0);
	// DDA_Line(GLOBALx0, GLOBALy0, GLOBALx1, GLOBALy1);
	Bres_Line(50, 100, 100, 400);
	Bres_Circle(250, 250, 100);
}

void myInit(void)
{
	glClearColor(0.2f, 0.2f, 0.2f, 1.0f);           // 设置背景颜色
	glColor3f(1.0, 1.0, 1.0);                       // 设置点颜色
	gluOrtho2D(0.0, 1000, 800.0, 0.0);              // 用来指定屏幕区域对应的模型坐标范围(left, right, bottom, top)
	glMatrixMode(GL_MODELVIEW);                     // 在进行变换前把当前矩阵设置为单位矩阵
}

void DDA_Line(int x0, int y0, int xEnd, int yEnd)
{
	int dx = xEnd - x0;			
	int dy = yEnd - y0;			
	int steps;
	float xIncrement, yIncrement, x = x0, y = y0;
	if (abs(dx) > abs(dy))	 // k < 1
		steps = abs(dx);
	else                     // k > 1
		steps = abs(dy);

	xIncrement = float(dx) / float(steps);         
	yIncrement = float(dy) / float(steps);			
	

	glBegin(GL_POINTS);            // 画点
	glVertex3f(x0, y0, 0);		   // 画起点
	for (int k = 0; k <= steps; k++)
	{
		x += xIncrement;		   // x点 + 增量
		y += yIncrement;		   // y点 + 增量
		glVertex3f(x, y, 0);       // 画点
	}
	glVertex3f(xEnd, yEnd, 0);	   // 画终点
	glEnd();
	glFlush();
}

void Bres_Line(int x1, int y1, int x2, int y2)
{
	glBegin(GL_POINTS);            // 画点
	glColor3f(0.7, 0.0, 0.6);
	glVertex3f(x1, y1, 0);		   // 画起点
	int dx = abs(x2 - x1), dy = abs(y2 - y1);
	if (dx == 0 && dy == 0)
		return;
	int flag = 0;
	if (dx < dy)    // k > 1
	{
		flag = 1;
		swap(x1, y1);
		swap(x2, y2);
		swap(dx, dy);
	}
	int tx = (x2 - x1 > 0 ? 1 : -1);
	int ty = (y2 - y1 > 0 ? 1 : -1);
	int curx = x1, cury = y1;
	int dS = 2 * dy, dT = 2 * (dy - dx);
	int d = dS - dT;               // 判别式
	while (curx != x2)
	{
		if (d < 0)
			d += dS;
		else
		{
			cury += ty;
			d += dT;
		}
		if (flag)  // k > 1
			glVertex3f(cury, curx, 0);
		else       // k <= 1
			glVertex3f(curx, cury, 0);
		curx += tx;
	}
	glEnd();
	glFlush();
}

void Cirpot(int x0, int y0, int x, int y)
{
	glVertex3f(x0 + x, y0 + y, 0);
	glVertex3f(x0 + y, y0 + x, 0);
	glVertex3f(x0 + y, y0 - x, 0);
	glVertex3f(x0 + x, y0 - y, 0);
	glVertex3f(x0 - x, y0 - y, 0);
	glVertex3f(x0 - y, y0 - x, 0);
	glVertex3f(x0 - y, y0 - x, 0);
	glVertex3f(x0 - y, y0 + x, 0);
	glVertex3f(x0 - x, y0 + y, 0);
}

void Bres_Circle(int x0, int y0, double r)
{
	int x = 0, y = (int)r;
	int d = int(3 - 2 * r);   // 判别式初始值
	glBegin(GL_POINTS);            // 画点
	glColor3f(1.0, 0.1, 0.0);
	while (x < y)
	{
		Cirpot(x0, y0, x, y);
		if (d < 0)
			d += (4 * x + 6);
		else
		{
			d += (4 * (x - y) + 10);
			y--;
		}
		x++;
	}
	if (x == y)
		Cirpot(x0, y0, x, y);
	glEnd();
	glFlush();
}
jinzhou742
关注
专栏目录
自学计算机图形学OpenGL(六）Bresenham直线算法
qq_60807086的博客
03-28 228
OpenGL，Bresenham算法画线段
【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。利用这两个加粗的方程，我们就可以遍历这条直线，每到一个地方就把这
OpenGL_DDA画线
weixin_45510058的博客
10-20 227
#define GLUT_DISABLE_ATEXIT_HACK #include "GLUT.H" #include<math.h> #define ZVALUE 20.0f int w_width = 600; int w_height = 600; //DDA绘制直线 void DDA(int x0, int y0, int x1, int y1) { float dx = x1 - x0; float dy = y1 - y0; float k = dy / dx; f
基于OpenGL的DDA算法画直线段
09-28
基于OpenGL的DDA算法画直线段，用鼠标在窗口随机选择点并连成折线段，按ESC键即可退出该这线段并开始绘制下一条这线段
OpenGL实现DDA画线算法
weixin_33895657的博客
04-28 737
数字微分分析仪（digital differential analyzer）方法是一种线段扫描转换算法。 DDA算法比直接使用直线方程计算的速度更快，它利用光栅特性消除了直线方程种的乘法。 本代码参考自《计算机图形学》第四版，该函数将在verts末尾按次序添加需要的点坐标 inline int round(const float a){ return int(a + 0.5);}v...
OpenGl中DDA算法画直线
cjx798280904的专栏
10-12 2379
void DDALine(int x0,int y0,int x1,int y1) { int dx,dy,epsl,k; float x,y,xIncre,yIncre; dx = x1 - x0; dy = y1 - y0; x = x0; y = y0; if(abs(dx)>abs(dy)) epsl=abs(dx); else epsl=abs(dy);
Opengl直线生成算法（Bresenham、DDA、逐点、中点）
qq_45228525的博客
05-14 4466
1.Bresenham.cpp #include<gl/glut.h> #include<math.h> void Bres_Line(int x1, int y1, int x2, int y2) { glColor3f(0.0f, 0.0f, 1.0f);//设置颜色，蓝色 glPointSize(3);//栅格化点，直径为3 int dx = abs(x2 - x1);//计算|∆x| int dy = abs(y2 - y1);//计算|∆y| if (dx
DDA算法绘制直线.zip_DDA算法绘制直线_绘制直线
09-23
虽然现代图形系统使用更高级的方法（如Bresenham算法）提高效率，但DDA算法对于理解图形绘制的基本原理仍然具有重要意义。通过实践C语言版的DDA算法，开发者不仅能掌握直线绘制，还能进一步深入学习计算机图形学的...
OpenGL通过中点法绘制直线和圆
08-25
DDALine()函数使用DDA算法来绘制直线，Mid_B()函数使用Bresenham算法来绘制直线，G_B()函数使用 Graphics_Basic 算法来绘制直线。CirclePoint()函数使用中点法来绘制圆。 结论 通过中点法绘制直线和圆是计算机图形...
图形学曲线_dda直线_椭圆画法_圆画法_bresenham绘制直线_
10-04
在计算机图形学中，绘制直线、椭圆和圆是基础且重要的部分，这些技术广泛应用于游戏开发、图像处理、UI设计等领域。以下是关于标题和描述中提到的几个关键概念的详细解释： 1. DDA（Digital Differential Analyzer...
opengl基础上的DDA画线程序
05-21
DDA算法的实现。是一个完整的vs2010项目，可以编译执行，鼠标任意获取屏幕上2点，实现画线。（任意斜率都可以！）
DDA算法-中点直线算法-OPENGL实现.zip
05-27
该项目采用VS2019开发, 使用OpenGL 1.1库文件()绘制, 采用包含直线段绘制的两种算法: 中点算法, 和 DDA算法. 分别采用两种算法描绘出4种不同斜率的直线, 外加一条单独处理的垂直x轴的直线. 有明确的注释. 虽然OpenGL1.1库文件较老, 但不论是对于教学还是实践, 对理解直线段算法都具有重要意义, VS2019环境配置教程: https://blog.csdn.net/BoyInC0de/article/details/90079870 三种直线算法的解释:https://blog.csdn.net/BoyInC0de/article/details/90549419#_8
计算机图形学实验【DDA；中点线，圆，椭圆】（OpenGL）
11-06
计算机图形学实验【DDA；中点线，圆，椭圆】（OpenGL实现）
openGL画线画圆算法实现
10-27
这个代码实现了openGL的dda画线算法，中点画圆算法等，适用于大学生课程设计
opengl画圆的多种方法
01-06
基于opengl的各种画圆方法，相信看完之后会大有所悟。
DDA算法绘制直线
03-13
DDA绘图
计算机图形学实验一（DDA算法、中点算法、Bresenham算法、中点画圆算法）
10-04
3、编程实现利用DDA算法、中点算法和Bresenham算法生成直线，并显示。 同时要求：（1）实现可动态修改直线的起始点坐标和终点坐标 （2）实现可动态选择线的颜色和线宽。 4、编程实现利用1/8圆中点算法和Bresenham...
数值微分法绘制直线c语言,OpenGL数值微分法（DDA）画直线
weixin_42364855的博客
05-22 877
DDA算法，是计算机图形学中一种基于直线的微分方程来生成直线的方法，由于有浮点数运算与取整，该算法不利于硬件实现。其主要思想是由直线公式y = kx + b推导出来的。我们已知直线段两个端点P0(x0,y0)和P1(x1,y1)，就能求出 k 和 b 。在k，b均求出的条件下，只要知道一个x值，我们就能计算出一个y值。如果x的步进为1(x每次加1，即x = x +1)，那么y的步进就为k+b；同样...
【计算机图形学】直线绘制算法-数值微分 (DDA) 和 Bresenham
最新发布
weixin_62466076的博客
07-10 1481
DDA 算法与Bresenham 算法的区别1.1 效率。
用opengl C语言写一段代码，要求用bresenham画线法画直线段，鼠标左键取点，鼠标右键画线
04-18
好的，我可以为您提供一个Bresenham算法的代码示例，以使用OpenGL的C语言编写直线段。以下是示例代码： ``` #include <GL/glut.h> #include <stdio.h> int winWidth = 640; int winHeight = 480; int pointCount = 0; int points[2][2]; void init(void) { glClearColor(0.0, 0.0, 0.0, 0.0); glMatrixMode(GL_PROJECTION); gluOrtho2D(0.0, winWidth, 0.0, winHeight); } void display() {} void bresenham(int x1, int y1, int x2, int y2) { int dx = abs(x2-x1), dy = abs(y2-y1); int p = 2*dy-dx; int x = x1, y = y1; glBegin(GL_POINTS); glVertex2i(x, y); while (x < x2) { if (p >= 0) { y++; p += 2*dy-2*dx; } else { p += 2*dy; } x++; glVertex2i(x, y); } glEnd(); glFlush(); } void mouse(int button, int state, int x, int y) { if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) { points[pointCount][0] = x; points[pointCount][1] = winHeight - y; pointCount++; } else if (button == GLUT_RIGHT_BUTTON && state == GLUT_DOWN) { bresenham(points[0][0], points[0][1], points[1][0], points[1][1]); pointCount = 0; } } int main(int argc, char** argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); glutInitWindowSize(winWidth, winHeight); glutInitWindowPosition(100, 100); glutCreateWindow("Bresenham Line Drawing"); glutDisplayFunc(display); glutMouseFunc(mouse); init(); glutMainLoop(); return 0; } ``` 该代码使用OpenGL库和GLUT库来实现直线段的创建和显示。Bresenham算法是在while循环中执行的，以在屏幕上绘制直线。当用鼠标左键单击时，该代码会记录所选点的坐标，并在用鼠标右键单击时使用这些点的坐标来绘制直线。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值