Lire les infos des headers d'un fichier bitmap et targa

Soyez le premier à donner votre avis sur cette source.

Vue 13 146 fois - Téléchargée 478 fois

Description

Voici une méthode simple qui permet de savoir à quel type de TGA ou BMP on a affaire (toujours utile en opengl pour charger les textures;))

Source / Exemple :


//Main
//
// Read Bitmap and Targa header informations
//
///////////////////////////////////////////
#include <windows.h>
#include <stdio.h>
#include "resource.h"

//Structure pour les header TGA (targa)
struct TgaHeader{
		unsigned char imageTypeCode;	//Type de TGA
		short int imageWidth;			//Largeur
		short int imageHeight;			// Hauteur
		unsigned char bitCount;			//Nombre de bits/pixel
		unsigned char BPP;				//Bytes/pixel

};

//Structure pour les infos Bitmaps
struct BmpInfo{

	//Les 2 structures définient dans windows.h
	BITMAPFILEHEADER	BitmapFileHeader;
	BITMAPINFOHEADER	BitmapInfoHeader;

};

#define UBYTE unsigned char

//Protos
LRESULT CALLBACK MainProc(HWND Dlg,UINT message,WPARAM wParam,LPARAM lParam);
BOOL GetTgaInfo(LPTSTR FilePath,TgaHeader *TH);
BOOL GetBMPInfo(LPTSTR FilePath,BmpInfo *BI);

//---------------------------------------------------------------------------------------------------

// Program Entry Point
// Bon gestion des dialogBoxs, on s'en fout un peu ^^
int APIENTRY WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nCmdShow){

HWND hDlg;

hDlg=CreateDialog(hInstance,(LPCTSTR)IDD_DIALOG1,NULL,(DLGPROC)MainProc);

ShowWindow(hDlg,SW_SHOW);

MSG msg;

while(GetMessage(&msg,NULL,0,0)==TRUE)

{

	TranslateMessage(&msg);
	DispatchMessage(&msg);

}
return 0;
}

//---------------------------------------------------------------------------------------------------

//function de notre fenêtre dialog

LRESULT CALLBACK MainProc(HWND Dlg,UINT message,WPARAM wParam,LPARAM lParam)

