精华内容
下载资源
问答
  • 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画直线实验报告

    2021-07-28 10:22:35
    dda画直线实验报告 (5页) 本资源提供全文预览,点击全文预览即可全文预览,如果喜欢文档就下载吧,查找使用更方便哦!9.9 积分本科实验报告实验名称: DDA直线画法 课程名称: 计算机图形学 院 系: 传媒学院 年级...

    a7f4a3f590493a1e451dd952a488fd7c.gif dda画直线实验报告

    (5页)

    a3ceddb002119d891838de725798740b.gif

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

    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

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

    展开全文
  • 流程,具体见算法。求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画线算法

    2017-05-24 21:24:02
    该算法为DDA画线算法,使用MATLAB语言
  • DDA算法画直线

    2013-04-08 18:34:11
    计算机绘制直线是在显示器所给定的有限个像素组成的矩阵中,确定最佳逼近该直线的一组像素,并且按扫描线顺序,对这些像素进行写操作,实现显示器绘制直线,即通常所说的直线的扫描转换,或称直线光栅化。
  • DDA画直线代码

    2011-12-19 21:56:01
    DDA算法画直线算法,程序能够运行,验证运行通过,放心下载
  • 使用DDA画直线

    2013-06-12 20:43:24
    通过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); //设置矩阵模式为模型变换模式,表示在世界坐标系下
        glLoadIdentity();   //将当前矩阵设置为单位矩阵

        if (flag == 1)  //画圆
            Bresenham_Circle_Algorithm(cx, cy, radius);
        if (flag == 2)  //画多边形
            NSidedPolygon(n, cx, cy, radius);
        if (flag == 3)  //画胖圆
            SampleCircle(ri, radius, samples, cx, cy);
        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':
            if ((flag == 1) && (radius>1))  radius--; //画单个圆时半径变小
            if ((flag == 3) && (radius>ri)) radius--;  //画胖圆时外径变小
            break;
        case 'R':
            if ((radius<ww / 2) && (radius<hh / 2))
                radius++;  //半径增加
            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);
        glLoadIdentity();
        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)
    {
        /* YOUR CODE HERE ,
        Update the followling codes with Bresenham_Circle_Algorithm  */

        glColor3f(1, 1, 1);
        glTranslatef(cx, cy, 0);
        glutWireSphere(radius, 40, 40);

    }


    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++)
        {
            x[i] = (int)(cx + radius*cos(i*angle));
            y[i] = (int)(cy + radius*sin(i*angle));
        }

        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)
    {

        /* YOUR CODE HERE */
        //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);
        double radius;

        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');
            MidPoint_Circle(line[i][0], line[i][1], radius, 1);

        }
    }


    void MidPoint_Circle(int x0, int y0, double radius, int color)
    {
        //参数x0,y0 表示圆心坐标, radius表示圆的半径,color表示圆的绘制颜色
        int x, y, h;
        x = 0; y = int(radius); h = 1 - int(radius);
        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画直线算法

    2010-02-12 22:18:37
    DDA画直线算法,VS2005的C++,OpenGL实现。代码有点问题,需要把x0,y0这些变量的声明类型改为float。我不知道怎么删除重新上传,所以只有让大家自己改了。
  • 计算机图形学,内含DDA画直线,画圆,直线裁剪,多边形裁剪,填充,三维透视,三维平移缩放,贝塞尔曲线,B样条曲线功能。
  • DDA算法画直线+源代码

    千次阅读 2021-03-31 19:13:22
    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算法画直线----计算机图形学

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

    2011-05-07 10:50:57
    这个做的非常简单就是DDA算法画直线和圆,使用MFC编写,VC6.0编译。
  • DDA画直线

    2011-02-24 22:22:00
     //用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圆弧生成算法或其它圆弧生成算法
  • Java实现DDA画直线算法

    热门讨论 2011-05-09 13:21:51
    此报告阐述用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...
  • DDA 画直线 tc原程序

    2008-11-19 21:39:10
    tc2.0图形学dda画直线dsfadsssssssssssssss
  • 计算机图形学:DDA算法画直线

    千次阅读 2020-06-06 14:28:08
    #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算法(数字微...

空空如也

空空如也

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

dda画直线