圆光栅算法
❶ 脉冲编码器上A B Z到底各代表什么意思，然后怎么用，望详解
A/B/Z是编码器的3个脉冲输出端，A和B一般是两个相差0.25个周期的连续脉冲输出，通过分析2个脉冲的相位可以知道旋转方向，通过频率可以知道旋转的速度。
Z脉冲式编码器旋转一圈才出现一个脉冲，它是编码器上面的一个固定的一个参照点，通过对它技术就知道转了多少圈，所以根据A/B/Z三个脉冲状态完全可以分析出编码器的运动状态，即速度，角度，方向，和旋转多圈的位置。
(1)圆光栅算法扩展阅读：
一，脉冲编码器的工作原理：
脉冲编码器是一种光学式位置检测元件，编码盘直接装在电机的旋转轴上，以测出轴的旋转角度位置和速度变化，其输出信号为电脉冲。是一种常用的角位移传感器。同时也可作速度检测装置。
脉冲编码器的优点是无摩擦和磨损，驱动力矩小，响应速度快。脉冲编码器的缺点是抗污染能力差，容易损坏。
二，脉冲编码器的分类与结构：
脉冲编码器分为光电式、接触式和电磁感应式三种。光电式的精度与可靠性都优于其他两种，因此数控机床上只使用光电式脉冲编码器。
脉冲编码器的结构：在一个圆盘的圆周上刻有等间距线纹，分为透明和不透明的部分，称为圆光栅。圆光栅与工作轴一起旋转。与圆光栅相对，平行放置一个固定的扇形薄片，称为指示光栅，上面制有相差1/4节距的两个狭缝（辨向狭缝）。
此外，还有一个零位狭缝（每转发出一个脉冲）。脉冲发生器通过十字连接头或键与伺服电动机相连。
❷ 关于Bresenham算法的求助
今天一下子遇到三个类似的问题，所以我这篇东西就连续复制粘贴了三遍：
（下面的坐标本来是有下标的，但复制过来就变没了，你可能看的有点晕）
Bresenham算法是Bresenham提出的一种光栅线生成算法！
DDA算法表面上看起来很有效，并且代码也比较容易实现，但是显示每个像素都需要进行一次浮点数加法运算，而Bresenham算法的最大优点是不需要进行浮点数运算！这是一种精确而有效的光栅线生成算法，该算法仅使用增量整数计算，计算速度比DDA要快，另外，Bresenham算法还可用于显示圆和其他曲线，这里暂时只显示直线！
与DDA一样，我们假设线段的两个端点坐标是整数值（x0,y0）（xEnd,yEnd）,且斜率m满足0<=m>=1!坐标轴的垂直轴表示扫描线位置，水平轴标识像素列，假设以单位x间隔取样，需要确定下一个每次取样时两个可能的像素位置中的哪一个更接近于线路径！
从给定线段的左端点（x0,y0）开始,逐步处理每个后继列（x位置），并在其扫描线y值最接近线段的像素处描出一点，假如已经确定要显示的像素在（xk,yk），那么下一步就要确定在列xk+1=xk+1上绘制哪个像素，是在位置(xk+1,yk)还是在(xk+1,yk+1)
在取样位置xk+1，我们使用dlower和pper来标识两个像素与数学上线路径的垂直偏移（就是通过这两个值来比较哪个点离线上的点最近，以下推导过程你可能看得有点晕，但都是为了推出后续的点而已，你可以结合下面例子程序中的Bresenham函数来看），在像素列xk+1处的直线上的y坐标根据直线方程可计算得：
y=m(xk+1)+b
那么可求得：
dlower=y-yk=m(xk+1)+b-yk
pper=(yk+1)-y=yk+1-m(xk+1)-b
令斜率m=dy/dx,引入决策参数Pk，定义为：
Pk=dx(dlower-pper)
=2dx*xk-2dy*yk+c
C是一个常数，值为2dx+dx(2b-1)
由此可以计算得到
pk+1=Pk+2dy-2dx(yk+1-yk)
其中yk+1-yk取0还是取1取决于参数Pk的符号，Pk为负时取0，Pk非负时取1！
而Pk为负时，下一个要绘制的点就是（xk+1,yk）且pk+1=Pk+2dy
Pk为非负时则下一个要绘制的点就是（xk+1,yk+1）且pk+1=Pk+2dy-2dx
至此，Bresenham算法介绍完毕，以下为某个示例：
#include<gl/glut.h>
#include<math.h>
#include<stdio.h>
voiddraw_pixel(intix,intiy)
{
glBegin(GL_POINTS);
glVertex2i(ix,iy);
glEnd();
}
voidBresenham(intx1,inty1,intxEnd,intyEnd)
{
intdx=abs(xEnd-x1),dy=abs(yEnd-y1);
intp=2*dy-dx;
inttwoDy=2*dy,twoDyMinusDx=2*dy-2*dx;
intx,y;
if(x1>xEnd)
{
x=xEnd;y=yEnd;
xEnd=x1;
}
else
{
x=x1;
y=y1;
}
draw_pixel(x,y);
while(x<xEnd)
{
x++;
if(p<0)
p+=twoDy;
else
{
y++;
p+=twoDyMinusDx;
draw_pixel(x,y);
}
}
}
voiddisplay()
{
glClear(GL_COLOR_BUFFER_BIT);
Bresenham(0,0,400,400);
glFlush();
}
voidmyinit()
{
glClearColor(0.8,1.0,1.0,1.0);
glColor3f(0.0,0.0,1.0);
glPointSize(1.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0,500.0,0.0,500.0);
}
voidmain(intargc,char**argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowSize(500,500);
glutInitWindowPosition(200.0,200.0);
glutCreateWindow("CG_test_Bresenham_Lineexample");
glutDisplayFunc(display);
myinit();
glutMainLoop();
}
运行效果：
❸ 请问中点bresenham算法画圆与bresenham算法画圆有区别吗
Bresenham算法画圆：
Bresenham算法用来画直线非常方便，但上次也说了，Bresenham算法也可以用来显示圆和其他曲线，只需要把直线方程改成圆方程或者其他曲线的方程就行，具体的推理过程就不演示了，大体跟直线的差不多！但由推算的结果可以看出，用Bresenham算法来画圆的确是不大明智的做法，要计算的步骤太多，计算速度比专门的画圆方法慢很多！并且在斜率越大的地方像素的间距就越大，当然我们可以在画某个像素之前先判断一下这一点跟前面一点的连线的斜率，然后在适当的时候交换x、y的坐标，但这样计算量必将增加！
直接给出Bresenham画圆的代码：
#include<gl/glut.h>
#include<math.h>
#include<stdio.h>
voiddraw_pixel(intix,intiy)
{
glBegin(GL_POINTS);
glVertex2i(ix,iy);
glEnd();
}
//intinlineround(constfloata){returnint(a+0.5);}
voidBresenham(intx1,inty1,intr,doublea,doubleb,doublec)/*圆心在（x1，y1），半径为r的圆*/
{
glColor3f(a,b,c);
intdx=r;//intdy=abs(yEnd-y1);
//intp=2*dy-dx;
//inttwoDy=2*dy,twoDyMinusDx=2*dy-2*dx;
intx,y,d1,d2;
/*if(x1>xEnd)
{
x=xEnd;y=yEnd;
xEnd=x1;
}
else
{
x=x1;
y=y1;
}
*/
x=x1;
y=y1+r;
draw_pixel(x1,y1);
draw_pixel(x,y);//起始点装入帧缓存,起始点是圆的最上面一点，然后按顺时针来画
while(x<=x1+dx)
{
d1=y1+sqrt(pow(r,2)-pow(x-x1,2));/*lower*/
x++;
d2=2*(y1+sqrt(pow(r,2)-pow(x-x1,2)))-2*d1-1;/*lower-upper*/
if(1)
{
y=d1;
draw_pixel(x,y);
draw_pixel(x,2*y1-y);
draw_pixel(2*x1-x,y);
draw_pixel(2*x1-x,2*y1-y);
}
else
{
y++;
//p+=twoDyMinusDx;
draw_pixel(x,y);
}
}
}
voiddisplay()
{
glClear(GL_COLOR_BUFFER_BIT);
Bresenham(250,250,200,0.0,0.0,1.0);
Bresenham(300,250,150,1.0,0.0,0.0);
Bresenham(200,250,150,0.0,1.0,0.0);
//Bresenham(250,300,150,0.8,0.4,0.3);
//Bresenham(250,200,150);
glFlush();
}
voidmyinit()
{
glClearColor(0.8,1.0,1.0,1.0);
//glColor3f(0.0,0.0,1.0);
glPointSize(1.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0,500.0,0.0,500.0);
}
voidmain(intargc,char**argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowSize(500,500);
glutInitWindowPosition(200.0,200.0);
glutCreateWindow("CG_test_Bresenham_Circleexample");
glutDisplayFunc(display);
myinit();
glutMainLoop();
}
以下为程序运行效果：
中点画圆：
用光栅画圆的不足在上次已经用实例表示的很明白了，上次画的那个圆怎么都不能算满意，虽然可以通过修改算法来得到改善，但本来计算步骤就已经很多了，交换坐标重新计算将会大大增加计算机的就是负担，为此我们采用另一种更加常用的画圆算法——中点画圆算法，之所以叫做“中点”画圆算法是由于它不是像Bresenham算法那样所绘像素不是（xk+1,yk）就是（xk+1,yk+1）,而是根据这两个点的中点来判断是（xk+1,yk）还是（xk+1,yk-1）更接近于圆！
对于给定的半径r和圆心（x0,y0）,我们先计算圆心在原点（0,0）的点，然后将其平移到圆心（x0,y0）处即可，跟Bresenham算法一样，我们也可以借助圆的高度对称性来减少计算机的计算步骤，在这里我们可以先计算出八分之一圆的像素点，然后根据对称性绘出其他点。这样可以大大加快画圆的速度！
跟光栅化方法一样，我们还是采用步进的方法来逐点描绘，但这里的决策参数计算方式跟Bresenham不大一样，设决策参数为p，则：
P=x2+y2-r2
对于任一个点（x，y），可以根据p的符号来判断点是在圆内还是圆外还是在圆上，这里不多说，假设我们在（xk,yk）处绘制了一个像素，下一步需要确定的是（xk+1,yk）还是（xk+1,yk-1）更接近于圆，在此代入这两个点的中点来求出决策参数：
Pk=（xk+1）2+（yk-1/2）2-r2
如果Pk<0,则yk上的像素更接近于圆，否则就是yk-1更接近于圆
同理可以推出Pk+1=Pk+2（xk+1）+（yk+12-yk2）-（yk+1-yk）+1
给出一个示例，这个圆比用Bresenham画出来的好看多了：
#include<glglut.h>
classscreenPt
{
private:
intx,y;
public:
screenPt(){x=y=0;}
voidsetCoords(GLintxCoordValue,GLintyCoordValue)
{
x=xCoordValue;
y=yCoordValue;
}
GLintgetx()const
{
returnx;
}
GLintgety()const
{
returny;
}
voidincrementx(){x++;}
voiddecrementy(){y--;}
};
voiddraw_pixel(intxCoord,intyCoord)
{
glBegin(GL_POINTS);
glVertex2i(xCoord,yCoord);
glEnd();
}
voidcircleMidpoint(GLintxc,GLintyc,GLintradius)
{
screenPtcircPt;
GLintp=1-radius;
circPt.setCoords(0,radius);
voidcirclePlotPoints(GLint,GLint,screenPt);
circlePlotPoints(xc,yc,circPt);
while(circPt.getx()<circPt.gety())
{
circPt.incrementx();
if(p<0)
p+=2*circPt.getx()+1;
else
{
circPt.decrementy();
p+=2*(circPt.getx()-circPt.gety())+1;
}
circlePlotPoints(xc,yc,circPt);
}
}
voidcirclePlotPoints(GLintxc,GLintyc,screenPtcircPt)//描绘八分圆各点
{
draw_pixel(xc+circPt.getx(),yc+circPt.gety());
draw_pixel(xc-circPt.getx(),yc+circPt.gety());
draw_pixel(xc+circPt.getx(),yc-circPt.gety());
draw_pixel(xc-circPt.getx(),yc-circPt.gety());
draw_pixel(xc+circPt.gety(),yc+circPt.getx());
draw_pixel(xc-circPt.gety(),yc+circPt.getx());
draw_pixel(xc+circPt.gety(),yc-circPt.getx());
draw_pixel(xc-circPt.gety(),yc-circPt.getx());
}
voiddisplay()
{
//screenPtPt;
glClear(GL_COLOR_BUFFER_BIT);
circleMidpoint(250,250,200);
glFlush();
}
voidmyinit()
{
glClearColor(0.8,1.0,1.0,1.0);
glColor3f(0.0,0.0,1.0);
glPointSize(1.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0,500.0,0.0,500.0);
}
voidmain(intargc,char**argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowSize(500,500);
glutInitWindowPosition(200.0,200.0);
glutCreateWindow("CG_test_中点画圆example");
glutDisplayFunc(display);
myinit();
glutMainLoop();
}
运行效果：
❹ 圆光栅最高精度是多少
* 脉冲周期：50到10000
* 精度：±1/10 脉冲周期
❺ 我看到了这么句话，关于圆光栅编码器的，求高手 告诉我下0.065arc sec 的分辨率怎么算的
我理解：
说明编码器的一周有10，000线；
但是通过插补可能实验0.065arc sec 的分辨率。
可能是2000细分；10，000 * 2000=20，000，000 即 0.0648 arc sec。
度 (degrees, deg)
角分(arc minutes, arc min, ′)
角秒(arc seconds, arc sec, ″)
密位(mils)
1 度=60角分=3600角秒
1deg=60 arc min=3600 arc sec
1°=60′=3600″
360度=6000密位
1密位=0.06度
360度 / 10000分辨率 = 0.036度/1分辨率
❻ 光栅测长技术有什么概念简介
光栅测长技术是利用光栅产生的莫尔条纹测量位移和轮廓形状等的长度计量技术。利用光栅产生的莫尔条纹测量位移和轮廓形状等的长度计量技术。测量位移时，将计量光栅副中的光栅尺和指示光栅分别固定在长度测量工具或机床等的移动件（例如滑架）和不动件(例如机床导轨)上。两者相隔一个很小的间隙(一般为0.05～0.1毫米)。当滑架移动时，出现在光栅副上的莫尔条纹的周期性光强变化，通过光电转换元件转换为正弦波形电信号，经放大、整形、细分、计数和显示等电子部分后即可得出光栅位移量。
由光源、计量光栅副和光电转换元件等组成的部件称为光栅式长度传感器。由光栅式长度传感器和放大、整形、细分、计数和显示等电子部分组成的系统称为光栅测量系统,常用具有相位依次差1/4线距的四组线条的光栅作为指示光栅。当以圆光栅副代替长光栅副时，类似的测量系统可用于测量角位移。长、圆光栅测量系统的精确度分别可达1微米/1000毫米和0.5″/360°以上。
随着光栅制造技术和电子技术的发展，从20世纪50年代开始应用光栅测长技术来测量位移。这种方法已用于三坐标测量机、数字显示工具显微镜、渐开线测量仪、齿轮单面啮合检查仪和电子千分尺等的测量系统中，也常用于数字控制机床的定位反馈系统和其他机床的定位系统中。70年代又开始利用莫尔轮廓图测量表面轮廓形状和变形等。
❼ 圆光栅测角精度怎么确定
主要看编码器的型号是多少线的？还有显示精度，确定到度分秒，