计算机图形学

最新推荐文章于 2023-03-16 03:00:14 发布
最新推荐文章于 2023-03-16 03:00:14 发布
阅读量202 收藏 1
点赞数
文章标签： 算法 c语言 图形学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/vmwarekali1/article/details/108901068
版权

计算机图形学

DDA和Bresenham直线绘制算法：
两种算法都是基于光栅显示原理，即在光栅显示平面上，我们只能用二维光栅网格上尽可能靠近这条直线的像素集合来表示它。每个像素具有一定的尺寸，是显示平面上可被访问的最小单位，它的坐标x和y只能是整数，也就是说相邻像素的坐标值是阶跃的而不是连续的。
1.DDA算法
原理：
假设直线段的宽度为1，直线段的斜率：|k|<=1
已知过端点(x0,y0)，(x1,y1)的直线段L：y=kx+b
直线斜率为：k=(y1-y0)/(x1-x0)
直线横坐标增量为1
直线纵坐标增量表示：y(i+1)=yi+k
即：当|k|<=1时，x每递增1，y递增k，当|k|>1时，y每递增1，x递增1/k。
DDA算法特点：算法简单易实现，但运算需用浮点数表示，每一步都需要进行四舍五入，不利于硬件实现。
核心代码：

void DDA() {
    //DDA直线画线算法
    line(x1, y1, x2, y2, RGB(0, 255, 0));
    double dx = x2 - x1, dy = y2 - y1;
    double k = dy / dx, k1 = dx / dy;
    if (k >= -1 && k <= 1) {
        double y = y1 / 10;
        if (x1 <= x2) {
            int x = x1;
            while (x <= x2) {
                line(x - 2, ((int)(y + 0.5)) * 10 - 2, x + 2, ((int)(y + 0.5)) * 10 - 2, RGB(255, 0, 0));
                line(x - 2, ((int)(y + 0.5)) * 10 - 2, x - 2, ((int)(y + 0.5)) * 10 + 2, RGB(255, 0, 0));
                line(x - 2, ((int)(y + 0.5)) * 10 + 2, x + 2, ((int)(y + 0.5)) * 10 + 2, RGB(255, 0, 0));
                line(x + 2, ((int)(y + 0.5)) * 10 - 2, x + 2, ((int)(y + 0.5)) * 10 + 2, RGB(255, 0, 0));
                x += 10;
                y += k;
                nanosleep((const struct timespec[]) { {0, 100000000L} }, NULL);
            }
        }
        else {
            int x = x1;
            while (x >= x2) {
                line(x - 2, ((int)(y + 0.5)) * 10 - 2, x + 2, ((int)(y + 0.5)) * 10 - 2, RGB(255, 0, 0));
                line(x - 2, ((int)(y + 0.5)) * 10 - 2, x - 2, ((int)(y + 0.5)) * 10 + 2, RGB(255, 0, 0));
                line(x - 2, ((int)(y + 0.5)) * 10 + 2, x + 2, ((int)(y + 0.5)) * 10 + 2, RGB(255, 0, 0));
                line(x + 2, ((int)(y + 0.5)) * 10 - 2, x + 2, ((int)(y + 0.5)) * 10 + 2, RGB(255, 0, 0));
                x -= 10;
                y -= k;
                nanosleep((const struct timespec[]) { {0, 100000000L} }, NULL);
            }
        }
    }
    if (k > 1 || k < -1) {
        double x = x1 / 10;
        if (y1 < y2) {
            int y = y1;
            while (y <= y2) {
                line(((int)(x + 0.5)) * 10 - 2, y - 2, ((int)(x + 0.5)) * 10 + 2, y - 2, RGB(255, 0, 0));
                line(((int)(x + 0.5)) * 10 - 2, y - 2, ((int)(x + 0.5)) * 10 - 2, y + 2, RGB(255, 0, 0));
                line(((int)(x + 0.5)) * 10 - 2, y + 2, ((int)(x + 0.5)) * 10 + 2, y + 2, RGB(255, 0, 0));
                line(((int)(x + 0.5)) * 10 + 2, y - 2, ((int)(x + 0.5)) * 10 + 2, y + 2, RGB(255, 0, 0));
                y += 10;
                x += k1;
                nanosleep((const struct timespec[]) { {0, 100000000L} }, NULL);
            }
        }
        else {
            int y = y1;
            while (y >= y2) {
                line(((int)(x + 0.5)) * 10 - 2, y - 2, ((int)(x + 0.5)) * 10 + 2, y - 2, RGB(255, 0, 0));
                line(((int)(x + 0.5)) * 10 - 2, y - 2, ((int)(x + 0.5)) * 10 - 2, y + 2, RGB(255, 0, 0));
                line(((int)(x + 0.5)) * 10 - 2, y + 2, ((int)(x + 0.5)) * 10 + 2, y + 2, RGB(255, 0, 0));
                line(((int)(x + 0.5)) * 10 + 2, y - 2, ((int)(x + 0.5)) * 10 + 2, y + 2, RGB(255, 0, 0));
                y -= 10;
                x -= k1;
                nanosleep((const struct timespec[]) { {0, 100000000L} }, NULL);
            }
        }
    }
}

