• Visual Studio 2013 Bresenham画直线、DDA画直线和中点画圆
2021-08-11 19:46:13

实现控制台点击鼠标左键两下画直线，和固定长为半径鼠标左击为圆心画圆。

Bresenham画直线，斜率有四种情况。

void Cdraw_lineView::Bresenhamline(int x0, int y0, int x1, int y1, int color)    //自写函数,两次点击画直线
{
CDC *pDC = GetDC();
int x, y, dx, dy, e;
dx = x1 - x0;
dy = y1 - y0;
e = -dx;
x = x0;
y = y0;

if ((dx >= 0 && dy >= 0) || (dx <= 0 && dy <= 0)) //k>0
{
if ((dx < 0) || (dx == 0 && dy < 0)) ///dx小于0说明终点x
{
dx = -dx;
x = x1;
dy = -dy;
y = y1;
}
if (dy < dx)     //第一种情况，k-(0,1)//
{
e = -dx;
for (int i = 0; i < dx; i++)
{
pDC->SetPixel(x, y, color);
x++;
e = e + dy + dy;
if (e >= 0)
{
y++;
e = e - dx - dx;
}
}
}
else  //第二种情况，k-(1,max)
{
e = -dy;
for (int i = 0; i < dy; i++)
{
pDC->SetPixel(x, y, color);
y++;
e = e + dx + dx;
if (e >= 0)
{
x++;
e = e - dy - dy;
}
}
}
}
else   //如果k小于0
{
int tempx, tempy; //保存x和y的绝对值
if (dx < 0) //dx小于0说明终点x
{
tempx = -dx;
tempy = dy;
}
if (dy < 0)
{
tempx = dx;
tempy = -dy;
}
if (tempx > tempy) //第三种情况，k-(-1,0)
{
if (dx < 0) //dx小于0说明终点x
{
dx = -dx;
x = x1;
dy = -dy;
y = y1;
}
e = -dx;
for (int i = 0; i < dx; i++)
{
pDC->SetPixel(x, y, color);
x++;
e = e - dy - dy;
if (e >= 0)
{
y--;
e = e - dx - dx;
}
}
}
else  //第四种情况，k-(-1,min)
{
if (dy < 0)//dx小于0说明终点x
{
dx = -dx;
x = x1;
dy = -dy;
y = y1;
}
e = -dy;
for (int i = 0; i < dy; i++)
{
pDC->SetPixel(x, y, color);
y++;
e = e - dx - dx;
if (e >= 0)
{
x--;
e = e - dy - dy;
}
}
}
}

ReleaseDC(pDC);
}


DDA画直线。

void Cdraw_lineView::DDAline(int x0, int y0, int x1, int y1, int c)
{
CDC *pDC = GetDC();
int i;
float dx, dy, length, x, y;

if (abs(x1 - x0) >= abs(y1 - y0))
length = abs(x1 - x0);
else
length = abs(y1 - y0);

dx = (x1 - x0) / length;
dy = (y1 - y0) / length;

i = 1;
x = x0;
y = y0;

while(i <= length)
{
pDC->SetPixel(int(x + 0.5), (y + 0.5), c);
x += dx;
y += dy;
i++;
}
ReleaseDC(pDC);
}


中点画圆法。

void Cdraw_lineView::MidPointCircle(int x0, int y0)
{
int r = 100, x = 0, y = r, color = RGB(255, 0, 0), e = 1-r;

Cdraw_lineDoc* pDoc = GetDocument();
ASSERT_VALID(pDoc);

circlepoints(x0, y0, x, y, color);

while (x <= y)
{
if (e < 0)
{
e += 2 * x + 3;
}

else
{
e += 2 * (x-y) + 5;
y--;
}
x++;

circlepoints(x0, y0, x, y, color);
}
}

