// baitapxulianh.cpp : Defines the entry point for the console application.

//
#include "stdafx.h"

// ReadImage.cpp : Defines the entry point for the console application.

#include <stdio.h>
#include <stdlib.h>
#include <io.h>
#include <fcntl.h>
#include <dos.h>
#include <math.h>
#include <malloc.h>
#include <string.h>
#include <conio.h>
#include <sys\types.h>
#include <sys\stat.h>
#define MAX_NAME_LENGTH 80
#define ROWS 100
#define COLS 100
#define GRAY_LEVELS 255
#define PREWITT 1
#define PEAK_SPACE 50
#define PEAKS 30
#define KIRSCH 2
#define SOBEL 3
#define STACK_SIZE 40000
#define STACK_FILE_LENGTH 500
#define FORGET_IT -50
#define STACK_FILE "c:stack"
struct bmpfileheader{
unsigned short filetype;
unsigned long filesize;
short reserved1;
short reserved2;
unsigned long bitmapoffset;
};
struct bitmapheader{
unsigned long size;
long width;
long height;
unsigned short planes;
unsigned short bitsperpixel;
unsigned long compression;
unsigned long sizeofbitmap;
unsigned long horzres;
unsigned long vertres;
unsigned long colorsused;
unsigned long colorsimp;
};
struct ctstruct{
unsigned char blue;
 unsigned char green;
unsigned char red;
};

union short_char_union{
short s_num;
char s_alpha[2];
};
union int_char_union{
int i_num;
char i_alpha[2];
};
union long_char_union{
long l_num;
char l_alpha[4];
};
union float_char_union{
float f_num;
char f_alpha[4];
};
union ushort_char_union{
short s_num;
char s_alpha[2];
};
union uint_char_union{
int i_num;
char i_alpha[2];
};
union ulong_char_union{
long l_num;
char l_alpha[4];
};
void extract_ushort_from_buffer(char buffer[], int lsb, int start, unsigned shor
t *number)
{
union ushort_char_union lcu;
if(lsb == 1){
lcu.s_alpha[0] = buffer[start+0];
lcu.s_alpha[1] = buffer[start+1];
} /* ket thuc lsb = 1 */
if(lsb == 0){
lcu.s_alpha[0] = buffer[start+1];
lcu.s_alpha[1] = buffer[start+0];
} /* ket thuc lsb = 0 */
*number = lcu.s_num;
} /* ket thuc extract_ushort_from_buffer */
void extract_ulong_from_buffer(char buffer[], int lsb, int start, unsigned long
*number)
{
union ulong_char_union lcu;
if(lsb == 1){
lcu.l_alpha[0] = buffer[start+0];
lcu.l_alpha[1] = buffer[start+1];
lcu.l_alpha[2] = buffer[start+2];
lcu.l_alpha[3] = buffer[start+3];
} /* ket thuc lsb = 1 */
if(lsb == 0){
lcu.l_alpha[0] = buffer[start+3];
lcu.l_alpha[1] = buffer[start+2];
lcu.l_alpha[2] = buffer[start+1];
lcu.l_alpha[3] = buffer[start+0];
} /* ket thuc lsb = 0 */
*number = lcu.l_num;
} /* ket thuc extract_ulong_from_buffer */
void extract_short_from_buffer(char buffer[], int lsb, int start, short *number)
{
union short_char_union lcu;
if(lsb == 1){
lcu.s_alpha[0] = buffer[start+0];
lcu.s_alpha[1] = buffer[start+1];
} /* ket thuc lsb = 1 */
if(lsb == 0){
lcu.s_alpha[0] = buffer[start+1];
lcu.s_alpha[1] = buffer[start+0];
} /* ket thuc lsb = 0 */
*number = lcu.s_num;

} /* ket thuc extract_short_from_buffer */

