Xử Lý Ảnh Phụ Lục

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.
Nhóm chương trình nạp và lưu ảnh
Việc nạp ảnh từ tệp vào mảng số và lưu ả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;
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);
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
}
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 //
{
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 {nb=buff[i];
for(j=0;j {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);
}
//***************************************** //
void SetRGBPalettes(RGBQUAD *pals,int numcl)
{
int i;
for(i=0;i {
SetRGBPalette(i,(pals+i)->rgbRed,(pals+i) ->rgbGreen,
(pals+i) - >rgbBlue);
}
}
//********************************************* //
// Đọc File BMP vào mảng bộ 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);
p= 0;
for(i=0;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
#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;
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;
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));
}
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]=``;
x=Gwrite(x,y,text,0);
strcat(gtext,text);
}
else
if (strcmp(gtext,""))
{
text[0]=gtext[strlen(gtext)-1];text[1]=``;
x=x-textwidth(text);
x=GwriteDel(x,y,"Û",0);
x=x-textwidth(text);
gtext[strlen(gtext)-1]=``;
}
}
} 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,®s,®s);
}
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();
printf("PCX Image Informa