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θ，一般依據峰位分析物相；ω掃描，即搖