精华内容
下载资源
问答
  • 主要为大家详细介绍了OpenGL通过中点法绘制直线和,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • OpenGl下中点法画椭圆的实现

    热门讨论 2009-04-25 20:24:53
    OpenGl下中点法画椭圆的实现,可以运行
  • 使用两种交互方式画圆:一个是鼠标拖动(可显示预生成的),另一个是从对话框输入数值自定义圆心和半径。
  • 【OpenGL】中点法画椭圆

    千次阅读 2017-09-28 16:34:13
    仍然可以看成是Bresenham算法的一个应用,书上叫它“中点法”(原因是当我们不能确定取哪个坐标的时候,就用两个待定的坐标的中点代入方程来帮助判断)。 Bresenham算法归根到底要解决的就是“下一个点怎么选更精确...

    仍然可以看成是Bresenham算法的一个应用,书上叫它“中点法”(原因是当我们不能确定取哪个坐标的时候,就用两个待定的坐标的中点代入方程来帮助判断)。

    Bresenham算法归根到底要解决的就是“下一个点怎么选更精确”这个问题,解决的套路是:

    1)先给出一个判别函数,这个函数就是所要画的曲线的方程式;

    2)求解这个判别函数的递推式;

    2)总是从像素点更密集的方向开始选点(方便起见从x开始,每次加1);

    3)判断下一个点x+1对应的理论坐标和实际坐标的差距,选差距小的作为y坐标;

    4)不断重复3),直到达到临界条件(通常是斜率,一般只需要考虑斜率小于1的情形,其他对称解决)

    椭圆的思路是一样的,只是方程更复杂,所以推导过程更繁琐一点:


    注意这里是用斜率来确定临界点,隐函数求导可以得到k=-2x^2Ry/2y^2Rx。每次的分子分母也可以用增量的方式来计算。

    最终的代码:

    //中心点法画椭圆
    
    #include<iostream>
    using namespace std;
    
    #include<windows.h>
    #include<gl/glut.h>
    
    /*函数申明*/
    void myDisplay(void);//用来调用eclipseBres()
    int round(const float x);
    void setPixel(int x,int y);//画点的函数
    void symmetricPoints(int xc,int yc,int rx,int ry);//在对称位置画点
    void changeSize(GLsizei w, GLsizei h);//窗口大小改变时调用的登记函数
    void eclipseBres(int xc,int yc,int rx,int ry);//画椭圆的主要函数
    
    /*函数实现*/
    void myDisplay(void){
    	eclipseBres(120,120,50,100);
    }
    
    int round(const float x){
    	return (x+0.5);
    }
    
    void setPixel(int x,int y){
    	//使用OpenGL的glVertex2i来画点
    	glPointSize(2.0f);
    	glBegin(GL_POINTS);
    		glVertex2i(x,y);
    	glEnd();
    	glFlush();
    }
    
    void symmetricPoints(int xc,int yc,int rx,int ry){
    	setPixel(xc+rx,yc+ry);
    	setPixel(xc-rx,yc+ry);
    	setPixel(xc+rx,yc-ry);
    	setPixel(xc-rx,yc-ry);
    }
    
    void changeSize(GLsizei w, GLsizei h){
    	//这个函数和OpenGL显示有关,和算法本身无关
        if(h==0)     
    		h=1;
        glViewport(0,0,w,h);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        if (w <= h)
            glOrtho(0.0f,250.0f,0.0f,250.0f*h/w,1.0,-1.0);
        else
            glOrtho(0.0f,250.0f*w/h,0.0f,250.0f,1.0,-1.0);
    }
    
    void eclipseBres(int xc,int yc,int rx,int ry){
    	int x=0,y=ry;
    	int rx2=rx*rx,ry2=ry*ry;
    	int tworx2=2*rx2,twory2=2*ry2;
    	int px=0,py=tworx2*y;
    	int p=round(ry2-rx2*ry+0.25*rx2);
    	symmetricPoints(xc,yc,x,y);
    	while(py>px){
    		x++;
    		px+=twory2;
    		if(p<0)
    			p+=ry2+px;
    		else{
    			y--;
    			py-=tworx2;
    			p+=ry2+px-py;
    		}
    		symmetricPoints(xc,yc,x,y);
    	}
    	//region2
    	p=round(ry2*(x+0.5)*(x+0.5)+rx2*(y-1)*(y-1)-rx2*ry2);
    	while(y>0){
    		y--;
    		py-=tworx2;
    		if(p>0)
    			p+=rx2-py;
    		else{
    			x++;
    			px+=twory2;
    			p+=rx2-py+px;
    		}
    		symmetricPoints(xc,yc,x,y);
    	}
    }
    
    int main(int argc,char* argv[]){
    	//OPenGL显示图形的框架
    	glutInit(&argc,argv);
    	glutInitDisplayMode(GLUT_RGB|GLUT_SINGLE);
    	glutInitWindowPosition(200,200);
    	glutInitWindowSize(400,400);
    	glutCreateWindow("练习");
    	glutDisplayFunc(&myDisplay);
    	glutReshapeFunc(changeSize);
    	glutMainLoop();
    	return 0;
    }
    运行效果:



    展开全文
  • 【寒江雪】中点画椭圆算法

    千次阅读 2016-11-16 23:58:07
    不能像那样扫描八分之一就可以绘制出整个。所以,必须要考虑在扫描四分之一椭圆的过程中,遇到斜率为-1的切线。 如下图 因此要绘制椭圆,就要把椭圆分成上部区域和下部区域 先考虑椭圆的曲线方程...

    中点画椭圆算法与中点画圆算法非常类似

    但是其中有区别的地方就是,椭圆不是八对称的。不能像圆那样扫描八分之一就可以绘制出整个圆。所以,必须要考虑在扫描四分之一椭圆的过程中,遇到斜率为-1的切线。

    如下图


    因此要绘制椭圆,就要把椭圆分成上部区域和下部区域

    先考虑椭圆的曲线方程

    x^2/a^2+y^2/b^2=1

    记F(x,y)=b^2*x^2+a^2*y^2-a^2*b^2=0

    对于椭圆上某点的切线法向量N如下


    也就是说,

    某点在x方向上的增量速度为2*b^2*x

    某点在y方向上的增量速度为2*a^2*y

    如果某点(x,y)有2*b^2*x>2*a^2*y时,表明x的增加速度大于y的增加速度。

     

    在绘制椭圆的时候,上图橘黄色部分是以x为基准进行扫描,直到y的增量速度大于x的增量速度为止,换y为基准扫描,直到y=0为止。

     

     

    接下来跟圆做同样的推导

    从点(0,b)开始绘制

    假设某点(xi,yi)为当前要绘制的点

    则下一点可能要绘制(xi+1,yi)或(xi+1,yi-1),这取决于这两点的中点是在椭圆内还是椭圆外

    因此可以得出如下判别式

    di=F(xi+1,yi-0.5)=b^2*(xi+1)^2+a^2*(yi-0.5)^2-a^2*b^2;

    当di<0时,下一点取(xi+1,yi)

    当di>=0时,下一点取(xi+1,yi-1)

    d(i+1)=F(x(i+1),y(i+1))=di+b^2*(2*xi+3)                                      (di<0)

    d(i+1)=F(x(i+1),y(i+1))=di+b^2*(2*xi+3)+a^2*(2-2*yi)                       (di>=0)

     

    一开始d0=F(1,b-0.5)=b^2+a^2*(0.25-b)

    以上是画椭圆四分之一的上半部分(上图的橘色部分)

     

    假设画完上半部分后,新的起点为(xi,yi)

    新的判别式

    di=F(xi+0.5,yi-1)

    当di<0时,下一点取(xi+1,yi-1)

    当di>=0时,下一点取(xi,yi-1)

    d(i+1)=F(x(i+1),y(i+1))=di+b^2*(2*xi+2)+a^2*(3-2*yi)                           (di<0)

    d(i+1)=F(x(i+1),y(i+1))=di+a^2*(3-2*yi)                                      (di>=0)

    当y<0时绘制完毕

    展开全文
  • 支持Visual Studio 2013 及以上版本,c语言实现代码,中点算法及Bresenham算法画圆,中点算法画椭圆,鼠标的交互方式利用OpenGL实现。
  • C语言绘制圆(中点法)

    2010-06-09 17:22:30
    该代码C语言完成绘制,是计算机图形学实验内容!!
  • 2)调用画点的函数,分别用DDA、中点Bresenham算法和改进Bresenham算法绘制直线和中点算法绘制直线、用不同的算法绘制圆和椭圆 ,并各自比较算法精度与效率的差别 。 3)实现二维图形的变换。(包括平移,放缩,...
  • 中点画椭圆

    2016-02-26 19:00:25
    华科图形学,用中点画椭圆法绘制整个椭圆。
  • QT实现DDA、中点画线以及画圆和椭圆,点击画图按钮,然后在网格上拖动鼠标,实现画线程序,画圆和椭圆和画直线方法类似。上传的是成功运行后的QT工程文件的压缩包。
  • opengl中点画圆

    2012-03-21 16:12:21
    计算机图形学中采了用中点画圆的方法,程序已经实现了,可以放心下载
  • 中点画椭圆算法_中点圆算法

    千次阅读 2020-07-29 06:38:39
    中点画椭圆算法 中点圆算法 (Midpoint circle Algorithm) This is an algorithm which is used to calculate the entire perimeter points of a circle in a first octant so that the points of the other octant ...

    中点画椭圆算法

    中点圆算法 (Midpoint circle Algorithm)

    This is an algorithm which is used to calculate the entire perimeter points of a circle in a first octant so that the points of the other octant can be taken easily as they are mirror points; this is due to circle property as it is symmetric about its center.

    这是一种算法,用于计算第一个八分圆中一个圆的整个周边点,以便可以轻松地将另一个八分圆的点视为镜像点; 这是由于圆的属性有关它的中心对称。

    Midpoint circle algo

    In this algorithm decision parameter is based on a circle equation. As we know that the equation of a circle is x2 +y2 =r2 when the centre is (0, 0).

    在该算法中,决策参数基于圆方程。 众所周知,当中心为(0,0)时,圆的方程为x 2 + y 2 = r 2

    Now let us define the function of a circle i.e.: fcircle(x,y)= x2 +y2 - r2

    现在让我们定义一个圆的函数,即: fcircle(x,y)= x 2 + y 2 -r 2

    1. If fcircle < 0 then x, y is inside the circle boundary.

      如果fcircle <0,xy在圆边界之内。

    2. If fcircle > 0 then x, y is outside the circle boundary.

      如果fcircle> 0,xy在圆边界之外。

    3. If fcircle = 0 then x, y is on the circle boundary.

      如果fcircle = 0,xy在圆边界上。

    决策参数 (Decision parameter)

    pk =fcircle(xk+1,yk-1/2) where pk is a decision parameter and in this ½ is taken because it is a midpoint value through which it is easy to calculate value of yk and yk-1.

    p k = fcircle(x k + 1 ,y k-1 / 2 ) ,其中p k是决策参数,在此1/2中采用p k是因为它是一个中点值,通过该中点值很容易计算y ky k -1

    I.e. pk= (xk+1)2+ (yk-1/2)2-r2

    p k =(x k + 1 ) 2 +(y k-1 / 2 ) 2 -r 2

    If pk <0 then midpoint is inside the circle in this condition we select y is yk otherwise we will select next y as yk-1 for the condition of pk > 0.

    如果p k <0,则在这种情况下中点在圆内,我们选择yy k,否则对于p k > 0的情况,我们将下一个y选择为y k-1

    结论 (Conclusion)

    1. If pk < 0 then yk+1=yk, by this the plotting points will be ( xk+1 ,yk). By this the value for the next point will be given as:

      如果p k <0,y k + 1 = y k ,由此绘制点将为(x k + 1 ,y k ) 。 这样,下一点的值将为:

      Pk+1=pk +2(xk+1) +1

      P k + 1 = p k +2(x k + 1 )+1

    2. If pk > 0 then yk+1=yk-1, by this the plotting points will be (xk+1, yk-1). By this the value of the next point will be given as:

      如果p k > 0,y k + 1 = y k-1 ,由此绘制点将为(x k + 1 ,y k-1 ) 。 这样,下一点的值将为:

      Pk+1=pk+2(xk+1) +1-2(yk+1)

      P k + 1 = p k +2(x k + 1 )+ 1-2(y k + 1 )

    初始决策参数 (Initial decision parameter)

    P0 = fcircle (1, r-1/2)

    P 0 =圆(1,r-1 / 2)

    This is taken because of (x0, y0) = (0, r)

    这是因为(x 0 ,y 0 )=(0,r)

    i.e. p0 =5/4-r or 1-r, (1-r will be taken if r is integer)

    p 0 = 5 / 4-r或1-r ,(如果r为整数则采用1-r )

    算法 (ALGORITHM)

    1. In this the input radius r is there with a centre (xc , yc). To obtain the first point m the circumference of a circle is centered on the origin as (x0,y0) = (0,r).

      在此,输入半径r以一个中心(x c ,y c )为中心。 为了获得第一个点m ,圆的圆周以(x 0 ,y 0 )=(0,r)为中心

    2. Calculate the initial decision parameters which are:

      计算初始决策参数为:

      p0 =5/4-r or 1-r

      p 0 = 5 / 4-r或1-r

    3. Now at each xk position starting k=0, perform the following task.

      现在,在从k = 0开始的每个x k位置,执行以下任务。

      if

      如果

      pk < 0 then plotting point will be ( xk+1 ,yk) and

      p k <0,则绘图点将为(x k + 1 ,y k )并且

      Pk+1=pk +2(xk+1) +1

      P k + 1 = p k +2(x k + 1 )+1

      else the next point along the circle is (x

      否则沿圆的下一个点是[x

      k+1, yk-1) and

      k + 1 ,y k-1 )和

      Pk+1=pk+2(xk+1) +1-2(yk+1)

      P k + 1 = p k +2(x k + 1 )+ 1-2(y k + 1 )

    4. Determine the symmetry points in the other quadrants.

      确定其他象限中的对称点。

    5. Now move at each point by the given centre that is:

      现在按照给定的中心在每个点处移动:

      x=x+xc

      x = x + x c

      y=y+yc

      y = y + y c

    6. At last repeat steps from 3 to 5 until the condition x>=y.

      最后重复步骤3到5,直到条件x> = y为止。

    翻译自: https://www.includehelp.com/algorithms/midpoint-circle.aspx

    中点画椭圆算法

    展开全文
  • 题目:用Besenham实现绘制 基本要求: (1)数据输入项为:圆心坐标与半径 (2)直线与输出在CDC设备中 附加要求: (1)通过用户输入可改变线型(实线、虚线与点划线) (2)通过用户输入可改变线宽(用方...
  • OpenGL绘制直线和中点法

    千次阅读 2013-10-11 22:56:21
    //设置投影参数 //指的是视图范围,如果(0,200,0,200)的话就只能在第一象限显示,就1/4,第1,3的参数是左下角坐标,第2,4的参数是右上角坐标 } /*void Display(void) { glClear(GL_COLOR_BUFFER_BIT); //用...
    #include <gl/glut.h>
    #include <math.h>
    
    static  int i=1;
    
    void Initial(void)
    {
    		glClearColor(1.0f, 1.0f, 1.0f, 1.0f);      //设置窗口背景颜色为白色
    		glMatrixMode(GL_PROJECTION);    //指定设置投影参数
    		gluOrtho2D(-200.0,200.0,-200.0,200.0); //设置投影参数  //指的是视图范围,如果(0,200,0,200)的话就只能在第一象限显示,就1/4圆,第1,3的参数是左下角坐标,第2,4的参数是右上角坐标
    }
    /*void Display(void)
    {
    		glClear(GL_COLOR_BUFFER_BIT);   //用当前背景色填充窗口
    		glColor3f(1.0f, 0.0f, 0.0f);            //设置当前的绘图颜色为红色
    		glRectf(50.0f, 100.0f, 150.0f, 50.0f);    //绘制一个矩形
                 glFlush();                         //处理所有的OpenGL程序
    }
    */
    
    void DDALine(int x0,int y0,int x1,int y1)
    {
    	//glVertex2f(10,10);
    	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);
    
    	xIncre=(float)dx/(float)epsl;
    	yIncre=(float)dy/(float)epsl;
    	glPointSize(2);
    	glBegin(GL_POINTS);
    	for(k = 0;k <= epsl; k++)
    	{
    		glColor3f(1.0f, 0.0f, 0.0f);
    		glVertex2f(int(x+0.5),int(y+0.5));
    		x += xIncre;
    		y += yIncre;
    	}
    	glEnd();
    
    }
    
    
    
    void Mid_B(int x0,int y0,int x1,int y1)
    {
    	int dx,dy,d,UpIncre,DownIncre,x,y;
    	if(x0 > x1)
    	{
    		x = x1;
    		x1 = x0;
    		x0 = x;
    		y = y1;
    		y1 = y0;
    		y0 = y;
    	}
    	x = x0;
    	y = y0;
    	dx = x1 - x0;
    	dy = y1 - y0;
    	d = dx - 2*dy;
    	UpIncre = 2*dx - 2*dy;
    	DownIncre =- 2*dy;
    
    	glPointSize(2);
    	glBegin(GL_POINTS);
    	while(x <= x1)
    	{
    		glColor3f(1.0f, 0.0f, 0.0f);
    		glVertex2f(x,y);
    		x++;
    		if(d < 0)
    		{
    			y++;
    			d += UpIncre;
    		}
    		else
    			d += DownIncre;
    	}
    	glEnd();
    
    }
    
    void G_B(int x0,int y0,int x1,int y1)
    {
    	int x,y,dx,dy,e;
    	dx = x1 - x0;
    	dy = y1 - y0;
    	e =- dx;
    	x=x0;
    	y=y0;
    	
    	glPointSize(2);
    	glBegin(GL_POINTS);
    	while(x <= x1)
    	{
    		glColor3f(1.0f, 0.0f, 0.0f);
    		glVertex2f(x,y);
    		x++;
    		e = e + 2*dy;
    		if(e > 0)
    		{
    			y++;
    			e = e - 2*dx;
    		}
    
    	}
    	glEnd();
    }
    
    void CirclePoint(int x, int y)
    {
    	glPointSize(2);
    	glBegin(GL_POINTS);
    	glColor3f(1.0f, 0.0f, 0.0f);
    	glVertex2f(x,y);
    	glVertex2f(y,x);	
    	glVertex2f(-y,x);	
    	glVertex2f(-x,y);	
    	glVertex2f(-x,-y);	
    	glVertex2f(-y,-x);	
    	glVertex2f(y,-x);	
    	glVertex2f(x,-y);
    	glEnd();
    }
    
    void MidBresenhamCircle(int r)
    {
    	int x = 0, y = r, d = 1-r;
    	//glPointSize(2);
    	//glBegin(GL_POINTS);
    	while(x <= y)
    	{
    		CirclePoint(x,y);
    		
    		if(d < 0)
    					d += 2*x+3;
    				else
    				{
    					d += 2*(x-y)+5;
    					y--;
    				}
    				x++;
    	}
    	glEnd();
    }
    
    void ProcessMenu(int value)
    {
    	i = value;  
    	glutPostRedisplay();
    }
    
    
    
    void Display(void)
    {
    		glClear(GL_COLOR_BUFFER_BIT);   //用当前背景色填充窗口
    		glViewport(0,0,400,400); //前两个参数改变原点坐标,后两个参数改变图形长宽(放大缩小)
    		switch(i)
    		{
    		case 1:
    			DDALine(2,3,55,83);
    			break;
    		case 2:
    			Mid_B(2,3,55,83);
    			break;
    		case 3:
    			G_B(2,3,55,83);
    			break;
    		case 4:
    			MidBresenhamCircle(50);
    			break;
    		
    		}
    		glFlush(); 
    }
    
    int main(int argc, char* argv[])
    
    {
    		glutInit(&argc, argv);				 //初始化GLUT库,处理命令行参数 
    		glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);  //初始化窗口的显示模式
    		glutInitWindowSize(400,400);              //设置窗口的尺寸
    		glutInitWindowPosition(100,100);       //设置窗口的位置
    		glutCreateWindow("直线");                 //创建一个名为矩形的窗口
    
    		int MainMenu = glutCreateMenu(ProcessMenu);  //创建主菜单
    		glutAddMenuEntry("DDA算法",1);
    		glutAddMenuEntry("中点Bresenham算法",2);
    		glutAddMenuEntry("改进的Bresenham算法",3);
    		glutAddMenuEntry("中点bresenham画圆",4);
    		glutAttachMenu(GLUT_RIGHT_BUTTON);		
    
    		glutDisplayFunc(Display);     //设置当前窗口的显示回调函数
    		Initial();                                    //完成窗口初始化
    		glutMainLoop();                     //启动主GLUT事件处理循环
    		return 0;
    	
    
    }
    

    展开全文
  • //窗口大小 glutCreateWindow("角度离散法绘制圆弧");//创建窗口,参数是窗口的标题 glutDisplayFunc(myDisplay);//告诉GLUT哪个函数负责绘图,即注册一个绘图函数myDisplay glutReshapeFunc(Reshape); //窗口发生...
  • 该项目采用VS2019开发, 使用OpenGL 1.1库文件(<GL.H><GLAUX.H>)绘制, 采用包含弧线段绘制的两种算法: 中点算法, 和 多边形内接算法. 分别采用两种算法分别采用函数来绘制, 可自选中点算法或内多边形逼近算法, 可调节...
  • 中点画圆程序

    2015-05-19 15:34:05
    这是一个运用中点画圆画圆的程序,使用了简单快捷的八分之一画圆方法,实现了绘制一个整,运用了OpenGL的图形框架,对于相关学习爱好者有一定的参考价值。
  • 中点画圆详解

    千次阅读 2020-06-08 07:33:03
    中点画圆 一、算法原理 利用的对称性,只须讨论1/8,即下图第二个8分区域: P为当前像素,那么,下一个像素可能是P1(Xp+1,Yp)或P2(Xp +1,Yp -1)。
  • 计算机图形学(第三版)图形学OPENGL画椭圆,中点算法
  • OpenGl下中点法画圆的实现运行可以过
  • 椭圆中点Bresenham算法

    2015-03-29 07:57:34
    使用MFC绘制的椭圆中点Bresenham源程序,直接运行即可看到效果。这是vs2010版程序。参考教材是孔令德编写的《计算机图形学实践教程(Visual C++版)第2版》。
  • 本文主要技术:直线、、椭圆四种绘制算法,Python3(Matplotlib,PyQt5) 本文是笔者上计算机图形学课程时课内实验的报告,内容仅供参考。 1-实验目的及要求 实现直线、、椭圆的四种绘图算法,保证其在所有...
  • 用DDA或中点算法实现直线段、椭圆或绘制,内有完整的实验报告和代码
  • 1、调用画点函数,实现任意斜率直线的绘制 (运用DDA算法、中点Bresenam算法实现并比较算法精度与效率) ② 基本论述 DDA算法又称数值微分,是计算机图形学中一种基于直线的微分方程来生成直线的方法。 原理就是最...
  • openGL-Bresenham中点画圆、椭圆算法

    千次阅读 2018-03-14 19:29:05
    //为了便于比较我们同时使用迭代进行openGL绘制圆。 real_circle(); //刷新缓冲,保证绘图命令能被执行 bresenham_circle(translater(x),translater(y),r); //进入bresenham算法 } const int n= 120 ; ...
  • Bresenham直线算法,是过各行各列象素中心构造一组虚拟网格线。按直线从起点到终点的顺序计算直线与各垂直网格线的交点,然后根据误差项的符号确定该列象素中与此交点最近的象素。
  • 计算机图形学第一次上机实验 课程实验报告   目录 计算机图形学第一次上机实验 课程实验报告 一、实验目的 ... 掌握并编写中点线算法和中点圆算法 二、实验环境 1.codeblocks-17.12 2.Windows...
  • 基于openGL编写,将三种算法集合到一个程序里,且中点画线和Bresenham画线包含所有斜率情况,360度无死角。直接上源文件,新建工程后添加源文件即可。

空空如也

空空如也

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

中点法绘制圆