注：此代码需在QEMU环境下运行，如若不是则需包含相应头文件
运行结果如下：
在这里插入图片描述

2.Bresenham算法（改进后）
原理：
在这里插入图片描述

Bresenham算法采用截距d的增量计算，在横坐标增加1的情况下，纵坐标y的增量可能为0或者1。
设直线方程为：y(i+1)=yi+k(x(i+1)-xi)=yi+k,因为直线起始点斜率为k，所以d=d+k，当d>=1,将d–，这样d就落在0和1之间。
然后判断d与0.5大小，当d>=0.5时，最接近当前像素右上方像素(xi+1,yi+1)
当d<0.5时，更接近右下方像素(xi+1,yi)

在这里插入图片描述
为方便计算令e=d-0.5，增量为k
由于上述方法也会进行浮点数运算，因此改进后的Bresenham算法将e乘上2dx，即e’=2e*dx，以下代码也是遵循改进后的Bresenham算法编码。

核心代码：

void Bresenham() {
    //Bresenham直线画线算法
    line(x1, y1, x2, y2, RGB(0, 255, 0));
    double dx = x2 - x1, dy = y2 - y1;
    if (dx != 0) {
        double k = dy / dx;
        if (k >= 0 && k <= 1) {
            if (x1 < x2) {
                int x = x1;
                int y = y1;
                double e = -dx;
                for (int i = 0; i <= dx; i = i + 10) {
                    line(x - 2, y - 2, x + 2, y - 2, RGB(255, 0, 0));
                    line(x - 2, y - 2, x - 2, y + 2, RGB(255, 0, 0));
                    line(x - 2, y + 2, x + 2, y + 2, RGB(255, 0, 0));
                    line(x + 2, y - 2, x + 2, y + 2, RGB(255, 0, 0));
                    x += 10;
                    e = e + 2 * dy;
                    if (e >= 0) {
                        y += 10;
                        e = e - 2 * dx;
                    }
                    nanosleep((const struct timespec[]) { {0, 100000000L} }, NULL);
                }
            }
            else {
                int x = x1;
                int y = y1;
                double e = dx;
                for (int i = 0; i <= (-dx); i = i + 10) {
                    line(x - 2, y - 2, x + 2, y - 2, RGB(255, 0, 0));
                    line(x - 2, y - 2, x - 2, y + 2, RGB(255, 0, 0));
                    line(x - 2, y + 2, x + 2, y + 2, RGB(255, 0, 0));
                    line(x + 2, y - 2, x + 2, y + 2, RGB(255, 0, 0));
                    x -= 10;
                    e = e - 2 * dy;
                    if (e >= 0) {
                        y -= 10;
                        e = e + 2 * dx;
                    }
                    nanosleep((const struct timespec[]) { {0, 100000000L} }, NULL);
                }
            }
        }
        if (k >= -1 && k < 0) {
            if (x1 < x2) {
                int x = x1;
                int y = y1;
                double e = -dx;
                for (int i = 0; i <= dx; i = i + 10) {
                    line(x - 2, y - 2, x + 2, y - 2, RGB(255, 0, 0));
                    line(x - 2, y - 2, x - 2, y + 2, RGB(255, 0, 0));
                    line(x - 2, y + 2, x + 2, y + 2, RGB(255, 0, 0));
                    line(x + 2, y - 2, x + 2, y + 2, RGB(255, 0, 0));
                    x += 10;
                    e = e + 2 * (-dy);
                    if (e >= 0) {
                        y -= 10;
                        e = e - 2 * dx;
                    }
                    nanosleep((const struct timespec[]) { {0, 100000000L} }, NULL);
                }
            }
            if (x1 > x2) {
                int x = x1;
                int y = y1;
                double e = dx;
                for (int i = 0; i <= -dx; i = i + 10) {
                    line(x - 2, y - 2, x + 2, y - 2, RGB(255, 0, 0));
                    line(x - 2, y - 2, x - 2, y + 2, RGB(255, 0, 0));
                    line(x - 2, y + 2, x + 2, y + 2, RGB(255, 0, 0));
                    line(x + 2, y - 2, x + 2, y + 2, RGB(255, 0, 0));
                    x -= 10;
                    e = e + 2 * dy;
                    if (e >= 0) {
                        y += 10;
                        e = e - 2 * (-dx);
                    }
                    nanosleep((const struct timespec[]) { {0, 100000000L} }, NULL);
                }
            }
        }
        if (k > 1) {
            if (x1 < x2) {
                int x = x1;
                int y = y1;
                double e = -dy;
                for (int i = 0; i <= dy; i = i + 10) {
                    line(x - 2, y - 2, x + 2, y - 2, RGB(255, 0, 0));
                    line(x - 2, y - 2, x - 2, y + 2, RGB(255, 0, 0));
                    line(x - 2, y + 2, x + 2, y + 2, RGB(255, 0, 0));
                    line(x + 2, y - 2, x + 2, y + 2, RGB(255, 0, 0));
                    y += 10;
                    e = e + 2 * dx;
                    if (e >= 0) {
                        x += 10;
                        e = e - 2 * dy;
                    }
                    nanosleep((const struct timespec[]) { {0, 100000000L} }, NULL);
                }
            }
            else {
                int x = x1;
                int y = y1;
                double e = dy;
                for (int i = 0; i <= (-dy); i = i + 10) {
                    line(x - 2, y - 2, x + 2, y - 2, RGB(255, 0, 0));
                    line(x - 2, y - 2, x - 2, y + 2, RGB(255, 0, 0));
                    line(x - 2, y + 2, x + 2, y + 2, RGB(255, 0, 0));
                    line(x + 2, y - 2, x + 2, y + 2, RGB(255, 0, 0));
                    y += 10;
                    e = e + 2 * (-dx);
                    if (e >= 0) {
                        x -= 10;
                        e = e - 2 * (-dy);
                    }
                    nanosleep((const struct timespec[]) { {0, 100000000L} }, NULL);
                }
            }
        }
        if (k <= -1) {
            if (x1 < x2) {
                int x = x1;
                int y = y1;
                double e = dy;
                for (int i = 0; i <= (-dy); i = i + 10) {
                    line(x - 2, y - 2, x + 2, y - 2, RGB(255, 0, 0));
                    line(x - 2, y - 2, x - 2, y + 2, RGB(255, 0, 0));
                    line(x - 2, y + 2, x + 2, y + 2, RGB(255, 0, 0));
                    line(x + 2, y - 2, x + 2, y + 2, RGB(255, 0, 0));
                    y -= 10;
                    e = e + 2 * dx;
                    if (e >= 0) {
                        x += 10;
                        e = e - 2 * (-dy);
                    }
                    nanosleep((const struct timespec[]) { {0, 100000000L} }, NULL);
                }
            }
            else {
                int x = x1;
                int y = y1;
                double e = -dy;
                for (int i = 0; i <= dy; i = i + 10) {
                    line(x - 2, y - 2, x + 2, y - 2, RGB(255, 0, 0));
                    line(x - 2, y - 2, x - 2, y + 2, RGB(255, 0, 0));
                    line(x - 2, y + 2, x + 2, y + 2, RGB(255, 0, 0));
                    line(x + 2, y - 2, x + 2, y + 2, RGB(255, 0, 0));
                    y += 10;
                    e = e + 2 * (-dx);
                    if (e >= 0) {
                        x -= 10;
                        e = e - 2 * dy;
                    }
                    nanosleep((const struct timespec[]) { {0, 100000000L} }, NULL);
                }
            }
        }
    }
    else {
        if (y1 < y2) {
            int x = x1, y = y1;
            for (int i = 0; i <= dy; i = i + 10) {
                line(x - 2, y - 2, x + 2, y - 2, RGB(255, 0, 0));
                line(x - 2, y - 2, x - 2, y + 2, RGB(255, 0, 0));
                line(x - 2, y + 2, x + 2, y + 2, RGB(255, 0, 0));
                line(x + 2, y - 2, x + 2, y + 2, RGB(255, 0, 0));
                y += 10;
                nanosleep((const struct timespec[]) { {0, 100000000L} }, NULL);
            }
        }
        else {
            int x = x1, y = y1;
            for (int i = 0; i <= (-dy); i = i + 10) {
                line(x - 2, y - 2, x + 2, y - 2, RGB(255, 0, 0));
                line(x - 2, y - 2, x - 2, y + 2, RGB(255, 0, 0));
                line(x - 2, y + 2, x + 2, y + 2, RGB(255, 0, 0));
                line(x + 2, y - 2, x + 2, y + 2, RGB(255, 0, 0));
                y -= 10;
                nanosleep((const struct timespec[]) { {0, 100000000L} }, NULL);
            }
        }
    }
}

