x扫描算法

‘壹’ x-scan 是怎么用的

X-Scan
是一个很好的扫描工具。但是你想进入别人的电脑，光靠他是不行的，你得有个侵入工具，还需要做了免杀的木马。

‘贰’ 有没有知道X射线衍射ω扫描和φ扫描是怎么一回事

xiaoshang(站内联系TA)ω扫描和φ扫描到底是一个什么样的原理，有什么作用呢？小狂野(站内联系TA)这要查看有关现代材料分析测试技术的书籍zhuzhen(站内联系TA)普通的2θ扫描是样品或x射线管转动θ，探测器转动2θ，一般依据峰位分析物相；ω扫描，即摇摆曲线，入射的X光保持不变，探测器保持不变，同时入射光同探测器之间的夹角也保持不变（固定在2theta）。然后样品围绕着平行于样品表面的一根轴（此轴也垂直于由入射光和探测器两相交直线构成的平面）来回转动，用来描述某一特定晶面在样品中角发散大小的测试方法；φ扫描，即phi-scan，是样品先倾斜一个角度（要扫的面和生长面的夹角）再自身旋转360度，一般用来分析样品面内排布（对称性，有无孪晶等）。个人理解，不完整哈 普通的2θ扫描是样品或x射线管转动θ，探测器转动2θ，一般依据峰位分析物相；ω扫描，即摇摆曲线，入射的X光保持不变，探测器保持不变，同时入射光同探测器之间的夹角也保持不变（固定在2theta）。然后样品围绕着 ... 恩，说的很好，支持。iphyaries(站内联系TA)常规的粉末衍射遇不到的 需要专门的高分辨衍射仪分别检查不同方向上晶体的缺陷

‘叁’ x扫描线算法平行于x轴的线怎么办

由于三角形的形状和位置,主要是靠三个顶点确定的. 那么是不是可以先找三个顶点,只要找到三个顶点就行了呢. 仅供参卡.

‘肆’ 什么叫X光断层扫描技术

电子计算机X射线断层扫描机简称X—CT或CT)，就是利用x射线对人体进行断层扫描后，由探测器收得的模拟信号再变成数字信号，经电子计算机计算出每一个像素的衰减系数，再重建图像，而能显示出人体各部位的断层结构的装置。

它以断层的图像形式，较清晰地显示人体组织的细微差别。彻底解决了内部重叠显示问题，而且能将人体各种组织对x线的吸收系数以相当精确 的数字表示出来，因而对软组织中的病变也能正确诊断。CT要区分不同的密度组织，则用C T值来表示，其范围取—1000至十1000，以空气为—1000，水为0，骨骼为十1000。

‘伍’ 扫描仪里面的扫描对象X是代表什么意思

X代表的是您选择扫描位置的横坐标,Y代表的是竖坐标.他决定您扫描区域的位置
W代表的是宽度,H代表的是高度!他决定您扫描区域的大小!

‘陆’ 计算机图形学：直线段扫描转换算法

//数值微分算法（DDA算法）
#include<iostream>
using namespace std;
int main()
{
float x0,y0,x1,y1,x2,y2;
cin>>x1>>y1;
cin>>x0>>y0;
float k;
k=(y1-y0)/(x1-x0);
if(k<1)
{
x2=x1+1;
y2=y2+k;
}
else if(k>=1)
{
y2=y1+1;
x2=1/k+x1;
}
cout<<x2<<" "<<y2<<endl;
return 0;
}
//中点划线算法
#include<iostream>
using namespace std;
int main()
{ float x,y;
float x0,y0,x1,y1;
cin>>x0>>y0>>x1>>y1;
float a,b,c;
a=y0-y1;
b=x1-x0;
c=x0*y1-x1*y0;
float sum;
sum=a*x+b*y+c;
float Xq,Yq;
float Xm,Ym;
Xm=x0+1;
Ym=y0+0.5;
float d;
d=a*Xm+b*Ym+c;
if(d<0)
{Xq=x0+1; Yq=y0+1; }
else if(d>0)
{ Xq=x0+1; Yq=y0; }
else if(d=0)
{ Xq=x0+1; Yq=y0; }
cout<<Xq<<" "<<Yq<<endl;return 0;
}
//Bresenham算法//有一个整数数组，请求出两两之差绝对值最大的值（最小的值）
#include<iostream>
using namespace std;
int jisuan(int a,int b)
{ int des=0; des=a-b; if(des<0)
des=-des;
return des;}
int main()
{ int dec=0; int max=0; int a[5]={0,2,5,9,4}; for(int i=1;i<5;i++)
{ dec=jisuan(a[i],a[i-1]); if(max<dec) max=dec; }
cout<<max<<endl;
return 0;
}
不好意思，最后一个是我写的另一个代码，贴错了

