Décomposer une image en plusieurs matrices de 8*8

Décomposer une image en plusieurs matrices de 8*8 - C - Programmation

Marsh Posté le 03-05-2009 à 16:46:57    

Bonjour,
J'aimerai savoir si quelqu'un connais un lib ou quelque chose en C qui me permet de décomposer une image bmp en matrices (bloks) de 8*8 afin d'appliquer des modifications sur chaque blok.
Merci.


Message édité par tomap le 03-05-2009 à 16:50:04
Reply

Marsh Posté le 03-05-2009 à 16:46:57   

Reply

Marsh Posté le 03-05-2009 à 16:56:51    

la célèbre SDL permet d'addresser des sous-surface de taille arbitraire, 8x8 par exemple. Une "surface" SDL est une généralisation du concept d'image/bitmap, tu peux charger un .bmp et faire ce que tu veux dedans.
Par contre je ne pense pas qu'il y ait de lib spécialisée dans les blocks 8x8, même si cette taille correspond aux macroblocks du JPEG. Ton travail ne consisterait pas à implémenter un compresseur JPEG ?

Message cité 1 fois
Reply

Marsh Posté le 03-05-2009 à 17:06:18    

jesus_christ a écrit :

Ton travail ne consisterait pas à implémenter un compresseur JPEG ?


Oui en effet c'est le cas, un compresseur/decompresseur JPEG.
J'ai implémenté toute les étapes de base qu'on peut faire sur une matrice de 8*8, à savoir:
Un blok pixels de 8*8 ---> matrice DCT ---> Matrice quantifié ---> Codage huffman ---> Décodage huffman ---> Quantification inverse ---> DCT inverse ---> blok pixels de 8*8
Et je voudrai tester le travail sur une image, il faut donc la décomposer en bloks de 8*8 pour appliquer les étapes sur chaque blok.

 

Donc c'est faisable avec la SDL ?


Message édité par tomap le 03-05-2009 à 17:20:00
Reply

Marsh Posté le 03-05-2009 à 19:04:10    

Il y a plusieurs types d'images BMP (je suppose qu'il s'agit du format BMP de Windows).
Il peut y avoir des images en noir et blanc, ou bien avec une palette de couleurs, ou avec 4 octets par pixel, ce qui est devenu le format le plus courant de nos jours.
 
Comme c'est mon jour de bonté, voici du code testé et approuvé qui permet de charger une image BMP en mémoire et d'obtenir la couleur de chaque pixel beaucoup plus rapidement qu'avec l'API GetPixel() qui marche aussi :
 

Code :
  1. #include <windows.h>
  3. BITMAP bmp1;
  4. HBITMAP hbmp1;
  5. BYTE *DIBits;
  6. HGLOBAL hDIBits;
  7. UINT picture_width, picture_height;
  9. /* ============================================================== */
  10. int init_bitmap(void)
  11. {
  12.    hbmp1 = NULL;
  13.    hDIBits = NULL;
  14.    DIBits = NULL;
  15.    picture_width = 0;
  16.    picture_height = 0;
  18.    return TRUE;
  19. }
  21. /* ============================================================== */
  22. int release_bitmaps(void)
  23. {
  24.    if (hbmp1 != NULL) {
  25.       DeleteObject(hbmp1);
  26.       hbmp1 = NULL;
  27.    }
  28.    if (hDIBits != NULL) {
  29.       GlobalUnlock(hDIBits);
  30.       GlobalFree(hDIBits);
  31.       hDIBits = NULL;
  32.       DIBits = NULL;
  33.    }
  34.    return TRUE;
  35. }
  37. /* ==============================================================
  38.    Load a BMP file into a DIB bitmap.
  39.    ============================================================== */
  40. static int loadDIBfromBMPfile(HWND hwnd, char *bmp_filename)
  41. {
  42.    BITMAPINFO bi;
  43.    UINT width, height, components_nb;
  44.    HDC hdc;
  45.    HDC hdcmem; HBITMAP hbmpmem;
  46.    int DIB_x0, DIB_y0, DIB_w;
  47.    HBITMAP h_tmp_bmp;
  48.    BITMAP  tmp_bm;
  50.    if (hwnd == NULL)
  51.       return -99;
  53.    if (hbmp1 != NULL) {
  54.       release_bitmaps();
  55.       init_bitmap();
  56.    }
  58.    DIB_x0 = 0; DIB_y0 = 0; DIB_w = 0;
  60.    memset(&bi, 0, sizeof(BITMAPINFO));
  61.    bi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
  62.    bi.bmiHeader.biPlanes = 1;
  63.    bi.bmiHeader.biBitCount = 32; // 32 bit so no padding of the horizontal lines is required
  64.    bi.bmiHeader.biCompression = BI_RGB;
  65.    bi.bmiHeader.biClrUsed = 0;
  66.    bi.bmiHeader.biClrImportant = 0;
  68.    // Load file
  69.    h_tmp_bmp = (HBITMAP)LoadImage(NULL, bmp_filename, IMAGE_BITMAP, 0, 0,
  70.                LR_LOADFROMFILE);
  71. //               LR_CREATEDIBSECTION | LR_DEFAULTSIZE | LR_LOADFROMFILE );
  72.    GetObject(h_tmp_bmp, sizeof(BITMAP), &tmp_bm);
  73.    // N.B.: The GetObject function returns only the width, height, and color format information of the bitmap
  75.    DIB_w = DIB_x0 + tmp_bm.bmWidth;
  76.    height = DIB_y0 + tmp_bm.bmHeight;
  77.    bi.bmiHeader.biWidth = DIB_w;
  78.    bi.bmiHeader.biHeight = -height;
  79.    bi.bmiHeader.biSizeImage = DIB_w * 4 * height * sizeof(BYTE);
  80.    picture_width = DIB_w;
  81.    picture_height = height;
  83.    // Allocate a buffer for the pixels
  84.    hDIBits = GlobalAlloc(GHND, bi.bmiHeader.biSizeImage);
  85.    if (hDIBits == NULL)
  86.       return(-3);
  87.    DIBits = (BYTE *)GlobalLock(hDIBits);
  88.    memset(DIBits, 255, bi.bmiHeader.biSizeImage); // Initiailize with white pixels
  90.    // Create a memory DC, with a bitmap
  91.    hdc = GetDC(hwnd);
  92.    if (!hdc) {
  93.       GlobalUnlock(hDIBits); GlobalFree(hDIBits);
  94.       hDIBits = NULL; DIBits = NULL;
  95.       return -5;
  96.    }
  98.    GetDIBits(hdc, h_tmp_bmp, 0, tmp_bm.bmHeight, DIBits, &bi, DIB_RGB_COLORS);
  99.    hbmp1 = CreateDIBitmap(hdc, &bi.bmiHeader, CBM_INIT,
  100.                           DIBits, &bi, DIB_RGB_COLORS);
  102.    DeleteObject(h_tmp_bmp);
  103.    ReleaseDC(hwnd, hdc);
  105.    if (hbmp1 == NULL) {
  106.       MessageBox(hwnd, "Image too big and/or not enough video ram.",
  107.                  "Error", MB_OK|MB_ICONERROR);
  108.       return FALSE;
  109.    }
  111.    InvalidateRect(hwnd, NULL, TRUE); // Refresh screen
  113.    return(0);
  114. }
  116. /* ================================================
  117.    Get the color of pixel at x, y
  118.    ================================================ */
  119. int get_pixel_color(int x, int y, int &blue, int &green, int &red)
  120. {
  121.    long int k;
  122.    k = (y * picture_width + x) * 4;
  123.    *blue = DIBits[k];
  124.    *green = DIBits[k + 1];
  125.    *red = DIBits[k + 2];
  126.    // The fourth integer is not used or is the alpha value
  127.    return TRUE;
  128. }

