Giáo trình xử lý ảnh y tế Tập 1b P5 doc

Các bộ lọc có đáp ứng tần với phần số thực thuần tuý được gọi là các bộ lọc pha zero.. Trong các bộ lọc này, các pha zero được dịch đi một góc , cụ thể là có các giá trị âm trong phổ

suy ra

1 2

1 1 2

1

1

1 1

1 ) , (













z z

z z U

Phổ tần số của tín hiệu bước nhảy có thể tính từ

2 1

2 1

1

1 1

1 )

, ( iw T iw T iw T iw T

e e

e e U













3.3 Các bộ lọc hai chiều có đáp ứng xung hữu hạn 2-D

Quan hệ giữa đầu vào và đầu ra cho bộ lọc FIR 2-D (FIR - Finite Impulse Response) được cho bởi





 1

1

2

2

2 2 1 1 2 1 2

1

) ,

( ) , ( )

, (

N N k

N N k

k n k n x k k h n

n

Trong biểu thức (3.11), h(n 1 ,n 2 ) là đáp ứng xung của bộ lọc và được định nghĩa

trên một cửa sổ có kích thước (2N1 + 1)  (2N2 + 1) có gốc toạ độ ở trung tâm;

x(n 1 ,n 2 ) là tín hiệu vào của bộ lọc

Nếu x(n 1 ,n 2 ) = 0 với (n1 0)(n2 0), thì bằng cách lấy biến đổi z cả hai phía

của biểu thức (3.11) chúng ta được

2 1

2 1 1

1 2

2

2 1 2 1 2

1, ) ( , ) ( , )

N N k N N k

z z z z X k k h z

z

 

 



(3.12) Hàm truyền đạt của bộ lọc 2-D FIR được cho bởi

2 1

2 1 1

1 2

2 2 1 2

1

2 1 2

) , (

) , ( ) ,

N N k N N k

z z k k h z

z X

z z Y z z

 





(3.13) Các bộ lọc trên được định nghĩa là có kích thước (2N1 + 1)  (2N2 + 1) Trong hầu hết các ứng dụng chúng ta đặt N1 = N2 = N

Đáp ứng tần số của bộ lọc 2-D có thể tính từ

2 2 1 1

2 1

1

1 2

2 2

1, ) ( )

,

N N k N N k

T j T j

e e k k h e

e

 

 



(3.14) Đáp ứng xung có thể tính từ đáp ứng tần số sau khi dùng biểu thức (2.17) trong chương 2

Các bộ lọc có đáp ứng tần với phần số thực thuần tuý được gọi là các bộ lọc

pha zero Trong các bộ lọc này, các pha zero được dịch đi một góc , cụ thể là có

các giá trị âm trong phổ tần số Một bộ lọc pha zero có đáp ứng xung là số thực thoả mãn

h(n1,n2)h(n1,n2)

Có nghĩa là mỗi một mẫu đều có một giá trị bằng nó tương ứng Vì thế, biểu thức (3.11) có thể viết lại thành:

) , h(0,0)

+

) , ( ) , ( )[

0 , ( +

)]

, ( ) ,

( )[

, ( )

,

(

2 1

2 1 1 1

k

2 1 1 1

2 2 1 1 1

2 2 1 1 2 1 2

1

1

n x(n

n k n x n k n x k h

k n k n x k n k n x k k h n

n

y

N

N

N k

N k





















 



 

(3.15)

Do vậy làm giảm đi số phép nhân cần thiết để thực hiện bộ lọc

Cho bộ lọc đối xứng vòng tròn chúng ta có

) , ( ) , ( ) , ( ) , (k1 k2 h k1 k2 h k1 k2 h k1 k2

Và N1 = N2 = N Biểu thức (3.14) có thể viết lại

) , 0 0

)]

, ( ) ,

(

) , ( ) ,

(

)]

, (

) ,

( ) ,

(

) ,