void extract_long_from_buffer(char buffer[], int lsb, int start,long *number)
{
union long_char_union lcu;
if(lsb == 1){
lcu.l_alpha[0] = buffer[start+0];
lcu.l_alpha[1] = buffer[start+1];
lcu.l_alpha[2] = buffer[start+2];
lcu.l_alpha[3] = buffer[start+3];
} /* ket thuc lsb = 1 */
if(lsb == 0){
lcu.l_alpha[0] = buffer[start+3];
lcu.l_alpha[1] = buffer[start+2];
lcu.l_alpha[2] = buffer[start+1];
lcu.l_alpha[3] = buffer[start+0];
} /* ket thuc lsb = 0 */
*number = lcu.l_num;
} /* ket thuc extract_long_from_buffer */
int calculate_pad(long width)
{
int pad = 0;
pad = ( (width%4) == 0) ? 0 : (4-(width%4));
return(pad);
} /* ket thuc calculate_pad */
void insert_short_into_buffer(char buffer[], int start, short number)
{
union short_char_union lsu;
lsu.s_num = number;
buffer[start+0] = lsu.s_alpha[0];
buffer[start+1] = lsu.s_alpha[1];
} /* ket thuc insert_short_into_buffer */
void insert_ushort_into_buffer(char buffer[], int start, unsigned short number)
{
union ushort_char_union lsu;
lsu.s_num = number;
buffer[start+0] = lsu.s_alpha[0];
buffer[start+1] = lsu.s_alpha[1];
} /* ket thuc insert_short_into_buffer */
void insert_long_into_buffer(char buffer[], int start, long number)
{
union long_char_union lsu;
lsu.l_num = number;
buffer[start+0] = lsu.l_alpha[0];
buffer[start+1] = lsu.l_alpha[1];
buffer[start+2] = lsu.l_alpha[2];
buffer[start+3] = lsu.l_alpha[3];
} /* ket thuc insert_short_into_buffer */
void insert_ulong_into_buffer(char buffer[], int start, unsigned short number)
{
union ulong_char_union lsu;
lsu.l_num = number;
buffer[start+0] = lsu.l_alpha[0];
buffer[start+1] = lsu.l_alpha[1];
buffer[start+2] = lsu.l_alpha[2];
buffer[start+3] = lsu.l_alpha[3];
} /* ket thuc insert_ulong_into_buffer */
int does_not_exist(char file_name[])
{
FILE *image_file;
int result;
result = 1;
image_file = fopen(file_name, "rb");
if(image_file != NULL){
result = 0;
 fclose(image_file);
}
return(result);
} /* ket thuc does_not_exist */
short **allocate_image_array(long length, long width)
{
int i;
short **the_array;
the_array = (short **)malloc(length * sizeof(short *));
for(i=0; i<length; i++){
the_array[i] = (short *)malloc(width * sizeof(short ));
if(the_array[i] == '\0'){
printf("\n\tkhong du bo nho cho hang the_image[%d]", i);
} /* ket thuc if */
} /* ket thuc loop over i */
return(the_array);
} /* ket thuc allocate_image_array */

int free_image_array(short **the_array, long length)

{
int i;
for(i=0; i<length; i++)
free(the_array[i]);
return(1);
} /* ket thuc free_image_array */

void read_bmp_file_header(char *file_name, bmpfileheader *file_header)