注：此代码同DDA算法编译环境
运行结果如下：
在这里插入图片描述
作为一名小菜鸡，这是本人第一篇博客（比较粗劣），希望自己的一点小见解能给大家带来一点想法，另外有不足的地方还望大家提出和包涵。

vmwarekali1
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
计算机图形学 dda,计算机图形DDA算法
weixin_33717595的博客
07-26 4072
本文概述DDA代表数字差分分析仪。它是行扫描转换的增量方法。在这种方法中, 计算是在每个步骤中执行的, 但要使用先前步骤的结果。假设在步骤i, 像素为(xi, yi)步骤i的方程式yi = mxi + b ………………….方程1Next value will be yi+1=mxi+1+b……………..equation 2 m = yi+1-yi=∆y…………………..equation 3 yi+...
计算机图形学DDA算法
01-28
是计算机图形学中的DDA画线算法，其实很简单，大家看看吧！
计算机图形学（二）输出图元_3_画线算法_2_DDA算法
heyuchang666的专栏
04-15 5348
数字微分分析仪(digital differential analyzer, DDA)方法是一种线段扫描转换算法，基于使用等式(3.4)或等式(3.5)计算的&x或&y。在一个坐标轴上以单位间隔对线段取样，从而确定另一个坐标轴上最靠近线路径的对应整数值。首先考虑如图3.6所示的具有正斜率的线段。例如，如果斜率小于等于1，则以单位x间隔(&x = 1）取样，并逐个计算每一个y值:下标k取整数值，从第一个点1开始递增直至最后端点。由于m可以是0与1之间的任意实数，所以计算出的y值必须取整。对于具有大于l的正斜率
计算机图形学——DDA算法
qq_44061866的博客
05-29 434
仅适用于|k|<=1,因为若|k|>1,中间画的点会太稀疏 #include<iostream> #include<Graphics.h> #include <conio.h> using namespace std; int main() { float x0 = 0, y0 = 0; float x1 = 480, y1 = 480; //画一个从(x0,y0)->(x2,y1)的直线 float k = (x1 - x0) / (y1 -
计算机图形学DDA算法.pdf
10-10
计算机图形学DDA算法.pdf
计算机图形学.pdf
12-22
计算机图形学 计算机图形学是一门研究如何使用数字计算机生成、处理和显示图形的学科，是计算机科学中最为活跃、得到广泛应用的一门分支。计算机图形学的主要研究内容包括图形硬件、图形标准、图形交互技术、光栅...
计算机图形学源码MFC实现
02-11
计算机图形学是一门深入研究如何在计算机中表示和处理图形的学科，它广泛应用于游戏开发、虚拟现实、图像处理、科学可视化等领域。本资源“计算机图形学源码MFC实现”是基于C++编程语言，利用Microsoft Foundation ...
计算机图形学-基于3D图形开发技术
12-12
计算机图形学-基于3D图形开发技术 本文档总结了计算机图形学的基本概念和技术，涵盖了三维图形开发的基础知识。下面是本文档的知识点摘要： 第一章 游戏模型在右手系中 * 三角形的顶点顺序是CCW逆时针排列方式 * ...
计算机图形学复习材料.pdf
最新发布
05-21
计算机图形学复习材料.pdf 本资源摘要信息将从计算机图形学的概述、图形分类、图形与图像的关系、计算机图形学应用领域、OpenGL 简介、光栅扫描的显示系统、帧缓冲存储器、计算机图形系统概述等方面进行详细的知识...
计算机图形学DDA画线算法
11-11
这是自己编写的一个计算机图形学的DDA算法的一个vs2005的一个程序，希望能对大家有所帮助，也希望大家有什么问题，欢迎来讨论
计算机图形学 直线DDA算法
12-03
计算机图形学 直线DDA算法计算机图形学 直线DDA算法计算机图形学 直线DDA算法计算机图形学 直线DDA算法计算机图形学 直线DDA算法计算机图形学 直线DDA算法计算机图形学 直线DDA算法计算机图形学 直线DDA算法计算机图形学 直线DDA算法计算机图形学 直线DDA算法计算机图形学 直线DDA算法计算机图形学 直线DDA算法计算机图形学 直线DDA算法计算机图形学 直线DDA算法计算机图形学 直线DDA算法计算机图形学 直线DDA算法计算机图形学 直线DDA算法计算机图形学 直线DDA算法计算机图形学 直线DDA算法计算机图形学 直线DDA算法
计算机图形学中的dda算法的实现
05-24
计算机图形学中的dda算法的实现，希望对大家有用
计算机图形学 DDA算法画直线
03-28
DDA称为数值微分画线算法，是直线生成算法中最简单的一种。原理相当简单，就是最直观的根据斜率的偏移程度，决定是以x为步进方向还是以y为步进方向。然后在相应的步进方向上，步进变量每次增加一个像素，而另一个相关坐标变量则为Yk_1=Yk+m
DDA直线算法(计算机图形学）
12-10
计算机图形学DDA直线算法实现代码，采取JavaScript、HTML实现，文件是一个DDA直线算法.html，可以直接点击运行，也可以通过查看其源代码
计算机图形学01：直线生成算法(DDA算法)
你的问题在于，读书太少而想得太多。
02-04 4147
计算机图形学之直线生成算法(DDA算法)——附原理及详细代码
计算机图形学DDA
gygygyyyyyy的博客
06-25 1228
计算机图形学DDA DDA算法是一个经典的画直线算法，也是直线生成算法中最简单的一种。它的原理比较简单，是一种数值微分的方法，这也是本系统中第一个接触增量思想的算法。它是利用直线最基本的格式，斜截式：y=kx+b来实现的。我们都知道在计算机中乘法的运算效率远低于加法，而DDA算法就是将效率低下的乘法计算改成了效率相对高的加法运算。首先需要计算出斜率k=（y1-y0）/（x1-x0）(x1!=x2) 每一次x移动一个像素，y值就像相应的增加k。但像素值都是整数，而所求出的k不一定都是整数，所以要对求出的下一个
计算机图形学学习(一) DDA算法讲解及matlab实现
Late_whale的博客 作者：代码搬运工老李的二师兄
03-02 4316
文章目录DDA算法matlab小知识matlab实现 DDA算法 我们都知道两点确定一条直线，所以假设(x1,y1),(x2,y2)为需要生成直线的两点， 分别求出x方向上的增量和y方向上的增量，记做dx和dy，即dx=x2-x1,dy=y2-y1 同时我们还知道直线的斜率k=(y2-y1)/(x2-x1),即k=dy/dx 我们可以发现得到dx、dy、k 之后直线上每一点的坐标都...
【计算机图形学|直线生成算法】DDA算法详解
爱喝冰红茶的方舟的博客
03-16 1312
计算机图形学DDA算法个人见解
计算机图形学基础概览
"本章内容-计算机图形学ppt1" 计算机图形学是一门涉及广泛领域的学科，它在现代社会中扮演着至关重要的角色。这门学科的主要目标是利用计算机来生成、处理和显示图像，从而实现视觉表现力和交互性的增强。计算机...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值