int Cdraw_lineView::circlepoints(int x0, int y0, int x, int y, int color)
{
CDC *pDC = GetDC();
pDC->SetPixel(x+x0, y+y0, color);
pDC->SetPixel(y+x0, x+y0, color);
pDC->SetPixel(-x+x0, y+y0, color);
pDC->SetPixel(y+x0, -x+y0, color);
pDC->SetPixel(x+x0, -y+y0, color);
pDC->SetPixel(-y+x0, x+y0, color);
pDC->SetPixel(-x+x0, -y+y0, color);
pDC->SetPixel(-y+x0, -x+y0, color);

return 0;
ReleaseDC(pDC);
}


更多相关内容
• 在 pycharm 加 pyqt5环境中开发，python实现 DDA算法 画直线。 有优美的 UI界面。
• 计算机图形学DDA算法，中点画直线算法，Bresenham算法java源代码
• //经过适配处理的数值微分算法，可以绘制斜率为零、斜率不存在、斜率绝对值大于一等情况下的直线，只需输入两个点的横纵坐标即可 void DDA(const unsigned& x1, const unsigned& y1, const unsigned& x2...
//经过适配处理的数值微分算法，可以绘制斜率为零、斜率不存在、斜率绝对值大于一等情况下的直线，只需输入两个点的横纵坐标即可
void DDA(const unsigned& x1, const unsigned& y1, const unsigned& x2, const unsigned& y2)
{
int dx(x2 - x1), dy(y2 - y1);//定义两个变量分别记录x和y的变化量
enum MainDirection { x, y };//定义一个枚举变量记录直线的主要变化方向（x方向或者y方向）（此处使用枚举变量更能体现取值约束）
MainDirection Direction;
if (abs(dx) >= abs(dy))//通过x变化量的绝对值和y变化量的绝对值进行比较确定主要变化方向
Direction = x;
else Direction = y;

//如果主要变化方向在x（y）上，但是两点的横（纵）坐标不满足递增排序，则递归调用自身
//（该操作相当于交换两个点的坐标）
if ((Direction == x && x1 > x2) || (Direction == y && y1 > y2))
{
DDA(x2, y2, x1, y1);
return;
}

initgraph(800, 640);//首先初始化绘图窗口备用

if (Direction == x)
{
double k = double(dy) / dx;//此处需要将dy转换成浮点型进行运算，否则得到的结果很可能是零（在此处出过错误，调试了很久）
double y = y1;
for (unsigned x = x1; x <= x2; ++x)
{
putpixel(x, int(y + 0.5), RED);
y += k;
}
_getch();
closegraph();
return;
}
else if (Direction == y)
{
double k = double(dx) / dy;//与上面一种情况同理需要转换成浮点型
double x = x1;
for (unsigned y = y1; y <= y2; ++y)
{
putpixel(int(x + 0.5), y, RED);
x += k;
}
_getch();
closegraph();
return;
}
}


注：运行该函数需要使用头文件<graphics.h>和<conio.h>，其中第一个头文件非系统库，可以到网上免费下载。

展开全文
• DDA画直线源代码！适合画稍微平一点的直线，用X的变化来控制y。这样的话得到的y的点相对多。 #include void linedda(int x0,int y0,int x1,int y1,int color) { int x,dy,dx,y; float m; dx=x1-x0; dy=y1-...
• 图形学绘制dda直线，bresenham直线，椭圆，圆，矩形和多边形
• dda画直线实验报告 (5页) 本资源提供全文预览，点击全文预览即可全文预览,如果喜欢文档就下载吧，查找使用更方便哦！9.9 积分本科实验报告实验名称： DDA直线画法 课程名称： 计算机图形学 院 系： 传媒学院 年级...

dda画直线实验报告

(5页)

本资源提供全文预览，点击全文预览即可全文预览,如果喜欢文档就下载吧，查找使用更方便哦！

9.9 积分