{
char buffer[10];
long ll;
short ss;
unsigned long ull;
unsigned short uss;
FILE *fp;
fp = fopen(file_name, "rb");
fread(buffer, 1, 2, fp);// doc 2*1 byte vao buffer
extract_ushort_from_buffer(buffer, 1, 0, &uss);
file_header->filetype = uss;
fread(buffer, 1, 4, fp);
extract_ulong_from_buffer(buffer, 1, 0, &ull);
file_header->filesize = ull;
fread(buffer, 1, 2, fp);
extract_short_from_buffer(buffer, 1, 0, &ss);
file_header->reserved1 = ss;
fread(buffer, 1, 2, fp);
extract_short_from_buffer(buffer, 1, 0, &ss);
file_header->reserved2 = ss;
fread(buffer, 1, 4, fp);
extract_ulong_from_buffer(buffer, 1, 0, &ull);
file_header->bitmapoffset = ull;
 fclose(fp);
} /* ket thuc read_bmp_file_header */
void print_bmp_file_header(struct bmpfileheader *file_header)
{
printf("\nfile type %x", file_header->filetype);
printf("\nfile size %d", file_header->filesize);
printf("\nbit map offset %d", file_header->bitmapoffset);
}
void read_bm_header(char *file_name, bitmapheader *bmheader)
{
char buffer[10];
long ll;
short ss;
unsigned long ull;
unsigned short uss;
FILE *fp;
fp = fopen(file_name, "rb");
fseek(fp, 14, SEEK_SET); // chuyen den vi tri bat dau 14
fread(buffer, 1, 4, fp);
extract_ulong_from_buffer(buffer, 1, 0, &ull);
bmheader->size = ull;
fread(buffer, 1, 4, fp);
extract_long_from_buffer(buffer, 1, 0, &ll);
bmheader->width = ll;
fread(buffer, 1, 4, fp);
extract_long_from_buffer(buffer, 1, 0, &ll);
bmheader->height = ll;
fread(buffer, 1, 2, fp);
extract_ushort_from_buffer(buffer, 1, 0, &uss);
bmheader->planes = uss;
fread(buffer, 1, 2, fp);
extract_ushort_from_buffer(buffer, 1, 0, &uss);
bmheader->bitsperpixel = uss;
fread(buffer, 1, 4, fp);
extract_ulong_from_buffer(buffer, 1, 0, &ull);
bmheader->compression = ull;
fread(buffer, 1, 4, fp);
extract_ulong_from_buffer(buffer, 1, 0, &ull);
bmheader->sizeofbitmap = ull;
fread(buffer, 1, 4, fp);
extract_ulong_from_buffer(buffer, 1, 0, &ull);
bmheader->horzres = ull;
fread(buffer, 1, 4, fp);
extract_ulong_from_buffer(buffer, 1, 0, &ull);
bmheader->vertres = ull;
 fread(buffer, 1, 4, fp);
extract_ulong_from_buffer(buffer, 1, 0, &ull);
bmheader->colorsused = ull;
fread(buffer, 1, 4, fp);
extract_ulong_from_buffer(buffer, 1, 0, &ull);
bmheader->colorsimp = ull;
fclose(fp);
} /* ket thuc read_bm_header */

void print_bm_header(bitmapheader *bmheader)

{
printf("\nwidth %d", bmheader->width);
printf("\nheight %d", bmheader->height);
printf("\nplanes %d", bmheader->planes);
printf("\nbitsperpixel %d", bmheader->bitsperpixel);
printf("\ncolorsused %d", bmheader->colorsused);
printf("\ncolorsimp %d", bmheader->colorsimp);
}
void read_color_table(char *file_name, ctstruct *rgb, int size)
{
int i;
char buffer[10];
FILE *fp;
fp = fopen(file_name, "rb");
fseek(fp, 54, SEEK_SET);// chuyen den vi tri doc bang mau
for(i=0; i<size; i++){
fread(buffer, 1, 1, fp);
rgb[i].blue = buffer[0];
fread(buffer, 1, 1, fp);
rgb[i].green = buffer[0];
fread(buffer, 1, 1, fp);
rgb[i].red = buffer[0];
fread(buffer, 1, 1, fp);
/* fourth byte nothing */
} /* ket thuc loop over i */
fclose(fp);
} /* ket thuc read_color_table */
void print_color_table(struct ctstruct *rgb, int size)
{
int i;
for(i=0; i<size; i++){
printf("\n %d %d %d",
rgb[i].blue,rgb[i].green,rgb[i].red);
if(i%10==0 && i!=0) getch();
} /* ket thuc loop over i */
} /* ket thuc print_color_table */
void flip_image_array(short **the_image, long rows, long cols)
{
int i, j;
long rd2;
short **temp;
temp = allocate_image_array(rows, cols);
rd2 = rows/2;
for(i=0; i<rd2; i++){
for(j=0; j<cols; j++){
temp[rows-1-i][j] = the_image[i][j];
} /* ket thuc loop over j */
} /* ket thuc loop over i */
for(i=rd2; i<rows; i++){
for(j=0; j<cols; j++){
temp[rows-1-i][j] = the_image[i][j];
} /* ket thuc loop over j */
} /* ket thuc loop over i */
for(i=0; i<rows; i++)
for(j=0; j<cols; j++)
the_image[i][j] = temp[i][j];
free_image_array(temp, rows);
} /* ket thuc flip_image_array */
void read_bmp_image(char *file_name, short **array_red, short **array_green, sho
rt **array_blue)
{
FILE *fp;
int i, j;
int negative = 0,
pad = 0,
place = 0;
long colors = 0,
height = 0,
position = 0,
width = 0;
struct bmpfileheader file_header;
struct bitmapheader bmheader;
struct ctstruct rgb[GRAY_LEVELS+1];
unsigned char uc;
read_bmp_file_header(file_name, &file_header);
read_bm_header(file_name, &bmheader);// info file
if(bmheader.bitsperpixel != 8){
printf("\nkhong doc duoc file co bit/pixel khac 8");
exit(1);
}
if(bmheader.colorsused == 0)
colors = GRAY_LEVELS + 1;
else
colors = bmheader.colorsused;
read_color_table(file_name, rgb, colors);
getch();
print_color_table(rgb,colors);
getch();
 fp = fopen(file_name, "rb");
fseek(fp, file_header.bitmapoffset, SEEK_SET);
width = bmheader.width;
if(bmheader.height < 0){ // neu height<0 -> anh ghi tu cuoi len
height = bmheader.height * (-1);
negative = 1;
}
else
height = bmheader.height;
pad = calculate_pad(width);
for(i=0; i<height; i++){
for(j=0; j<width; j++){
place = fgetc(fp);
// printf("%4d",place);
// if(j==width-1) printf("\n");
uc = (place & 0xff);// dac trung bmp
place = uc;
array_red[i][j] = rgb[place].red;
array_green[i][j] = rgb[place].green;
array_blue[i][j] = rgb[place].blue;
} /* ket thuc loop over j */
if(pad != 0){
position = fseek(fp, pad, SEEK_CUR);
} /* ket thuc if pad 1= 0 */
} /* ket thuc loop over i */
if(negative == 0)
{
flip_image_array(array_red, height, width);
flip_image_array(array_green, height, width);
flip_image_array(array_blue, height, width);
}
} /* ket thuc read_bmp_image */

