Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
1436 connectés 

  FORUM HardWare.fr
  Programmation
  C

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

 


 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

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

n°1880321
tomap
Posté le 03-05-2009 à 16:46:57  profilanswer
 

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
mood
Publicité
Posté le 03-05-2009 à 16:46:57  profilanswer
 

n°1880328
jesus_chri​st
votre nouveau dieu
Posté le 03-05-2009 à 16:56:51  profilanswer
 

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 ?

n°1880331
tomap
Posté le 03-05-2009 à 17:06:18  profilanswer
 

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
n°1880357
billgatesa​nonym
Posté le 03-05-2009 à 19:04:10  profilanswer
 

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

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
n°1880368
tomap
Posté le 03-05-2009 à 19:43:51  profilanswer
 

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
n°1880972
Pat333
Posté le 05-05-2009 à 10:31:42  profilanswer
 

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 (!)

n°1881104
tomap
Posté le 05-05-2009 à 16:10:12  profilanswer
 

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


Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Programmation
  C

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

 

Sujets relatifs
écrire sur une imageeffectuer des opérations sur les matrices...
Requête sur plusieurs tables avec un nombre de champs différentcomment changer une ligne sur plusieurs pages
Durée de vie session PHP et imagepositionner une image gif sous le curseur
envoi mail php pièce jointe a plusieurs destinatairesreconnaissance de plusieurs mots sur une même ligne
Supprimer plusieurs lignes dans une sélectionPlusieurs comptes à rebours sur la même page html
Plus de sujets relatifs à : Décomposer une image en plusieurs matrices de 8*8


Copyright © 1997-2022 Hardware.fr SARL (Signaler un contenu illicite / Données personnelles) / Groupe LDLC / Shop HFR