本科实验报告实验名称： DDA直线画法 课程名称： 计算机图形学 院 系： 传媒学院 年级专业： 学生姓名： 学 号： 合作人员： 无 指导教师： 李大锦 实验日期： 实验地点： 实验成绩：良好批阅教师：李大锦实验目的：了解基本图元输出算法, 实验内容：利用DDA算法编程实现直线绘制，要求：利用MFC创建绘制窗口，创建直线绘制按钮，点击 鼠标并拖动鼠标绘制直线。实验条件与设备：机房 Microsoft Visual 0+6. 0实验步骤与数据记录：(源代码)void CDrawView::DrawLine(CPoint pl,CPoint p2){int dx = p2. x -pl. x,；int dy = p2? y 一 pl? y, ； int steps, k;float xincrement, yincrement； float x =pl. x, ; float y = pl. y; if (abs (dx) > abs(dy) steps = abs (dx);else steps = abs (dy);xincrement = dx / (float) steps; yincrement = dy /(float) steps; m dib. in pData[ (y*600+x) *3] =0;m dib. m pData[(y*600+x)*3+1]=0;m_dib.m_pData[(y*600+x)*3+21=255;for (k二0; k

天天文库所有资源均是用户自行上传分享，仅供网友学习交流，未经上传用户书面授权，请勿作他用。

展开全文
• 流程，具体见算法。求x,y的增量tx,ty，求步数n（tx，ty最大值），x,y赋初值为起点，求出每步的增量dx，dy，定义点point，并赋初值，point.x=int(x);...，判断i，点；确定下一个点 x=x+dx;y=y+dy;i++
• 该算法为DDA画线算法，使用MATLAB语言
• 计算机绘制直线是在显示器所给定的有限个像素组成的矩阵中，确定最佳逼近该直线的一组像素，并且按扫描线顺序，对这些像素进行写操作，实现显示器绘制直线，即通常所说的直线的扫描转换，或称直线光栅化。
• DDA算法画直线算法，程序能够运行，验证运行通过，放心下载
• 通过C语言编程可以简单的出任意直线段，关键字：c语言，任意直线
• 计算机图形学原理课，用C语言实现DDA算法画直线，实验操作，下载后直接用VC或者VC++打开工作空间即可。
• //DDA画直线  if (flag == 6)  {  drawCircle();//bresenham中心画圆法  }  if (flag == 7)  {  Bresenham_Drawlines();//bresenham画直线  }  glutSwapBuffers(); } void Keyboard(unsigned...

// 计算机图形学_实验5_20181017.cpp : 定义应用程序的入口点。
//

#include "计算机图形学_实验5_20181017.h"
#include <graphics.h>
#include <conio.h>

// circle algorithm.cpp : Defines the entry point for the console application.
//

//This program was updated by Ms Huang Jing in Beijing Normal Unbersity Zhuhai Campus
//  in Oct 20 in 2012,Contact email: 306744855@qq.com

#include "stdafx.h"

#include <glut.h>
//#include <stdio.h>
//#include <stdlib.h>
#include <math.h>

#define N 1000       //maximum line numbers

int cx = 150, cy = 150, radius = 80, ri = 50, ro = 80, n = 3, samples = 1, flag = 1;
int ww, hh;     // for display window width and height
int line[N][4], k = 0;  //for line's endpoint coordinates and line number

void Myinit(void);
void plotC(int x, int y, int xc, int yc);
void Bresenham_Circle_Algorithm(int cx, int cy, int radius);
void DrawOneLine(int x1, int y1, int x2, int y2);
void NSidedPolygon(int n, int cx, int cy, int radius);
void SampleCircle(int inner, int outer, int samples, int cx, int cy);
void Keyboard(unsigned char key, int x, int y);
void Display(void);
void Reshape(int w, int h);
void Drawlines();
void myMouse(int button, int state, int x, int y);
void myMotion(int x, int y);
void  DDA_Drawlines();
void CirPot(int x0, int y0, int x, int y, int color);
void drawCircle();
void MidPoint_Circle(int x0, int y0, double radius, int color);
void Bresenham_line(int xa, int ya, int xb, int yb);
void Bresenham_line2(int xa, int ya, int xb, int yb);
void  Bresenham_Drawlines();

int APIENTRY _tWinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPTSTR    lpCmdLine,
int       nCmdShow)
{

UNREFERENCED_PARAMETER(hPrevInstance);
UNREFERENCED_PARAMETER(lpCmdLine);

char *argv[] = { "hello ", " " };
int argc = 2; // must/should match the number of strings in argv

glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutCreateWindow("Basic_Primitive_Algorithm");
Myinit();  //初始设置
glutDisplayFunc(Display);  //注册绘制响应回调函数
glutKeyboardFunc(Keyboard);  //注册键盘响应回调函数
glutReshapeFunc(Reshape);    //注册窗口改变回调函数
glutMouseFunc(myMouse);    //注册鼠标按钮回调函数
glutMotionFunc(myMotion);  //注册鼠标移动回调函数
glutMainLoop();
return 0;
}

void Myinit(void)
{
glClearColor(0.0, 0.0, 0.0, 0.0);  //背景色
glLineWidth(4.0);  //线宽
}

void Display(void)
{

glClear(GL_COLOR_BUFFER_BIT);

glMatrixMode(GL_MODELVIEW); //设置矩阵模式为模型变换模式，表示在世界坐标系下

if (flag == 1)  //画圆
if (flag == 2)  //画多边形
if (flag == 3)  //画胖圆
if (flag == 4)  //鼠标划线
Drawlines();
if (flag == 5)
DDA_Drawlines();//DDA画直线
if (flag == 6)
{
drawCircle();//bresenham中心画圆法
}
if (flag == 7)
{
Bresenham_Drawlines();//bresenham画直线
}
glutSwapBuffers();
}

void Keyboard(unsigned char key, int x, int y)
{
switch (key)
{

case 'r':
break;
case 'R':
break;
case 'n':
if ((flag == 2) && (n>3)) n--;  //多边形边数递减
break;
case 'N':
if (flag == 2) n++;  //多边形边数递增
break;
case 'i':
if ((flag == 3) && (ri>1)) ri--;  //画胖圆时内径变小
break;
case 'I':
if ((flag == 3) && (ri<radius)) ri++;  //画胖圆时内径变大
break;
case 's':
if (samples>1) samples--; //采样数减少
break;
case 'S':
samples++;   //采样数增加
break;
case 'a':
//cancel antialias
glDisable(GL_BLEND);
glDisable(GL_LINE_SMOOTH);
glDisable(GL_POINT_SMOOTH);
glDisable(GL_POLYGON_SMOOTH);
break;
case 'A':
//enable antialias
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
glEnable(GL_POINT_SMOOTH);
glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);
glEnable(GL_LINE_SMOOTH);
glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
glEnable(GL_POLYGON_SMOOTH);
break;
case '1':
flag = 1;  //画圆
break;
case '2':
flag = 2;  //画多边形
break;
case '3':
flag = 3;   //画胖圆
//cancel antialias
glDisable(GL_BLEND);
glDisable(GL_LINE_SMOOTH);
glDisable(GL_POINT_SMOOTH);
glDisable(GL_POLYGON_SMOOTH);
break;
case '4':
flag = 4;  //鼠标划线
for (int i = 0; i <= k; i++)
{
line[i][0] = 0;
line[i][1] = 0;
line[i][2] = 0;
line[i][3] = 0;
}
k = 0;
break;
case '5':
flag = 5;
for (int i = 0; i <= k; i++)
{
line[i][0] = 0;
line[i][1] = 0;
line[i][2] = 0;
line[i][3] = 0;
}
k = 0;
break;
case '6':
flag = 6;
for (int i = 0; i <= k; i++)
{
line[i][0] = 0;
line[i][1] = 0;
line[i][2] = 0;
line[i][3] = 0;
}
k = 0;
break;
case '7':
flag = 7;
for (int i = 0; i <= k; i++)
{
line[i][0] = 0;
line[i][1] = 0;
line[i][2] = 0;
line[i][3] = 0;
}
k = 0;
break;
case 27:
exit(0);
//  default:
//     return;
}

glutPostRedisplay();
}

void Reshape(int w, int h)
{
glMatrixMode(GL_PROJECTION);
glViewport(0, 0, w, h);
gluOrtho2D(0, w, 0, h);
ww = w;
hh = h;
cx = w / 2;
cy = h / 2;
}

void Bresenham_Circle_Algorithm(int cx, int cy, int radius)
{
Update the followling codes with Bresenham_Circle_Algorithm  */

glColor3f(1, 1, 1);
glTranslatef(cx, cy, 0);

}

void NSidedPolygon(int n, int cx, int cy, int radius)
{

int x[100], y[100];
double angle;

angle = 2 * 3.1415926 / n;

glColor3f(1, 1, 1);

for (int i = 0; i <= n; i++)
{
}

for (int i = 0; i <= (n - 1); i++)
{
DrawOneLine(x[i], y[i], x[i + 1], y[i + 1]);
}

}

void DrawOneLine(int xa, int ya, int xb, int yb)
{

//update the following codes with DDA line algorithm

glColor3f(1, 1, 1);
glBegin(GL_LINES);
glVertex2f(xa, ya);
glVertex2f(xb, yb);
glEnd();

}

void  Drawlines()
{

for (int i = 0; i <= k; i++) //********
{
DrawOneLine(line[i][0], line[i][1], line[i][2], line[i][3]);

}
}

void SampleCircle(int inner, int outer, int samples, int cx, int cy)
{

float r2, ro2, ri2;   //r2为子像素的半径
int x, y, nx, ny;   //x,y 为胖圆内的一点
float color_value;  //颜色亮度
int count; //计数合格的子像素

//#########  Calculate outer radius's square and inner's square

ro2 = outer*outer;   //胖圆外径平方
ri2 = inner*inner;   //胖圆内径平方

//#########  for each pixel(x,y), testing its sample

//1/4胖圆内的点测试
for (x = 0; x<outer; x++)
for (y = 0; y <= outer; y++)
{

//######## count available subpixels for each pixel
count = 0;

//每个点切分成smaples*samples个子像素
//判断子像素是否在胖圆内
for (nx = 0; nx <= samples; nx++)
for (ny = 0; ny <= samples; ny++)
{
r2 = (x + (float)nx / (float)samples)*(x + (float)nx / (float)samples);
r2 = r2 + (y + (float)ny / (float)samples)*(y + (float)ny / (float)samples);

if ((r2 <= ro2) && (r2 >= ri2))  count++; //计数合格的子像素

}

//########## calculate color gray level for each pixel
color_value = ((float)count) / (((float)samples + 1.0)*((float)samples + 1.0));

//########## draw pixel by using the color calculated above
glColor3f(color_value, color_value, color_value);

//对称画点
glBegin(GL_POINTS);
glVertex2f(cx + x, cy + y);
glVertex2f(cx + x, cy - y);
glVertex2f(cx - x, cy + y);
glVertex2f(cx - x, cy - y);
glEnd();

}
}

//鼠标按钮响应事件..
void myMouse(int button, int state, int x, int y)
{

if (button == GLUT_LEFT_BUTTON&&state == GLUT_DOWN)
{
line[k][0] = x;   //线段起点x坐标
line[k][1] = hh - y;  //线段起点y坐标
}

if (button == GLUT_LEFT_BUTTON&&state == GLUT_UP)
{
line[k][2] = x;   //线段终点x坐标
line[k][3] = hh - y;   //线段终点y坐标
k++;
glutPostRedisplay();
}

}

//鼠标移动时获得鼠标移动中的坐标-----------------------------------------------------
void myMotion(int x, int y)
{

//get the line's motion point
line[k][2] = x;   //动态终点的x坐标
line[k][3] = hh - y;  //动态终点的y坐标
glutPostRedisplay();

}

//DDA画直线算法
void DDA_line(int xa, int ya, int xb, int yb)
{
int dx = xb - xa;
int dy = yb - ya;

float xIncrement, yIncrement, steps, x = xa, y = ya;
if (abs(dx) > abs(dy))
{
steps = abs(dx);
}
else
{
steps = abs(dy);
}
xIncrement = (float)(dx) / steps;
yIncrement = (float)(dy) / steps;
for (int k = 0; k < steps; k++)
{
glBegin(GL_POINTS);
glVertex2i((int)(x + 0.5), (int)(y + 0.5));
glEnd();
x += xIncrement;
y += yIncrement;
}

}

void  DDA_Drawlines()
{
glColor3f(1, 1, 1);
for (int i = 0; i <= k; i++) //********
{
DDA_line(line[i][0], line[i][1], line[i][2], line[i][3]);
}
}

void  Bresenham_Drawlines()
{
glColor3f(1, 1, 1);
for (int i = 0; i <= k; i++) //********
{
Bresenham_line2(line[i][0], line[i][1], line[i][2], line[i][3]);
}
}

//DDA画直线算法
void Bresenham_line(int x0, int y0, int x1, int y1)
{
if (x0 - x1 < 0 && y0 - y1 < 0)
{
int dx = abs(x0 - x1);
int dy = abs(y0 - y1);
int h = 2 * dy - dx;
int x = x0;
int y = y0;

glColor3f(1, 1, 1);

glBegin(GL_POINTS);
glVertex2i(x, y);
glEnd();

while (x < x1)
{
if (h < 0)
{
h += 2 * dy;
}
else
{
h += 2 * (dy - dx);
y++;
}
glBegin(GL_POINTS);
glVertex2i(x, y);
glEnd();
x++;
}
}
else if (x0 - x1 > 0 && y0 - y1 > 0)
{
int dx = abs(x0 - x1);
int dy = abs(y0 - y1);
int h = (2 * dy - dx);
int x = x0;
int y = y0;

glColor3f(1, 1, 1);

glBegin(GL_POINTS);
glVertex2i(x, y);
glEnd();

while (x > x1)
{
if (h < 0)
{
h += 2 * dy;
}
else
{
h += 2 * (dy - dx);
y--;
}
glBegin(GL_POINTS);
glVertex2i(x, y);
glEnd();
x--;
}
}
}

/*
-------------------- -
作者：谛听 -
来源：CSDN
原文：https ://blog.csdn.net/u012319493/article/details/53289132
版权声明：本文为博主原创文章，转载请附上博文链接！
*/
void Bresenham_line2(int x0, int y0, int x1, int y1)
{
int dx = abs(x1 - x0);
int dy = abs(y1 - y0);
int x = x0;
int y = y0;
int stepX = 1;
int stepY = 1;
if (x0 > x1)  //从右向左画
stepX = -1;
if (y0 > y1)
stepY = -1;

if (dx > dy)  //沿着最长的那个轴前进
{
int e = dy * 2 - dx;
for (int i = 0; i <= dx; i++)
{
glColor3f(1, 1, 1);
glBegin(GL_POINTS);
glVertex2i(x, y);
glEnd();
x += stepX;
e += 2*dy;
if (e >= 0)
{
y += stepY;
e -= 2*dx;
}
}
}
else
{
int e = 2 * dx - dy;
for (int i = 0; i <= dy; i++)
{
glColor3f(1, 1, 1);
glBegin(GL_POINTS);
glVertex2i(x, y);
glEnd();
y += stepY;
e += dx;
if (e >= 0)
{
x += stepX;
e -= dy;
}
}
}
}

void drawCircle()
{
//glColor3f(1, 1, 1);

for(int i = 0; i <=k; i++)
{
radius = sqrt((double)((line[i][0] - line[i][2])*(line[i][0] - line[i][2])+ (line[i][1] - line[i][3])*(line[i][1] - line[i][3])));
//glColor3f(1.0f, 0.0f, 0.0f);
//glRasterPos2f(line[i][0], line[i][1]);
//glutBitmapCharacter(GLUT_BITMAP_9_BY_15,'A');

}
}

void MidPoint_Circle(int x0, int y0, double radius, int color)
{
int x, y, h;
CirPot(x0, y0, x, y, color);
while (x<y)
{
if (h<0)   h += 2 * x + 3;
else { h += 2 * (x - y) + 5;  y--; }
x++;
CirPot(x0, y0, x, y, color);
}
}
void CirPot(int x0, int y0, int x, int y, int color)
{

//根据圆的对称性绘出8个对称点
glBegin(GL_POINTS);
glColor3f(1, 1, 1);
glVertex2i(x0 + x, y0 + y);
glVertex2i(x0 + x, y0 - y);
glVertex2i(x0 - x, y0 + y);
glVertex2i(x0 - x, y0 - y);
glVertex2i(x0 + y, y0 + x);
glVertex2i(x0 + y, y0 - x);
glVertex2i(x0 - y, y0 + x);
glVertex2i(x0 - y, y0 - x);
glEnd();
//putpixel(x0 + x, y0 + y, color); //用color颜色在x0+x,y0+y处绘制一点
//putpixel(x0 + x, y0 - y, color);
//putpixel(x0 - x, y0 + y, color);
//putpixel(x0 - x, y0 - y, color);
//putpixel(x0 + y, y0 + x, color);
//putpixel(x0 + y, y0 - x, color);
//putpixel(x0 - y, y0 + x, color);
//putpixel(x0 - y, y0 - x, color);
}

展开全文
• 当用C语言实现DDA算法画直线时，需要先安装此工具函数，否则无法运行
• DDA画直线算法,VS2005的C++，OpenGL实现。代码有点问题，需要把x0,y0这些变量的声明类型改为float。我不知道怎么删除重新上传，所以只有让大家自己改了。
• 计算机图形学，内含DDA画直线，画圆，直线裁剪，多边形裁剪，填充，三维透视，三维平移缩放，贝塞尔曲线，B样条曲线功能。
• DDA算法画直线+源代码 DDA算法画直线+源代码 文章目录DDA算法画直线+源代码一、DDA算法二、斜率为0时的直线扫描1.垂直直线2.水平直线三、斜率小于1时的直线扫描四、斜率大于1的直线扫描总结 一、DDA算法 算法原理...
• DDA(数值微分法)基于直线微分方程生成直线。点xi，yi满足直线方程yi=kxi+b，若xi增加一个单位，则下一步点的位置(xi + 1，yi+1)满足yi+1=k(xi + 1)+ b。即yi+1=yi+k。yi同理，不再赘述。算法基本思想：选择平缓的...
• 生成直线DDA算法： 假设待扫描转换的直线段为 Pb（xb, yb）, Pe（xe, ye）,如图所示： 令,斜率,则直线方程为 为方便起见，这里假定。显然，对于每一个 xi的取值（x的变化规律是每次递增1），都有唯一的 yi...
• 这个做的非常简单就是DDA算法画直线和圆，使用MFC编写，VC6.0编译。
•  //用DDA画直线，定义了直线始点（10，10*m+30）#include &lt;graphics.h&gt;main(){ float m; printf("the m is "); //输入直线的斜率m scanf("%f",&amp;m); if(abs(m)&...
• MFC画直线程序，课选择DDA和Brensenham算法，可调颜色、坐标
• 1. 编程实现DDA直线生成算法或其它直线生成算法 2. 编程实现Bresenham圆弧生成算法或其它圆弧生成算法
• 此报告阐述用DDA算法实现画直线，等一系列问题，适合初学计算机图形学的同学，很实用，而且有图形界面
• 先上效果图 代码#!/usr/bin/env python# coding=utf-8from pylab import *from matplotlib.ticker import MultipleLocatorimport matplotlib.... 输入直线两端点 x0,y0 xn,yn2. 计算初始值delta_x, delta_y,k=delta...
• #include<stdio.h>...void DDA(float x1, float y1, float x2, float y2) //x1,y1起始点，x2,y2终止点 { int i, steps; int x0 = 400, y0 = 300; //坐标轴原点 float x, y, delta_x, delt
• DDA、Bresenham、Midpoint算法画直线
• ## DDA直线算法

千次阅读 2019-09-21 21:29:03
** 这次我们要学的是直线的生成算法。 ** 简单来说就是画一条从(x1, y1)到...像素逼近待画直线 直线的生成算法 步骤： 先要确定像素序列→确定像素点的坐标 我们先来看看最常见的方法： DDA算法(数字微...

...