afficher une image grâce à un tableau de pixel

[takout]

Ah ok!
J'ai pensé à cette solution mais je ne sais pas comment récupérer la taille de l'écran automatiquement.

[edgarjacobs]

En supposant que tu n'aies pas changé le nom des variables, ecran->w te donne la largeur actuelle de ta fenêtre, ecran->h sa hauteur.

Si tu parles de la taille maximale de la fenêtre que peut contenir ton écran,

Code :

1
2
3
4
5
const SDL_VideoInfo *videoInfo;
 
	videoInfo=SDL_GetVideoInfo();
	largeur_max=videoInfo->current_w;
	hauteur_max=videoInfo->current_h;

qui est à faire immédiatement après SDL_Init(); sinon tu vas récupérer la taille que tu as fournie lors du dernier SDL_SetVideoMode();

[takout]

ah D'accord ! Je vous remercie.
J'ai remarqué cependant que j'avais un autre problème. Lorsque je veux diviser la taille de la fenêtre par deux en utilisant la touche 2 du clavier, l'image diminue mais la fenêtre reste à la même taille (ce qui est bizarre).
J'ai aussi des fuites de mémoires dû à la SDL.
Pouvez vous m'aidez svp ?

Voici le code un peu modifié que j'utilise :

Code :

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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
 
 
#include<stdio.h>
#include<stdlib.h>
#include <SDL/SDL.h>
#include <SDL/SDL_rotozoom.h>
#include "affichage.h"
 
/* creation de l'image*/
SDL_Surface *createImage(short **image,int height,int width)
{
      int i,j; 
 
    SDL_Surface *simage= NULL;
    SDL_Rect position;
 
    simage=SDL_CreateRGBSurface(SDL_HWSURFACE,width,height,32,0,0,0,0);
    position.w=position.h=1;
 
    for (i = 0 ; i < height; ++i){
     for(j=0;j<width;++j){
        position.x = j; 
        position.y = i;
        SDL_FillRect(simage,&position,SDL_MapRGB(simage->format,image[i][j],image[i][j],image[i][j]));
    }}
 
return(simage);
}
 
/* affichage de l'image suivant sa taille*/
 
void displayImage(SDL_Surface **ecran,SDL_Surface *simage,int height,int width)
{
	SDL_Surface *newSurf=NULL;
 
	if(*ecran!=NULL) SDL_FreeSurface(*ecran); /*on efface l'ecran si c'est la premiere fois qu'il est utilise*/
 
	if(simage->w!=width || simage->h!=height) /*si le redimensionement change la taille de l'image on cree une nouvelle surface */
		newSurf=rotozoomSurfaceXY(simage,0.,(double)width/(double)simage->w,(double)height/(double)simage->h,1);
	else newSurf=simage;
 
	*ecran=SDL_SetVideoMode(newSurf->w,newSurf->h,32,SDL_HWSURFACE|SDL_RESIZABLE|SDL_DOUBLEBUF);
	SDL_BlitSurface(newSurf,NULL,*ecran,NULL);
	SDL_Flip(*ecran);
 
	if(newSurf!=simage) SDL_FreeSurface(newSurf);
}
 
 
 
/* Traitement des evenements */
void treatEvent(SDL_Surface **ecran,SDL_Surface *simage,int height,int width)
{
	int done;
	SDL_Event event;
 
	done=0;
 
 
 
	while(!done) {
		SDL_WaitEvent(&event);
 
 
 
		switch(event.type) {
			case SDL_QUIT: done=1; break;
 
		        case SDL_KEYDOWN:
				switch(event.key.keysym.sym) {
					case SDLK_ESCAPE: done=1; break;
					case SDLK_1: case SDLK_KP1: displayImage(ecran,simage,height,width); break;
					case SDLK_2: case SDLK_KP2:
						if(event.key.keysym.mod&KMOD_CTRL) displayImage(ecran,simage,height*2,width*2);
						else displayImage(ecran,simage,height/2,width/2);
						break;
 
					default: break;
				      }	break;
 
 
			case SDL_VIDEORESIZE:
				displayImage(ecran,simage,event.resize.h,event.resize.w);
				break; 
 
 
			} 
 
		}
 
}
 
 
 
void affiche(short **image,int nrow,int ncol)
{
	SDL_Surface *ecran,*imgSurf; 
	const SDL_VideoInfo *videoInfo;
	int largeur_max,hauteur_max;
        ecran=NULL;
 
	SDL_Init(SDL_INIT_VIDEO);
 
        videoInfo=SDL_GetVideoInfo();  /*determination de la taille de l'ecran*/
	largeur_max=videoInfo->current_w;
	hauteur_max=videoInfo->current_h;
 
 
	imgSurf=createImage(image,nrow,ncol); /*creation de la surface associee à l'image*/
 
	if(hauteur_max<nrow ||largeur_max<ncol){ nrow=hauteur_max;ncol=largeur_max;} /*si l'image a une plus grande resolution que l'ecran*/
 
	displayImage(&ecran,imgSurf,nrow,ncol); /*creation de l'image a l'ecran*/
        SDL_WM_SetCaption("My Picture SDL !", NULL); /*mettre un titre a la fenetre*/
 
	treatEvent(&ecran,imgSurf,nrow,ncol); /* gestion des evenements(clavier,redimensionement, ect...)*/
 
     /* liberation de la memoire */
	SDL_FreeSurface(imgSurf);
	SDL_FreeSurface(ecran);
	SDL_Quit();
	return;
}

et la maniere de construire mon tableaux à deux dimensions :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
 
short ** image=NULL;
size_t i,j,nrow=1920,ncol=2560;
 
  image=malloc(nrow*sizeof(short*)); assert(image!=NULL);  
 
  image[0]=malloc(nrow*ncol*sizeof(short)); assert(image[0]!=NULL);
  for(i=1;i<nrow;++i)image[i]=image[i-1]+ncol; 
 
   for(i=0;i<nrow;i++){
   for(j=0;j<ncol;j++){
 
                 image[i][j]=rand()%256;
      }}
 
  affiche(image,nrow,ncol);

[edgarjacobs]

Hello,

Je suppose que tu fais appel à la fonction affiche() à chaque fois l'utilisateur demande une modification de la taille de l'image. Et là, tu fais un SDL_GetVideoInfo(). Mais comme tu as déjà utilisé SDL_SetVideoMode(), les tailles renvoyées sont celles du dernier SDL_SetVideoMode().

Refaire à chaque fois un SDL_Init() n'a pas de sens (pour ce que j'en sais), car cette fonction initialise ceraines "choses" (structures, espace mémoire, etc... je n'ai jamais lu les sources) nécessaires à la SDL, mais ne réinitialise pas la SDL.

Il faut faire le SDL_Init() une seule fois, et immédiatement derrière le SDL_GetVideoInfo(). Là, tu as les tailles maximales de la fenêtre que ton écran peut contenir.

Exemple:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
main(...)
{
  ...
  SDL_Init();
  tailles=SDL_GetVideoInfo();
  ...
  while() {
     affiche(image,tailles);
     ... 
     ...
     tailles=nouvelles tailles;
     }
}
 
affiche(image,taille)
{
   SDL_SetVideoMode(taille);
   blit(image,ecran);
}

[takout]

Hi,

Je n'y avais pas pensé, je vais faire l'initiation de la SDL dans le main.
Cependant je ne pense pas que le problème vienne de là car j'appelle affiche une seule fois pour le moment. Le redimensionnement s'effectue dans la fonction treatEvent, j'ai peut être aussi un souci dans la fonction displayImage ou treatEvent.

[edgarjacobs]

Peux-tu poster tout ton code, qu'on voie l'ensemble?

[takout]

D'accord,
Pour que se soit plus simple j'ai réécrit mon code pour ne prendre en considération que l'affichage.
Le problème se situe au niveau de la gestion des événements lorsque j'appuie sur la touche 2 de mon clavier l'image diminue mais la fenêtre reste à la même taille.

[edgarjacobs]

Je viens de compiler ton application et de l'exécuter, pas de soucis, l'affichage est normal; quand j'appuie sur la touche 2 ma fenêtre se réduit bien de moitié, ctrl+2 l'agrandit bien du double et 1 la ramène à la proportion 1:1

Par contre, j'ai noté un petit soucis dans ton code (qui ne l'empêche pas de fonctionner, mais qui empêche d'avoir ce que voudrait)

Code :

if(largeur_max<ncol || hauteur_max<nrow)nrow=hauteur_max;ncol=largeur_max;}

Dans ton main, change ceci (par exemple):

Code :

int i,j,nrow=1920,ncol=100;

Par contre, je ne comprends pas ceci:

Code :

1
2
  image[0]=malloc(nrow*ncol*sizeof(double));
  for(i=1;i<nrow;++i)image[i]=image[i-1]+ncol;

Edgar.

[takout]

Je viens de compiler ton application et de l'exécuter, pas de soucis, l'affichage est normal; quand j'appuie sur la touche 2 ma fenêtre se réduit bien de moitié, ctrl+2 l'agrandit bien du double et 1 la ramène à la proportion 1:1

C'est bizarre car chez moi ça ne fonctionne pas bien. Quand j'appuie sur la touche 2 mon image se réduit mais la taille de ma fenêtre reste identique.
Par contre j'ai constaté que si j'appuyais sur l'onglet de redimensionnement de la fenêtre avant d'appuyer sur 2 la ça marche.

Code :

1
2
3
4
5
 
image=malloc(nrow*sizeof(double*)); assert(image!=NULL);  
 
  image[0]=malloc(nrow*ncol*sizeof(double)); assert(image[0]!=NULL);
  for(i=1;i<nrow;++i)image[i]=image[i-1]+ncol;

Ces instructions permettent de transformer image (qui est un double **) en un tableau de dimension 2 avec une représentation contigu en mémoire.

voici une image de ce que j'obtiens en appuyant sur la touche 2:

[edgarjacobs]

Ces instructions permettent de transformer image (qui est un double **) en un tableau de dimension 2 avec une représentation contigu en mémoire.

Que je suis bête. Je devais encore avoir la tête dans mon application

Sous quel système es-tu? Perso, sous win7, et que j'exécute l'application à partir d'une fenêtre DOS (qui elle ne change pas de taille évidemment) ou d'un raccourci sur le bureau, tout est ok. Je ne l'exécute pas à partir d'un EDI.

Essaie en mettant un raccourci vers ton application, ça aidera peut-être.

[takout]

Je suis sur Linux Ubuntu. J'execute mon programme dans un terminal à l'aide d'un makefiles. Je n'utilise pas de IDE mais gedit.
Par contre je ne comprends pas pourquoi dès que je lance mon exécutable la fenêtre est automatiquement redimensionner, elle n’apparaît pas à sa taille réelle.

[edgarjacobs]

Hélas, à partir d'ici, je vais plus pouvoir t'aider, je ne connais pas l'environnement dans lequel tu travailles.

Pour ce qui est de l'application, pour moi, elle fonctionne. J'espère que quelqu'un qui connait ton environnement viendra jeter un oeil à cette discussion.

[EDIT]
Peut-être que gedit réagit 'un peu' comme mon dos, et ne redimensionne pas sa fenêtre en fonction de celle qu'elle contient?
[/EDIT]

Edgar.

[takout]

D'accord pas de soucis, je vous remercie.

[LittleWhite]

J'ai testé (sous Linux et tout).

Le problème, me semble t-il, est que la fenêtre est créer en Maximize. Du coup, le redimensionnement n'est pas possible.
Après, c'est peut être à cause de l'implémentation de la SDL, sous Linux, je ne sais pas trop. Car il ne me semble pas qu'il y ai de flag pour dire que ce n'est pas maximisé.

@edgarjacobs : gedit est juste un éditeur de texte, tout simple. Le seul truc que je vois, c'est que sous Windows, la fenêtre n'est pas nécessairement maximisé dans ces conditions.

Peut être qu'il faut d'abord créer la fenêtre en une moitié de l'écran et ensuite, la faire grandir.

[takout]

ah ok d'accord, c'est bizarre.

[edgarjacobs]

@littlewhite

gedit est juste un éditeur de texte, tout simple. Le seul truc que je vois, c'est que sous Windows, la fenêtre n'est pas nécessairement maximisé dans ces conditions.

Merci pour l'information.

Le problème, me semble t-il, est que la fenêtre est créer en Maximize. Du coup, le redimensionnement n'est pas possible.

Si on parle de la fenêtre créée par SDL, elle est créée avec le flag RESIZABLE, donc on peut en modifier les dimensions (ça fonctionne d'ailleurs sous windows sans problème).

La fenêtre (noire) montrée dans la maniature, par qui (quoi?) est-elle créée?

[LittleWhite]

Sauf que, la première apparition de la fenêtre est en maximise (oui, je sais, il n'y a pas de flags par rapport à ça). On ne peut pas la redimensionner. Il faut d'abord cliquer sur le bouton pour la rendre redimensionnable (celui qui est a coté de la croix). Je pense que c'est parce que la SDL, lorsque la fenêtre est identique à la taille de l'écran, se met directement en maximise. C'est pour cela que je propose de créer d'abord une fenêtre réduite.
Sinon, je ne comprend pas plus l'erreur que ça.

[takout]

J'ai fais la même constatation tant qu'on ne clic pas sur l'onglet de redimensionnement de la fenêtre ça ne fonctionne pas. Et la fenêtre apparaît dès le début à la même résolution de l'écran. Il y a un petit souci des gestions d’évidemment on aurait dit sur Linux.

[LittleWhite]

Donc, le principe que je pense pouvant être une solution au problème, c'est de créer la fenêtre, mais réduite (comme lorsque l'on appuie sur la touche 2 (ou 1, je ne sais plus ))

[takout]

Re bonjour,

J'aurais une autre question à vous poser.
J'ai affiché une image avec la SDL, j'ai remarqué que sous certaine résolution je perdais la qualité de mon image.
Par exemple sur cette image de contour de coquillage, on constate en faisant un zoom que le contour est fermé mais qu'en dé-zoomant certain pixels disparaissaient c'est normal ?