[Source][SDL] Horloge graphique

**_-Slash-_** · 13/08/2006, 18h41

A la suite des échanges par mp avec FearYourself. Je veux bien mettre à contribution ma source (et surtout avec SES corrections

cf : http://www.developpez.net/forums/sho...96#post1260896) d'une horloge graphique.

Voici la source (incluse les corrections/améliorations de Fearyourself et quelques commentaires pour expliquer certains points.)

A noter que l'on pourrait comme me l'a suggérer Fearyourself

Envoyé par fearyourself

Interporler la position de l'heure par rapport aux minutes comme toute horloge à aiguilles. Donc à 15h30, l'aiguille des heures se retrouve entre la point 3 et le point 4...

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
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
 
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <locale.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
 
/* Definition de certaines constantes */
#define RAYON 80    /* rayon... mais aussi longueur de l'aiguille des secondes*/
#define rectifHEU 30 /* servira pour réduire le rayon de l'aiguille des heures */
#define rectifMIN 15 /* de même pour les minutes */
 
/* Fonctions statiques */
static void allume_pixel(int x, int y,Uint32 couleur);
static void dessineHorloge(void);
static void recupTemps(void);
static void afficheSecondes(int seconde);
static void afficheMinutes(int minute);
static void afficheHeures(int heure);
static void tracerSegment(int xi,int yi,int xf,int yf, Uint32 couleur);
 
/* Structure pour les variables globales */
typedef struct sVarGlob
{
	SDL_Surface *ecran, *points;
	int init;
}SVarGlob;
 
/* Variable globale */
SVarGlob param = {NULL, NULL, 0 };
 
/* Fonction main */
int main (int argc, char *argv[])
{
    SDL_Event event;
    int done = 0;
 
    atexit(SDL_Quit);
 
    if (SDL_Init(SDL_INIT_VIDEO) == -1)
    {
        fprintf(stderr, "Erreur lors de l'initialisation de la SDL : %s\n", SDL_GetError());
        exit (EXIT_FAILURE);
    }
 
    param.ecran = SDL_SetVideoMode(200, 200, 32, SDL_HWSURFACE|SDL_DOUBLEBUF);
    if ( param.ecran == NULL )
    {
        fprintf(stderr, "Impossible de mettre la fenêtre en 200x200x32 : %s\n", SDL_GetError());
        exit(EXIT_FAILURE);
    }
 
    param.points = IMG_Load("points.bmp");
    if (!param.points)
    {
        fprintf(stderr, "Erreur chargement image : %s.\n", SDL_GetError());
        exit(EXIT_FAILURE);
    }
 
    SDL_WM_SetCaption("Horloge","horloge.ico");
 
    while(!done)
    {
        while(SDL_PollEvent(&event))
        {
            switch(event.type)
            {
                case SDL_QUIT:
                	done = 1;
                break;
 
                default:
                break;
            }
        }
 
        recupTemps(); /* On va récupérer l'heure */
    }
    (void) argc;
    (void) argv;
 
    return EXIT_SUCCESS;
}
 
 
/* Sert pour dessiner le cadran */
/* Celui ci est composé de 12 points */
void dessineHorloge(void)
{
 
    SDL_Rect positionPixel;
 
    int compteur;
    int angle = 30; /* Angle entre chaque points/heures sur le cercle */
    int decalage = 10; /* Un décalage pour bien centrer le cadran */
                             /* Certainement un bricolage de ma part    */
 
    SDL_FillRect(param.ecran, NULL, SDL_MapRGB(param.ecran->format,0,0,0));
 
    /* La boucle for permet de calculer la position, grâce à de la trigo..., */
    /* des points que l'on blitera*/
 
    for (compteur = 12; compteur > 0; compteur --)
    {
        positionPixel.x = RAYON * cos((M_PI * (angle) / 180) * compteur) +RAYON 
		+ param.points->w + decalage;
        positionPixel.y = RAYON * sin((M_PI * (angle) / 180) * compteur) +RAYON 
		+ param.points->h + decalage;
        SDL_BlitSurface(param.points, NULL, param.ecran, &positionPixel);
    }
}
 
void recupTemps(void)
{
 
    time_t timePresent;
    struct tm *tPre; /* structure pour le temps présent */
    static struct tm tAnc; /* pour le temps antérieur, qui nous servira comparer*/
 
    /* récupération du temps */
    timePresent = time (NULL);
    tPre = localtime(&timePresent);
 
    /* Si on a pas encore récupéré le temps Ancien : lancement du programme*/
    /* alors sec, min et heure pour tAnc = 0*/
    /* mais on n'oublie pas d'afficher le temps présent tout de même */
    if (param.init == 0)
    {
        tAnc.tm_sec = 0;
        tAnc.tm_min = 0;
        tAnc.tm_hour = 0;
        afficheSecondes(tPre->tm_sec);
        afficheMinutes(tPre->tm_min);
        afficheHeures(tPre->tm_hour);
        param.init = 1;
    }
    else
    {
        /* On affiche les aiguilles que si la seconde à changée */
        if (tAnc.tm_sec != tPre->tm_sec)
        {
            dessineHorloge();
            afficheMinutes(tPre->tm_min);
            afficheHeures(tPre->tm_hour);
            afficheSecondes(tPre->tm_sec);
            tAnc.tm_sec = tPre->tm_sec;
	    SDL_Flip(param.ecran);
        }
    }
 
 
}
 
/* Le commentaire est identique pour les affichages suivants */
/* Donc ici, c'est pour afficher l'aiguille des secondes*/
void afficheSecondes(int seconde)
{
    SDL_Rect positionCentre;
    positionCentre.x = param.ecran->w/2;
    positionCentre.y = param.ecran->h/2;
    SDL_Rect positionFin;
 
    Uint32 rose = SDL_MapRGB(param.ecran->format, 255, 4, 255);
 
    double R = RAYON;
    double A; /* l'angle */
 
    /* que l'on calcule.... dur, dur la trigonométrie */
    A = (M_PI_2)-seconde*(M_PI)/30;
 
    /* de même pour la position "Finale" de l'aiguille */
    /* l'aiguille est un segment du centre, vers le cercle du cadran */
    /* on calcul donc cette dernière position pour pouvoir tracer le segment */
    positionFin.x = (int)(cos(A)*R + positionCentre.x);
    positionFin.y = (int)(-sin(A)*R + positionCentre.y);
 
    tracerSegment(positionCentre.x, positionCentre.y, positionFin.x, positionFin.y, rose);
}
 
void afficheMinutes(int minute)
{
    SDL_Rect positionCentre;
    positionCentre.x = param.ecran->w/2;
    positionCentre.y = param.ecran->h/2;
    SDL_Rect positionFin;
 
    Uint32 bleu = SDL_MapRGB(param.ecran->format, 4, 4, 255);
 
    double R = RAYON - rectifMIN;
    double A;
 
    A = (M_PI_2)-minute*(M_PI)/30;
    positionFin.x = (int)(cos(A)*R + positionCentre.x);
    positionFin.y = (int)(-sin(A)*R + positionCentre.y);
 
    tracerSegment(positionCentre.x, positionCentre.y, positionFin.x, positionFin.y, bleu);
}
 
void afficheHeures(int heure)
{
    SDL_Rect positionCentre;
    positionCentre.x = param.ecran->w/2;
    positionCentre.y = param.ecran->h/2;
    SDL_Rect positionFin;
 
    Uint32 blanc = SDL_MapRGB(param.ecran->format, 255, 255, 255);
 
    double R = RAYON-rectifHEU;
    double A;
 
    A =(M_PI_2)-heure*(M_PI)/6;
    positionFin.x = (int)(cos(A)*R + positionCentre.x);
    positionFin.y = (int)(-sin(A)*R + positionCentre.y);
 
    tracerSegment(positionCentre.x, positionCentre.y, positionFin.x, positionFin.y, blanc);
}
 
/* On peut faire avec les coefficients directeurs, y=ax+b, etc... */
/* Mais d'après ce que j'ai pu lire, les algorithmes de Bresenham sont plus adaptés */
/* Donc on utilise un de ces algorithmes */
 
/* Algo de Bresenham */
/* http://raphaello.univ-fcomte.fr/Ig/Algorithme/ */
void tracerSegment(int xi,int yi,int xf,int yf, Uint32 couleur)
{
 
    int dx,dy,i,xinc,yinc,cumul,x,y ;
    x = xi ;
    y = yi ;
    dx = xf - xi ;
    dy = yf - yi ;
    xinc = ( dx > 0 ) ? 1 : -1 ;
    yinc = ( dy > 0 ) ? 1 : -1 ;
    dx = abs(dx) ;
    dy = abs(dy) ;
    allume_pixel(x,y, couleur) ;
    if ( dx > dy )
    {
        cumul = dx / 2 ;
        for ( i = 1 ; i <= dx ; i++ )
        {
            x += xinc ;
            cumul += dy ;
            if (cumul >= dx)
            {
                cumul -= dx ;
                y += yinc ;
            }
            allume_pixel(x,y, couleur) ;
        }
    }
    else
    {
        cumul = dy / 2 ;
        for ( i = 1 ; i <= dy ; i++ )
        {
            y += yinc ;
            cumul += dx ;
            if ( cumul >= dy )
            {
                cumul -= dy ;
                x += xinc ;
            }
            allume_pixel(x,y,couleur) ;
        }
    }
 
}
 
 
void allume_pixel(int x, int y,Uint32 couleur)
{
    SDL_Rect position;
    position.x = x;
    position.y = y;
    position.w = 2;
    position.h = 2;
 
    SDL_FillRect(param.ecran, &position, couleur);
}

**fearyourself** · 13/08/2006, 19h35

A savoir que ce source utilise l'algorithme de Bresenham et qu'Anomaly a présenté le même algorithme ici :

http://anomaly.developpez.com/tutoriel/sdl/partie2/#L3

Autre remarque, cette source utilise encore une image points.bmp qui pourrait être remplacer par un SDL_FillRect mais cette version permet de personnaliser l'horloge.

Par contre, je pense que l'utilisation de l'interpolation est une chose nécessaire (ou très très souhaitable) pour en faire une source digne de ce nom...

Dernière chose, je me demande si c'est vraiment nécessaire d'avoir un affichage toute les secondes... Pourquoi ne pas avoir juste la boucle événementielle qui appelle une fonction dessine :

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
 
void dessine()
{
    struct tm *tPre; /* structure pour le temps présent */
 
           /* récupération du temps */
           timePresent = time (NULL);
           tPre = localtime(&timePresent);
 
           /* Affichage */
           afficheMinutes(tPre->tm_min);
           afficheHeures(tPre->tm_hour);
           afficheSecondes(tPre->tm_sec);
  	   SDL_Flip(param.ecran);
}

A mon avis, le rafraîchissement de la fenêtre ne peut que être amélioré comme ceci...

Sinon, c'est une bonne application qui montre comment :

- Utiliser les fonctions mathématiques pour faire des rotations
- Utiliser l'algorithme de Bresenham
- Utiliser les icônes d'une application

Jc

**_-Slash-_** · 13/08/2006, 22h11

Alors ayant arrêté les maths en Term S pour naviguer vers d'autres sujets d'études, les angles et tout ça, c'est un peu du "fait à la main". Je n'ai pas trouvé (peu cherché) d'info sur le net, sur le mécanisme exact d'une horloge, mais après différents tests, il me semble que ma fonction est correcte.

Voici le nouveau code (icone comprise, car elle n'y était pas plus haut). Je n'ai pas pris la peine de faire la même chose avec l'aiguille des minutes, bien qu'il est possible de le faire je pense, et poussez le vice avec l'ajout des secondes dans celle des heures

Sinon j'ai testé, et le if utilise un touuuuuut petit peu plus de ressources, donc j'ai ajouté (en corrigeant deux oublis time_t tempsPresent et dessineHorloge());

**_-Slash-_** · 13/08/2006, 22h15

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
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
 
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <locale.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
 
/* Definition de certaines constantes */
#define RAYON 80
#define rectifHEU 30
#define rectifMIN 15
 
/* Fonctions statiques */
static void allume_pixel(int x, int y,Uint32 couleur);
static void dessineHorloge(void);
static void dessine(void);
static void afficheSecondes(int seconde);
static void afficheMinutes(int minute);
static void afficheHeures(int heure, int minute);
static void tracerSegment(int xi,int yi,int xf,int yf, Uint32 couleur);
 
/* Structure pour les variables globales */
typedef struct sVarGlob
{
    SDL_Surface *ecran, *points;
    int init;
}
SVarGlob;
 
/* Variable globale */
SVarGlob param =
    {
        NULL, NULL, 0
    };
 
/* Fonction main */
int main (int argc, char *argv[])
{
    SDL_Event event;
    int done = 0;
 
    atexit(SDL_Quit);
 
    if (SDL_Init(SDL_INIT_VIDEO) == -1)
    {
        fprintf(stderr, "Erreur lors de l'initialisation de la SDL : %s\n", SDL_GetError());
        exit (EXIT_FAILURE);
    }
 
    SDL_Surface *icone = IMG_Load("horloge.gif");
    if (!icone)
    {
        fprintf(stderr, "Impossible de charger l'image : %s.\n",SDL_GetError());
        exit(EXIT_FAILURE);
    }
    SDL_WM_SetIcon(icone, NULL);
    SDL_FreeSurface(icone);
 
    param.ecran = SDL_SetVideoMode(200, 200, 32, SDL_HWSURFACE|SDL_DOUBLEBUF);
    if ( param.ecran == NULL )
    {
        fprintf(stderr, "Impossible de mettre la fenêtre en 200x200x8 : %s\n", SDL_GetError());
        exit(EXIT_FAILURE);
    }
 
    param.points = IMG_Load("points.bmp");
    if (!param.points)
    {
        fprintf(stderr, "Erreur chargement image : %s.\n", SDL_GetError());
        exit(EXIT_FAILURE);
    }
 
    SDL_WM_SetCaption("Horloge",NULL);
 
    while(!done)
    {
        while(SDL_PollEvent(&event))
        {
            switch(event.type)
            {
                case SDL_QUIT:
                done = 1;
                break;
 
                default:
                break;
            }
        }
 
        dessine();
    }
    (void) argc;
    (void) argv;
 
    return EXIT_SUCCESS;
}
 
/* Sert pour dessiner le cadran */
/* Celui ci est composé de 12 points */
void dessineHorloge(void)
{
 
    SDL_Rect positionPixel;
 
    int compteur;
    int angle = 30;     /* Angle entre chaque points/heures sur le cercle */
    int decalage = 10;  /* Un décalage pour bien centrer le cadran */
                        /* Certainement un bricolage de ma part    */
 
    SDL_FillRect(param.ecran, NULL, SDL_MapRGB(param.ecran->format,0,0,0));
 
    /* La boucle for permet de calculer la position, grâce à de la trigo..., */
    /* des points que l'on blitera */
    for (compteur = 12; compteur > 0; compteur --)
    {
        positionPixel.x = RAYON * cos((M_PI * (angle) / 180) * compteur) +RAYON
                          + param.points->w + decalage;
        positionPixel.y = RAYON * sin((M_PI * (angle) / 180) * compteur) +RAYON
                          + param.points->h + decalage;
        SDL_BlitSurface(param.points, NULL, param.ecran, &positionPixel);
    }
}
 
/* Le commentaire est identique pour les affichages suivants */
/* Donc ici, c'est pour afficher l'aiguille des secondes     */
void afficheSecondes(int seconde)
{
    SDL_Rect positionCentre;
    positionCentre.x = param.ecran->w/2;
    positionCentre.y = param.ecran->h/2;
    SDL_Rect positionFin;
 
    Uint32 rose = SDL_MapRGB(param.ecran->format, 255, 4, 255);
 
    double R = RAYON;
    double A; /* l'angle */
 
    /* que l'on calcule.... dur, dur la trigonométrie */
    A = (M_PI_2)-seconde*(M_PI)/30;
 
    /* de même pour la position "Finale" de l'aiguille */
    /* l'aiguille est un segment du centre, vers le cercle du cadran */
    /* on calcul donc cette dernière position pour pouvoir tracer le segment */
    positionFin.x = (int)(cos(A)*R + positionCentre.x);
    positionFin.y = (int)(-sin(A)*R + positionCentre.y);
 
    tracerSegment(positionCentre.x, positionCentre.y, positionFin.x, positionFin.y, rose);
}
 
void afficheMinutes(int minute)
{
    SDL_Rect positionCentre;
    positionCentre.x = param.ecran->w/2;
    positionCentre.y = param.ecran->h/2;
    SDL_Rect positionFin;
 
    Uint32 bleu = SDL_MapRGB(param.ecran->format, 4, 4, 255);
 
    double R = RAYON - rectifMIN;
    double A;
 
    A = (M_PI_2)-minute*(M_PI)/30;
    positionFin.x = (int)(cos(A)*R + positionCentre.x);
    positionFin.y = (int)(-sin(A)*R + positionCentre.y);
 
    tracerSegment(positionCentre.x, positionCentre.y, positionFin.x, positionFin.y, bleu);
}
 
void afficheHeures(int heure, int minute)
{
    SDL_Rect positionCentre;
    positionCentre.x = param.ecran->w/2;
    positionCentre.y = param.ecran->h/2;
    SDL_Rect positionFin;
 
    Uint32 blanc = SDL_MapRGB(param.ecran->format, 255, 255, 255);
 
    double R = RAYON-rectifHEU;
    double A;
 
    A =(M_PI_2)-heure*(M_PI)/6;
 
    /* Contrairement aux minutes et secondes, on fait avancer cette aiguille */
    /* un peu différement. Son mouvement est basé sur celui des minutes.     */
    /* A chaque minutes, l'aiguille avance d'un cran.                        */
    positionFin.x = (int)(cos( A+ ((((M_PI_2)-minute*(M_PI))/30)*0.5)/6 )*R + positionCentre.x);
    positionFin.y = (int)(-sin(A+ ((((M_PI_2)-minute*(M_PI))/30))*0.5/6)*R + positionCentre.y);
 
 
    tracerSegment(positionCentre.x, positionCentre.y, positionFin.x, positionFin.y, blanc);
}
 
/* Algo de Bresenham */
/* http://raphaello.univ-fcomte.fr/Ig/Algorithme/ */
void tracerSegment(int xi,int yi,int xf,int yf, Uint32 couleur)
{
 
    int dx,dy,i,xinc,yinc,cumul,x,y ;
    x = xi ;
    y = yi ;
    dx = xf - xi ;
    dy = yf - yi ;
    xinc = ( dx > 0 ) ? 1 : -1 ;
    yinc = ( dy > 0 ) ? 1 : -1 ;
    dx = abs(dx) ;
    dy = abs(dy) ;
    allume_pixel(x,y, couleur) ;
    if ( dx > dy )
    {
        cumul = dx / 2 ;
        for ( i = 1 ; i <= dx ; i++ )
        {
            x += xinc ;
            cumul += dy ;
            if (cumul >= dx)
            {
                cumul -= dx ;
                y += yinc ;
            }
            allume_pixel(x,y, couleur) ;
        }
    }
    else
    {
        cumul = dy / 2 ;
        for ( i = 1 ; i <= dy ; i++ )
        {
            y += yinc ;
            cumul += dx ;
            if ( cumul >= dy )
            {
                cumul -= dy ;
                x += xinc ;
            }
            allume_pixel(x,y,couleur) ;
        }
    }
 
}
 
 
void allume_pixel(int x, int y,Uint32 couleur)
{
    SDL_Rect position;
    position.x = x;
    position.y = y;
    position.w = 2;
    position.h = 2;
 
    SDL_FillRect(param.ecran, &position, couleur);
}
 
void dessine()
{
    struct tm *tPre; /* structure pour le temps présent */
    time_t timePresent;
    /* récupération du temps */
    timePresent = time (NULL);
    tPre = localtime(&timePresent);
 
    /* Affichage */
    dessineHorloge();
    afficheMinutes(tPre->tm_min);
    afficheHeures(tPre->tm_hour, tPre->tm_min);
    afficheSecondes(tPre->tm_sec);
    SDL_Flip(param.ecran);
}

**fearyourself** · 13/08/2006, 23h24

Cela me semble très bien, et tu remarqueras que faire le dessin à chaque itération de la boucle événementielle a enlever un problème d'affichage qui se produisait si on passait une autre fenêtre sur l'horloge.

Pour les minutes je ne pense pas que ce soit nécessaire

Dernière remarque, pour l'interpolation, cette version me semble plus parlante (sinon je pense que tu vas perdre plus d'un avec ton calcul

) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
    /*Interpolation*/
    min = minute/60.0;
 
    /*Calcul l'heure actuelle*/
    AInter =(M_PI_2)-(heure+min)*(M_PI)/6;
 
    /* Contrairement aux minutes et secondes, on fait avancer cette aiguille */
    /* un peu différement. Son mouvement est basé sur celui des minutes.     */
    /* A chaque minutes, l'aiguille avance d'un cran.                        */
    positionFin.x = (int)(cos(AInter)*R + positionCentre.x);
    positionFin.y = (int)(-sin(AInter)*R + positionCentre.y);