Conway's life (jeu de la vie) pour images

Bonsoir à tous,

Voilà, c'est l'éclate ;) j'ai enfin finit un prog me revoila dans un autre.

Je vous propose une version du jeu de la vie.

1) Soit une image de format PPM
2) J'ai un seuil (faisons simple, on le fixe à 128)
3) Toutes couleurs dépassant le seuil sont considérées comme vivantes sinon non.
(On aurait pu faire la version pixel (formule des 3 couleurs ensembles vis à vis du seuil))

Je m'occuperait des optimisations dès que j'aurais déboggué cette fonction. :aie:

Voici le code (un peu long 150 lignes)

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
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
 
Image_PPM* Jeu_De_La_Vie_Anim(Image_PPM* im, int seuil) {
  if (im != NULL) {
    long i = 0,
         max = im->NbColonne*im->NbLigne*3,
         j = 0, position_Actuelle = 0, calc_Temp = 3*im->NbColonne;
    int cptR = 0, cptV = 0, cptB = 0;
    unsigned char* mat = (unsigned char*) malloc(max*sizeof(unsigned char));
    if (mat == NULL) return NULL;//erreur à gérer ici
 
    for (j = 0; j < im->NbLigne; j++) {
      for (i = 0; i < (3*im->NbColonne); i+=3) {
        // on réinitialise les compteurs.
        cptR = 0;
        cptV = 0;
        cptB = 0;
        position_Actuelle = i*3 + j*3*im->NbColonne;
 
        // on met les valeurs des compteurs
        if (exist(im, i-1, j-1)) {
          cptR += (im->Couleur[position_Actuelle - (3+calc_Temp)] > seuil)
           ? 1 : 0;
          cptV += (im->Couleur[position_Actuelle - (2+calc_Temp)] > seuil)
           ? 1 : 0;
          cptB += (im->Couleur[position_Actuelle - (1+calc_Temp)] > seuil)
           ? 1 : 0;
        }
        if (exist(im, i-1, j)) {
          cptR += (im->Couleur[position_Actuelle - 3] > seuil) ? 1 : 0;
          cptV += (im->Couleur[position_Actuelle - 2] > seuil) ? 1 : 0;
          cptB += (im->Couleur[position_Actuelle - 1] > seuil) ? 1 : 0;
        }
        if (exist(im, i-1, j+1)) {
          cptR += (im->Couleur[position_Actuelle -3 + calc_Temp] > seuil)
           ? 1 : 0;
          cptV += (im->Couleur[position_Actuelle -2 + calc_Temp] > seuil)
           ? 1 : 0;
          cptB += (im->Couleur[position_Actuelle -1 + calc_Temp] > seuil)
           ? 1 : 0;
        }
        if (exist(im, i, j-1)) {
          cptR += (im->Couleur[position_Actuelle - calc_Temp] > seuil) ? 1 : 0;
          cptV += (im->Couleur[position_Actuelle - calc_Temp + 1] > seuil)
           ? 1 : 0;
          cptB += (im->Couleur[position_Actuelle - calc_Temp + 2] > seuil)
           ? 1 : 0;
        }
        if (exist(im, i, j+1)) {
          cptR += (im->Couleur[position_Actuelle + calc_Temp] > seuil) ? 1 : 0;
          cptV += (im->Couleur[position_Actuelle + calc_Temp + 1] > seuil)
           ? 1 : 0;
          cptB += (im->Couleur[position_Actuelle + calc_Temp + 2] > seuil)
           ? 1 : 0;
        }
        if (exist(im, i+1, j-1)) {
          cptR += (im->Couleur[position_Actuelle + 3 - calc_Temp] > seuil)
           ? 1 : 0;
          cptV += (im->Couleur[position_Actuelle + 3 - calc_Temp + 1] > seuil)
           ? 1 : 0;
          cptB += (im->Couleur[position_Actuelle + 3 - calc_Temp + 2] > seuil)
           ? 1 : 0;
        }
        if (exist(im, i+1, j)) {
          cptR += (im->Couleur[position_Actuelle + 3] > seuil) ? 1 : 0;
          cptV += (im->Couleur[position_Actuelle + 4] > seuil) ? 1 : 0;
          cptB += (im->Couleur[position_Actuelle + 5] > seuil) ? 1 : 0;
        }
        if (exist(im, i+1, j+1)) {
          cptR += (im->Couleur[position_Actuelle + 3 + calc_Temp] > seuil)
           ? 1 : 0;
          cptV += (im->Couleur[position_Actuelle + 4 + calc_Temp] > seuil)
           ? 1 : 0;
          cptB += (im->Couleur[position_Actuelle + 5 + calc_Temp] > seuil)
           ? 1 : 0;
        }
 
        // le compteur pour la couleur rouge.
        if (cptR > 3)
          if (im->Couleur[position_Actuelle] > seuil) 
            mat[position_Actuelle] = 255 - im->Couleur[position_Actuelle];
          else 
            mat[position_Actuelle] = im->Couleur[position_Actuelle];
        else if (cptR == 3) {
          if (im->Couleur[position_Actuelle] < seuil) 
            mat[position_Actuelle] = 255 - im->Couleur[position_Actuelle];
          else 
            mat[position_Actuelle] = im->Couleur[position_Actuelle];
        }
        else if (cptR < 2) {
             if (im->Couleur[position_Actuelle] > seuil) 
               mat[position_Actuelle] = 255 - im->Couleur[position_Actuelle];
             else 
               mat[position_Actuelle] = im->Couleur[position_Actuelle];
        }
        else // sinon (=2) il reste inchangé.
          mat[position_Actuelle] = im->Couleur[position_Actuelle];
 
        // le compteur pour la couleur verte.
        if (cptV > 3)
          if (im->Couleur[position_Actuelle + 1] > seuil) 
            mat[position_Actuelle + 1] =
             255 - im->Couleur[position_Actuelle + 1];
          else
            mat[position_Actuelle + 1] = im->Couleur[position_Actuelle + 1];
        else if (cptV == 3) {
          if (im->Couleur[position_Actuelle + 1] < seuil) 
            mat[position_Actuelle + 1] =
             255 - im->Couleur[position_Actuelle + 1];
          else 
            mat[position_Actuelle + 1] = im->Couleur[position_Actuelle + 1];
        }
        else if (cptV < 2) {
             if (im->Couleur[position_Actuelle + 1] > seuil) 
               mat[position_Actuelle + 1] =
                255 - im->Couleur[position_Actuelle + 1];
             else 
               mat[position_Actuelle + 1] = im->Couleur[position_Actuelle + 1];
        }
        else // sinon (=2) il reste inchangé.
          mat[position_Actuelle + 1] = im->Couleur[position_Actuelle + 1];
 
        // le compteur pour la couleur bleue.
        if (cptB > 3)
          if (im->Couleur[position_Actuelle + 2] > seuil) 
            mat[position_Actuelle + 2] =
             255 - im->Couleur[position_Actuelle + 2];
          else
            mat[position_Actuelle + 2] = im->Couleur[position_Actuelle + 2];
        else if (cptB == 3) {
          if (im->Couleur[position_Actuelle + 2] < seuil) 
            mat[position_Actuelle + 2] =
             255 - im->Couleur[position_Actuelle + 2];
          else 
            mat[position_Actuelle + 2] = im->Couleur[position_Actuelle + 2];
        }
        else if (cptB < 2) {
             if (im->Couleur[position_Actuelle + 2] > seuil) 
               mat[position_Actuelle + 2] =
                255 - im->Couleur[position_Actuelle + 2];
             else 
               mat[position_Actuelle + 2] = im->Couleur[position_Actuelle + 2];
        }
        else // sinon (=2) il reste inchangé.
          mat[position_Actuelle + 2] = im->Couleur[position_Actuelle + 2];
      }
    }
 
   for (i = 0; i < max; i++)
     im->Couleur[i] = mat[i];
 
   free(mat);
 
   return im;
  }
  return NULL;
}

Le problème apparemment est
-> Lorsque j'applique deux fois le code sur une image il y a plantage 8O
-> Lorsque j'applique le code sur une image ayant du blanc (255) et du noir(0) il y a plantage :aie:

J'opterais pour un problème du côté des couleurs :?
Enfin je relirais mon code, dès que j'aurais finit de bailler ;)