Từ 1 tới 4 trên tổng số 4 kết quả

Đề tài: Bài tập xử lí ảnh XLA. Các bạn giúp mình?

  1. #1
    Ngày gia nhập
    04 2009
    Bài viết
    4

    Mặc định Bài tập xử lí ảnh XLA. Các bạn giúp mình?

    mình có bài tập XLA đọc khó hiểu quá
    post code lên đây mong các bạn giải thix chi tiết hộ với
    PHP Code:
    // 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 lsbint startunsigned short *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 lsbint startunsigned 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 lsbint startshort *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 lsbint 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) ? : (4-(width%4));
       return(
    pad);
    }  
    /* ket thuc calculate_pad */

    void insert_short_into_buffer(char buffer[], int startshort 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 startunsigned 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 startlong 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 startunsigned 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 lengthlong width)
    {
       
    int i;
       
    short **the_array;
       
    the_array = (short **)malloc(length sizeof(short  *));
       for(
    i=0i<lengthi++){
          
    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_arraylong length)
    {
       
    int i;
       for(
    i=0i<lengthi++)
          
    free(the_array[i]);
       return(
    1);
    }  
    /* ket thuc free_image_array */


    void read_bmp_file_header(char *file_namebmpfileheader *file_header)
    {
       
    char  buffer[10];
       
    long  ll;
       
    short ss;
       
    unsigned long  ull;
       
    unsigned short uss;
       
    FILE     *fp;

       
    fp fopen(file_name"rb");

       
    fread(buffer12fp);// doc 2*1 byte vao buffer
       
    extract_ushort_from_buffer(buffer10, &uss);
       
    file_header->filetype uss;

       
    fread(buffer14fp);
       
    extract_ulong_from_buffer(buffer10, &ull);
       
    file_header->filesize ull;

       
    fread(buffer12fp);
       
    extract_short_from_buffer(buffer10, &ss);
       
    file_header->reserved1 ss;

       
    fread(buffer12fp);
       
    extract_short_from_buffer(buffer10, &ss);
       
    file_header->reserved2 ss;

       
    fread(buffer14fp);
       
    extract_ulong_from_buffer(buffer10, &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_namebitmapheader *bmheader)
    {
       
    char  buffer[10];
       
    long  ll;
       
    short ss;
       
    unsigned long  ull;
       
    unsigned short uss;
       
    FILE *fp;

       
    fp fopen(file_name"rb");

       
    fseek(fp14SEEK_SET); // chuyen den vi tri bat dau 14
       
    fread(buffer14fp);
       
    extract_ulong_from_buffer(buffer10, &ull);
       
    bmheader->size ull;

       
    fread(buffer14fp);
       
    extract_long_from_buffer(buffer10, &ll);
       
    bmheader->width ll;

       
    fread(buffer14fp);
       
    extract_long_from_buffer(buffer10, &ll);
       
    bmheader->height ll;

       
    fread(buffer12fp);
       
    extract_ushort_from_buffer(buffer10, &uss);
       
    bmheader->planes uss;

       
    fread(buffer12fp);
       
    extract_ushort_from_buffer(buffer10, &uss);
       
    bmheader->bitsperpixel uss;

       
    fread(buffer14fp);
       
    extract_ulong_from_buffer(buffer10, &ull);
       
    bmheader->compression ull;

       
    fread(buffer14fp);
       
    extract_ulong_from_buffer(buffer10, &ull);
       
    bmheader->sizeofbitmap ull;

       
    fread(buffer14fp);
       
    extract_ulong_from_buffer(buffer10, &ull);
       
    bmheader->horzres ull;

       
    fread(buffer14fp);
       
    extract_ulong_from_buffer(buffer10, &ull);
       
    bmheader->vertres ull;

       
    fread(buffer14fp);
       
    extract_ulong_from_buffer(buffer10, &ull);
       
    bmheader->colorsused ull;

       
    fread(buffer14fp);
       
    extract_ulong_from_buffer(buffer10, &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_namectstruct *rgbint size)
    {
       
    int  i;
       
    char buffer[10];
       
    FILE *fp;

       
    fp fopen(file_name"rb");

       
    fseek(fp54SEEK_SET);// chuyen den vi tri doc bang mau

       
    for(i=0i<sizei++){
          
    fread(buffer11fp);
          
    rgb[i].blue buffer[0];
          
    fread(buffer11fp);
          
    rgb[i].green buffer[0];
          
    fread(buffer11fp);
          
    rgb[i].red buffer[0];
          
    fread(buffer11fp);
             
    /* fourth byte nothing */
       
    }  /* ket thuc loop over i */

       
    fclose(fp);

    }  
    /* ket thuc read_color_table */

    void print_color_table(struct ctstruct *rgbint size)
    {
       
    int i;

       for(
    i=0i<sizei++){
          
    printf("\n %d %d %d",
          
    rgb[i].blue,rgb[i].green,rgb[i].red);
          if(
    i%10==&& i!=0getch();
       }  
    /* ket thuc loop over i */
    }  /* ket thuc print_color_table */

    void flip_image_array(short **the_imagelong rowslong cols)
    {
       
    int  ij;
       
    long rd2;
       
    short **temp;

       
    temp allocate_image_array(rowscols);
       
    rd2  rows/2;
       for(
    i=0i<rd2i++){
          for(
    j=0j<colsj++){
             
    temp[rows-1-i][j] = the_image[i][j];
          }  
    /* ket thuc loop over j */
       
    }  /* ket thuc loop over i */

       
    for(i=rd2i<rowsi++){
          for(
    j=0j<colsj++){
             
    temp[rows-1-i][j] = the_image[i][j];
          }  
    /* ket thuc loop over j */
       
    }  /* ket thuc loop over i */

       
    for(i=0i<rowsi++)
          for(
    j=0j<colsj++)
             
    the_image[i][j] = temp[i][j];

       
    free_image_array(temprows);
    }  
    /* ket thuc flip_image_array */

    void read_bmp_image(char *file_nameshort **array_redshort **array_greenshort **array_blue)
    {
       
    FILE   *fp;
       
    int    ij;
       
    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_namergbcolors);
        
       
    getch();
       
    print_color_table(rgb,colors);
       
    getch();

       
    fp fopen(file_name"rb");
       
    fseek(fpfile_header.bitmapoffsetSEEK_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=0i<heighti++){
          for(
    j=0j<widthj++){
             
    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(fppadSEEK_CUR);
          }  
    /* ket thuc if pad 1= 0 */
       
    }  /* ket thuc loop over i */

       
    if(negative == 0)
       {
          
    flip_image_array(array_redheightwidth);
          
    flip_image_array(array_greenheightwidth);
          
    flip_image_array(array_blueheightwidth);
       }

    }  
    /* ket thuc read_bmp_image */


    void create_allocate_bmp_file(char *file_namebmpfileheader *file_headerbitmapheader *bmheader)
    {
       
    char buffer[100];
       
    int  ipad 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(buffer0file_header->filetype);
       
    fwrite(buffer12fp);

       
    insert_ulong_into_buffer(buffer0file_header->filesize);
       
    fwrite(buffer14fp);

       
    insert_short_into_buffer(buffer0file_header->reserved1);
       
    fwrite(buffer12fp);

       
    insert_short_into_buffer(buffer0file_header->reserved2);
       
    fwrite(buffer12fp);

       
    insert_ulong_into_buffer(buffer0file_header->bitmapoffset);
       
    fwrite(buffer14fp);


          
    /*********************************************
          *
          *   ghi 40 byte info vao anh.
          *
          *********************************************/

       
    insert_ulong_into_buffer(buffer0bmheader->size);
       
    fwrite(buffer14fp);

       
    insert_long_into_buffer(buffer0bmheader->width);
       
    fwrite(buffer14fp);

       
    insert_long_into_buffer(buffer0bmheader->height);
       
    fwrite(buffer14fp);

       
    insert_ushort_into_buffer(buffer0bmheader->planes);
       
    fwrite(buffer12fp);

       
    insert_ushort_into_buffer(buffer0bmheader->bitsperpixel);
       
    fwrite(buffer12fp);

       
    insert_ulong_into_buffer(buffer0bmheader->compression);
       
    fwrite(buffer14fp);

       
    insert_ulong_into_buffer(buffer0bmheader->sizeofbitmap);
       
    fwrite(buffer14fp);

       
    insert_ulong_into_buffer(buffer0bmheader->horzres);
       
    fwrite(buffer14fp);

       
    insert_ulong_into_buffer(buffer0bmheader->vertres);
       
    fwrite(buffer14fp);

       
    insert_ulong_into_buffer(buffer0bmheader->colorsused);
       
    fwrite(buffer14fp);

       
    insert_ulong_into_buffer(buffer0bmheader->colorsimp);
       
    fwrite(buffer14fp);

          
    /*********************************************
          *
          *   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=0i<(256*4); i++)
          
    fwrite(buffer11fp);

          
    /*********************************************
          *
          *   tao anh rong
          *
          *********************************************/

       
    buffer[0] = 0x00;

       for(
    i=0i<bmheader->sizeofbitmapi++)
          
    fwrite(buffer11fp);

       
    fclose(fp);

    }  
    /* ket thuc create_allocate_bmp_file */


    void write_bmp_image(char *file_nameshort **array)
    {
       
    char   *bufferc;
       
    FILE   *image_file;
       
    int    pad 0,
              
    position;
       
    int    bytesij;
       
    long   height 0width 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 0height height*(-1);

       
    buffer = (char  *) malloc(width sizeof(char ));
       for(
    i=0i<widthi++)
          
    buffer[i] = '\0';

       
    image_file fopen(file_name"rb+");
          
    /****************************************
          *
          *   ghi bang mau
          *
          ****************************************/
       
    position   fseek(image_file54SEEK_SET);
       for(
    i=0i<GRAY_LEVELS+1i++){
          
    rgb[i].blue  i;
          
    rgb[i].green 255-i;
          
    rgb[i].red   i;
       }  
    /* ket thuc loop over i */

       
    for(i=0i<bmheader.colorsusedi++){
          
    buffer[0] = rgb[i].blue;
          
    fwrite(buffer 11image_file);
          
    buffer[0] = rgb[i].green;
          
    fwrite(buffer 11image_file);
          
    buffer[0] = rgb[i].red;
          
    fwrite(buffer 11image_file);
          
    buffer[0] = 0x00;
          
    fwrite(buffer 11image_file);
       }  
    /* ket thuc loop over i */

       
    position   fseek(image_file,
                          
    file_header.bitmapoffset
                          
    SEEK_SET);

       
    pad calculate_pad(width);

       for(
    i=0i<heighti++)
       {
          for(
    j=0j<widthj++){

             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(buffer1widthimage_file);
          
          
    //for(int k=0;k<width;k++)
             // printf("%4d",(int)buffer[k]);
          //printf("\n");

          
    if(pad != 0){
             for(
    j=0j<padj++)
                
    buffer[j] = 0x00;
             
    fwrite(buffer1padimage_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_namelong *rowslong *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_namelong *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 *srcbmpfileheader *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 *srcbitmapheader *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 *file1char *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_namechar *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_namechar *out_namelong lengthlong 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 rowslong cols)
    {
        
    int i,j;
        for(
    i=0;i<rows;i++)
            for(
    j=0;j<cols;j++)
            {
                
    printf("%4d ",array[i][j]);
                if(
    j==cols-1printf("\n");
            }
    }
    short **grey_level_image(short **redshort **greenshort **bluelong rowslong 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 lw;
    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_redallocate_image_array(lw);
    the_image_greenallocate_image_array(lw);
    the_image_blueallocate_image_array(lw);
    bmheader.height l;
    bmheader.width w;
    create_allocate_bmp_file(duongdan2,&bmp_file_header,&bmheader);

    read_bmp_image(duongdan1the_image_redthe_image_greenthe_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_redthe_image_greenthe_image_blue,l,w),l,w);

    write_bmp_image(duongdan2the_image_red);
    free_image_array(the_image_redl);
    free_image_array(the_image_greenl);
    free_image_array(the_image_bluel);
     
    getch();

    Đã được chỉnh sửa lần cuối bởi chieftain2t : 28-04-2009 lúc 10:47 AM.
    khi đi mang nặng lời thề
    không đầy 2 bị không về quê hương

  2. #2
    Ngày gia nhập
    07 2008
    Nơi ở
    /media/Anime
    Bài viết
    2,288

    Bạn bọc code vào tag đi, nhìn muốn chết con mắt luôn. Bài này ko có gì là phức tạp cả, có lẽ là bạn chưa biết về cấu trúc của file bitmap nên thấy khó hiểu thôi. Bạn tham khảo cấu trúc file bitmap tại đây :
    http://msdn.microsoft.com/en-us/libr...86(VS.85).aspx
    Càng yêu mèo thì mèo càng mập. Mèo càng mập ta lại càng yêu.

  3. #3
    Ngày gia nhập
    04 2009
    Bài viết
    4

    thank bạn mèo con nhá

    nhưng có thể nói rõ cho tớ chức năng từng hàm trong đấy được ko
    Đã được chỉnh sửa lần cuối bởi langman : 28-04-2009 lúc 01:26 PM.
    khi đi mang nặng lời thề
    không đầy 2 bị không về quê hương

  4. #4
    Ngày gia nhập
    07 2008
    Nơi ở
    /media/Anime
    Bài viết
    2,288

    - extract_xxxx_from_buffer : lấy ra số kiểu xxxx từ buffer, tại vị trí start, trật tự màu là lsb
    - insert_xxxx_from_buffer : ghi số kiểu xxxx vào buffer, tại vị trí start
    - Các hàm còn lại : đọc file .bmp dựa trên cấu trúc bitmap header
    Càng yêu mèo thì mèo càng mập. Mèo càng mập ta lại càng yêu.

Các đề tài tương tự

  1. Sự cố Nhờ mod chuyển giúp bài "Sắp xếp số thứ tự ngay trong bảng của 1 database?" từ MySQL sang MSSQL giúp!
    Gửi bởi hu-xeko trong diễn đàn Ý kiến, đề xuất và khiếu nại
    Trả lời: 1
    Bài viết cuối: 12-03-2012, 07:48 PM
  2. Mới nhập môn khó quá , cần trợ giúp [Vấn đề của bạn cần muốn giúp là gì ?]
    Gửi bởi cuingo212 trong diễn đàn Nhập môn lập trình C#, ASP.NET
    Trả lời: 5
    Bài viết cuối: 22-10-2011, 08:43 AM
  3. Chương trình giúp một học sinh cấp 1 học phép nhân, xử lý hàm rand, giúp mình với?
    Gửi bởi chankx trong diễn đàn Nhập môn lập trình C/C++
    Trả lời: 2
    Bài viết cuối: 12-05-2009, 08:52 PM
  4. Code giúp add một key vào registry, ai giúp em?
    Gửi bởi olavien trong diễn đàn Nhập môn lập trình C/C++
    Trả lời: 5
    Bài viết cuối: 12-12-2007, 08:45 AM

Quyền hạn của bạn

  • Bạn không thể gửi đề tài mới
  • Bạn không thể gửi bài trả lời
  • Bạn không thể gửi các đính kèm
  • Bạn không thể chỉnh sửa bài viết của bạn