‘柒’ 求C源码：计算机图形学程序——扫描线算法

这是我以前上学的时候写的，你改改，凑活用巴。

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

#include <graphics.h>
#include <stdio.h>
#include <dos.h>
#include <math.h>
#include <bios.h>
#include <string.h>

void parspl ( int p[10000][2] , long n , int precision , int color )
{
int x = 0 , y = 0 , i = 0 , j = 0 , m = 0 ;
double t2 = 0 , t3 = 0 , t = 0 , a , b , c , d , e = p[1][0] + 5 , f = p[1][1] + 5 ;
setcolor ( color ) ;
m=n+1;
p[0][0] = p[n][0] ;
p[0][1] = p[n][1] ;
p[m][0] = p[1][0] ;
p[m][1] = p[1][1] ;
p[m+1][0] = p[2][0] ;
p[m+1][1] = p[2][1] ;
moveto ( p[1][0] , p[1][1] ) ;
for ( i = 0 ; i < n ; i ++ )
{
t = 0.5 / precision ;
for ( j = 1 ; j < precision ; j ++ )
{
t2 = t * t ;
t3 = t2 * t ;
a = 4 * t2 - t - 4 * t3 ;
b = 1 - 10 * t2 + 12 * t3 ;
c = t + 8 * t2 - 12 * t3 ;
d = 4 * t3 - 2 * t2 ;
x = a * p[i][0] + b * p[i+1][0] + c * p[i+2][0] + d * p[i+3][0] ;
y = a * p[i][1] + b * p[i+1][1] + c * p[i+2][1] + d * p[i+3][1] ;
lineto ( x , y ) ;
line ( e , f , x + 5 , y + 5 ) ;
moveto ( x , y ) ;
t += 0.5 / precision ;
e = x + 5 ;
f = y + 5 ;
}
lineto ( p[i+2][0] , p[i+2][1] ) ;
moveto ( e , f ) ;
lineto ( p[i+2][0] + 5 , p[i+2][1] + 5 ) ;
moveto ( p[i+2][0] , p[i+2][1] ) ;
}
}

