Phụ lục - Xử lý ảnh
Phụ lục gồm listing chơng trình trình bày một cách chi tiết các định dạng
ảnh: BMP, PCX, TIFF, GIF,... và các môđul chơng trình thực hiện các công đoạn của
quá trình xử lý ảnh. Chơng trình đợc viết trên C và Visual C và có thể coi nh một công
cụ đơn giản minh hoạ các bớc của xử lý ảnh. Các ảnh minh hoạ trong cuốn sách này
lấy từ kết quả thực hiện chơng trình trên.
1. Nhóm chơng trình nạp và lu ảnh
Việc nạp ảnh từ tệp vào mảng số và lu ảnh từ mảng lên tệp là cần thiết cho
mọi chức năng xử lý. Chính vì thế, phần chơng trình có tổ chức 2 moduls riêng:
- BMP.H: Thực hiện việc mở và đọc ảnh số từ tệp *.BMP vào mảng 2
chiều.
- PCX.H: Thực hiện việc mở và đọc ảnh số từ tệp *.PCX vào mảng 2
chiều.
BMP.H
// Chứa các khai báo về file ảnh BMP & các thủ tục mở file. //
typedef unsigned int WORD;
typedef unsigned long DWORD;
typedef unsigned char BYTE;
typedef struct tagBITMAPFILEHEADER
{
WORD bfType;
DWORD bfSize;
WORD bfReserved1;
WORD bfReserved2;
DWORD bfoffBits;
} BITMAPFILEHEADER;
typedef struct tagBITMAPINFOHEADER
{
DWORD biSize;
long biWidth;
long biHeight;

//***************************************** //
//Mở file bitmap //
int OpenBitmapFile(char *fname,int *fh,BITMAPFILEHEADER
*bmfhd, BITMAPINFOHEADER *bmihd)
{int tmp;
*fh = _open(fname,O_RDONLY);
if(*fh == -1) return -1; // không mở đợc file
tmp = _read(*fh,bmfhd,sizeof(BITMAPFILEHEADER));
if (tmp == -1)
{ close(*fh); return -1;// lỗi đọc file
}
if(bmfhd->bfType != 0x4D42)
{
close(*fh);
return -2 ;// không phải dạng BMP
Nhập môn xử lý ảnh số - ĐHBK Hà nội 12
Phô lôc - Xö lý ¶nh
}
tmp = _read(*fh,bmihd,sizeof(BITMAPINFOHEADER));
if(tmp != sizeof(BITMAPINFOHEADER))
{
close(*fh);
return -2 ;//kh«ng ph¶i d¹ng BMP
}
if (bmihd->biCompression == 0)
{
bmihd->biSizeImage = (bmfhd->bfSize-bmfhd-
>bfoffBits);
}
return 0;

tmp=_read(fh,buff,BytePerLine);
if(tmp != BytePerLine)
{return -1;
}
ppb=8/bih->biBitCount;
mask=(1 << bih->biBitCount)-1;
for(i=0,cx=0;i<BytePerLine;i++)
{nb=buff[i];
for(j=0;j<ppb;j++,cx++)
{cl=nb >> (bih->biBitCount * (ppb-1-j));
cl=cl & mask;
InImage[p++]= cl;
if(cx == bih->biWidth) break;
}
if(cx >= bih->biWidth) break;
}
free(buff); return 0;
}
//****************************************//
void SetRGBPalette(int index,int red ,int green,int blue)
{
int r,g,b,cl;
red >>= 6; r=(red & 1) << 5; r +=(red & 2) << 1 ;
green >>= 6; g= (green & 1) << 4; g += (green & 2);
blue >>= 6; b= (blue & 1) << 3; b += (blue & 2) >> 1;
cl=r+g+b;
_AX=0x1000;
_BL=index;
_BH=cl;
geninterrupt(0x10);

BytePerLine=bminfohdr.biSizeImage/bminfohdr.biHeight;
bmpalettes=(RGBQUAD far*)
malloc(numcolor*sizeof(RGBQUAD));
if(bmpalettes==NULL) return (3);
tmp=ReadBitmapPalette(bmfilehand,numcolor,bmpalettes);
if (tmp != 0) return(1);
SetRGBPalettes(bmpalettes,numcolor);
farfree(bmpalettes);
lseek(bmfilehand,bmfilehdr.bfoffBits,SEEK_SET);
if((InImage =(BYTE huge *)
farcalloc(bminfohdr.biHeight*bminfohdr.biWidth,
sizeof(BYTE)))==NULL)
return(3);
p= 0;
for(i=0;i<bminfohdr.biHeight;i++)
{ if (bminfohdr.biCompression==0)
tmp=GetScanLine(bmfilehand,BytePerLine,&bminfohdr);
}
Nhập môn xử lý ảnh số - ĐHBK Hà nội 15
Phô lôc - Xö lý ¶nh
close(bmfilehand);
return(0);
}
• PCX.H
// Chøa c¸c khai b¸o cña File PCX
//
#define TRUE 1
#define FALSE 0
#define VIDEO 0x10
#define Enter 13

BYTE Green;
BYTE Blue;
}ColorRegister;
struct PCXFileHeader
{
BYTE Header;
BYTE Version;
BYTE Encode;
BYTE BitPerPix;
unsigned X1;
unsigned Y1;
unsigned X2;
unsigned Y2;
unsigned Hres;
unsigned Vres;
};
struct PCXInfo
{
BYTE Vmode;
BYTE NumOfPlanes;
unsigned BytesPerLine;
BYTE unused[60];
};
struct ExtendedPalette
{
BYTE ExtendedPalette;
ColorRegister Palette[MAX256PALETTECOLORS];
};
struct PCX_File
{

WriteXYB(x,y,gtext,1,1,0,0,0,0);
return (x+inc+textwidth(gtext));
}
int Gwriteln(int x,int y,char *gtext)
{
WriteXYB(x,y,gtext,1,1,15,0,0,0);
return (y+10+textheight(gtext));
}
char *Gread(int x,int y)
{
char *gtext,text[2];
char ch;
gtext[0]=0x0;
do
{
ch=getch();
if (ch!=Enter)
{
if (ch!=BackSpace)
{
NhËp m«n xö lý ¶nh sè - §HBK Hµ néi 18
Phô lôc - Xö lý ¶nh
text[0]=ch;text[1]='\0';
x=Gwrite(x,y,text,0);
strcat(gtext,text);
}
else
if (strcmp(gtext,""))
{
text[0]=gtext[strlen(gtext)-1];text[1]='\0';

return(EFileNotFound);
NhËp m«n xö lý ¶nh sè - §HBK Hµ néi 19
Phụ lục - Xử lý ảnh
}
if(fread(&PCXData,sizeof(struct PCX_File),1,PCXFile)!=1)
{
Gwrite(col,row,"Lỗi đọc Header File ",0);
return(EReadFileHdr);
}
if(PCXData.PCXHeader.Header!=PCXHdrTag)
{
Gwrite(col,row,"Không phải PCX File ",0);
return(ENotPCXFile);
}
if (Verbose)
{
clrscr();
printf("PCX Image Information for file %s\n\n",Filename);
printf("\tVersion %d\n",PCXData.PCXHeader.Version);
printf("\tCompression %s\n",
PCXData.PCXHeader.Encode==0?"none":"RLL");
printf("\tBit per Pixel %d\n",PCXData.PCXHeader.BitPerPix);
printf("\tX1: %d\n",PCXData.PCXHeader.X1);
printf("\tY1: %d\n",PCXData.PCXHeader.Y1);
printf("\tX2: %d\n",PCXData.PCXHeader.X2);
printf("\tY2: %d\n",PCXData.PCXHeader.Y2);
printf("\tHoriz Resolution: %d\n",PCXData.PCXHeader.Hres);
printf("\tVert Resolution: %d\n",PCXData.PCXHeader.Vres);
printf("\tVmode: %d\n",PCXData.Info.Vmode);
printf("\tNumber of Planes: %d\n",PCXData.Info.NumOfPlanes);

{
printf("\tPalette[ %X ] : R=%6X G=%6X B=%6X
\n",Index,PCXData.Palette[Index].Red,
PCXData.Palette[Index].Green,PCXData.Palette[Index].Blue);
}
printf("\n\tHit any key to continue");
getch();
}
return(NoError);
}
static int ExpandScanLine(FILE *InFile)
{
register short BitNum;
register unsigned ByteNum;
register short CharRead;
unsigned InPtr,RepCount,PixelsData;
unsigned BytesToRead,PlaneNum;
unsigned ByteOffset,BitOffset;
BytesToRead=PCXData.Info.NumOfPlanes*PCXData.Info.BytesPerLin
e;
InPtr=0;
NhËp m«n xö lý ¶nh sè - §HBK Hµ néi 21
Phô lôc - Xö lý ¶nh
do
{
CharRead=getc(InFile);
if(CharRead==EOF) return(FALSE);
if((CharRead & 0xC0)==0xC0)
{
RepCount=CharRead & ~0xC0;

int86(VIDEO,&regs,&regs);
return(TRUE);
NhËp m«n xö lý ¶nh sè - §HBK Hµ néi 22
Phô lôc - Xö lý ¶nh
}
else
{
palette.size=MAXPALETTECOLORS;
for (Index=0;Index<MAXPALETTECOLORS;Index++)
{
palette.colors[Index]=Index;
PCXData.Palette[Index].Red>>=2;
PCXData.Palette[Index].Green>>=2;
PCXData.Palette[Index].Blue>>=2;
}
regs.h.ah=0x10;
regs.h.al=0x12;
regs.x.bx=0;
regs.x.cx=MAXPALETTECOLORS;
_ES=FP_SEG(&PCXData.Palette);
int86(VIDEO,&regs,&regs);
setallpalette(&palette);
return(TRUE);
}
}
else return(FALSE);
}
void DisplayPCXFile(char *FileName,int Verbose)
{
int i;

case 199: setgraphmode(VGALO);
ImageHeight=200;break;
}
}
CurrentPos=ftell(PCXFile);
fseek(PCXFile,-769,SEEK_END);
if(fread(&Color256Palette.ExtendedPalette,
sizeof(struct ExtendedPalette) ,1,PCXFile)==TRUE)
if(Color256Palette.ExtendedPalette==PCX256ColorTag)
Is256ColorFile=TRUE;
InstallPCXFilePalette();
fseek(PCXFile,CurrentPos,SEEK_SET);
for(ScanNum=0;ScanNum<ImageHeight;ScanNum++)
{
if(ExpandScanLine(PCXFile) != TRUE)
{
closegraph();
printf("\nScanLine corrupt in PCX file\n");
exit(ECorrupt);
}
PtrScreen=MK_FP(0xA000,0);
if(ImageWidth==320)
{
NhËp m«n xö lý ¶nh sè - §HBK Hµ néi 24
Phụ lục - Xử lý ảnh
OffsetDisplay=ScanNum*ImageWidth;
for (ColNum=0;ColNum<ImageWidth;ColNum++)
PtrScreen[OffsetDisplay++]=ScanLine[ColNum];
}
else

{ km mang;int i;int ch;
button("",0,0,0,getmaxx(),30,2,15,8,12,RED);
Nhập môn xử lý ảnh số - ĐHBK Hà nội 25
Phô lôc - Xö lý ¶nh
rectangle(0+2,0+2,getmaxx()-2,30-2);
button("Image Processing System ",200,0+2,0+2,getmaxx()-4,30-4,
1,8,15,0,WHITE);
button("",200,0,460,getmaxx(),getmaxy(),1,0,13,0,WHITE);
outtextxy(70,465,
"Chon: <ENTER> Di Chuyen: <Up><Down><Left><Right>
Thoat:<ESC>");
}
//* ************************* //
void WriteText(int *x,int *y,char *s)
{ settextjustify(1,1);
outtextxy(*x,*y,s);
settextjustify(0,2);
*x+=textwidth(s); }
//------------------------------------------------//
void ReadText(int *x,int *y,char *s)
{int i=0;char ch[2];
ch[1]=0;
while(1)
{ch[0]=getch();
if((ch[0]==ENTER)||(ch[0]==ESCAPE)) break;
settextjustify(1,1);
WriteText(x,y,ch);
settextjustify(0,2);
s[i]=ch[0];++i;
} s[i]=0;}

void Warning(void)
{ int x,y,y1= 190;
char *st,*st1;
st=" *** Process Running - Please wait ! ***";
st1="WARNING !!!";
int trai= (getmaxx()/2)-(textwidth(st)/2)-10;
int cao= 80; int phai= (getmaxx()/2)+(textwidth(st)/2)+10;
button("",0,trai,y1,phai,y1+cao,2,15,15,0,7);
rectangle(trai+1,y1+1,phai-1,y1+cao-1);
rectangle(trai+3,y1+3,phai-3,y1+cao-3);
y= y1+22;x= getmaxx()/2;
WriteText(&x,&y,st1);
y= y+textheight(st1)+25;x= getmaxx()/2;
WriteText(&x,&y,st);line(trai+3,y-17,phai-3,y-17);
}
PROCESS.H
// Chứa các thao tác chính : Hiện ảnh, Lọc TB, Trung bình KG, Lọc
Trung vị,
//Lọc Sobel, Lọc Homomorphie
int Averaging(BYTE huge *Image,unsigned cotbd,unsigned
hangbd,unsigned rong, unsigned cao,unsigned avecol,
unsigned averow,double *matran);
void DipslayImageInBuf(BYTE huge *Image,unsigned hang,
Nhập môn xử lý ảnh số - ĐHBK Hà nội 27
Phô lôc - Xö lý ¶nh
unsigned cot);
void DipslayPCXInBuf(BYTE huge *Image,unsigned hang,
unsigned cot);
BYTE ReadPixel(BYTE huge *Image,unsigned cot,unsigned hang);
void WritePixel(BYTE huge *Image,unsigned hang,unsigned

p= hang;
p*= chieurong;
p+= cot;
return(Image[p]);}
NhËp m«n xö lý ¶nh sè - §HBK Hµ néi 28
Phụ lục - Xử lý ảnh
//Ghi 1 pixel vào buffer
void WritePixel(BYTE huge *Image,unsigned hang,unsigned
cot,unsigned color)
{ unsigned long p;
if ((cot<=chieurong) && (hang<=chieucao))
{ p= hang;
p*= chieurong;
p+= cot;
Image[p]= color;
}
else
{ Error(16);
getch();
}
}
void SortPixel(BYTE *a)
// Sắp xếp thứ tự hai pixels
{ BYTE i,j,tg;
for(i= 0;i<8;i++)
for(j=i;j<9;j++)
if(a[i]<a[j])
{ tg= a[i];a[i]= a[j];a[j]= tg;}
}
// Lọc trung vị (medianfilter)-lọc phi tuyến //

double *AvePtr;
double tong;
for(i=hangbd;i<cao;i++)
for (j=cotbd;j<rong;j++)
{
tong= 0;
AvePtr= matran;
for(k=0;k<avecol;k++)
for(l=0;l<averow;l++)
tong+=(ReadPixel(Image,j-k+2,i-l+2)*(*AvePtr++));
tong=fabs(tong);//10 la tham so chia cac gia tri cua loc
WritePixel(Image,i,j,(BYTE)tong);//doc 9 ghi 1
} //end of for
return(0);
}
// ***************************************************//
// Läc Spatial Convolution
int SpatialConvolution(BYTE huge *Image,unsigned cotbd,unsigned
hangbd, unsigned rong,unsigned cao,unsigned KernelCol, unsigned
KernelRow, short *Kernel)
{ register unsigned i,j,k,l;
short *KernelPtr;
long tong;
for(i=hangbd;i<cao;i++)
for (j=cotbd;j<rong;j++)
NhËp m«n xö lý ¶nh sè - §HBK Hµ néi 30
Phô lôc - Xö lý ¶nh
{
tong= 0L;
KernelPtr= Kernel;

{ A= ReadPixel(Image,j-1,i-1);
B= ReadPixel(Image,j,i-1);
C= ReadPixel(Image,j+1,i-1);
D= ReadPixel(Image,j-1,i);
E= ReadPixel(Image,j,i);
NhËp m«n xö lý ¶nh sè - §HBK Hµ néi 31
Phụ lục - Xử lý ảnh
F= ReadPixel(Image,j+1,i);
G= ReadPixel(Image,j-1,i+1);
H= ReadPixel(Image,j,i+1);
I= ReadPixel(Image,j+1,i+1);
// Tính các giá trị sai phân //
LineAEIAveBelow= (D+G+H)/3;
LineAEIAveAbove= (B+C+F)/3;
LineAEIMaxDif= abs(LineAEIAveBelow- LineAEIAveAbove);
LineBEHAveBelow= (A+D+G)/3;
LineBEHAveAbove= (C+F+I)/3;
LineBEHMaxDif= abs(LineBEHAveBelow- LineBEHAveAbove);
LineCEGAveBelow= (F+H+I)/3;
LineCEGAveAbove= (A+B+D)/3;
LineCEGMaxDif= abs(LineCEGAveBelow- LineCEGAveAbove);
LineDEFAveBelow= (G+H+I)/3;
LineDEFAveAbove= (A+B+C)/3;
LineDEFMaxDif= abs(LineDEFAveBelow- LineDEFAveAbove);
/*Tìm giá trị lớn nhất*/
MaxDif= Max(LineAEIMaxDif,LineBEHMaxDif);
MaxDif= Max(LineCEGMaxDif,MaxDif);
MaxDif= Max(LineDEFMaxDif,MaxDif);
if (MaxDif>=16)
WritePixel(Image,i,j,63);

tong+=(ReadPixel(Image,j1+k,i1+l)*(*matranptr++));
tong= exp(tong);
tong=fabs(tong);
tong/=(double)(1<<0);
tong= (tong<0) ? 0:tong;
tong= (tong>255) ? 255:tong; //max lµ 63 v× lµ ¶nh 16 mµu
WritePixel(Image,i1,j1,(BYTE)tong);//doc 9 ghi 1
} //end of for
}
}
//==============================================//
void Addnoise(BYTE huge *theImage)
{
register i,r;
for(i=0;i<1000;i++)
{theImage[(long)random(chieucao)*chieurong+random(chieurong)] =
200+random(20);
putpixel(r+rand()%chieurong,r+59+rand()%chieucao,200+random(20));
}
}
// TÝnh Histogram cña ¶nh //
void TinhHisto(BYTE huge *Image,unsigned rong,unsigned cao,
long HISTO[])
{ register unsigned i,j;
for(i = 0; i < 256; i++) HISTO[i] = 0;
for(i = 0; i < cao; i++)
for(j = 0; j < rong; j++)
NhËp m«n xö lý ¶nh sè - §HBK Hµ néi 33
Phô lôc - Xö lý ¶nh
HISTO[Image[(long)i * rong +j]]++;

}
return ;
}
// BiÕn ®æi lîc ®å //
void HistoModify(BYTE huge *Image,unsigned rong,unsigned cao,
long HISTO[])
NhËp m«n xö lý ¶nh sè - §HBK Hµ néi 34
Phô lôc - Xö lý ¶nh
{ register int i,j,l,k;
unsigned Limited,Tansuat;
long Heso,TotalPixel,HIS[256];
unsigned char LUT[256];
TinhHisto(Image,rong,cao,HISTO);
for (l = 0; l < 256; l++)
LUT[l] = l;
Limited = 256;
TotalPixel = (long)rong*cao;
Tansuat = TotalPixel / Limited;
for(l = 0; l < 256; l++)
{ Heso = 0;
for(k = 0; k < l; k++)
Heso += HISTO[k];
Heso += HISTO[l]/2;
LUT[l] = Heso/Tansuat;
}
for(l=0;l<256;l++)
HIS[l] = 0;
for(l=0;l<256;l++)
HIS[LUT[l]] += HISTO[l];
//T¹o b¶ng mµu møc x¸m;