Xử lý ảnh số -P19

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;
Nhập môn xử lý ảnh số - ĐHBK Hà nội 1
Phô lôc - Xö lý ¶nh
long biHeight;
WORD biPlanes;

WORD biBitCount;
DWORD biCompression;
DWORD biSizeImage;
long biXPelsPerMeter;
long biYPelsPerMeter;
DWORD biClrUsed;
DWORD biClrImportant;
} BITMAPINFOHEADER;
typedef struct tagRGBQUAD
{
BYTE rgbBlue;
BYTE rgbGreen;
BYTE rgbRed;
BYTE rgbReserved;
} RGBQUAD;
BYTE huge *InImage;
unsigned long p,chieucao,chieurong;
int OpenBitmapFile(char *fname,int *fh,
BITMAPFILEHEADER *bmfhd,
BITMAPINFOHEADER *bmihd);
int ReadBitmapPalette(int fh, int numcl, RGBQUAD *bmpals);
int GetScanLine(int fh, int BytePerLine, BITMAPINFOHEADER *bih, int x, int y);
void SetRGBPalette(int index,int red ,int green,int blue);
NhËp m«n xö lý ¶nh sè - §HBK Hµ néi 2
Phụ lục - Xử lý ảnh
void SetRGBPalettes(int index, int red, int green, int blue);
int GetBitmapToArray(char *fname);
extern void Error(unsigned OrderError);
//***************************************** //
//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
}
tmp = _read(*fh,bmihd,sizeof(BITMAPINFOHEADER));
if(tmp != sizeof(BITMAPINFOHEADER))
{
close(*fh);
return -2 ;//không phải dạng BMP
}
Nhập môn xử lý ảnh số - ĐHBK Hà nội 3
Phô lôc - Xö lý ¶nh
if (bmihd->biCompression == 0)
{
bmihd->biSizeImage = (bmfhd->bfSize-bmfhd->bfoffBits);
}
return 0;
} //end of function
//******************************************************** //
//§äc b¶ng mµu file bitmap //

int ReadBitmapPalette(int fh,int numcl,RGBQUAD *bmpals)
{
int numbyte,tmp;
numbyte=numcl*sizeof(RGBQUAD);
lseek(fh,sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER), SEEK_SET);
tmp=_read(fh,(void*)bmpals,numbyte);
if (tmp == -1)
{ close(fh);return -1;
}
if(tmp!=numbyte)
{close(fh);return -2;
}
return 0;
} // end of function
//******************************************//
int GetScanLine(int fh,int BytePerLine,BITMAPINFOHEADER *bih)
//§äc dßng ¶nh vµo m¶ng //
NhËp m«n xö lý ¶nh sè - §HBK Hµ néi 4
Phô lôc - Xö lý ¶nh
{
BYTE *buff;
int tmp,ppb,mask,i,j,cx,nb,cl;
buff=(BYTE *)malloc(BytePerLine+1);
if(buff==NULL)
{return -3; //Kh«ng ®ñ bé nhí
}
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;
}
NhËp m«n xö lý ¶nh sè - §HBK Hµ néi 5
Phô lôc - Xö lý ¶nh
//****************************************//
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);
}
//***************************************** //

void SetRGBPalettes(RGBQUAD *pals,int numcl)
{
int i;
for(i=0;i<numcl;i++)
{
SetRGBPalette(i,(pals+i)->rgbRed,(pals+i) ->rgbGreen,
(pals+i) - >rgbBlue);
}
}
//********************************************* //
// §äc File BMP vµo m¶ng bé nhí //
NhËp m«n xö lý ¶nh sè - §HBK Hµ néi 6
Phụ lục - Xử lý ảnh
int GetBitmapToArray(char *fname)
{
int i,j,tmp,numcolor,BytePerLine,bmfilehand;
BITMAPINFOHEADER bminfohdr;
BITMAPFILEHEADER bmfilehdr;
RGBQUAD *bmpalettes;
tmp=OpenBitmapFile(fname,&bmfilehand,&bmfilehdr,
&bminfohdr);
chieucao= bminfohdr.biHeight;
chieurong= bminfohdr.biWidth;
switch(tmp)
{case -1: return(1); //break; //không mở đợc file
case -2: return(2); //break; //lỗi file
}
numcolor=1 << (bminfohdr.biBitCount);
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);
Nhập môn xử lý ảnh số - ĐHBK Hà nội 7
Phô lôc - Xö lý ¶nh
p= 0;
for(i=0;i<bminfohdr.biHeight;i++)
{ if (bminfohdr.biCompression==0)
tmp=GetScanLine(bmfilehand,BytePerLine,&bminfohdr);
}
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
#define BackSpace 8
#define MAXSCREENWIDTH 640
#define MAXSCREENHEIGHT 480
#define BITSPERBYTE 8

