精华内容
下载资源
问答
  • 该项目采用VS2019开发, 使用OpenGL 1.1库文件(<GL.H><GLAUX.H>)绘制, 采用包含直线段绘制的两种算法: 中点算法, 和 DDA算法. 分别采用两种算法描绘出4种不同斜率的直线, 外加一条单独处理的垂直x轴的直线. 有明确的...
  • 在 pycharm 加 pyqt5环境中开发,python实现 DDA算法 画直线。 有优美的 UI界面。
  • 3、编程实现利用DDA算法、中点算法和Bresenham算法生成直线,并显示。 同时要求:(1)实现可动态修改直线的起始点坐标和终点坐标 (2)实现可动态选择线的颜色和线宽。 4、编程实现利用1/8圆中点算法和Bresenham...
  • 生成直线的DDA算法

    2020-08-09 19:39:36
    数值微分法即DDA法(Digital Differential Analyzer),是一种基于直线的微分方程来生成直线的方法。
  • DDA算法实验报告

    2018-03-06 10:35:48
    DDA算法,是计算机图形学中一种基于直线的微分方程来生成直线的方法,由于有浮点数运算与取整,该算法不利于硬件实现。
  • 用WebGL绘制一条(0,0)到(10,6)的直线段的光栅化处理算法(DDA算法),压缩包内包含Html和JavaScript源代码,可以打开直接运行。
  • OpenGL之DDA算法

    2015-06-04 02:30:17
    关于直线的DDA算法,有k和k>1两部分
  • 计算机图形DDA算法

    2014-05-20 18:19:05
    计算机图形学DDA算法,也可称为中点画直线算法,图形学最基础的算法
  • 1. 通过实验,进一步理解直线段扫描转换的DDA算法、中点bresenham算法及bresenham算法的基本原理; 2. 掌握以上算法生成直线段的基本过程; 3. 通过编程,会在C/C++环境下完成用DDA算法、中点bresenham算法及...
  • DDA算法画直线

    2013-04-08 18:34:11
    数学上,理想的直线是由无数个点构成的集合,没有宽度。计算机绘制直线是在显示器所给定的有限个像素组成的矩阵中,确定最佳逼近该直线的一组像素,并且按扫描线顺序,对这些像素进行写操作,实现显示器绘制直线,即...
  • 基于OpenGL的DDA算法画直线段,用鼠标在窗口随机选择点并连成折线段,按ESC键即可退出该这线段并开始绘制下一条这线段
  • DDA算法OPENGL程序实现

    2012-09-25 08:38:00
    OPENGL程序实现DDA算法的代码,在GLUT下实现
  • 计算机图形学原理课,用C语言实现DDA算法画直线,实验操作,下载后直接用VC或者VC++打开工作空间即可。
  • 计算机图形学中的dda算法的实现,希望对大家有用
  • python实现DDA算法

    2020-10-29 09:14:14
    @python实现DDA算法 DDA 算法,即数值微分法(Digital Differential Analyzer),是一种基于直线的微分方程 线段的光栅化过程可以循环的让 方向变化一个像素或者让 方向变化一个像素,相应的另一个方向变化 个像素...

    @python实现DDA算法

    DDA 算法,即数值微分法(Digital Differential Analyzer),是一种基于直线的微分方程

    线段的光栅化过程可以循环的让 x方向变化一个像素或者让 y方向变化一个像素,相应的另一个方向变化0 个像素或者1 个像素得到。这样计算直线段上的每个像素的坐标只需执行一次浮点数加法即可。此外,为了使得生成的直线段尽量连续均匀,相邻两个像素之间 ,x或y 的坐标最多相差 1 个像素。

    生成直线的方法。
    先上源码:

    import matplotlib.pyplot as plt
    
    
    def DDALine(x1, y1, x2, y2, color):
        dx = x2 - x1
        dy = y2 - y1
        steps = 0
        # 斜率判断
        if abs(dx) > abs(dy):
            steps = abs(dx)
        else:
            steps = abs(dy)
        # 必有一个等于1,一个小于1
        delta_x = float(dx / steps)
        delta_y = float(dy / steps)
        # 四舍五入,保证x和y的增量小于等于1,让生成的直线尽量均匀
        x = x1 + 0.5
        y = y1 + 0.5
        for i in range(0, int(steps + 1)):
    		# 绘制像素点
            plt.plot(int(x), int(y), color)
            x += delta_x
            y += delta_y
        plt.show()
    
    
    def main():
        x = 0
        y = 0
        xEnd = 5
        yEnd = 2
        color = "r."
        DDALine(x, y, xEnd, yEnd, color)
    
    
    if __name__ == '__main__':
        main()
    
    

    效果展示:
    效果展示

    算法特点:
    DDA 算法中, 必须用浮点数表示,而且每一个像素的绘制都必须对 x 和 y 坐标进行舍入取整,这使得该算法不利于硬件实现。

    展开全文
  • dda算法 DDA(数字差分分析仪)算法 (DDA (Digital Differential Analyzer) Algorithm) In computer graphics, the DDA algorithm is the simplest algorithm among all other line generation algorithms. Here, the ...

    dda算法

    DDA(数字差分分析仪)算法 (DDA (Digital Differential Analyzer) Algorithm)

    In computer graphics, the DDA algorithm is the simplest algorithm among all other line generation algorithms. Here, the DDA is an abbreviation that stands for "Digital Differential Analyzer". It is an incremental method, i.e. it works by incrementing the source coordinate points according to the values of the slope generated.

    在计算机图形学中, DDA算法是所有其他线生成算法中最简单的算法。 在此, DDA“数字差分分析仪”的缩写。 这是一种增量方法,即,它根据生成的坡度值通过增加源坐标点来工作。

    Hence, we can define DDA as follows,

    因此,我们可以如下定义DDA,

    "DDA stands for Digital Differential Analyzer. This algorithm is incremental and is used for the rasterization of lines, triangles, and polygons."

    “ DDA代表数字差分分析仪。此算法是增量算法,用于线,三角形和多边形的栅格化。”

    DDA算法的工作 (Working of the DDA Algorithm)

    Suppose we have to draw a line PQ with coordinates P (x1, y1) and Q (x2, y2).

    假设我们必须绘制一条坐标为P(x1,y1)和Q(x2,y2)的直线PQ

    1. First, Calculate dx = (x2 - x1) and dy = (y2 - y1)

      首先,计算dx =(x2-x1)和dy =(y2-y1)

    2. Now calculate the slope m = (dy / dx)

      现在计算斜率m =(dy / dx)

    3. Calculate the number of points to be plotted (i.e. n) by finding the maximum of dx and dy, i.e. n = abs (max (dx , dy))

      通过找到dxdy的最大值来计算要绘制的点数(即n ),即n = abs(最大值(dx,dy))

      To draw an accurate line, more number of points are required. Therefore, the maximum of the two values is used here.

      要绘制一条精确的线,需要更多的点。 因此,此处使用两个值中的最大值。

    4. Now as the n is calculated, to know by how much each source point should be incremented, calculate xinc and yinc as follows: xinc = (dx / n) and yinc = (dy / n)

      现在,当计算n时,要知道每个源点应增加多少,请按以下方式计算x incy incx inc =(dx / n)和y inc =(dy / n)

    5. Now we draw the points from P to Q. The successive points are calculated as follows: (xnext, ynext) = (x + xinc, y + yinc)

      现在我们将点从P画到Q。 连续点的计算如下: (x next ,y next )=(x + x inc ,y + y inc )

      Start plotting the points from

      从开始绘制点

      P and stop when Q is reached. In case the incremented values are decimal, use the round off values.

      P并在达到Q时停止。 如果增量值为十进制,请使用四舍五入值。

    Now, let us have a look at the algorithm that is followed in DDA.

    现在,让我们看一下DDA中遵循的算法。

    DDA算法 (DDA Algorithm)

    • Step 1: Start.

      步骤1:开始。

    • Step 2: Declare x1, y1, x2, y2.

      步骤2:声明x1,y1,x2,y2。

    • Step 3: Calculate the following,

      步骤3:计算以下内容,

          dx = x2 - x1
          dy = y2 - y1
      
      
    • Step 4: Calculate slope as follows,

      步骤4:按以下方式计算斜率,

          m = dy / dx
      
      
    • Step 5: Calculate the no. of points (n) between x1 and x2 as follows,

      步骤5:计算编号。 x1和x2之间的点(n)如下,

          n = abs ( max ( dx , dy ) )
      
      
    • Step 6: Calculate xincand yinc as follows,

      步骤6:按以下方式计算x inc和y inc

          xinc = (dx / n) and yinc = (dy / n)
      
      
    • Step 7: Now, Initialize x = x1 and y = y1.

      步骤7:现在,初始化x = x1和y = y1。

    • Step 8:

      步骤8:

          while ( x <= x2 )
              x = x + xinc
              y = y + yinc
      
      
    • Step 9: Now, Plot (x,y) on the graph, and hence we get our required line between the given points.

      步骤9:现在,在图形上绘制(x,y),因此我们得到了给定点之间的所需线。

    • Step 10: End.

      步骤10:结束。

    Formula:

    式:

    In the entire DDA algorithm, there are three conditions and according to these conditions, the formula for calculating the coordinates is changed. These formulas are as follows,

    在整个DDA算法中 ,存在三个条件,并根据这些条件更改了计算坐标的公式。 这些公式如下:

        If m < 1 :      If m > 1 :          If m = 1 :
            xinc = 1        xinc = (1 / m)      xinc = 1
            yinc = m        yinc = 1            yinc = 1
    
    

    Example:

    例:

    Now let us take an example to understand the whole working of the DDA algorithm,

    现在让我们举一个例子来了解DDA算法的整个工作原理

    Question: Draw a line from A(2 , 2) to B(5 , 5) using the DDA algorithm.

    问题:使用DDA算法A(2,2)B(5,5 )画一条线。

    Solution:

    解:

        Given:
        x1 = 2 , y1 = 2
        x2 = 5 , y2 = 6 
    
        Calculating:    
        dx  = (x2 - x1) = (5 - 2) = 3
        dy  = (y2 - y1) = (6 - 2) = 4
        n   = abs (max (dx , dy ) ) = abs (max (3 , 4) ) = 4
    
        xinc = dx / n = 3/4 = 0.75
        yinc = dy / n = 4 / 4 = 1
    
    
    XYx = round(x + xinc)y = y + yinc
    222 + 0.75 = 2.75 = 32 + 1 = 3
    333 + 0.75 = 3.75 = 43 + 1 = 4
    444 + 0.75 = 4.75 = 54 + 1 = 5
    555 + 0.75 = 5.75 = 65 + 1 = 6
    X ÿ x =圆(x + x inc ) y = y + y inc
    2 2 2 + 0.75 = 2.75 = 3 2 +1 = 3
    3 3 3 + 0.75 = 3.75 = 4 3 +1 = 4
    4 4 4 + 0.75 = 4.75 = 5 4 +1 = 5
    5 5 5 + 0.75 = 5.75 = 6 5 +1 = 6

    Stop here as we have reached point B.

    当我们到达B点时,在此停止。

    Now, Plot the points ( (2 , 2) , (3 , 3) , (4 , 4) , (5 , 5) ) on the graph and thus we get our required line from point A to point B.

    现在,在图形上绘制点((2,2),(3、3),(4、4),(5、5)) ,这样我们就得到了从点A到点B所需的线。

    DDA算法的优点 (Advantages of the DDA algorithm)

    Now, we will be looking at the advantages that the DDA algorithm offers over other line drawing algorithms.

    现在,我们将探讨DDA算法相对于其他线条绘制算法的优势。

    1. It is the simplest line generation algorithm.

      它是最简单的线生成算法。

    2. Implementation of the DDA algorithm is very easy as compared to other line generation algorithms.

      与其他线路生成算法相比,DDA算法的实现非常容易。

    3. It does not use multiplication which reduces the time complexity of implementation.

      它不使用乘法来减少实现的时间复杂度。

    4. It is a faster and a better method than using the direct method of the line equation: i.e. y = mx + c

      与使用线性方程式的直接方法相比,这是一种更快,更好的方法:即y = mx + c

    DDA算法的缺点 (Disadvantages of the DDA algorithm)

    • DDA algorithm use floating-point arithmetic as it involves the use of division in the calculation of xinc and yinc. This floating-point arithmetic makes the algorithm time-consuming.

      DDA算法使用浮点算法,因为它涉及在x inc和y inc的计算中使用除法。 这种浮点算法使算法耗时。

    • The use of floating-point arithmetic decreases the accuracy of the generated points. Hence the points that we get are not accurate, i.e. they may not lie accurately on the line.

      使用浮点算法会降低生成点的准确性。 因此,我们得到的点是不准确的,即它们可能不准确地位于线上。

    • As the points that we get from the DDA algorithm are not accurate, the lines generated by this algorithm are not smooth, i.e. some discontinuation and zigzag nature can be commonly seen in the lines drawn through this algorithm.

      由于我们从DDA算法获得的点不准确,因此该算法生成的线条不平滑,即在通过该算法绘制的线条中通常可以看到一些不连续和之字形性质。

    翻译自: https://www.includehelp.com/computer-graphics/dda-digital-differential-analyzer-algorithm.aspx

    dda算法

    展开全文
  • dda算法Here you will learn aboutdda line drawing algorithm in C and C++. 在这里,您将了解C和C ++中的dda线条绘制算法。 In Computer Graphics the first basic line drawing algorithm is Digital ...

    dda算法

    Here you will learn about dda line drawing algorithm in C and C++.

    在这里,您将了解C和C ++中的dda线条绘制算法。

    In Computer Graphics the first basic line drawing algorithm is Digital Differential Analyzer (DDA) Algorithm.

    在计算机图形学中,第一个基本的线条绘制算法是数字差分分析器(DDA)算法。

    A line connects two points. It is a basic element in graphics. To draw a line, you need two points between which you can draw a line.

    一条线连接两个点。 它是图形中的基本元素。 要绘制一条线,您需要两个点之间可以绘制一条线。

    Also Read: Bresenham’s Line Drawing Algorithm in C and C++

    另请参阅: Bresenham的C和C ++线条画算法

    数字差分分析仪(DDA)算法 (Digital Differential Analyzer (DDA) Algorithm)

    Step 1: Read the input of the 2 end points of the line as (x1, y1) & (x2, y2) such that x1 != x2 and y1 != y2

    步骤1:将线的两个端点的输入读取为(x1,y1)&(x2,y2),以使x1!= x2和y1!= y2

    Step 2: Calculate dx = x2 – x1 and dy = y2 – y1

    步骤2:计算dx = x2 – x1和dy = y2 – y1

    Step 3:

    第三步:

    if(dx>=dy)

    如果(dx> = dy)

    step=dx

    步长= dx

    else

    其他

    step=dy

    步长= dy

    Step 4: xin = dx / step & yin = dy / step

    步骤4: xin = dx / step和yin = dy / step

    Step 5: x = x1 + 0.5 & y = y1 + 0.5

    步骤5: x = x1 + 0.5&y = y1 + 0.5

    Step 6: 

    步骤6:

    for(k = 0; k < step; k++)

    for(k = 0; k <步骤; k ++)

    {

    {

    x = x + xin

    x = x +鑫

    y = y + yin

    y = y + yin

    putpixel(x, y)

    putpixel(x,y)

    }

    }

    C语言中的DDA线图绘制算法程序 (Program for DDA Line Drawing Algorithm in C)

    #include <graphics.h>
    #include <stdio.h>
    #include <math.h>
    #include <dos.h>
     
    void main( )
    {
    	float x,y,x1,y1,x2,y2,dx,dy,step;
    	int i,gd=DETECT,gm;
     
    	initgraph(&gd,&gm,"c:\\turboc3\\bgi");
     
    	printf("Enter the value of x1 and y1 : ");
    	scanf("%f%f",&x1,&y1);
    	printf("Enter the value of x2 and y2: ");
    	scanf("%f%f",&x2,&y2);
     
    	dx=abs(x2-x1);
    	dy=abs(y2-y1);
     
    	if(dx>=dy)
    		step=dx;
    	else
    		step=dy;
     
    	dx=dx/step;
    	dy=dy/step;
     
    	x=x1;
    	y=y1;
     
    	i=1;
    	while(i<=step)
    	{
    		putpixel(x,y,5);
    		x=x+dx;
    		y=y+dy;
    		i=i+1;
    		delay(100);
    	}
     
    	closegraph();
    }

    Outptut

    输出

    DDA Line Drawing Algorithm in C and C++

    C ++中DDA线条绘制算法程序 (Program for DDA Line Drawing Algorithm in C++)

    #include <graphics.h>
    #include <iostream.h>
    #include <math.h>
    #include <dos.h>
     
    void main( )
    {
    	float x,y,x1,y1,x2,y2,dx,dy,step;
    	int i,gd=DETECT,gm;
     
    	initgraph(&gd,&gm,"c:\\turboc3\\bgi");
     
    	cout<<"Enter the value of x1 and y1 : ";
    	cin>>x1>>y1;
    	cout<<"Enter the value of x2 and y2: ";
    	cin>>x2>>y2;
     
    	dx=abs(x2-x1);
    	dy=abs(y2-y1);
     
    	if(dx>=dy)
    		step=dx;
    	else
    		step=dy;
     
    	dx=dx/step;
    	dy=dy/step;
     
    	x=x1;
    	y=y1;
     
    	i=1;
    	while(i<=step)
    	{
    		putpixel(x,y,5);
    		x=x+dx;
    		y=y+dy;
    		i=i+1;
    		delay(100);
    	}
     
    	closegraph();
    }

    Comment below if you have any doubts related above algorithm.

    如果您对以上算法有任何疑问,请在下面评论。

    翻译自: https://www.thecrazyprogrammer.com/2017/01/dda-line-drawing-algorithm-c-c.html

    dda算法

    展开全文
  • (运用DDA算法、中点Bresenam算法实现并比较算法精度与效率) ② 基本论述 DDA算法又称数值微分法,是计算机图形学中一种基于直线的微分方程来生成直线的方法。 原理就是最直观的根据斜率的偏移程度,决定是以x为...

    1、调用画点函数,实现任意斜率直线的绘制 (运用DDA算法、中点Bresenam算法实现并比较算法精度与效率)

    ② 基本论述
    DDA算法又称数值微分法,是计算机图形学中一种基于直线的微分方程来生成直线的方法。 原理就是最直观的根据斜率的偏移程度,决定是以x为步进方向还是以y为步进方向。然后在相应的步进方向上,每次增加一个像素,而另一个相关坐标变量则为Y k+1=Y k + m(以x为步进变量为例,m为斜率)
    假定直线斜率k在0~1之间,当前象素点为(xp,yp),则下一个象素点有两种可选择点P1(xp+1,yp)或P2(xp+1,yp+1)。若P1与P2的中点(xp+1,yp+0.5)称为M,Q为理想直线与x=xp+1垂线的交点。当M在Q的下方时,则取P2应为下一个象素点;当M在Q的上方时,则取P1为下一个象素点。这就是中点画线法的基本原理
    Bresenham算法:过各行、各列像素中心构造一组虚拟网格线,按直线从起点到终点的顺序计算直线各垂直网格线的交点,然后确定该列像素中与此交点最近的像素。该算法的优点在于可以采用增量计算,使得对于每一列,只要检查一个误差项的符号,就可以确定该列所求的像素。

    ②算法
    DDA算法描述:
    m =直线的斜率
    可通过计算由x方向的增量△x引起y的改变来生成直线:
    xi+1=xi+△x
    yi+1=yi+△y=yi+△x·m
    也可通过计算由y方向的增量△y引起x的改变来生成直线:
    yi+1=yi+△y
    xi+1=xi+△x=xi+△y/m
    以此类推。
    中点Bresenam算法描述:
    任意给定的两点所绘制的线段斜率k可能有四种情况,分别是:0<k<1,k>=1,-1<k<0,
    k<=-1。下面对这四种情况分别进行分析。

    (一)  当0<k<1时
       1.算法原理的推导
    (1)	构造中点误差项为:
    di=F(xM,yM)=F(xi + 1,yi + 0.5)=yi + 0.5 –k(xi + 1) -b
    (2)	中点误差的初始值是:
    d0=F(x0 + 1,y0 + 0.5)=y0 + 0.5 –k(x0 + 1) -b
    =y0 – kx0 – b – k +0.5
    其中,因为(x0,y0)在直线上,所以y0-kx0-b=0,则:d0=0.5-k
    (3)	推导di+1
    a.	当di>=0时;中点在直线上方,取下面的点(x i+1,yi)
    di+1 = F(xi+2,yi+0.5)
    =yi+0.5-k(xi+2)-b
    =di-k
    b.	当d<i0时;中点在直线下方,取下面的点(x i+1,yi+1)
    di+1 = F(xi+2,yi+1.5)
    =yi+1.5-k(xi+2)-b
    =di+1 - k
    
    (二)  当k>=1时
       1.算法原理的推导
    (1)	构造中点误差项
    di=F(xM,yM)=F(xi + 0.5,yi +1)=yi + 1 –k(xi + 0.5) -b
    (2)	中点误差的初始值
    d0=F(x0 + 0.5,y0 + 1)=y0 + 1 –k(x0 + 0.5) -b
    =y0 – kx0 – b –0.5k+1
    其中,因为(x0,y0)在直线上,所以y0-kx0-b=0,则:d0=1-0.5k
    ( 3 )  推导di+1
    a.当di>=0时;中点在直线左方,取右方的点(x i+1,yi+1)
    di+1 = F(xi+1.5,yi+2)
    =yi+2-k(xi+1.5)-b
    =di+1-k
    b.当d<i0时;中点在直线右方,取左方的点(x i+1,yi+1)
    di+1 = F(xi+0.5,yi+2)
    =yi+2-k(xi+0.5)-b
    =di+1 
    
    (三)当-1<k<0时
    1.算法原理的推导
    (1)	构造中点误差项
    di=F(xM,yM)=F(xi + 1,yi -0.5)=yi - 0.5 –k(xi + 1) -b
    (2)	中点误差的初始值
    d0=F(x0 + 1,y0 - 0.5)=y0 - 0.5 –k(x0 + 1) -b
    =y0 – kx0 – b – k -0.5
    其中,因为(x0,y0)在直线上,所以y0-kx0-b=0,则:d0=-0.5-k
    ( 3 )  推导di+1
    a.当di>=0时;中点在直线上方,取下方的点(x i+1,yi-1)
    di+1 = F(xi+2.,yi-1.5)
    =yi+1.5-k(xi+2)-b
    =di-1-k
    b.当di<0时;中点在直线下方,取下方的点(x i+1,yi)
    di+1 = F(xi+2.,yi-0.5)
    =yi-0.5-k(xi+2)-b
    =di-k
    
    (四)  当k<=-1时
       1.算法原理的推导
    (1)	构造中点误差项
    di=F(xM,yM)=F(xi + 0.5,yi -1)=yi - 1 –k(xi + 0.5) -b
    (2)	中点误差的初始值
    d0=F(x0 + 0.5,y0 - 1)=y0 - 1 –k(x0 + 0.5) -b
    =y0 – kx0 – b –0.5k-1
    其中,因为(x0,y0)在直线上,所以y0-kx0-b=0,则:d0=0.5-k
    ( 3 )  推导di+1
    a.当di>=0时;中点在直线右方,取左方的点(x i,yi-1)
    di+1 = F(xi+0.5,yi-2)
    =yi-2-k(xi+0.5)-b
    =di-1
    b.当d<i0时;中点在直线下方,取下方的点(x i+1,yi-1)
    di+1 = F(xi+1.5,yi-2)
    =yi-2-k(xi+1.5)-b
    =di-1-k
    
    
    

    ③ 程序源代码(是能直接运行的源代码)

    #include <conio.h>
    #include<stdio.h>	
    #include <string.h>
    #include <queue>
    #include <windows.h>
    #include<iostream>
    #include<graphics.h>  // 引用 EasyX 图形库
    #include<time.h>
    #include<math.h>
    #include<stdlib.h>
    using namespace std;
    
    
    //(DDA算法实现)
    void DDA_Line(int x1,int y1,int x2,int y2) {
    	float increx, increy, x, y, length;//定义变量
    	int i;
    	if (abs(x2 - x1) > abs(y2 - y1))//判断以哪个可以作为增量
    		length = abs(x2 - x1);
    	else
    		length = abs(y2 - y1);
    	increx = (x2 - x1) / length;//设置增量,分别为1和k
    	increy = (y2 - y1) / length;
    	x = x1, y = y1;//这是起点
    	for (i = 1; i <= length; i++) {
    		putpixel(int(x + 0.5), int(y + 0.5), RED);//强制转换为整型(因为像素点都是整个整个的)
    		x += increx;// x加增量
    		y += increy;// y加增量
    	}
    }
    
    
    //(中点Bresenam算法实现)
    void Bresenham_line(int x0,int y0,int x1,int y1)
    {
     int x,y,dx,dy;
     float k,e;  //定义变量
     dx=x1-x0;
     dy=y1-y0;
     k=dy/dx;//这是完成k值的初始化
     e=-0.5;
     x=x0;
     y=y0;  
    
     for(int i=0;i<=dx;i++)//i每次加一个,直到终点,y选择性加一或者不加
     {
    putpixel(x,y,BLUE); //画像素点
     x=x+1;
     e=e+k;
     if(e>=0)  //这里e大于零就减一
     {
     y=y+1;
     e=e-1;
     }
     }
    }
    
    void main()  //主函数测试调用算法
    {
     int x0,y0,x1,y1;
    
     initgraph(640, 480); // 定义640 x 480的画面
     setbkcolor(GREEN);  //背景
     cleardevice();
     setcolor(BLACK);
    
     DDA_Line(100, 100, 640, 480);
     Bresenham_line(100, 100, 640, 480);  
    
    
     getch();    // 按任意键继续
     closegraph();   // 关闭图形界面
    }
    

    关于二者效率和精度的研究:
    bresenham算法的特点是:
    1,不必计算直线之斜率,因此不做除法;
    2,不用浮点数,只用整数;
    3,只做整数加减法和乘2运算,而乘2运算可以用硬件移位实现.
    DDA算法的特点:
    浮点数运算
    不易硬件实现
    所以:Bresenham算法相比较于dda算法,速度很快,但是精度没有dda高,适于用硬件实现.

    3、圆或椭圆的绘制

    ①基本论述

    中点画圆法,考虑圆心在原点,半径为R的圆在第一象限内的八分之一圆弧,从点(0, R)到点(R, R )顺时针方向确定这段圆弧。

    ②算法
    假定某点Pi(xi, yi)已经是该圆弧上最接近实际圆弧的点,那么Pi的下一个点只可能是正右方的P1或右下方的P2两者之一
    构造判别函数:
    F(x, y)= x2 + y2 – R2

    当F(x, y)= 0,表示点在圆上,当F(x, y)> 0,表示点在圆外,当F(x, y)< 0,表示点在圆内。如果M是P1和P2的中点,则M的坐标是(xi + 1, yi – 0.5),当F(xi + 1, yi – 0.5)< 0时,M点在圆内,说明P1点离实际圆弧更近,应该取P1作为圆的下一个点。同理分析,当F(xi + 1, yi – 0.5)> 0时,P2离实际圆弧更近,应取P2作为下一个点。当F(xi + 1, yi – 0.5)= 0时,P1和P2都可以作为圆的下一个点,算法约定取P2作为下一个点。

    现在将M点坐标(xi + 1, yi – 0.5)带入判别函数F(x, y),得到判别式d:
    d = F(xi + 1, yi – 0.5)= (xi + 1)2 + (yi –0.5)2 – R2
    若d < 0,则取P1为下一个点,此时P1的下一个点的判别式为:
    d’ = F(xi + 2, yi – 0.5)= (xi + 2)2 + (yi –0.5)2 – R2

    展开后将d带入可得到的递推关系:
    d’ = d + 2xi + 3
    若d > 0,则取P2为下一个点,此时P2的下一个点的判别式为:
    d’ = F(xi + 2, yi – 1.5)= (xi + 2)2 + (yi –1.5)2 – R

    展开后将d带入可得到判别式的递推关系:
    d’ = d + 2(xi - yi) + 5
    特别的,在第一个象限的第一个点(0, R)时,可以推倒出判别式d的初始值d0:
    d0 = F(1, R – 0.5) = 1 – (R – 0.5)2 –R2 = 1.25 - R

    ③程序源代码(是能直接运行的源代码)
    //圆的绘制
    #include<stdio.h>
    #include<graphics.h>  // 引用 EasyX 图形库
    #include<conio.h>
    #define x0 400
    #define y0 400     //坐标轴中心(x0,y0)
    void draw_circle(int x1, int y1, int r) //定义中点画圆方法
    {
    	int d0, x = 0, y = r;//d0为判别式的值
    	d0 = 1.25 - r;   //判别式的初始值,1.25可以改为1(方便计算)
    	while (x < y)   //
    	{
    		if (d0 >= 0) 
    		{
    			d0 = d0 + 2 * (x - y) + 5;  //这是d<0时,判别式的递推关系
    			x += 1;                //因为x,y是上一个点,所以要更新坐标
    			y -= 1;
    			//这里体现八段画法:
    			putpixel(((x + x1) + x0), (y0 - (y + y1)), RED);         //像素点(x,y)着色
    			putpixel(((-x + x1) + x0), (y0 - (y + y1)), RED);        //像素点(-x,y)着色
    			putpixel(((y + x1) + x0), (y0 - (x + y1)), RED);         //像素点(y,x)着色
    			putpixel(((-y + x1) + x0), (y0 - (x + y1)), RED);        //像素点(-y,x)着色
    			putpixel(((x + x1) + x0), (y0 - (-y + y1)), RED);        //像素点(x,-y)着色
    			putpixel(((-x + x1) + x0), (y0 - (-y + y1)), RED);       //像素点(-x,-y)着色
    			putpixel(((y + x1) + x0), (y0 - (-x + y1)), RED);        //像素点(y,-y)着色
    			putpixel(((-y + x1) + x0), (y0 - (-x + y1)), RED);       //像素点(-y,-x)着色
    			Sleep(50);  //休眠函数,作用是延时
    		}
    		else 
    		{ 
    			d0 = d0 + 2 * x + 3;  //这是d》0时,判别式的递推关系
    			x += 1;
    			y = y;    //更新坐标点
    			putpixel(((x + x1) + x0), (y0 - (y + y1)), RED);         //像素点(x,y)
    			putpixel(((-x + x1) + x0), (y0 - (y + y1)), RED);        //像素点(-x,y)
    			putpixel(((y + x1) + x0), (y0 - (x + y1)), RED);         //像素点(y,x)
    			putpixel(((-y + x1) + x0), (y0 - (x + y1)), RED);        //像素点(-y,x)
    			putpixel(((x + x1) + x0), (y0 - (-y + y1)), RED);        //像素点(x,-y)
    			putpixel(((-x + x1) + x0), (y0 - (-y + y1)), RED);       //像素点(-x,-y)
    			putpixel(((y + x1) + x0), (y0 - (-x + y1)), RED);        //像素点(y,-y)
    			putpixel(((-y + x1) + x0), (y0 - (-x + y1)), RED);       //像素点(-y,-x)
    			Sleep(50);
    		}
    	}
    }
    void main() 
    {
    	int x1, y1, r;
    	printf("输入圆心坐标(x1,y1)和圆的半径r:\n");  //用户可以通过圆心坐标和圆的半径来定义圆的形状
    	scanf("%d %d %d", &x1, &y1, &r);    //输入算法
    	initgraph(x0 * 2, y0 * 2);		    //这是在初始化图形窗口大小
    	setbkcolor(GREEN);    //背景为绿色
    	cleardevice();   这里插入图片描述](https://img-blog.csdnimg.cn/20200730202245196.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RvbWF0b2FhYWE=,size_16,color_FFFFFF,t_70)
    
    	setcolor(BLUE);    //坐标轴为蓝色
    	line(x0, 0, x0, y0 * 2);			//这是描绘坐标轴X
    	line(0, y0, x0 * 2, y0);			 //这是描绘坐标轴Y
    	draw_circle(x1, y1, r);             //中点画圆算法调用
    	_getch();                                        //等待一个任意输入结束
    	closegraph();                                    //关闭图形窗口
    	}
    

    ② 程序运行截图(提交你的测试数据及运行结果)

    在这里插入图片描述

    加油加油!

    展开全文
  • DDA(Digital Differential Analyzer):数字积分法   计算机中,直线并不是连续的,二是离散的点,这是光珊化的本质决定的。   两点确定一条直线,假设如果给出了起点和终点分别是(x1,y1),(x2,y2),假设这条...
  • Python matplotlib 实现DDA算法 DDA算法全称数值微分法(Digital Differential Analyzer),是用数值方法解微分方程,即通过对x和y各增加一个小量,计算下一步的x、y值。实际上,应该令一个值增加1个单位,同时保证另...
  • DDA算法

    2021-03-17 23:40:16
    //调用DDA算法画线 LineDDA(0, 0, 200, 300); glBegin(GL_LINES); glColor3f(1.0f, 0.0f, 0.0f); glVertex2f(100.0, 0.0); glColor3f(0.0, 1.0, 0.0); glVertex2f(180.0, 240.0); glEnd(); glFlush(); } void Init...
  • 常用的DDA算法画直线

    2011-05-24 11:03:02
    dda算法画直线,在斜率大于0小于1的时候采用的DDA算法
  • opengl dda算法

    2020-12-01 16:32:51
    opengl dda 算法计算机图形学作业之一opengl dda 算法计算机图形学作业之一opengl dda 算法计算机图形学作业之一opengl dda 算法计算机图形学作业之一opengl dda 算法计算机图形学作业之一opengl dda 算法计算机图形...
  • C#完成DDA算法的实现

    2011-05-25 20:19:07
    使用C#完成图形学经典DDA算法DDA算法就是中值微分算法,
  • 易语言dda算法源码

    2020-08-21 00:24:50
    易语言dda算法源码系统结构:子程序1,aaa,dda,ddaa,SwapInt,ddaaa, ======窗口程序集1 || ||------_按钮1_被单击 || ||------子程序1 || ||------aaa || ||------dda || ||------ddaa || ||------SwapInt || ||------...
  • DDA算法画直线+源代码

    2021-03-31 19:13:22
    DDA算法画直线+源代码 DDA算法画直线+源代码 文章目录DDA算法画直线+源代码一、DDA算法二、斜率为0时的直线扫描1.垂直直线2.水平直线三、斜率小于1时的直线扫描四、斜率大于1的直线扫描总结 一、DDA算法 算法原理...
  • 图形学-DDA算法

    千次阅读 2020-07-14 23:22:00
    图形学-DDA算法数值微分法代码 对于光栅扫描显示器等数字设备来说,图形的输出是将输出平面,如光栅扫描显示屏幕,看做像素的矩阵,在该矩阵上确定一个像素的集合来逼近该图形,如下图。 逼近过程的本质可以认为是...
  • DDA算法中点bresenham算法及bresenham算法实现任意给定两点的直线段的绘制(直线宽度和线型可自定)。
  • DDA算法画直线----计算机图形学

    千次阅读 2019-10-08 09:54:32
    生成直线的DDA算法: 假设待扫描转换的直线段为 Pb(xb, yb), Pe(xe, ye),如图所示: 令,斜率,则直线方程为 为方便起见,这里假定。显然,对于每一个 xi的取值(x的变化规律是每次递增1),都有唯一的 yi...
  • DDA算法和Bresenham算法

    千次阅读 2018-11-04 21:57:47
    DDA算法主要是根据直线公式y = kx + b来推导出来的,其关键之处在于如何设定单位步进,即一个方向的步进为单位步进,另一个方向的步进必然是小于1。算法的具体思路如下: 1. 输入直线的起点、终点; 2. 计算x方向...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,660
精华内容 1,464
关键字:

dda算法