{

//routine des messages
int Select;
switch(message)

{

case WM_COMMAND:

	Select=LOWORD(wParam);

	switch(Select)

	{

	case IDCANCEL:

		EndDialog(Dlg,Select);

		PostQuitMessage(0);
		return 1;

	case IDC_BROWS: //Si le bouton brows est clické

            OPENFILENAME ofn;						// Structure pour la common dialog
            char szFileName[1000];					// String de l'emplacement du fichier
            memset(szFileName,0,1000);				// Mise à Zero

            
            ZeroMemory( &ofn, sizeof( OPENFILENAME ) ); //Mise à zero de la struc

			//Configuration de la dialogBox
            ofn.lStructSize = sizeof( OPENFILENAME );
            ofn.hwndOwner = NULL;
            ofn.hInstance = GetModuleHandle(NULL);
            lstrcpy( szFileName, TEXT("") );
            ofn.lpstrFile = szFileName;
            ofn.nMaxFile = 1000;
            ofn.Flags = OFN_FILEMUSTEXIST;
            ofn.lpstrFilter = "Bitmap (*.bmp)\0*.bmp\0Targa (*.tga)\0*.tga\0";
            ofn.lpstrTitle = "Open File";
			
            // On ouvre notre boîte ;)

            if(GetOpenFileName( &ofn )){
				
				//On met l'emplacement dans le premier EditBox
				SetDlgItemText(Dlg, IDC_EDIT1,szFileName);

				int nLen = strlen (szFileName); //Longeur de la chaine
				
				//On met l'exention en majuscule (comme ça on ne se fait pas chier avec les Bmp qui sont bmp ce qui revient au même)
				for(int i=(nLen-3);i<=nLen;i++){
					szFileName [i] = toupper (szFileName [i]);
				}

				//Si l'extention est TGA

			//==================================	
			//------------ Targa ---------------
			//==================================

				if(!strcmp (szFileName + (nLen - 3), "TGA")){	
					TgaHeader TgaH;
					char Buff[10];
					
					//ON envoi notre structure TgaHeader à la fonction, qui va nous chercher les infos ;)
					GetTgaInfo(szFileName,&TgaH);
					
					//On affiche les infos comme la taille de l'image et la profondeur de couleur
					sprintf(Buff,"%ix%i pixels",TgaH.imageWidth,TgaH.imageHeight);
					SetDlgItemText(Dlg, IDC_EDIT2,Buff);
					sprintf(Buff,"%i",TgaH.BPP);
					SetDlgItemText(Dlg, IDC_EDIT3,Buff);

					//Pas encore au point, il faut que je me rensiegne plus sur le type de codage TGA.
					if(TgaH.imageTypeCode==2){
						sprintf(Buff,"Image Targa de Type : BGR (%i)",TgaH.imageTypeCode);
						SetDlgItemText(Dlg, IDC_EDIT4,Buff);
					}else if(TgaH.imageTypeCode==3){
						sprintf(Buff,"Image Targa de Type : BGRA (%i)",TgaH.imageTypeCode);
						SetDlgItemText(Dlg, IDC_EDIT4,Buff);
					}else{
						sprintf(Buff,"Image Targa de Type inconnu : %i",TgaH.imageTypeCode);
						SetDlgItemText(Dlg, IDC_EDIT4,Buff);
					}

			//==================================	
			//----------- BitMap ---------------
			//==================================

				}else if(!strcmp (szFileName + (nLen - 3), "BMP")){

					BmpInfo bmpinfo;
					char Buff[30];

					

					if(GetBMPInfo(szFileName,&bmpinfo)){//Idem que pour les TGA, on envoi notre structure d'headers

					//On traite les résultats :

					//Résolution :
					sprintf(Buff,"%ix%i pixels",bmpinfo.BitmapInfoHeader.biWidth,bmpinfo.BitmapInfoHeader.biHeight);
					SetDlgItemText(Dlg, IDC_EDIT2,Buff);

					//Pronfondeur des couleurs (Byte.pixel)
					sprintf(Buff,"%i (%i bits)",bmpinfo.BitmapInfoHeader.biBitCount/8,bmpinfo.BitmapInfoHeader.biBitCount);
					SetDlgItemText(Dlg, IDC_EDIT3,Buff);
		
					//La Bitmap estcompressée?
					
					switch(bmpinfo.BitmapInfoHeader.biCompression){
						
					case 0:
						sprintf(Buff,"Bitmap non compressée, %i plan(s)",bmpinfo.BitmapFileHeader.bfType,bmpinfo.BitmapInfoHeader.biPlanes);
						break;
					case 1:
						sprintf(Buff,"Bitmap compressée RLE 8bits (%i) , %i plan(s)",bmpinfo.BitmapInfoHeader.biCompression,bmpinfo.BitmapInfoHeader.biPlanes);
						break;
					case 2:
						sprintf(Buff,"Bitmap compressée RLE 4bits (%i) , %i plan(s)",bmpinfo.BitmapInfoHeader.biCompression,bmpinfo.BitmapInfoHeader.biPlanes);
						break;
					case 3:
						sprintf(Buff,"Bitmap compressée bitfield enc. (%i) , %i plan(s)",bmpinfo.BitmapInfoHeader.biCompression,bmpinfo.BitmapInfoHeader.biPlanes);
						break;
					default:
						sprintf(Buff,"Bitmap de type inconnu (%i) , %i plan(s)",bmpinfo.BitmapInfoHeader.biCompression,bmpinfo.BitmapInfoHeader.biPlanes);

					}
					
					SetDlgItemText(Dlg, IDC_EDIT4,Buff);
					}

			//==================================	
			//------------- ELSE ---------------
			//==================================	

				}else{
					//SI c'est pas la bonne extention malgré les filtres de la common dialog
					MessageBox(NULL,"Mauvais type de fichier !\nLes formats suportés sont BMP et TGA","Inccorect File",1);
				}
				}
			
			
		
		return 1;
		

	return TRUE;

	}

default:

return FALSE;

}

}

//-------------------------------------------------------------------------------------------------------------------------------

//Fonction Pour les TGAs

BOOL GetTgaInfo(LPTSTR FilePath,TgaHeader *TH){
	
	FILE		  *pFile;	//Pointeur sur le fichier
	UBYTE uCharDummy;		//Byte qui nest jamais utilisée, juste pour parcourire le Bmp
	short		  sIntDummy;//Idem mais en short
	

	//On ouvre le fichier en mode lecture binaire
	pFile = fopen(FilePath, "rb");

	//Si on a réussi à ouvrir le fichier ;)
	if (!pFile)return 0;
	//On passe les 2première byte car on n'en a pas l'usage
	fread (&uCharDummy, sizeof (UBYTE), 1, pFile);
	fread (&uCharDummy, sizeof (UBYTE), 1, pFile);
	
	//On récupaire le Type Code (Le type de TGA)
	fread(&TH->imageTypeCode, sizeof (unsigned char), 1, pFile);

	//On passe 1Byte et 4 short..
	fread (&uCharDummy, sizeof (unsigned char), 1, pFile);
	fread (&sIntDummy,  sizeof (short), 1, pFile);
	fread (&sIntDummy,  sizeof (short), 1, pFile);
	fread (&sIntDummy,  sizeof (short), 1, pFile);
	fread (&sIntDummy,  sizeof (short), 1, pFile);

	// On récupaire la largeur, hauteur et la profondeur de couleur
	fread (&TH->imageWidth,  sizeof (short int), 1, pFile);
	fread (&TH->imageHeight, sizeof (short int), 1, pFile);
	fread (&TH->bitCount, sizeof (unsigned char), 1, pFile);

	//On transforme les bits en Bytes (/8 car 8bits = 1Bytes ^^)
	TH->BPP=TH->bitCount / 8;
	fclose(pFile);
	
	return 1;
}

