Ouvrir une fenêtre en C

**Formule1** · 28/10/2014, 17h22

Bonjour à tous

Mon but est de créer un code afin de pouvoir ouvrir une image en C (sans utiliser OpenGL) de la façon RGB.
Ci joint mon code mais je ne comprends pas pourquoi lorsque je lance le programme, l'image ne s'affiche pas.

Merci d'avance de votre aide

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
int readImage(image_desc *pDesc, char * fName)
{
    FILE *fp;
    targa_header *header;
    long length;
    uint8_t *buffer=NULL;
    uint8_t *colourmap=NULL;
    uint8_t *ptr;
 
    fp = fopen (fName, "rb");
    if (!fp)
    {
        fprintf (stderr, "error: couldn't open \"%s\"!\n",fName);
        return NULL;
    }
    else printf("fichier ouvert\n");
 
    fseek(fp,0,SEEK_END);
    length=ftell(fp);
    fseek(fp,0,SEEK_SET);
 
 
    buffer=(uint8_t*)malloc(sizeof(uint8_t)*length);
    if (!buffer)
    {
        printf(stderr,"Error: memory allocation failed");
        fclose(fp);
        return NULL;
    }
    fread(buffer,1,length,fp);
    fclose(fp);
 
    printf("length: %d\n",length);
 
    ptr=buffer;
 
    header=(struct targa_header*)ptr;
    ptr+=sizeof(targa_header);
 
    pDesc=(struct targa_header*)malloc(sizeof(targa_header));
    ptr+=header->idlength;
 
    pDesc->pRed=(uint8_t*)malloc(sizeof(uint8_t)*pDesc->width*pDesc->height);
    pDesc->pBlue=(uint8_t*)malloc(sizeof(uint8_t)*pDesc->width*pDesc->height);
    pDesc->pGreen=(uint8_t*)malloc(sizeof(uint8_t)*pDesc->width*pDesc->height);
 
    if(header->colourmaptype)
    {
        colourmap=ptr;
    }
 
    int i;
    uint8_t colour;
    for(i=0;i<pDesc->width*pDesc->height;++i)
    {
        colour=ptr[i];
 
        pDesc->pRed[(i*3)]=colourmap[(colour*3)+0];
        pDesc->pBlue[(i*3)]=colourmap[(colour*3)+1];
        pDesc->pGreen[(i*3)]=colourmap[(colour*3)+2];
        printf("pDesc->pRed[%d]: %d\n",i,pDesc->pRed[i]);
    }
    printf("%d\n",pDesc->width);
 
    fclose (fp);
 
    return pDesc;
 
}
 
int main()
{
    image_desc *pDesc;
    char * fName;
    fName="image.tga";
    readImage(&pDesc,fName);
}

**Médinoc** · 28/10/2014, 17h41

Dans ton message, je vois du code pour lire l'image vers une structure targa_header (non-déclarée...

), mais rien qui serve à l'affichage.
De plus, ton code retourne un pointeur en tant qu'entier; si ton compilo ne gueule pas c'est qu'il est mal réglé.

**Formule1** · 28/10/2014, 18h18

Merci de votre réponse.
En fait, j'utilise codeBlocks et je débute en C. J'ai déclarée la structure dans un fichier .h
Comment s'occuper de l'affichage et des problèmes éventuels que vous soulevez ...

Merci d'avance de votre aide

PS: Mon but final est de créer un code qui puisse dupliquer l'image, changer de couleur, zoomer ...

**Formule1** · 28/10/2014, 18h21

Je me doute bien que ce que je tente de faire est plutôt facile pour des programmeurs. Si vous avez une autre façon de procéder, je la veux bien ^^

**Médinoc** · 28/10/2014, 20h25

En fait non, ce n'est pas si évident.

La première chose à savoir, c'est qu'il n'existe pas de fonction en C standard pour ouvrir une fenêtre. Tu vas devoir soit te servir d'une bibliothèque appropriée (GTK+, SFML) soit utiliser l'API Windows, si c'est pour ce système que tu développes.

**imperio** · 29/10/2014, 11h27

Et openGL ne permet pas d'ouvrir une image, seulement de l'afficher (si tu vois la différence). Si tu veux lire une image, soit tu crées toi-même la fonction pour le faire, soit tu t'appuies sur une lib tierce (SDL_image, SFML...).