int main()
{
long n = 5 ;
char pwd[4] ;
int p[100][2] ;
int a1 , a2 , b1 , b2 , c1 , c2 , d1 , d2 , e1 , e2 ;
int gdriver = VGA , gmode = VGAHI ;
initgraph( &gdriver , &gmode , "c:\\tc" ) ;
setbkcolor ( 0 ) ;
a1 = p[1][0] = 320 ;
a2 = p[1][1] = 240 ;
b1 = p[2][0] = 320 ;
b2 = p[2][1] = 120 ;
c1 = p[3][0] = 452 ;
c2 = p[3][1] = 128 ;
d1 = p[4][0] = 382 ;
d2 = p[4][1] = 388 ;
e1 = p[5][0] = 364 ;
e2 = p[5][1] = 280 ;
loop:
if ( a1 <= p[1][0] && p[1][0] <= 520 )
{
a1 = p[1][0] ;
p[1][0] += 1 ;
}
else
{
if ( p[1][0] >= 120 )
{
a1 = p[1][0] ;
p[1][0] -= 1 ;
}
else
a1 = p[1][0] = 120 ;
}
if ( a2 >= p[1][1] && p[1][1] >= 60 )
{
a2 = p[1][1] ;
p[1][1] -= 2 ;
}
else
{
if ( p[1][1] <= 420 )
{
a2 = p[1][1] ;
p[1][1] += 2 ;
}
else
a2 = p[1][1] = 420 ;
}
if ( b1 >= p[2][0] && p[2][0] >= 120 )
{
b1 = p[2][0] ;
p[2][0] -= 2 ;
}
else
{
if ( p[2][0] <= 520 )
{
b1 = p[2][0] ;
p[2][0] += 2 ;
}
else
b1 = p[2][0] = 520 ;
}
if ( b2 <= p[2][1] && p[2][1] <= 420 )
{
b2 = p[2][1] ;
p[2][1] += 1 ;
}
else
{
if ( p[2][1] >= 60 )
{
b2 = p[2][1] ;
p[2][1] -= 1 ;
}
else
b2 = p[2][1] = 60 ;
}
if ( c1 <= p[3][0] && p[3][0] <= 520 )
{
c1 = p[3][0] ;
p[3][0] += 1 ;
}
else
{
if ( p[3][0] >= 120 )
{
c1 = p[3][0] ;
p[3][0] -= 1 ;
}
else
c1 = p[3][0] = 120 ;
}
if ( c2 <= p[3][1] && p[3][1] <= 420 )
{
c2 = p[3][1] ;
p[3][1] += 1 ;
}
else
{
if ( p[3][1] >= 60 )
{
c2 = p[3][1] ;
p[3][1] -= 1 ;
}
else
c2 = p[3][1] = 60 ;
}
if ( d1 >= p[4][0] && p[4][0] >= 120 )
{
d1 = p[4][0] ;
p[4][0] -= 1 ;
}
else
{
if ( p[4][0] <= 520 )
{
d1 = p[4][0] ;
p[4][0] += 1 ;
}
else
d1 = p[4][0] = 520 ;
}
if ( d2 >= p[4][1] && p[4][1] >= 60 )
{
d2 = p[4][1] ;
p[4][1] -= 1 ;
}
else
{
if ( p[4][1] <= 420 )
{
d2 = p[4][1] ;
p[4][1] += 1 ;
}
else
d2 = p[4][1] = 420 ;
}
if ( e1 <= p[5][0] && p[5][0] <= 520 )
{
e1 = p[5][0] ;
p[5][0] += 1 ;
}
else
{
if ( p[5][0] >= 120 )
{
e1 = p[5][0] ;
p[5][0] -= 1 ;
}
else
e1 = p[5][0] = 120 ;
}
if ( e2 <= p[5][1] && p[5][1] <= 420 )
{
e2 = p[5][1] ;
p[5][1] += 2 ;
}
else
{
if ( p[5][1] >= 60 )
{
e2 = p[5][1] ;
p[5][1] -= 2 ;
}
else
e2 = p[5][1] = 60 ;
}
parspl ( p , n , 100 , 4 ) ;
parspl ( p , n , 100 , 4 ) ;
if ( bioskey ( 1 ) > 0 )
{
printf ("Please Input Password:") ;
gets (pwd) ;
if ( !strcmp(pwd,"cmy") )
{
clearviewport () ;
closegraph () ;
return 1 ;
}
}
cleardevice () ;
goto loop ;
}

‘捌’ 我需要用C++程序做的Nstep-scan

自己看着修改了，修改下还不简单。

#include "stdio.h"
#include "stdlib.h"

void CopyL(int Sour[],int Dist[] ,int x); //数组Sour复制到数组Dist，复制到x个数
void SetDI(int DiscL[]); //随机生成磁道数
void Print(int Pri[],int x); //打印输出数组Pri
void DelInq(int Sour[],int x,int y); //数组Sour把x位置的数删除，并把y前面的数向前移动，y后的数保持不变(即会出现2个y)
void FCFS(int Han,int DiscL[]); //先来先服务算法(FCFS)
void SSTF(int Han,int DiscL[]); //最短寻道时间优先算法(SSTF)
int SCAN(int Han,int DiscL[],int x,int y); //扫描算法(SCAN)
void CSCAN(int Han,int DiscL[]); //循环扫描算法(CSCAN)
void N_Step_SCAN(int Han1,int DiscL[]); //N步扫描算法(NStepScan)
void PaiXu(); //寻道长度由低到高排序
void Pri();
int NAll=0;
int Best[5][2]; //用作寻道长度由低到高排序时存放的数组
int Limit=0; //输入寻找的范围磁道数i
int Jage;
float Aver=0;

