1. 图形学中的中点画线法与Bresenham算法画线的区别
个人认为最关键的区别就是那个决策参数的计算方式！
在Bresenham算法中，假设我们在（x0，y0）处画了一个点，那我们就要决定下一个点是在（x0+1，y0）还是在（x0+1，y0+1）处画，这两个点一般都不在直线上，我们要计算这两个点离直线有多远，分别设两个点离直线的距离为p1、p2，然后决策参数就是p=p2-p1，再根据p的符号来判断选择哪个点
至于中点法，我没有用它来画过直线，只用来画过圆（自我感觉画圆用这个算法比Bresenham算法要好很多），但原理应该差不多！
在中点算法中，决策参数的就是方式就是圆的方程（换成直线就是直线的方程了），比如要画x^2+y^2=r^2的圆，那决策参数p=x^2+y^2-r^2,然后就不是代入上面找到的两个点直接代进去，而是代这两个点的中点进去，求出p的值，根据p的符号来判断那个中点是在圆上、圆内还是圆外，再进一步决定选择绘哪个点！
具体的计算过程没办法在这里完整演示，但个人认为不同之处还是在于决策参数的选择与计算
2. C语言用Bresenham算法画圆，哪位高手教教，主要是算法里的内容，谢谢！
的确哈，关键在于对delta的理解
可以看到，都是delta=2*(1-radius)这样的，起作用应该是判断要画的点x、y坐标的变化趋势，先把我注释了的代码贴下，加了getch();可以看到画的过程
-----------------------------------------------------------------
#include<graphics.h>
#include<stdio.h>
void BresenhemCircle(int centerx, int centery, int radius, int color, int type);
void main()
{
int drive=DETECT,mode;
int i,j;
initgraph(&drive,&mode,"");
BresenhemCircle(300,200,100,15,0);
getch();
}
void BresenhemCircle(int centerx, int centery, int radius, int color, int type)
{
int x =type = 0;/*初始横坐标为原点*/
int y = radius; /*初始纵坐标远离原点*/
int delta = 2*(1-radius);
int direction;
while (y >= 0)
{
getch();
if (!type)/*执行*/
{
/*在上半圆画两点*/
putpixel(centerx+x, centery+y, color);
putpixel(centerx-x, centery+y, color);
/*在下半圆画两点*/
putpixel(centerx-x, centery-y, color);
putpixel(centerx+x, centery-y, color);
getch();
}
else/*不执行*/
{
line(centerx+x, centery+y, centerx+x, centery-y);
line(centerx-x, centery+y, centerx-x, centery-y);
getch();
}
/*以下代码设置下次四点的位置，圆是对称的，且此方法相当于同时画四个圆弧
观察右上方圆弧可知，前一半是x增的要快些，后一半是y减的快些*/
if (delta < 0)
{
if ((2*(delta+y)-1) < 0)
direction = 1; /*选择横向加*/
else
direction = 2;
}
else if(delta > 0)
{
if ((2*(delta-x)-1) > 0)
direction = 3; /*选择纵向减*/
else
direction = 2;
}
else
direction=2;
switch(direction)
{
case 1:
x++;/*只横坐标远离原点*/
delta += (2*x+1); /*小执行到这，所以加*/
break;
case 2:
x++;
y--;/*横向远离，同时纵向靠近*/
delta += 2*(x-y+1); /*即(2*x+1)+(-2*y+1)*/
break;
case 3:
y--;/*只纵坐标靠近原点*/
delta += (-2*y+1); /*大执行到这，所以减*/
break;
}
}
}
3. Bresenham画线算法
基本上Bresenham画线算法的思路如下:
// 假设该线段位于第一象限内且斜率大于0小于1,设起点为(x1,y1),终点为(x2,y2).
// 根据对称性,可推导至全象限内的线段.
1.画起点(x1,y1).
2.准备画下个点。x坐标增1，判断如果达到终点，则完成。否则，由图中可知,下个要画的点要么为当前点的右邻接点,要么是当前点的右上邻接点.
2.1.如果线段ax+by+c=0与x=x1+1的交点的y坐标大于M点的y坐标的话,下个点为U(x1+1,y1+1)
2.2.否则,下个点为B(x1+1,y1+1)
3.画点(U或者B).
4.跳回第2步.
5.结束.
这里需要细化的是怎么判断下个要画的点为当前点的右邻接点还是当前点的右上邻接点.
设线段方程：ax+by+c=0(x1<x<x2,y1<y<y2)
令dx=x2-x1,dy=y2-y1
则：斜率-a/b = dy/dx.
从第一个点开始，我们有F(x,1,y1) = a*x1+b*y1+c=0
下面求线段ax+by+c=0与x=x1+1的交点:
由a*(x1+1)+b*y+c = 0, 求出交点坐标y=(-c-a(x1+1))/b
所以交点与M的y坐标差值Sub1 = (-c-a(x1+1))/b - (y1+0.5) = -a/b-0.5，即Sub1的处始值为-a/b-0.5。
则可得条件当 Sub1 = -a/b-0.5>0时候,即下个点为U.
反之,下个点为B.
代入a/b,则Sub1 = dy/dx-0.5.
因为是个循环中都要判断Sub,所以得求出循环下的Sub表达式,我们可以求出Sub的差值的表达式.下面求x=x1+2时的Sub，即Sub2
1.如果下下个点是下个点的右上邻接点，则
Sub2 = (-c-a(x1+2))/b - (y1+1.5) = -2a/b - 1.5
故Sub差值Dsub = Sub2 - Sub1 = -2a/b - 1.5 - (-a/b-0.5) = -a/b - 1.代入a/b得Dsub = dy/dx -1;
2.如果下下个点是下个点的右邻接点，
Sub2 = (-c-a(x1+2))/b - (y1+0.5) = -2a/b - 0.5
故Sub差值Dsub = Sub2 - Sub1 = -2a/b - 0.5 - (-a/b-0.5) = -a/b. 代入a/b得Dsub = dy/dx;
于是，我们有了Sub的处始值Sub1 = -a/b-0.5 = dy/dx-0.5,又有了Sub的差值的表达式Dsub = dy/dx -1 （当Sub1 > 0）或 dy/dx（当Sub1 < 0）.细化工作完成。
于是pcode可以细化如下：
// Pcode for Bresenham Line
// By SoRoMan
x=x1;
y=y1;
dx = x2-x1;
dy = y2-y1;
Sub = dy/dx-0.5; // 赋初值，下个要画的点与中点的差值
DrawPixel(x, y); // 画起点
while(x<x2)
{
x++;
if(Sub > 0) // 下个要画的点为当前点的右上邻接点
{
Sub += dy/dx - 1; //下下个要画的点与中点的差值
y++; // 右上邻接点y需增1
}
else// 下个要画的点为当前点的右邻接点
{
Sub += dy/dx;
}
// 画下个点
DrawPixel(x,y);
}
PS:一般优化：
为避免小数转整数以及除法运算，由于Sub只是用来进行正负判断，所以可以令Sub = 2*dx*Sub = 2dy-dx,则
相应的DSub = 2dy - 2dx或2dy.
思考1:如果Sub = 0时，会产生取两个点都可以的问题。这个问题还没深入。
4. 求一用C语言画直线的程序
C语言的话画直线用MoveTo()和LineTo()很简单啊。
帮你复制一份我学习时老师给的画线两例：
#include<graphics.h>
#include<math.h>
/*
###############################################################################
功 能：本函数的作用是用逐点比较法来画一条直线
格 式：void myline1(int x1,int y1,int x2,int y2,int color)
参数说明：x1,y1是起始点坐标,x2,y2是终止点,color是画线的颜色
调用示例：myline1(10,20,500,440,4)
###############################################################################
*/
void myline1(int x1,int y1,int x2,int y2,int color)
{
/*变量定义开始（2007/10/16增加）*/
int iTx; /*x轴终点的相对坐标xa或临时变量*/
int iTy; /*y轴终点的相对坐标ya或临时变量*/
int iDx; /*x轴方向的步长dx*/
int iDy; /*y轴方向的步长dy*/
int iFt; /*偏差Fm*/
int iSt; /*记数循环数(dx+dy)S*/
int iXt; /*x方向循环变量xm*/
int iYt; /*y方向循环变量ym*/
/*变量定义结束*/
/*变量初始化开始*/
/*如果是第三象限或第四象限则换成第一或第二象限*/
if(y2<y1)
{
iTx=x1;
x1=x2;
x2=iTx;
iTy=y1;
y1=y2;
y2=iTy;
}
iTx=x2-x1; /*取x轴的相对坐标*/
iTy=y2-y1; /*取y轴的相对坐标*/
iDx=1;
iDy=1;
iFt=0;
iSt=iTx+iTy;
if(iTx<0)iSt=-1*iTx+iTy;; /*如果在第二象限，则x轴方向步长取负值*/
iXt=0;
iYt=0;
/*变量初始化结束*/
/*数据处理开始*/
while(iSt>0)
{
putpixel(x1+iXt,y1+iYt,color);
if(iTx>=0) /*如果在第一象限*/
{
if(iFt<0) /*如果偏差小于0*/
{
iYt+=iDy; /*y方向走一步*/
iFt+=iTx;
}
else /*如果偏差大于或等于0*/
{
iXt+=iDx; /*x方向走一步*/
iFt-=iTy;
}
}
else
{
if(iFt<0) /*如果偏差小于0*/
{
iXt-=iDx; /*负x方向走一步*/
iFt+=iTy;
}
else /*如果偏差大于或等于0*/
{
iYt+=iDy; /*y方向走一步*/
iFt+=iTx;
}
}
iSt--;
}
}
/*
###############################################################################
功 能：本函数的作用是用来画一条直线
格 式：void myline2(int x1,int y1,int x2,int y2,int color)
参数说明：x1,y1是起始点坐标,x2,y2是终止点,color是画线的颜色
调用示例：myline2(10,20,500,440,4)
###############################################################################
*/
int myline2(int x1,int y1,int x2,int y2,int color)
{
int iX; /*x方向的坐标变量*/
int iY; /*y方向的坐标变量*/
int iTx; /*x方向的步长变量*/
int iTy; /*y方向的步长变量*/
float fDx; /*x方向的差分变量*/
float fDy; /*y方向的差分变量*/
float fMinf; /*算法中的f*/
float fMaxF; /*算法中的F*/
float fS; /*终点判断变量*/
fMinf=0.5; /*f=0.5*/
iX=x1;
iY=y1;
putpixel(x1,y1,color);
if(x1==x2&&y1==y2) /*如果终点和起始点相同*/
{
return(1);
}
iTx=1;
iTy=1;
fDx=(float)(x2-x1);
fDy=(float)(y2-y1);
fMaxF=fDy/fDx>0?fDy/fDx:(-fDy/fDx); /*F=|dy/dx|*/
if(fDx<0)iTx=-1;
if(fDy<0)iTy=-1;
fS=fDx>0?fDx:(-fDx);
if(fMaxF==1) /*如果F=1*/
{
iX=x1;
iY=y1;
while(fS>0)
{
iX+=iTx; /*x方向走一步*/
iY+=iTy; /*y方向走一步*/
putpixel(iX,iY,color);
fS--;
}
}
else if(fMaxF>1) /*如果F>1*/
{
fS+=fDy>0?fDy:(-fDy);
while(fS>0)
{
iY+=iTy; /*y方向走一步*/
putpixel(iX,iY,color);
fMinf+=1/fMaxF; /*f=f+1/F*/
fS--;
if(fMinf>=1) /*如果f>=1*/
{
iX+=iTx; /*x方向走一步*/
fMinf--; /*f=f-1*/
putpixel(iX,iY,color);
fS--;
}
}
}
else /*如果F<1*/
{
fS+=fDy>0?fDy:(-fDy);
while(fS>0)
{
iX+=iTx; /*x方向走一步*/
putpixel(iX,iY,color);
fMinf+=fMaxF; /*f=f+F*/
fS--;
if(fMinf>=1) /*如果f>=1*/
{
iY+=iTy; /*y方向走一步*/
fMinf--; /*f=f-1*/
putpixel(iX,iY,color);
fS--;
}
}
}
}
5. bresenham画线算法与计算机图形学画线算法有什么不同
计算机图形学画线算法很多，有DDA算法、逐点比较法、Bresenham算法等，Bresenham算法是最着名的，而且算法中只用到了加法和移位运算，没有浮点数，没有乘除法，所以执行速度最快。
6. 分别解释直线生成算法DDA法、中点画线法和Bresenham法的基本原理
DDA称为数值微分画线算法，是直线生成算法中最简单的一种。原理相当简单，就是最直观的根据斜率的偏移程度，决定是以x为步进方向还是以y为步进方向。然后在相应的步进方向上，步进变量每次增加一个像素，而另一个相关坐标变量则为Yk_1=Yk+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：过各行、各列像素中心构造一组虚拟网格线，按直线从起点到终点的顺序计算直线各垂直网格线的交点，然后确定该列像素中与此交点最近的像素。该算法的优点在于可以采用增量计算，使得对于每一列，只要检查一个误差项的符号，就可以确定该列所求的像素。
大概就是这样，预知详细，可以参考图形学的书籍
7. 用C++如何实现bresenham画线算法计算机图形学上面有个drawpixel的函数。不知道怎么用。
drawpixel()函数这就是VC画点的，不同的平台由不同的函数来画点，这个是API函数不管什么平台归结到底都是调用这个函数来画点。
COLORREF SetPixel(
HDC hdc, // handle to DC
int X, // x-coordinate of pixel
int Y, // y-coordinate of pixel
COLORREF crColor // pixel color
);
8. 用C实现Bresenham算法生成直线和圆的程序(要求具体步骤有必要解述)
Bresenham算法生成直线
假定直线从(x1,y1)到(x2,y2)，
令dx=x2-x1，dy=y2-y1
不妨设(dx,dy)在第一象限,并且直线的斜率不大于1
画线过程中有三个循环变量
x,y,d
初值
x=x1,y=y1,d=2*dy-dx
循环，直到x==x2为止
{
如果d>=0,y++,d+=2*(dy-dx)
如果d<0 ,x++,d+=2*dy
}
如果(dx,dy)不在第一象限，要做变换，即先把第一象限的画出来
如果斜率大于1，x,y交换
非常简单的，很容易实现
圆的算法：
int Bres(int x0,int y0,double r,int color)
{
int x,y,d;
x=0;
y=(int)r;
d=(int)(3-2*r);
while(x<y)
{
cirpot(x0,y0,x,y,color);
if(d<0)
d+=4*x+6;
else
{
d+=4*(x-y)+10;
y--;
}
x++;
}
if(x==y)
cirpot(x0,y0,x,y,color);
return(0);
}
int cirpot(int x0,int y0,int x,int y,int color)
{
setcolor(color);
putxicl((x0+x),(y0+y));
putxicl((x0+y),(y0+x));
putxicl((x0+y),(y0-x));
putxicl((x0+x),(y0-y));
putxicl((x0-x),(y0-y));
putxicl((x0-y),(y0-x));
putxicl((x0-y),(y0+x));
putxicl((x0-x),(y0+y));
setcolor(color);
return(0);
}
这是圆的算法，你若要整个程序，把你的电邮给我，我给你发过去、
运行环境是Turboc 2.0
int Bresline(int x1,inty1,int x2,int y2,int color)
{
int color,itag;
int dx,dy,tx,ty,inc1,inc2,d,curx,cury;
setcolor(color);
putxicl(x1,y1);
if(x1==x2&&y1==y2)
{
setcolor(color);
return(1);
}
itag=0;
dx=abs(x2-x1);
dy=abs(y2-y1);
if(dx<dy)
{
itag=1;]
iswap(&x1,&y1);
iswap(&x2,&y2);
iswap(&dx,&dy);
}
tx=(x2-x1)>0? 1:-1;
ty=(y2-y1)>0? 1:-1;
curx=x1;
cury=y1;
inc1=2*dy;
inc2=2*(dy-dx);
d=inc1-dx;
while(curx!x2)
{
if(d<0)
{
d+=inc1;
}
else
{
cury+=ty;
d+=inc2;
}
if(itag)
setpixel(cury,curx);
else
setpixel(curx,cury);
curxd+=tx;
}
setcolor(color);
return(0);
}
iswap(int*a,int*b)
{
int tmp;
tmp=*a;
*a=*b;
*b=tmp;
}
这是直线的算法：和圆的差不多，你可以参考一下：）