void create_allocate_bmp_file(char *file_name, bmpfileheader *file_header, bitma

pheader *bmheader)
{
char buffer[100];
int i, pad = 0;
FILE *fp;
pad = calculate_pad(bmheader->width);
bmheader->size = 40;
bmheader->planes = 1;
bmheader->bitsperpixel = 8;
bmheader->compression = 0;
bmheader->sizeofbitmap = bmheader->height *
(bmheader->width + pad);
bmheader->horzres = 300;
bmheader->vertres = 300;
bmheader->colorsused = 256;
bmheader->colorsimp = 256;
file_header->filetype = 0x4D42;
file_header->reserved1 = 0;
file_header->reserved2 = 0;
file_header->bitmapoffset = 14 +
bmheader->size +
bmheader->colorsused*4;
file_header->filesize = file_header->bitmapoffset +
bmheader->sizeofbitmap;
if((fp = fopen(file_name, "wb")) == NULL){
printf("\nKhong the tao file %s",file_name);
exit(2);
}
/*********************************************
*
* ghi 14 byte vao header file.
*
*********************************************/
insert_ushort_into_buffer(buffer, 0, file_header->filetype);
fwrite(buffer, 1, 2, fp);
insert_ulong_into_buffer(buffer, 0, file_header->filesize);
fwrite(buffer, 1, 4, fp);
insert_short_into_buffer(buffer, 0, file_header->reserved1);
fwrite(buffer, 1, 2, fp);
insert_short_into_buffer(buffer, 0, file_header->reserved2);
fwrite(buffer, 1, 2, fp);
insert_ulong_into_buffer(buffer, 0, file_header->bitmapoffset);
fwrite(buffer, 1, 4, fp);

/*********************************************
*
* ghi 40 byte info vao anh.
*
*********************************************/
insert_ulong_into_buffer(buffer, 0, bmheader->size);
fwrite(buffer, 1, 4, fp);
insert_long_into_buffer(buffer, 0, bmheader->width);
fwrite(buffer, 1, 4, fp);
insert_long_into_buffer(buffer, 0, bmheader->height);
fwrite(buffer, 1, 4, fp);
insert_ushort_into_buffer(buffer, 0, bmheader->planes);
fwrite(buffer, 1, 2, fp);
insert_ushort_into_buffer(buffer, 0, bmheader->bitsperpixel);
fwrite(buffer, 1, 2, fp);
insert_ulong_into_buffer(buffer, 0, bmheader->compression);
fwrite(buffer, 1, 4, fp);
 insert_ulong_into_buffer(buffer, 0, bmheader->sizeofbitmap);
fwrite(buffer, 1, 4, fp);
insert_ulong_into_buffer(buffer, 0, bmheader->horzres);
fwrite(buffer, 1, 4, fp);
insert_ulong_into_buffer(buffer, 0, bmheader->vertres);
fwrite(buffer, 1, 4, fp);
insert_ulong_into_buffer(buffer, 0, bmheader->colorsused);
fwrite(buffer, 1, 4, fp);
insert_ulong_into_buffer(buffer, 0, bmheader->colorsimp);
fwrite(buffer, 1, 4, fp);
/*********************************************
*
* Voi anh co bitcount=8, ghi 256 thong tin mau vao anh
* moi thong tin mau co 4 byte (thong tin rong)
*
*********************************************/
buffer[0] = 0x00;
for(i=0; i<(256*4); i++)
fwrite(buffer, 1, 1, fp);
/*********************************************
*
* tao anh rong
*
*********************************************/
buffer[0] = 0x00;
for(i=0; i<bmheader->sizeofbitmap; i++)
fwrite(buffer, 1, 1, fp);
fclose(fp);
} /* ket thuc create_allocate_bmp_file */

void write_bmp_image(char *file_name, short **array)

{
char *buffer, c;
FILE *image_file;
int pad = 0,
position;
int bytes, i, j;
long height = 0, width = 0;
struct bitmapheader bmheader;
struct bmpfileheader file_header;
struct ctstruct rgb[GRAY_LEVELS+1];
union short_char_union scu;
read_bmp_file_header(file_name, &file_header);
read_bm_header(file_name, &bmheader);
height = bmheader.height;
width = bmheader.width;
if(height < 0) height = height*(-1);
buffer = (char *) malloc(width * sizeof(char ));
for(i=0; i<width; i++)
buffer[i] = '\0';
image_file = fopen(file_name, "rb+");
/****************************************
*
* ghi bang mau
*
****************************************/
position = fseek(image_file, 54, SEEK_SET);
for(i=0; i<GRAY_LEVELS+1; i++){
rgb[i].blue = i;
rgb[i].green = 255-i;
rgb[i].red = i;
} /* ket thuc loop over i */
for(i=0; i<bmheader.colorsused; i++){
buffer[0] = rgb[i].blue;
fwrite(buffer , 1, 1, image_file);
buffer[0] = rgb[i].green;
fwrite(buffer , 1, 1, image_file);
buffer[0] = rgb[i].red;
fwrite(buffer , 1, 1, image_file);
buffer[0] = 0x00;
fwrite(buffer , 1, 1, image_file);
} /* ket thuc loop over i */
position = fseek(image_file,
file_header.bitmapoffset,
SEEK_SET);
pad = calculate_pad(width);
for(i=0; i<height; i++)
{
for(j=0; j<width; j++){
if(bmheader.bitsperpixel == 8){
scu.s_num = 0;
if(bmheader.height > 0)
scu.s_num = array[height-1-i][j];
else
scu.s_num = array[i][j];
buffer[j] = scu.s_alpha[0];
} /* ket thuc if bits_per_pixel == 8 */
else{
printf("\nLoi, bitsperpixel khong phai la 8");
exit(1);
}
} /* ket thuc loop over j */
bytes = fwrite(buffer, 1, width, image_file);
//for(int k=0;k<width;k++)
// printf("%4d",(int)buffer[k]);
//printf("\n");
 if(pad != 0){
for(j=0; j<pad; j++)
buffer[j] = 0x00;
fwrite(buffer, 1, pad, image_file);
} /* ket thuc if pad != 0 */
} /* ket thuc loop over i */
fclose(image_file);
free(buffer);
} /* ket thuc write_bmp_image */
int get_image_size(char *file_name, long *rows, long *cols)
{
int result = 1; // dam bao file mo ra la bitmap
struct bitmapheader bmph;// info cua file
read_bm_header(file_name, &bmph);
*rows = bmph.height;
*cols = bmph.width;
return(result);
} /* ket thuc get_image_size */
int get_bitsperpixel(char *file_name, long *bitsperpixel)
{
int result = 1;
long temp;
struct bitmapheader bmph;
read_bm_header(file_name, &bmph);
temp = (long)bmph.bitsperpixel;
*bitsperpixel = temp;
return(result);
} /* ket thuc get_image_size */
/**********************************************
*
* is_a_bmp(...
*
* Kiem tra xem file co phai bmp khong, kiem tra phan mo rong va
* kiem tra filetype bang 0x4d42?
*
***********************************************/
int is_a_bmp(char *file_name)
{
char *cc;
int result = 0;
struct bmpfileheader file_header;
cc = strstr(file_name, ".bmp");
if(cc == NULL)
return(result);
read_bmp_file_header(file_name, &file_header);
if(file_header.filetype != 0x4d42)
return(result);
 result = 1;
return(result);
} /* ket thuc is_a_bmp */
/*********************************************
*
* equate_bmpfileheaders(...
*
* chuyen header cua file nguon va file dich cho nhau
*
*********************************************/
void equate_bmpfileheaders(bmpfileheader *src, bmpfileheader *dest)
{
dest->filetype = src->filetype;
dest->filesize = src->filesize;
dest->reserved1 = src->reserved1;
dest->reserved2 = src->reserved2;
dest->bitmapoffset = src->bitmapoffset;
} /* ket thuc equate_bmpfileheaders */
/*********************************************
*
* equate_bitmapheaders(...
*
* chuyen info cua file nguon va file dich cho nhau
*
*********************************************/
void equate_bitmapheaders(bitmapheader *src, bitmapheader *dest)
{
dest->size = src->size;
dest->width = src->width;
dest->height = src->width;
dest->planes = src->planes;
dest->bitsperpixel = src->bitsperpixel;
dest->compression = src->compression;
dest->sizeofbitmap = src->sizeofbitmap;
dest->horzres = src->horzres;
dest->vertres = src->vertres;
dest->colorsused = src->colorsused;
dest->colorsimp = src->colorsimp;
} /* ket thuc equate_bitmapheader */
/*********************************************
*
* are_not_same_size(...
*
* Kiem tra xem 2 file co cung kich thuoc khong?
*********************************************/
int are_not_same_size(char *file1, char *file2)
{
int result = 0;
long cols1 = 1,
cols2 = 2,
rows1 = 3,
rows2 = 4;
get_image_size(file1, &rows1, &cols1);
 get_image_size(file2, &rows2, &cols2);
if(rows1 != rows2 || cols1 != cols2)
result = 1;
return(result);
} /* ket thuc are_not_same_size */

/*********************************************
*
* create_image_file(...
*
* tao file bmp moi
*
*********************************************/
void create_image_file(char *in_name, char *out_name)
{
struct bmpfileheader bmp_file_header;
struct bitmapheader bmheader;
read_bmp_file_header(in_name, &bmp_file_header);
read_bm_header(in_name, &bmheader);
create_allocate_bmp_file(out_name, &bmp_file_header, &bmheader);
} /* ket thuc create_image_file */
void create_resized_image_file(char *in_name, char *out_name, long length, long
width)
{
struct bmpfileheader bmp_file_header;
struct bitmapheader bmheader;
read_bmp_file_header(in_name, &bmp_file_header);
read_bm_header(in_name, &bmheader);
bmheader.height = length;
bmheader.width = width;
create_allocate_bmp_file(out_name, &bmp_file_header, &bmheader);
} /* ket thuc create_resided_image_file */
void print_array_image(short **array, long rows, long cols)
{
int i,j;
for(i=0;i<rows;i++)
for(j=0;j<cols;j++)
{
printf("%4d ",array[i][j]);
if(j==cols-1) printf("\n");
}
}
short **grey_level_image(short **red, short **green, short **blue, long rows, lo
ng cols)
{
short **g_level;
int i,j;
g_level=allocate_image_array(rows,cols);
for(i=0;i<rows;i++)
for(j=0;j<cols;j++)
 {
g_level[i][j]=(red[i][j]+green[i][j]+blue[i][j])/3;
}
return g_level;
}
void main()
{
// clrscr();
char duongdan1[30];
char duongdan2[30];
short **the_image_red;
short **the_image_green;
short **the_image_blue;
long l, w;
struct bmpfileheader bmp_file_header;
struct bitmapheader bmheader;
printf("Nhap duong dan thu 1: "); scanf("%s",duongdan1);
printf("Nhap duong dan thu 2: "); scanf("%s",duongdan2);
get_image_size(duongdan1, &l, &w);
the_image_red= allocate_image_array(l, w);
the_image_green= allocate_image_array(l, w);
the_image_blue= allocate_image_array(l, w);
bmheader.height = l;
bmheader.width = w;
create_allocate_bmp_file(duongdan2,&bmp_file_header,&bmheader);
read_bmp_image(duongdan1, the_image_red, the_image_green, the_image_blue);
printf("Mau RED cua anh\n");
print_array_image(the_image_red,l,w);
printf("Mau GREEN cua anh\n");
print_array_image(the_image_green,l,w);
printf("Mau BLUE cua anh\n");
print_array_image(the_image_blue,l,w);
printf("Anh xam cua anh goc\n");
print_array_image(grey_level_image(the_image_red, the_image_green, the_image_blu
e,l,w),l,w);
write_bmp_image(duongdan2, the_image_red);
free_image_array(the_image_red, l);
free_image_array(the_image_green, l);
free_image_array(the_image_blue, l);
getch();
}
//===================================//
//load file bmp
/* Function to open and display a 16-color bitmap file
* Written by Vineeth Kaimal
* For Turbo C++ 3.0
* http://writeka.com/emage/bmp16_format.html
* Please retain these comments if you use the code.
*/
int loadbitmap(char *filename)
{
FILE *ptr=NULL; //file handle to open bitmap file
int width,height; //width and height of the bitmap
unsigned long temp=0,i=0,j=0; //some variables i need
unsigned long ww;
 ptr=fopen(filename,"rb"); //open the bitmap file
if(!ptr) return 0; //if its not there return
width=0;height=0; //initialise wisth and height to zero
fseek(ptr,18,SEEK_SET); //got to offset 18 in file
for(i=0x1;i<=0x10000;i*=0x100) //read the width
{
temp=fgetc(ptr);
width+=(temp*i);
}
fseek(ptr,22,SEEK_SET); //go to offset 22 in file
for(i=0x1;i<=0x10000;i*=0x100) //read the height
{
temp=fgetc(ptr);
height+=(temp*i);
}
ww=width; //ww is the number of reads to make for each horizontal lin
e
if(ww%2) //ww has to be half of width - since each pixel is only 4 b
its of information
ww++;ww/=2; //just getting the correct value
if(ww%4) //now - ww is stored as sets of 4 pixels each - i think !?!
:so this is the adjustment made
ww=(ww/4)*4+4; //if width is less than ww*2 we ignore what we read
fseek(ptr,119,SEEK_SET); //Ok! offset 119 - lets read the pixels -
//remember the bitmap is stroed up - side - down
int ch,ch1,ch2;
for(i=0;i<height;i++)
for(j=0;j<ww;j++)
{
ch=fgetc(ptr); //each character read is 2 pixels - yes 4 bits per
pixel - so 16 colors
ch1=ch;ch2=ch; //find those colors usi
ng bitwise ops
ch1=ch1&(0xf0);ch1=ch1>>4; // ~~
ch2=ch2&(0x0f); // ~~
if(j*2<width) //ok so put the first p
ixel read on screen
putpixel((j)*2,(height-1-i),getcol(ch1));
if(j*2+1<width) //put the second pixel
read on screen
putpixel((j)*2+1,(height-1-i),getcol(ch2));
}
fclose(ptr); //close the file handle
return 1;
}

int getcol(int col)

{
switch(col)
{
case 0: return 0; //BLACK;
case 1: return 4; //RED;
case 2: return 2; //GREEN
case 3: return 6; //BROWN
case 4: return 1; //BLUE;
case 5: return 5; //MAGENTA;
 case 6: return 3; //CYAN;
case 7: return 7; //LIGHTGRAY;
case 8: return 8; //DARKGRAY;
case 9: return 12; //LIGHTRED;
case 10:return 10; //LIGHTGREEN
case 11:return 14; //YELLOW;
case 12:return 9; //LIGHTBLUE;
case 13:return 13; //LIGHTMAGENTA
case 14:return 11; //LIGHTCYAN;
case 15:return 15; //WHITE;
}
return col;
}
//====================================================