( )[

, ( )

, (

2 1

2 1

2 1

2 1

2 1

2 2 1 1

2 2 1 1 2

2 1 1

1 1

2 2 1 1 2 1 2

1

n )x(n , h(

n k n x k n n x

n k n x k n n x

k n k n x

k n k n x k n k n x

k n k n x k k h n

n y

N k N k

+

+

k)[

h(0, +

+

+

N

1

= k



































 

 

(3.16)

Các bộ lọc đối xứng vòng tròn biểu diễn tích đối xứng bát giác (xem kết quả của ví dụ 2.5 và 2.6 cho trong chương 2) Vì vậy

h(k 1 ,k 2 ) = h(k 2 ,k 1 )

Và ở đây biểu thức (3.16) có thể viết lại thành

 

 







N k N k

k n k n x k k h n

n y

1 1

2 2 1 1 2 1 2

1

) ,

( )[

, ( )

, (

+x(n1k2,n2k1)x(n1k1,n2k2)

)]

, (

) ,

( ) ,

(

) ,

( ) ,

(

1 2 2 1

2 2 1 1 1

2 2 1

2 2 1 1 1

2 2 1

k n k n x

k n k n x k n k n x

k n k n x k n k n x

























+

+

+

) , ( ) 0 , 0 ( )]

, ( ) , (

) , ( ) , (

)]

, ( ) ,

(

) , ( ) , ( )[

, (

2 1 2

1 2

1

2 1 2

1

2 1 2

1 1

2 1 2

1

n n x h n k n x k n n x

n k n x k n n x

k n k n x k n k n x

k n k n x k n k n x k k h

k









































+

k)[

h(0, +

+ +

N

1

= k

3.4 Phần mềm thực hiện của các bộ lọc 2-D có đáp ứng xung hữu hạn

Trong phần này chúng tôi sẽ trình bày phương pháp thực hiện bằng phần mềm

bộ lọc 2-D FIR cho xử lý ảnh số Chúng ta sẽ coi rằng ảnh được lưu trên bộ nhớ ngoài như đĩa cứng hay vùng đệmảnh Số dòng tối thiểu cần cho việc xử lý, được lưu trong bộ nhớ, cho phép lọc các ảnh lớn mà không cần dự trữ một lượng lớn bộ nhớ của máy tính Phương pháp này được mô tả bằng sơ đồ trong hình 3.1

Hình 3.1 Lọc 2-D

Thuật toán gồm các bước sau:

1 Xoá bộ đệm ảnh, w

2 Cho n 1 = (0, 1, 2, , (chiều dài ảnh -1), hãy làm các công việc sau:

a Chuyển hàng thứ n 1 từ bộ đệm ảnh hoặc từ file ảnh lên hàng cuối cùng trong

w (Chúng ta coi rằng ảnh được biểu diễn bằng 8 bit hay 256 mức xám)

b Cho n 2 = 0, 1, 2, , (chiều rộng ảnh-1) làm các công việc sau:

(1) Tính z(n 2 ) từ

Lưu trữ tại bộ nhớ ngoài hay

bộ đệm ảnh

Hàng thứ n 1

dịch

n 2

Bộ đệm chuyển đổi ảnh w

(trong bộ nhớ trong) kích thước = (2N + 1)  độ rộng của ảnh

) ,

( ) ,

2 1

z

N N k N

N

k





Buffer

Kích thước = 1  độ rộng ảnh

2

n

z

(0,2N)

(0,0)

Độ rộng của ảnh Chiều dài của ảnh ((độ_rộng_của_ảnh-1),0)

n 1

Bộ đệm ảnh

 

 







N

k n k N w k k h n

z

) ,

( ) , ( )

(2) Lưu z(n 2 ) trong bộ đệm tại vùng n2

c Copy bộ đệm ra file trung gian trên đĩa cứng

d Dịch chuyển hàng của w theo hướng như trong hình 3.1, cụ thể,

cho i = 0, 1, , (2N - 1) làm các công việc sau:

row i row i1

3 Đọc ảnh đã lọc từ file trung gian, chia độ và dịch chuyển để các giá trị nằm trong khoảng từ 0 đến 255 (8 bit)

4 Lưu ảnh đã được chia độ lên file hoặc bộ đệm ảnh

5 Xoá file trung gian

6 Hiện thị ảnh đã được lọc

Chú ý rằng biểu thức được dùng trong thuật toán này,

 

 







N N k N N k

k n k N w k k h n

z

) ,

( ) , ( )

(3.18)

Để lọc ảnh có hơi khác với biểu thức truy hồi (3.11) Điểm khác thứ nhất: N là một hằng số thay thế cho n 1,với n 1 là một biến trong biểu thức (3.11) Biến trong

thuật toán này được tính ra bằng cách dịch chuyển hàng trong w Giải thuật trên

dẫn đến cùng một kết quả với biểu thức

 









N N k

N N k

k n k N n x k k h n

n y

) ,

( ) , ( )

, ( 1 2 1 2 1 1 2 2 (3.19)

Tương tự như biểu thức (3.11) ngoại trừ một dịch chuyển của N hàng trên ảnh

ra,

 









N N k

N N k

k k N

z z z z X k k h z

z Y

2 1

2 1 2 1 2 1 2

(

hay

 

 









N N k N N k

k k N

z z k k h z

z z X

z z

Y

2 1

2 1 2 1 1

2 1

2 1

) , ( )

, (

) , (

(3.20)

Chính là biến đổi z trong biểu thức (3.11) được nhân với một trễ dọc z1N

Để tính bộ lọc đối xứng vòng tròn, biểu thức (3.18) có thể viết lại dưới dạng

biểu thức (3.17) bằng cách thay n 1 bằng N

) , (

)]

, ( ) ,

(

) , ( ) ,

(

)]

, ( ) ,

(

) ,

( ) ,

(

)]

, ( ) ,

(

) ,

( ) ,

(

) ,

( ) ,

(

) ,

( ) ,

( [ ) , ( )

(

2

2 2

2 2

2 2

2 2

1 2 2 2

2 1

1 2 2 2

2 1

1 2 2 2

2 1

1 1

1 2 2 2

2 1 2

1 2

2 1

n N w

n k N w k n N w

n k N w k n N w

k n k N w k n k N w

k n k N w k n k N w

k n k N w k n k N w

k n k N w k n k N w

k n k N w k n k N w

k n k N w k n k N w k k h n

z

k k

k k

h(0,0) +

+

k)[

h(0, +

+

k)[

h(k, +

+

+

+

N

1

= k

N

1

= k

















































































 



 

(3.21)

Chương trình 3.1 “FIR.C” Lọc ảnh dùng kiểu lọc FIR

/*PROGRAM 3.1 "FIR.C" Program for filtering Images using FIR type filters.*/

/* This program is for filtering images using the algorithm described in sec.3.4 The filter type

is FIR No assumptions are made regarding the filter coefficients (e.g circular symmetry) Thus, the program is general enough to be used with any type

of FIR filter

The FIR filter coefficients can be obtained using the the Simpson's double integration program described in chapter II */

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

#include <alloc.h>

#include <conio.h>

#include <io.h>

#include <ctype.h>

#include <string.h>

void main()

{

int i,j,n1,n2,N,NT,N2,image_width, image_length,k1,k2; int true_width,true_length,ind;

char file_name[14],ch;

unsigned char **w;

unsigned char *temp;

float **h,max,min;

float nsq, zn2, tmp;

FILE *fptr, *fptr1, *fptr_tmp;

clrscr();

printf

("Enter file name containing FIR filter

coefficients ->");

scanf("%s",file_name);

if((fptr=fopen(file_name,"r"))==NULL)

{

printf("%s does not exist.",file_name);

exit(1);

}

/* calculating order of filter */

nsq=0;

while(fscanf(fptr,"%f ", &tmp)!=EOF) nsq++;

rewind(fptr);

NT=sqrt(nsq);

printf("Order of filter %d x %d",NT,NT);

N=(NT-1)>>1;

N2=N<<1;

/* Allocating memory for filter coefficients h[i][j] */ h=(float **)malloc(NT*sizeof(float *));

for(i=0;i<NT;i++)

*(h+i)=(float *)calloc(NT,sizeof(float));

printf("\n FILTER COEFFICIENTS.\n");

for(i=0;i<NT;i++)

{

for(j=0;j<NT;j++)

{

fscanf(fptr,"%f ", &h[i][j]);

printf("%f ",*((*(h+i))+j));

}

printf("\n");

}

fclose(fptr);

printf

("Press any key to continue, Screen will be

cleared ");

getch();

clrscr();

printf("Enter file name for input image ->");

scanf("%s",file_name);

if((fptr=fopen(file_name,"rb"))==NULL)

{

printf("%s does not exist.", file_name);

printf("\nPress any key to exit.");

getch();

exit(1);

}

nsq=filelength(fileno(fptr));

printf("is this a square image ?");

printf("\n i.e Is image_length=image_width (y or n)? -> ");

while(((ch=tolower(getch()))!='y')&&(ch!='n'));

putch(ch);

switch(ch)

{

case 'y':

image_length=image_width=sqrt(nsq);

printf("\n Image size = %d x %d", image_length, image_width);

break;

case 'n':

printf("\nEnter image_width >");

scanf("%d",&image_width);

image_length=nsq/image_width;

printf("Image length is %d", image_length); break;

}

/* opening a temporary file */

fptr_tmp=fopen("temp_img.dat","w+");

gotoxy(70,25);

textattr(WHITE+(GREEN<<4)+BLINK);

cputs("WAIT");

/* Allocating memory for Image Transfer Buffer, w */ w=(unsigned char **)malloc(NT*sizeof(char *));

for(i=0;i<NT;i++)

*(w+i)=(char *)calloc(image_width,sizeof(char));

/* Clear Image Transfer Buffer */

for(i=0;i<NT;i++)

for(j=0;j<image_width;j++)

*((*(w+i))+j)=(unsigned char)0;

max=(float)0.0;

min=(float)255.0;

true_length=(int)image_length*0.90;

true_width=image_width-NT;

/*************

* Algorithm *

*************/

for(n1=0; n1<image_length;n1++)

{

gotoxy(1,9);

printf(" Transferred line %-4d to image transfer

buffer ",n1);

/* Transfer row n2 of the image to the last row of w

*/

for(j=0;j<image_width;j++)

{

ch= (char)fgetc(fptr);

*((*(w+N2))+j) = (unsigned char)ch;

}

for(n2=0; n2<image_width; n2++)

{

zn2=(float)0.0;

for(k1=-N; k1<=N; k1++)

for(k2=-N; k2<=N; k2++)

{

if( ((n2-k2)<0) || ((n2-k2)>=image_width) )

continue;

tmp=(float) (*((*(w+N-k1))+(n2-k2)));

zn2+=(*((*(h+N+k1))+(N+k2)))*tmp;

}

/* Excluding boundary values from determining the max and

min.values */

if((n1>N2)&&(n1<true_length)&&(n2>N2)&&(n2<true_width))