int main()
{
int i;
int DiscLine[10]; //声明准备要生成的随机磁道号的数组
int Hand; //磁道数
int Con=1;
int n;
while (Con==1)
{
Jage=0;
printf("\n 请输入初始的磁道数(0<n<65536):");
scanf("%d",&Hand);
printf("\n+ 输入寻找的范围:");
scanf("%d",&Limit);
if (Limit>65536)
{
printf("超出范围!");
}
else
{
printf(" ╭═══════════════╮ \n");
printf(" ║ 操作系统课程设计 ║ \n");
printf(" ╭═════┤ 磁盘调度算法 ├═════╮\n");
printf(" ║ ║ ║ ║\n");
printf(" ║ ╰═══════════════╯ ║\n");
printf(" ║ 1.先来先服务算法(FCFS) ║\n");
printf(" ║ ║\n");
printf(" ║ 2.最短寻道时间优先算法(SSTF) ║\n");
printf(" ║ ║\n");
printf(" ║ 3.扫描算法(SCAN) ║\n");
printf(" ║ ║\n");
printf(" ║ 4.循环扫描算法(CSCAN) ║\n");
printf(" ║ ║\n");
printf(" ║ 5.N步扫描算法(NStepScan) ║\n");
printf(" ║ ║\n");
printf(" ║ 6.各类算法的比较 ║\n");
printf(" ║ ║\n");
printf(" ║ ║\n");
printf(" ║ ╭———————————————————————╮ ║\n");
printf(" ╰═┤ 请输入你的选择的算法(输入0离开) ├═╯\n");
printf(" ╰———————————————————————╯\n");
scanf("%d",&n);
if (n==0) exit(0);
printf("\n");
switch (n)
{
case 1:
SetDI(DiscLine); //随机生成磁道数
FCFS(Hand,DiscLine); //先来先服务算法(FCFS)
break;
case 2:
SetDI(DiscLine); //随机生成磁道数
SSTF(Hand,DiscLine); //最短寻道时间优先算法(SSTF)
break;
case 3:
SetDI(DiscLine); //随机生成磁道数
SCAN(Hand,DiscLine,0,9); //扫描算法(SCAN)
break;
case 4:
SetDI(DiscLine); //随机生成磁道数
CSCAN(Hand,DiscLine); //循环扫描算法(CSCAN)
break;
case 5:
SetDI(DiscLine); //随机生成磁道数
N_Step_SCAN(Hand,DiscLine); //N步扫描算法(NStepScan)
break;
case 6:
SetDI(DiscLine); //随机生成磁道数
FCFS(Hand,DiscLine); //先来先服务算法(FCFS)
SSTF(Hand,DiscLine); //最短寻道时间优先算法(SSTF)
SCAN(Hand,DiscLine,0,9); //扫描算法(SCAN)
CSCAN(Hand,DiscLine); //循环扫描算法(CSCAN)
N_Step_SCAN(Hand,DiscLine); //N步扫描算法(NStepScan)
PaiXu(); //寻道长度由低到高排序
printf("\n\n+ 寻道长度由低到高排序:");
for (i=0;i<5;i++)
{
printf("%4d ",Best[i][0]);
}
break;
}
printf("\n\n+ 是否继续(按0结束,按1继续)?");
scanf("%5d",&Con);
}

}
}