#define MAXPLANES 4
#define MAXBYTESPERSCAN 640
#define MAXPALETTECOLORS 16
#define MAX256PALETTECOLORS 256
#ifndef_BYTE
NhËp m«n xö lý ¶nh sè - §HBK Hµ néi 8
Phô lôc - Xö lý ¶nh
#define _BYTE
typedef char BYTE;
#endif
#define NoError 0
#define EBadParms -1
#define EFileNotFound -2
#define EReadFileHdr -3
#define ENotPCXFile -4
#define ECorrupt -5
#define EWrtFileHdr -6
#define EWrtOutFile -7
#define EWrtScanLine -8
#define EPCCFile -9
#define PCXHdrTag 0x0A
#define MaxRepCount 0x3F
#define PCX256ColorTag 0x0C
typedef struct
{
BYTE Red;
BYTE Green;
BYTE Blue;
}ColorRegister;
struct PCXFileHeader

{
BYTE Header;
NhËp m«n xö lý ¶nh sè - §HBK Hµ néi 9
Phô lôc - Xö lý ¶nh
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
{
struct PCXFileHeader PCXHeader;
NhËp m«n xö lý ¶nh sè - §HBK Hµ néi 10

Phô lôc - Xö lý ¶nh
ColorRegister Palette[MAXPALETTECOLORS];
struct PCXInfo Info;
} PCX_FileType;
int looping;
struct PCX_File PCXData;
unsigned ImageWidth,ImageHeight;
FILE *PCXFile;
BYTE ScanLine[MAXBYTESPERSCAN];
BYTE PixelColorNum[MAXSCREENWIDTH];
struct ExtendedPalette Color256Palette;
unsigned ImageWidth,ImageHeight,NumOfPlanes;
unsigned Is256ColorFile=FALSE;
struct PCX_File PCXData;
int ReadPCXFileHdr(char *Filename,int Verbose);
static int ExpandScanLine(FILE *InFile);
unsigned InstallPCXFilePalette(void);
void DisplayPCXFile(char *FileName,int Verbose);
void Set256ColorMode(void);
void interrupt (*oldkb)();
void interrupt newkb();
int Gwrite(int x,int y,char *gtext,int inc)
{
WriteXYB(x,y,gtext,1,1,15,0,0,0);
return (x+inc+textwidth(gtext));
}
NhËp m«n xö lý ¶nh sè - §HBK Hµ néi 11
Phô lôc - Xö lý ¶nh
int GwriteDel(int x,int y,char *gtext,int inc)
{

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)
{
text[0]=ch;text[1]='\0';
x=Gwrite(x,y,text,0);
strcat(gtext,text);
NhËp m«n xö lý ¶nh sè - §HBK Hµ néi 12
Phô lôc - Xö lý ¶nh
}
else
if (strcmp(gtext,""))
{
text[0]=gtext[strlen(gtext)-1];text[1]='\0';

x=x-textwidth(text);
x=GwriteDel(x,y,"Û",0);
x=x-textwidth(text);
gtext[strlen(gtext)-1]='\0';
}
}
} while (ch!=Enter);
return gtext;
}
void interrupt newkb()
{
if(inportb(0x60)==1) looping=0;
oldkb();
}
void Set256ColorMode(void)
{
union REGS regs;
regs.h.ah=0;
regs.h.al=0x13;
int86(VIDEO,&regs,&regs);
NhËp m«n xö lý ¶nh sè - §HBK Hµ néi 13
Phụ lục - Xử lý ảnh
}
int ReadPCXFileHdr(char *Filename,int Verbose)
{
unsigned Index,i;
int row=100,col=100;
for(i=0;i<=strlen(Filename);i++) Filename[i]=toupper(Filename[i]);
if(!strchr(Filename,'.')) strcat(Filename,".PCX");
if((PCXFile=fopen(Filename,"rb"))==NULL)

{
Gwrite(col,row,"Không tìm thấy File ",0);
return(EFileNotFound);
}
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();
Nhập môn xử lý ảnh số - ĐHBK Hà nội 14
Phô lôc - Xö lý ¶nh
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("\tByte per Scan Line of Plane :%d\n"
,PCXData.Info.BytesPerLine);
printf("\n\tHit any key to proceed");
getch();
clrscr();
if ((PCXData.PCXHeader.Hres==320)&&(PCXData.PCXHeader.Vres==200)&&
(PCXData.Info.NumOfPlanes==1))
Is256ColorFile=TRUE;
printf("\n\tColor Register Value of PCX file: %s\n\n",Filename);
if (Is256ColorFile)
for(Index=0;Index<MAX256PALETTECOLORS;Index++)
{
NhËp m«n xö lý ¶nh sè - §HBK Hµ néi 15
Phô lôc - Xö lý ¶nh
printf("\tPalette[ %X ] : R=%6X G=%6X B=%6X
/n,Index,PCXData.Palette[Index].Red,
PCXData.Palette[Index].Green,PCXData.Palette[Index].Blue);
if ((Index+1)%16==0)
{
getch();
clrscr();
if(Index!=0xFF)
printf("\n\tColor Register Value of PCX file: %s\n\n", Filename);
}
}
else
for (Index=0;Index<MAXPALETTECOLORS;Index++)
{
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;
NhËp m«n xö lý ¶nh sè - §HBK Hµ néi 16
Phô lôc - Xö lý ¶nh
register unsigned ByteNum;
register short CharRead;
unsigned InPtr,RepCount,PixelsData;
unsigned BytesToRead,PlaneNum;
unsigned ByteOffset,BitOffset;
BytesToRead=PCXData.Info.NumOfPlanes*PCXData.Info.BytesPerLine;
InPtr=0;
do
{
CharRead=getc(InFile);
if(CharRead==EOF) return(FALSE);
if((CharRead & 0xC0)==0xC0)
{
RepCount=CharRead & ~0xC0;
CharRead=getc(InFile);
if(CharRead==EOF) return(FALSE);
while (RepCount--) ScanLine[InPtr++] = CharRead;

}
else
ScanLine[InPtr++]=CharRead;
} while (InPtr < BytesToRead);
return(TRUE);
}
unsigned InstallPCXFilePalette(void)
NhËp m«n xö lý ¶nh sè - §HBK Hµ néi 17
Phô lôc - Xö lý ¶nh
{
struct palettetype palette;
union REGS regs;
unsigned Index;
if(PCXData.PCXHeader.Version!=3)
{
if(Is256ColorFile)
{
for (Index=0;Index<MAX256PALETTECOLORS;Index++)
{
Color256Palette.Palette[Index].Red>>=2;
Color256Palette.Palette[Index].Green>>=2;
Color256Palette.Palette[Index].Blue>>=2;
}
regs.h.ah=0x10;
regs.h.al=0x12;
regs.x.bx=0;
regs.x.cx=MAX256PALETTECOLORS;
_ES=FP_SEG(&Color256Palette.Palette);
regs.x.dx=FP_OFF(&Color256Palette.Palette);
int86(VIDEO,&regs,&regs);

return(TRUE);
}
else
{
NhËp m«n xö lý ¶nh sè - §HBK Hµ néi 18
Phô lôc - Xö lý ¶nh
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;
BYTE far *PtrScreen;

register unsigned ScanNum;
NhËp m«n xö lý ¶nh sè - §HBK Hµ néi 19
Phô lôc - Xö lý ¶nh
register unsigned ColNum;
unsigned OffsetDisplay,BytePerLine;
int PCXError,color,Plane;
long CurrentPos;
if((PCXError=ReadPCXFileHdr(FileName,Verbose))!=NoError)exit(PCXError);
if((PCXData.PCXHeader.X1!=0) || (PCXData.PCXHeader.Y1!=0))
{
printf("\nError PCC file not PCX file\n");
exit(EPCCFile);
}
if(PCXData.PCXHeader.X2==319)
{
Set256ColorMode();
ImageWidth = 320;
ImageHeight= 200;
}
else
{
ImageWidth=640;
switch(PCXData.PCXHeader.Y2)
{
case 479: setgraphmode(VGAHI);
ImageHeight=480;break;
case 349: setgraphmode(VGAMED);
NhËp m«n xö lý ¶nh sè - §HBK Hµ néi 20
Phô lôc - Xö lý ¶nh
ImageHeight=350;break;

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)
{
OffsetDisplay=ScanNum*ImageWidth;
NhËp m«n xö lý ¶nh sè - §HBK Hµ néi 21
Phụ lục - Xử lý ảnh
for (ColNum=0;ColNum<ImageWidth;ColNum++)
PtrScreen[OffsetDisplay++]=ScanLine[ColNum];
}
else

{
BytePerLine=PCXData.Info.BytesPerLine;
for(Plane=0;Plane<PCXData.Info.NumOfPlanes;Plane++)
{
outp(0x3C4,2);
outp(0x3C5,1<<Plane);
OffsetDisplay=ScanNum*BytePerLine;
for (ColNum=0;ColNum<BytePerLine;ColNum++)
PtrScreen[OffsetDisplay++]=ScanLine[Plane*BytePerLine+ColNum];
}
outp(0x3C4,2);
outp(0x3C5,0x0F);
}
}
putch(0x07);
fclose(PCXFile);
}
2. Nhóm chơng trình xử lý ảnh (viết trên Turbo C).
Thực hiện các chức năng cải thiện ảnh, phát hiện biên:
- PROCESS.H
Nhập môn xử lý ảnh số - ĐHBK Hà nội 22
Phô lôc - Xö lý ¶nh
- MESSAGE.H
- MAIN.C
• MESSAGE.H
// Néi dung tÖp message.h – t¹o giao diÖn trong m«i trêng DOS //
extern void button(title st,int centre,int x1,int y1,int x2,
int y2,int v,int mtren,int mduoi,int mc,int mn);
extern char *fname;
//* ************************* *//

void manhinh(void)
{ km mang;int i;int ch;
button("",0,0,0,getmaxx(),30,2,15,8,12,RED);
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); }
//------------------------------------------------//
NhËp m«n xö lý ¶nh sè - §HBK Hµ néi 23
Phô lôc - Xö lý ¶nh
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 Message(char *st,char *st1,int thongtin)
{ int x,y,y1= 190;
void far *q; unsigned kt;
int trai= (getmaxx()/2)-(textwidth(st)/2)-10;
int cao= 100; int phai= (getmaxx()/2)+(textwidth(st)/2)+10;
kt= imagesize(trai,y1,phai,y1+cao);
if((q=(unsigned far*)farmalloc(kt))== NULL)
{outtextxy(70,465,"Kh«ng cßn vïng nhí cho cÊt mµn h×nh !");
exit(1);
}
getimage(trai,y1,phai,y1+cao,q);
button("",0,trai,y1,phai,y1+cao,2,15,15,0,7);
rectangle(trai+1,y1+1,phai-1,y1+cao-1);
NhËp m«n xö lý ¶nh sè - §HBK Hµ néi 24
Phô lôc - Xö lý ¶nh
rectangle(trai+3,y1+3,phai-3,y1+cao-3);
y= y1+18;x= getmaxx()/2;
WriteText(&x,&y,st1);
y= y+textheight(st1)+19;x= getmaxx()/2;
WriteText(&x,&y,st);line(trai+3,y-13,phai-3,y-13);
if(thongtin==1)
{ y= y+textheight(st)+15; x= getmaxx()/2-30;
ReadText(&x,&y,fname);
}
getch();
putimage(trai,y1,q,COPY_PUT);
farfree((unsigned far*)q);
}
//------------------------------------------------------------//
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;
NhËp m«n xö lý ¶nh sè - §HBK Hµ néi 25