**Formule1** · 29/10/2014, 14h36

Pourriez vous me donner des pistes pour ouvrir un fichier sans utiliser de librairies tierces ?
Merci d'avance

**Médinoc** · 29/10/2014, 15h17

L'API Windows n'est pas la façon la plus simple pour ouvrir une fenêtre. Et le sample "hello world" de Microsoft tend à en faire trop d'un coup (notamment, il montre l'utilisation de Ressources).

La première chose à comprendre, c'est comment marche une procédure de fenêtre (Window proc) qui traite les événements liés à la fenêtre. Ensuite, le code doit créer et enregistrer une classe de fenêtre (WNDCLASS, enregistrée avec RegisterClass()) qui référence cette procédure, puis créer la fenêtre (CreateWindow()) et faire tourner la boucle de messages jusqu'à ce que soit reçu l'ordre d'arrêter.

Une procédure de fenêtre minimale pour la fenêtre principale du programme ressemble à ceci:

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
LRESULT CALLBACK MyWindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	LRESULT ret = 0;
	switch(message)
	{
	case WM_DESTROY: /* Reçu quand la fenêtre est détruite */
		PostQuitMessage(0); /*Ordre de terminer la boucle de messages*/
		break;
	default:
		ret = DefWindowProc(hWnd, message, wParam, lParam);
		break;
	}
	return ret;
}

Cette procédure permet une fenêtre vide qui ne fait rien de spécial, à part terminer le programme quand l'utilisateur la ferme.

On attache cette procédure à une classe de fenêtre et on l'affiche:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
#include <windows.h>
#include <tchar.h>
 
LRESULT CALLBACK MyWindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	LRESULT ret = 0;
	switch(message)
	{
	case WM_DESTROY: /* Reçu quand la fenêtre est détruite */
		PostQuitMessage(0); /*Ordre de terminer la boucle de messages*/
		break;
	default:
		ret = DefWindowProc(hWnd, message, wParam, lParam);
		break;
	}
	return ret;
}
 
/*On verra plus tard les programmes sans console du tout;
   après tout, la console est utile pour le débogage.*/
int main(void)
{
	WNDCLASS wc = {0};
	HWND hWnd = NULL;
	MSG msg = {0};
 
	/*Création classe de fenêtre*/
	wc.lpfnWndProc = MyWindowProc; /*Notre procédure de fenêtre ici*/
	wc.hInstance = GetModuleHandle(NULL); /*Indique que la procédure est contenue dans l'EXE et non pas une DLL*/
	wc.hCursor = LoadCursor(NULL, IDC_ARROW); /*Curseur flèche normal*/
	wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1); /*Donne à l'arrière-plan de la fenêtre la couleur normale d'une fenêtre comme Bloc-Notes (généralement, blanc)*/
	wc.lpszClassName = _T("Ma classe de fenêtre"); /*Le nom qu'on donne à la classe de fenêtre.*/
	RegisterClass(&wc);
 
	/*Création de la fenêtre*/
	hWnd = CreateWindow(
		_T("Ma classe de fenêtre"), /*Nom de la classe de fenêtre*/
		_T("Mon Titre"), /*Titre de la fenêtre*/
		WS_OVERLAPPEDWINDOW|WS_VISIBLE, /*Style: Fenêtre principale.*/
		CW_USEDEFAULT, 0, /*Laisser Windows définir où placer la fenêtre*/
		320, 240, /*Dimensions de la fenêtre (tour et barre de titre y compris)*/
		NULL, /*Pas de fenêtre parente*/
		NULL, /*Pas de menu*/
		wc.hInstance,
		NULL); /*Pas de paramètre supplémentaire*/
	if(hWnd == NULL)
		return EXIT_FAILURE;
	ShowWindow(hWnd, SW_SHOW); /*Pour des raisons difficiles à expliquer, le style WS_VISIBLE ne suffit pas toujours.*/
 
	/*Boucle de messages*/
	while(GetMessage(&msg, NULL, 0, 0) > 0) /*Récupère le premier message de la file. Retournera zéro après un PostQuitMessage(), terminant la boucle.*/
	{
		DispatchMessage(&msg); /*Se charge d'appeler la bonne procédure de fenêtre.*/
	}
	return EXIT_SUCCESS;
}

