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

Đề tài: Xử Lý Ảnh

  1. #1
    Ngày gia nhập
    01 2008
    Bài viết
    1

    Mặc định Xử Lý Ảnh

    Các anh chị ơi giúp em với !
    có ai có code của chương trình :đọc vào 1 ảnh BMP và đưa ra màn hình bằng c ko cho em xin với , bọn em đang phải làm bài tập về phần này mà khó quá ko làm dc !
    Rất mong được sự giúp đỡ!
    Em xim cảm ơn!

  2. #2
    Ngày gia nhập
    01 2008
    Bài viết
    1

    không ai giup em ư! hu hu

  3. #3
    Ngày gia nhập
    12 2006
    Nơi ở
    US
    Bài viết
    1,917

    1 ví dụ trên Windows :
    C++ Code:
    1. #include <windows.h>
    2. #include <fstream.h>
    3.  
    4. char szAppName [] = "BMPLoad";
    5.  
    6. LRESULT CALLBACK WindowProc (HWND, UINT, WPARAM, LPARAM);
    7.  
    8. // **********
    9. // class CRaster
    10. //   - Generic class for BMP raster images.
    11. class CRaster {
    12.     public:
    13.         int Width,Height;       // Dimensions
    14.         int BPP;                // Bits Per Pixel.
    15.         char * Raster;          // Bits of the Image.
    16.         RGBQUAD * Palette;      // RGB Palette for the image.
    17.         int BytesPerRow;        // Row Width (in bytes).
    18.         BITMAPINFO * pbmi;      // BITMAPINFO structure
    19.  
    20.         // Member functions (defined later):
    21.         int LoadBMP (char * szFile);
    22.         int GDIPaint (HDC hdc,int x,int y);
    23. };
    24.  
    25. // **********
    26. // Windows Main Function.
    27. //   - Here starts our demo program
    28. int WINAPI WinMain ( HINSTANCE hInstance, HINSTANCE hPrevInstance,
    29.                     LPSTR lpCmdLine, int nCmdShow )
    30. {
    31.     HWND hwnd;
    32.     MSG msg;
    33.  
    34.     WNDCLASS wc;
    35.     wc.style = CS_HREDRAW|CS_VREDRAW;
    36.     wc.lpfnWndProc = WindowProc;
    37.     wc.cbClsExtra = 0;
    38.     wc.cbWndExtra = 0;
    39.     wc.hInstance = hInstance;
    40.     wc.hIcon = LoadIcon (NULL, IDI_APPLICATION);
    41.     wc.hCursor = LoadCursor (NULL, IDC_ARROW);
    42.     wc.hbrBackground = (HBRUSH) (COLOR_WINDOW+1);
    43.     wc.lpszMenuName = NULL;
    44.     wc.lpszClassName = szAppName;
    45.  
    46.     RegisterClass (&wc);
    47.  
    48.     hwnd = CreateWindow (szAppName,"BMP Load",WS_OVERLAPPEDWINDOW,
    49.         CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT,
    50.         0,0,hInstance,0);
    51.  
    52.     ShowWindow (hwnd,nCmdShow);
    53.     UpdateWindow (hwnd);
    54.  
    55.     while (GetMessage(&msg,0,0,0))
    56.     {
    57.         TranslateMessage (&msg);
    58.         DispatchMessage (&msg);
    59.     }
    60.  
    61.     return msg.wParam;
    62. }
    63.  
    64. // **********
    65. // Main Window Procedure.
    66. //   - Processes Window Messages
    67. LRESULT CALLBACK WindowProc
    68.     (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
    69. {
    70.     static CRaster bmp;
    71.     HDC hdc;
    72.     PAINTSTRUCT ps;
    73.  
    74.     switch (message)
    75.     {
    76.         case WM_CREATE:
    77.             bmp.LoadBMP ("example.bmp");
    78.             return 0;
    79.         case WM_PAINT:
    80.             hdc=BeginPaint (hwnd,&ps);
    81.             bmp.GDIPaint (hdc,10,10);
    82.             EndPaint (hwnd,&ps);
    83.             return 0;
    84.         case WM_DESTROY:
    85.             PostQuitMessage (0);
    86.             return 0;
    87.     }
    88.     return DefWindowProc (hwnd,message,wParam,lParam);
    89. }
    90.  
    91. // **********
    92. // CRaster::LoadBMPFile (FileName);
    93. //   - loads a BMP file into a CRaster object
    94. //   * supports non-RLE-compressed files of 1, 2, 4, 8 & 24 bits-per-pixel
    95. int CRaster::LoadBMP (char * szFile)
    96. {
    97.     BITMAPFILEHEADER bmfh;
    98.     BITMAPINFOHEADER bmih;
    99.  
    100.     // Open file.
    101.     ifstream bmpfile (szFile , ios::in | ios::binary);
    102.     if (! bmpfile.is_open()) return 1;      // Error opening file
    103.  
    104.     // Load bitmap fileheader & infoheader
    105.     bmpfile.read ((char*)&bmfh,sizeof (BITMAPFILEHEADER));
    106.     bmpfile.read ((char*)&bmih,sizeof (BITMAPINFOHEADER));
    107.  
    108.     // Check filetype signature
    109.     if (bmfh.bfType!='MB') return 2;        // File is not BMP
    110.  
    111.     // Assign some short variables:
    112.     BPP=bmih.biBitCount;
    113.     Width=bmih.biWidth;
    114.     Height= (bmih.biHeight>0) ? bmih.biHeight : -bmih.biHeight; // absoulte value
    115.     BytesPerRow = Width * BPP / 8;
    116.     BytesPerRow += (4-BytesPerRow%4) % 4;   // int alignment
    117.  
    118.     // If BPP aren't 24, load Palette:
    119.     if (BPP==24) pbmi=(BITMAPINFO*)new char [sizeof(BITMAPINFO)];
    120.     else
    121.     {
    122.         pbmi=(BITMAPINFO*) new char[sizeof(BITMAPINFOHEADER)+(1<<BPP)*sizeof(RGBQUAD)];
    123.         Palette=(RGBQUAD*)((char*)pbmi+sizeof(BITMAPINFOHEADER));
    124.         bmpfile.read ((char*)Palette,sizeof (RGBQUAD) * (1<<BPP));
    125.     }
    126.     pbmi->bmiHeader=bmih;
    127.  
    128.     // Load Raster
    129.     bmpfile.seekg (bmfh.bfOffBits,ios::beg);
    130.  
    131.     Raster= new char[BytesPerRow*Height];
    132.  
    133.     // (if height is positive the bmp is bottom-up, read it reversed)
    134.     if (bmih.biHeight>0)
    135.         for (int n=Height-1;n>=0;n--)
    136.             bmpfile.read (Raster+BytesPerRow*n,BytesPerRow);
    137.     else
    138.         bmpfile.read (Raster,BytesPerRow*Height);
    139.  
    140.     // so, we always have a up-bottom raster (that is negative height for windows):
    141.     pbmi->bmiHeader.biHeight=-Height;
    142.  
    143.     bmpfile.close();
    144.  
    145.     return 0;
    146. }
    147.  
    148. // **********
    149. // CRaster::GDIPaint (hdc,x,y);
    150. // * Paints Raster to a Windows DC.
    151. int CRaster::GDIPaint (HDC hdc,int x=0,int y=0)
    152. {
    153.     // Paint the image to the device.
    154.     return SetDIBitsToDevice (hdc,x,y,Width,Height,0,0,
    155.         0,Height,(LPVOID)Raster,pbmi,0);
    156. }

  4. #4
    Ngày gia nhập
    12 2006
    Nơi ở
    US
    Bài viết
    1,917

    Cái trên phụ thuộc vào các hàm của Windows, nếu muốn dùng cross-platform ( Linux, Unix ) thì thủ công hơn 1 tí, và đây là 1 ví dụ :
    Image.h
    C++ Code:
    1. class Image {
    2. public:
    3.     Image(char* ps, int w, int h);
    4.     ~Image();
    5.     char* pixels; //mãng các pixel
    6.     int width;
    7.     int height;
    8. };
    9.  
    10. //Đọc các bitmap từ file vào.
    11. Image* loadBMP(const char* filename);
    Image.cpp
    C++ Code:
    1. #include <assert.h>
    2. #include <fstream>
    3.  
    4. #include "imageloader.h"
    5.  
    6. using namespace std;
    7. Image::Image(char* ps, int w, int h) : pixels(ps), width(w), height(h)
    8. {}
    9.  
    10. Image::~Image()
    11. {
    12.     delete[] pixels;
    13. }
    14.  
    15. namespace {
    16.     //Chuyển mãng 4-kí tự về int
    17.     int toInt(const char* bytes)
    18.     {
    19.         return (int)(((unsigned char)bytes[3] << 24)  |
    20.                           ((unsigned char)bytes[2] << 16) |
    21.                           ((unsigned char)bytes[1] << 8)   |
    22.                           (unsigned char)bytes[0]);
    23.     }
    24.    
    25.     //Chuyển mãng 2-kí tự thành kiểu short
    26.     short toShort(const char* bytes)
    27.     {
    28.         return (short)(((unsigned char)bytes[1] << 8) |
    29.                              (unsigned char)bytes[0]);
    30.     }
    31.     //Đọc 4 bytes kế tiếp kiểu int
    32.     int readInt(ifstream &input)
    33.     {
    34.         char buffer[4];
    35.         input.read(buffer, 4);
    36.         return toInt(buffer);
    37.     }
    38.    
    39.     //Đọc 2 byte kế tiếp kiểu short
    40.     short readShort(ifstream &input)
    41.     {
    42.         char buffer[2];
    43.         input.read(buffer, 2);
    44.         return toShort(buffer);
    45.     }
    46.    
    47.     //Giống như auto_ptr nhưng bi h là auto_array
    48.     template<class T>
    49.     class auto_array {
    50.     private:
    51.         T* array;
    52.         mutable bool isReleased;
    53.     public:
    54.         explicit auto_array(T* array_ = NULL) : array(array_), isReleased(false)
    55.         {}
    56.         auto_array(const auto_array<T> &aarray)
    57.         {
    58.             array = aarray.array;
    59.             isReleased = aarray.isReleased;
    60.             aarray.isReleased = true;
    61.         }
    62.         ~auto_array()
    63.         {
    64.             if (!isReleased && array != NULL)
    65.                 delete[] array;
    66.         }
    67.            
    68.         T* get() const
    69.         {
    70.             return array;
    71.         }
    72.            
    73.         T &operator*() const
    74.         {
    75.             return *array;
    76.         }
    77.            
    78.         void operator=(const auto_array<T> &aarray)
    79.         {
    80.             if (!isReleased && array != NULL)
    81.                 delete[] array;
    82.            
    83.             array = aarray.array;
    84.             isReleased = aarray.isReleased;
    85.             aarray.isReleased = true;
    86.         }
    87.            
    88.         T* operator->() const
    89.         {
    90.             return array;
    91.         }
    92.            
    93.         T* release()
    94.         {
    95.             isReleased = true;
    96.             return array;
    97.         }
    98.            
    99.         void reset(T* array_ = NULL)
    100.         {
    101.             if (!isReleased && array != NULL)
    102.                 delete[] array;
    103.            
    104.             array = array_;
    105.         }
    106.            
    107.         T* operator+(int i)
    108.         {
    109.             return array + i;
    110.         }
    111.            
    112.         T &operator[](int i)
    113.         {
    114.             return array[i];
    115.         }
    116.     };
    117. }
    118.  
    119. Image* loadBMP(const char* filename)
    120. {
    121.     ifstream input;
    122.     input.open(filename, ifstream::binary);
    123.     assert(!input.fail() || !"Could not find file");
    124.     char buffer[2];
    125.     input.read(buffer, 2);
    126.    
    127.     assert(buffer[0] == 'B' && buffer[1] == 'M' || !"Not a bitmap file");
    128.     input.ignore(8);
    129.     int dataOffset = readInt(input);
    130.    
    131.     //Đọc header vào
    132.     int headerSize = readInt(input);
    133.     int width;
    134.     int height;
    135.    
    136.     switch(headerSize)
    137.     {
    138.         case 40:
    139.             width = readInt(input);
    140.             height = readInt(input);
    141.             input.ignore(2);
    142.             assert(readShort(input) == 24 || !"Image is not 24 bits per pixel");
    143.             assert(readShort(input) == 0 || !"Image is compressed");
    144.             break;
    145.         case 12:
    146.             width = readInt(input);
    147.             height = readInt(input);
    148.             input.ignore(2);
    149.             assert(readShort(input) == 24 || !"Image is not 24 bits per pixel");
    150.             break;
    151.         case 64:
    152.             assert(!"Can't load OS/2 V2 bitmaps");
    153.             break;
    154.         case 108:
    155.             assert(!"Can't load Windows V4 bitmaps");
    156.             break;
    157.         case 124:
    158.             assert(!"Can't load Windows V5 bitmaps");
    159.             break;
    160.         default:
    161.             assert(!"Unknown bitmap format");
    162.     }
    163.    
    164.     //Đọc raw data vào
    165.     int bytesPerRow = ((width * 3 + 3) / 4) * 4 - (width * 3 % 4);
    166.     int size = bytesPerRow * height;
    167.     auto_array<char> pixels(new char[size]);
    168.     input.seekg(dataOffset, ios_base::beg);
    169.     input.read(pixels.get(), size);
    170.    
    171.     //Đọc dữ liệu vào ở đúng format của nó
    172.     auto_array<char> pixels2(new char[width * height * 3]);
    173.     for(int y = 0; y < height; y++)
    174.     {
    175.         for(int x = 0; x < width; x++)
    176.         {
    177.             for(int c = 0; c < 3; c++)
    178.             {
    179.                 pixels2[3 * (width * y + x) + c] = pixels[bytesPerRow * y + 3 * x + (2 - c)];
    180.             }
    181.         }
    182.     }
    183.    
    184.     input.close();
    185.     return new Image(pixels2.release(), width, height);
    186. }

  5. #5
    Ngày gia nhập
    01 2008
    Bài viết
    1

    thanks, nhiều nha!

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