//-------------------------------------------------------------------------------------------------------------------------------

//Pour les Bmp, plus simple ;)
BOOL GetBMPInfo(LPTSTR FilePath,BmpInfo *BI){

	FILE  *pFile;	//pointeur sur le fichier...

	//on ouvre le fichier
	pFile = fopen(FilePath, "rb");

	//si pas d'erreur.
	if (pFile == 0) return 0;

	//On lit l'Headeur (l'en-tête) contient l'offset de certaine donné la taille etc;)
	fread (&BI->BitmapFileHeader, sizeof (BITMAPFILEHEADER), 1, pFile);
	
	//LEs infos du Header. la résolution et la profondeur des couleursn compression etc.. :)
	fread (&BI->BitmapInfoHeader, sizeof (BITMAPINFOHEADER), 1, pFile);
	
	// c'est Tout,  facile !
	//En effet, les structures header de windows.h permettent de lire facilement les données d'une bitmap ;)

	//fermeture du fichier.
	fclose(pFile);

	if(BI->BitmapFileHeader.bfType==0x4d42) //Si les 2premières Bytes vallent MB -> c'est une bitmap.
	{
		return 1;
	}else{
	
	return 0;
	}

}

//Il y a d'autres information des les headers tga et bitmaps :

/*
Donnée
 Structure
 Valeur
 Explication
 
entête du fichier
 
 
 
 
file_type
 S[2]
 'BM'
 identification du format
 
file_size
 DW
 
 taille du fichier
 
reserved
 DW
 0
 réservé (inutilisé)
 
bitmap_offset
 DW
 
 offset de l?image
 
entête du bitmap
 
 
 
 
header_size
 DW
 
 taille de l'entête en octets
 
width
 DW
 
 largeur en pixels de l'image
 
height
 DW
 
 hauteur en pixels de l'image
 
planes
 W
 1
 nombre de plans utilisés
 
bits_per_pixel
 W
 {1,4,8,16,24,32}
 nombre de bits utilisés par pixel
 
compression
 DW
 0 = pas de comp.
1 = RLE 8bits
2 = RLE 4bits
3 = bitfield enc.
 méthode de compression
 
size_bitmap
 DW
 
 taille de l'image en octets
 
horiz_resolution
 DW
 
 résolution horiz. en pixels par mètre
 
vert_resolution
 DW
 
 résolution vert. en pixels par mètre
 
colors_used
 DW
 0 = palette entière
 
 
colors_important
 DW
 
 nombre de couleurs importantes
 
palette (optionnelle)

  • /

Conclusion :


Voilà, ça utilise les resources, la common dialog et les structure Bitmap header de WIndows.h, open,read file...
Code assez simple mais toujours utile ;)

Codes Sources

A voir également

Ajouter un commentaire Commentaires
Messages postés
4
Date d'inscription
dimanche 17 octobre 2010
Statut
Membre
Dernière intervention
17 octobre 2010

Comment écrire et lire un fichier bmp en C++? voir les sources en C++ sur
www.gravitomagnetism.com en bas de page d'accueil.
c'est facile!
Messages postés
2
Date d'inscription
lundi 11 juin 2007
Statut
Membre
Dernière intervention
2 décembre 2009

ça fesait un petit moment que je cherchais un moyen de lire les header d'un fichier image!
Merci bcps!
Sinon concernant cette remarque:
"On ne peut dire que c'est si pratique si ça n'est pas portable" << Je pense qu'elle ce passe de commentaires...........
Messages postés
4
Date d'inscription
vendredi 28 janvier 2005
Statut
Membre
Dernière intervention
2 septembre 2006

Mouais... Ça donne quoi sans windows.h ? -_- On ne peut dire que c'est si pratique si ça n'est pas portable...
Messages postés
1467
Date d'inscription
samedi 13 mars 2004
Statut
Membre
Dernière intervention
5 mai 2010
2
Oui, c'est pratique, c vrai...

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.