Ceci est le strict minimum pour un programme qui ouvre une fenêtre et se termine quand elle est fermée.

**Formule1** · 29/10/2014, 15h41

Merci pour votre code mais windows.h pose un problème dans ma console: "file not found"
(j'utilise codeblocks sous mac). Auriez vous une idée pour me débloquer ?

**Médinoc** · 29/10/2014, 16h49

Dans ce cas, ce n'est pas l'API Windows qui marchera, mais les trucs destinés à Mac. MacOS X étant un unixoïde, tu risques fort d'être obligé d'utiliser une bibliothèque externe, car je ne suis pas sûr qu'il y ait une API "dédiée" à Mac (et la recherche Google me donne peut d'infos là-dessus).

**Christophe** · 29/10/2014, 16h51

Sous Mac, tu ne pourras pas trouver windows.h, qui sert aux API Windows. Il te faut l'équivalent Apple : l'API Cocoa. Sous Apple on développe en général avec Xcode et en Objective C. Pour programmer sous Mac, je te conseilles de regarder du coté de Qt ou tu auras ce qu'il faut pour créer une fenêtre, afficher une image , faire de l'OpenGL si besoin ton code sera portable sur windows, Linux, (et Mac bien-sûr) et tu as un forum dédié à Qt ici : http://qt.developpez.com/ qui pourra t'aider, la doc de Qt est bien faite. Tu peux demander aussi conseil dans la partie Apple.

**Médinoc** · 29/10/2014, 21h25

Par contre, avec tes solutions, il semblerait qu'il faille forcément apprendre un nouveau langage: Ni Qt ni Cocoa ne semblent être utilisables depuis C.

**Formule1** · 30/10/2014, 00h23

Merci pour vos réponses. Ainsi, mac ne semble vraiment pas être le bon outils pour développer en C. (il n'existe vraiment pas de .h à charger pour un code permettant d'ouvrir une image en RGB puis de la modifier ?)
Sous Linux, window.h existe ou il faut encore autre chose d'équivalent ?

**SkyZoThreaD** · 30/10/2014, 08h45

Si je ne me trompe pas, mac est basé sur l'objective-c ... Il faut bien comprendre que le C n’intègre pas de GUI. Il faut utiliser des librairies externes et elle ne sont pas toute portables... Tu peux essayer certains moteurs de rendu muti-plateforme comme Ogre3d ou Irrlicht3d qui de surcroît intègrent à la foi la lecture et l'affichage d'images. Ou tu peux utiliser des GUI multi-plateforme comme Qt (dispo pour mac). Sous linux il existe beaucoup de gui différentes dont Qt, Gtk, kde... on a vraiment l'embarras du choix. Mais la vrai question c'est "quel est le but de votre démarche?" Si c'est d'apprendre le C en faisant des petits programmes: "bienvenue dans l'univers du C !!", si par contre le but est de faire un petit programme graphique fonctionel qui ne nécessite pas forcément de performances géniales: peut-être qu'un autre langage plus directement connecté à la GUI serait plus intéressant (java, c#, obj-c ....).

**Médinoc** · 30/10/2014, 09h05

Envoyé par Formule1

Merci pour vos réponses. Ainsi, mac ne semble vraiment pas être le bon outils pour développer en C.

Ça reste un unixoïde, donc les bibliothèques graphiques accessibles ek C restent utilisables (GTK+, ou si tu descends dans le bas niveau, XLib...)

(il n'existe vraiment pas de .h à charger pour un code permettant d'ouvrir une image en RGB puis de la modifier ?)

Il y a des bibliothèques pour ça. Selon le format d'image, tu dois aussi pouvoir l'implémenter manuellement pour les formats les plus simples, mais les bibliothèques ont l'avantage d'en gérer plusieurs à la fois.

Sous Linux, window.h existe ou il faut encore autre chose d'équivalent ?

Cela risque de te surprendre, mais windows.h n'existe que pour la plate-forme Windows.

Ouvrir une fenêtre en C

C

Discussions similaires

Partager

Partager