//数组Sour复制到数组Dist，复制到x个数
void CopyL(int Sour[],int Dist[] ,int x)
{
int i;
for (i=0;i<=x;i++)
{
Dist[i]=Sour[i];
}
}
//打印输出数组Pri
void Print(int Pri[],int x)
{
int i;
for (i=0;i<=x;i++)
{
printf("%5d",Pri[i]);
}
}
//随机生成磁道数
void SetDI(int DiscL[])
{
int i;
for (i=0;i<=9;i++)
{
DiscL[i]=rand()%Limit;//随机生成10个磁道号
}
printf("+ 需要寻找的磁道号:");
Print(DiscL,9); //输出随机生成的磁道号
printf("\n");
}
//数组Sour把x位置的数删除，并把y前面的数向前移动，y后的数保持不变(即会出现2个y)
void DelInq(int Sour[],int x,int y)
{
int i;
for (i=x;i<y;i++)
{
Sour[i]=Sour[i+1];
x++;
}
}
//先来先服务算法(FCFS)
void FCFS(int Han,int DiscL[])
{
int RLine[10]; //将随机生成的磁道数数组Discl[]复制给数组RLine[]
int i,k,All,Temp; //Temp是计算移动的磁道距离的临时变量
All=0; //统计全部的磁道数变量
k=9; //限定10个的磁道数
CopyL(DiscL,RLine,9); //复制磁道号到临时数组RLine
printf("\n+ 按照FCFS算法磁道的访问顺序为:");
All=Han-RLine[0];
for (i=0;i<=9;i++)
{
Temp=RLine[0]-RLine[1];//求出移动磁道数,前一个磁道数减去后一个磁道数得出临时的移动距离
if (Temp<0)
Temp=(-Temp);//移动磁道数为负数时,算出相反数作为移动磁道数
printf("%5d",RLine[0]);
All=Temp+All;//求全部磁道数的总和
DelInq(RLine,0,k);//每个磁道数向前移动一位
k--;
}
Best[Jage][1]=All;//Best[][1]存放移动磁道数
Best[Jage][0]=1; //Best[][0]存放算法的序号为:1
Jage++;//排序的序号加1
Aver=((float) All)/10;//求平均寻道次数
printf("\n+ 移动磁道数:<%5d> ",All);
printf("\n+ 平均寻道长度:*%0.2f* ",Aver);
}
//最短寻道时间优先算法(SSTF)
void SSTF(int Han,int DiscL[])
{
int i,j,k,h,All;
int Temp; //Temp是计算移动的磁道距离的临时变量
int RLine[10]; //将随机生成的磁道数数组Discl[]复制给数组RLine[]
int Min;
All=0; //统计全部的磁道数变量
k=9; //限定10个的磁道数
CopyL(DiscL,RLine,9); //复制磁道号到临时数组RLine
printf("\n+ 按照SSTF算法磁道的访问顺序为:");
for (i=0;i<=9;i++)
{
Min=64000;
for (j=0;j<=k;j++) //内循环寻找与当前磁道号最短寻道的时间的磁道号
{
if (RLine[j]>Han) //如果第一个随机生成的磁道号大于当前的磁道号，执行下一句
Temp=RLine[j]-Han; //求出临时的移动距离
else
Temp=Han-RLine[j]; //求出临时的移动距离
if (Temp<Min) //如果每求出一次的移动距离小于Min，执行下一句
{
Min=Temp; //Temp临时值赋予Min
h=j; //把最近当前磁道号的数组下标赋予h
}
}
All=All+Min; //统计一共移动的距离
printf("%5d",RLine[h]);
Han=RLine[h];
DelInq(RLine,h,k); //每个磁道数向前移动一位
k--;
}
Best[Jage][1]=All;//Best[][1]存放移动磁道数
Best[Jage][0]=2;//Best[][0]存放算法的序号为:2
Jage++;//排序序号加1
Aver=((float)All)/10;//求平均寻道次数
printf("\n+ 移动磁道数:<%5d> ",All);
printf("\n+ 平均寻道长度:*%0.2f* ",Aver);
}
//扫描算法(SCAN)
int SCAN(int Han,int DiscL[],int x,int y)
{
int j,n,k,h,m,All;
int t=0;
int Temp;
int Min;
int RLine[10]; //将随机生成的磁道数数组Discl[]复制给数组RLine[]
int Order;
Order=1;
k=y;
m=2; //控制while语句的执行，即是一定要使当前磁道向内向外都要扫描到
All=0; //统计全部的磁道数变量
CopyL(DiscL,RLine,9); //复制磁道号到临时数组RLine
printf("\n+ 按照SCAN算法磁道的访问顺序为:");
Min=64000;
for (j=x;j<=y;j++) //寻找与当前磁道号最短寻道的时间的磁道号
{
if (RLine[j]>Han) //如果第一个随机生成的磁道号大于当前的磁道号，执行下一句
Temp=RLine[j]-Han; //求出临时的移动距离
else
Temp=Han-RLine[j]; //求出临时的移动距离
if (Temp<Min)
{
Min=Temp; //Temp临时值赋予Min
h=j; //把最近当前磁道号的数组下标赋予h
}
}
All=All+Min;
printf("%5d",RLine[h]);
if (RLine[h]>=Han) //判断磁道的移动方向，即是由里向外还是由外向里
{
Order=0;
t=1;
}
Han=RLine[h];
DelInq(RLine,h,k); //每个磁道数向前移动一位
k--;
while (m>0)
{
if (Order==1) //order是判断磁盘扫描的方向标签，order是1的话，磁道向内移动
{
for (j=x;j<=y;j++)
{
h=-1;
Min=64000;
for (n=x;n<=k;n++) //判断离当前磁道最近的磁道号
{
if (RLine[n]<=Han)
{
Temp=Han-RLine[n];
if (Temp<Min)
{
Min=Temp; //Temp临时值赋予Min
h=n; //把最近当前磁道号的数组下标赋予h
}
}
}
if (h!=-1)
{
All=All+Min; //叠加移动距离
printf("%5d",RLine[h]);
Han=RLine[h]; //最近的磁道号作为当前磁道
DelInq(RLine,h,k);
k--;
}
}
Order=0; //当完成向内的移动，order赋予0，执行else语句，使磁道向外移动
m--; //向内完成一次，m减一次，保证while循环执行两次
}
else //order是0的话，磁道向外移动
{
for (j=x;j<=y;j++)
{
h=-1;
Min=64000;
for (n=x;n<=k;n++) //判断离当前磁道最近的磁道号
{
if (RLine[n]>=Han)
{
Temp=RLine[n]-Han;
if (Temp<Min)
{
Min=Temp; //Temp临时值赋予Min
h=n; //把最近当前磁道号的数组下标赋予h
}
}
}
if (h!=-1)
{
All=All+Min; //叠加移动距离
printf("%5d",RLine[h]);
Han=RLine[h]; //最近的磁道号作为当前磁道
DelInq(RLine,h,k);
k--;
}
}
Order=1; //当完成向内的移动，order赋予0，执行else语句，使磁道向外移动
m--; //向内完成一次，m减一次，保证while循环执行两次
}
}
NAll=NAll+All;
if ((y-x)>5)
{
Best[Jage][1]=All;//Best[][1]存放移动磁道数
Best[Jage][0]=3;//Best[][0]存放算法的序号为:3
Jage++;//排序序号加1
Aver=((float)All)/10;//求平均寻道次数
printf("\n+ 移动磁道数:<%5d> ",All);
printf("\n+ 平均寻道长度:*%0.2f* ",Aver);
}
if (t==1) printf("\n+ 磁道由内向外移动");
else printf("\n+ 磁道由外向内移动");
return(Han);
}
//循环扫描算法(CSCAN)
void CSCAN(int Han,int DiscL[])
{

int j,h,n,Temp,m,k,All,Last,i;
int RLine[10]; //将随机生成的磁道数数组Discl[]复制给数组RLine[]
int Min;
int tmp=0;
m=2;
k=9;
All=0; //统计全部的磁道数变量
Last=Han;
CopyL(DiscL,RLine,9); //复制磁道号到临时数组RLine
printf("\n+ 按照CSCAN算法磁道的访问顺序为:");
while (k>=0)
{
for (j=0;j<=9;j++) //从当前磁道号开始，由内向外搜索离当前磁道最近的磁道号
{
h=-1;
Min=64000;
for (n=0;n<=k;n++)
{
if (RLine[n]>=Han)
{
Temp=RLine[n]-Han;
if (Temp<Min)
{
Min=Temp;
h=n;
}
}
}
if (h!=-1)
{
All=All+Min; //统计一共移动的距离
printf("%5d",RLine[h]);
Han=RLine[h];
Last=RLine[h];
DelInq(RLine,h,k);
k--;
}
}
if (k>=0)
{
tmp=RLine[0];
for (i=0;i<k;i++)//算出剩下磁道号的最小值
{
if (tmp>RLine[i]) tmp=RLine[i];
}
Han=tmp;//把最小的磁道号赋给Han
Temp=Last-tmp;//求出最大磁道号和最小磁道号的距离差
All=All+Temp;
}
}
Best[Jage][1]=All;//Best[][1]存放移动磁道数
Best[Jage][0]=4;//Best[][0]存放算法的序号为:4
Jage++;//排序序号加1
Aver=((float)All)/10;//求平均寻道次数
printf("\n+ 移动磁道数:<%5d> ",All);
printf("\n+ 平均寻道长度:*%0.2f* ",Aver);
}
//N步扫描算法(NStepScan)
void N_Step_SCAN(int Han1,int DiscL[])
{
int i,m,k;
int RLine1[10];
NAll=0;
m=2;
k=9; //限定10个的磁道数
i=-1;
CopyL(DiscL,RLine1,9); //复制磁道号到临时数组RLine
printf("\n+ 按照N_Step_SCAN算法磁道的访问顺序为:");
for (m=0;m<2;m++) //由于限定10磁道数，将10个磁道数分为两组，每组5个磁道数，每个组按照SCAN算法执行，该循环循环2次
{
Han1=SCAN(Han1,RLine1,i+1,i+5);
i=i+5;
}
Best[Jage][1]=NAll;//Best[][1]存放移动磁道数
Best[Jage][0]=5;//Best[][0]存放算法的序号为:5
Aver=((float)NAll)/10;//求平均寻道次数
printf("\n+ 移动磁道数:<%5d> ",NAll);
printf("\n+ 平均寻道长度:*%0.2f* ",Aver);
}
//寻道长度由低到高排序
void PaiXu()
{
int i,j,Temp;
for (i=0;i<5;i++)
{
for (j=0;j<4;j++)
{
if (Best[j][1]>Best[j+1][1]) //如果前一个算法的移动磁道距离大于后一个移动磁道数，执行下面语句
{
Temp=Best[j+1][1]; //从这起下三行执行冒泡法将移动距离大小排序，排完后则执行每个算法的排序
Best[j+1][1]=Best[j][1];
Best[j][1]=Temp;
Temp=Best[j+1][0]; //将每个算法的序号用冒泡法排序
Best[j+1][0]=Best[j][0];
Best[j][0]=Temp;
}
}
}
}