Edit : correction pour enlever des lignes qui ne sont pas utiles dans ce cadre et qui utilisaient des variables définies ailleurs, et aussi pour rajouter #include <windows.h> qu'il faut évidemment ajouter quand on programme pour Windows en C.

Message cité 1 fois
Message édité par billgatesanonym le 03-05-2009 à 20:51:30
Reply

Marsh Posté le 03-05-2009 à 19:43:51    

Salut billgatesanonym, en fait les images bmp que je evux traiter c'est du niveau de gris.
Sinon j'ai les erreurs suivantes à la compilation en C avec GCC avec CodeBocks sous Windows:
 

Citation :

main.c||In function `init_bitmap':|
main.c|16|error: `picture_x0' undeclared (first use in this function)|
main.c|16|error: (Each undeclared identifier is reported only once|
C:\Documents and Settings\TheShNaYkHs\Bureau\projetttt\tpR\main.c|16|error: for each function it appears in.)|
main.c|17|error: `picture_y0' undeclared (first use in this function)|
main.c||In function `loadDIBfromBMPfile':|
main.c|41|warning: unused variable `width'|
main.c|41|warning: unused variable `components_nb'|
main.c|43|warning: unused variable `hdcmem'|
main.c|43|warning: unused variable `hbmpmem'|
main.c|103|error: syntax error before "pixel_color"|
main.c|103|error: syntax error before '&' token|
main.c|104|warning: return type defaults to `int'|
main.c||In function `pixel_color':|
main.c|106|error: `y' undeclared (first use in this function)|
main.c|106|error: `x' undeclared (first use in this function)|
main.c|107|error: `blue' undeclared (first use in this function)|
main.c|108|error: `green' undeclared (first use in this function)|
|109|error: `red' undeclared (first use in this function)|
|39|warning: 'loadDIBfromBMPfile' defined but not used|
||=== Build finished: 11 errors, 6 warnings ===|


Message édité par tomap le 03-05-2009 à 19:48:11
Reply

Marsh Posté le 05-05-2009 à 10:31:42    

billgatesanonym a écrit :


Comme c\'est mon jour de bonté, voici du code testé et approuvé qui permet de charger une image BMP en mémoire et d\'obtenir la couleur de chaque pixel beaucoup plus rapidement qu\'avec l\'API GetPixel() qui marche aussi :.


C\'est du grand n\'importe quoi (coipier-coller du code MSDN datant de 15 ans, quelle originalité !)
et aucun rapport avec le sujet ou 8 lignes suffisent pour découper un BMP en matrice (!)

Reply

Marsh Posté le 05-05-2009 à 16:10:12    

En fait j'ai trouvé comment faire avec la SDL, ça a l'aire bien. Merci.

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed