Công cụ bảo vệ mã nguồn .NET mạnh nhất, không thể unpack, miễn phí cho các khách hàng đầu tiên đăng ký.
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!
    Công cụ bảo vệ mã nguồn .NET mạnh nhất hiện tại, miễn phí cho các khách hàng đầu tiên đăng ký.

  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!
    Công cụ bảo vệ mã nguồn .NET mạnh nhất hiện tại, miễn phí cho các khách hàng đầu tiên đăng ký.

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