‘玖’ 扫描算法增加方向和减少方向算出来的值一样吗.

一样
要实现区域的扫描线填充必须先确定填充区边界与屏幕扫描线的交点位置。然后，将填充色应用于扫描线上位于填充区域内部的每一段。扫描线填充算法利用奇偶规则识别同一内部区域（参见）。最简单的填充区域是多边形，因为每一扫描线和多边形的交点可通过求解一对联立的线性方程来获得，其中扫描线的方程是y = 常数。
给出了多边形区域的实心填充的扫描线过程。对每一条与多边形相交的扫描线，与边的交点从左向右排序，且将每一对交点之间的像素位置包括这对交点在内，设定为指定颜色。在图4.20的例子中，与边界的四个交点像素位置定义了两组内部像素。这样，填充色应用于从x=10到x = 14的5个像素和从x = 18到x = 24的7个像素。如果图案填充应用于多边形，则沿一条扫描线的每一像素颜色由与填充图案重叠的位置来确定。

‘拾’ 在x射线连续扫描中，为什么采用θ

xiaoshang(站内联系TA)ω扫描和φ扫描到底是一个什么样的原理，有什么作用呢？小狂野(站内联系TA)这要查看有关现代材料分析测试技术的书籍zhuzhen(站内联系TA)普通的2θ扫描是样品或x射线管转动θ，探测器转动2θ，一般依据峰位分析物相；ω扫描，即摇