Discussion :

[romain1986]

Bonjour voici ma fonction qui a pour but de faire la rotation de ma matrice! C'est à dire que je dois faire la rotation d'une image de format .ppm! Mais avec mon code ci dessous j'arrive à faire la rotation mais ce n'est que la moitié de l'image qui est tourné de 90°! Et je ne comprends pas pourquoi!
//colonne signifie le nombre de colonnes
//ligne signifie le nombre de lignes

Je n'ai pas tout mon code mtn ici sur cette rubrique car cela prendrai trop de place mais j'espère que vous avez assez d'informations pour comprende mon problème et pouvoir m'aider! Le code pour ecrire fonctionne car j'ai deja réaliser d'autres fonctions et cela va tres bien! Merci d'avance

le code de ma fonction:

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
struct pixel 
{
	int R;
	int G;
	int B;
};
 
struct pixel temp[MAX][MAX];
 
void rotation (struct pixel mat[MAX][MAX],int colonne, int ligne)
{
	int i,j;
	for(i=0;i<=ligne;i++) 
      {
            for(j=colonne;j>=1;j--) 
            {
	            temp[j][i].R =mat[i][j].R;
	            temp[j][i].G =mat[i][j].G; 
	            temp[j][i].B =mat[i][j].B;
	        }
	  } 
	for(i=1;i<=(ligne);i++) 
    {
	   for(j=1;j<=(colonne);j++) 
	       { 
		       mat[i][j].R = temp[i][j].R;  
		       mat[i][j].G = temp[i][j].G; 
		       mat[i][j].B = temp[i][j].B;
		   }
	}
}

[diogene]

- Même si le résultat y ressemble, ce n'est pas une rotation de 90° que tu as programmé puisque tous les pixels pour lequel i=j n'ont pas bougé. Une rotation laisse un seul point invariant : le centre de rotation
- Pour ton problème qui doit se produire si l'image n'est pas carrée,

Code :

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

1
2
3
4
5
6
for(i=0;i<=ligne;i++) 
            for(j=colonne;j>=1;j--) 
            {
	            temp[j][i].R =mat[i][j].R;
                     ....
	        }

fait que si l'image d'origine a ligne lignes et colonne colonnes, dans temp, elle a colonne ligne et ligne colonnes

Code :

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

1
2
3
4
5
6
	for(i=1;i<=(ligne);i++) 
    {
	   for(j=1;j<=(colonne);j++) 
	       { 
		       mat[i][j].R = temp[i][j].R;
                       ....

copie dans l'image d'origine le contenu de temp de ligne lignes et colonne colonnes, donc pas le contenu "utile".
Par exemple, si l'image a 5 lignes et 10 colonnes, temp a 10 lignes et 5 colonnes " utiles" (les colonnes suivantes de temp sont à zéro puisque temp est semble t-il en global) et je recopie 5 lignes et 10 colonnes de temp dans l'image. L'image finale n'est modifiée que pour le carré de 5 lignes et 5 colonnes , le reste est noir.

si l'image a 10 lignes et 5 colonnes, temp a 5 lignes et 10 colonnes " utiles" (les lignes suivantes de temp sont à 0) et je recopie 10 lignes et 5 colonnes de temp dans l'image. L'image finale n'est modifiée que pour le carré de 5 lignes et 5 colonnes , les 5 colonnes suivantes sont celles de l'image originale et le reste est noir.

[souviron34]

pour une rotation d'iage, TOUJOURS partir du pixel résultat et calculer le pixel d'origine, à cause des erreurs d'arrondi qui donneront dans l'image résultante des pixels noirs, et donc des effets de moirés.

De plus, ton image résultante n'aura pas les mêmes dimensions, et aura des angles noirs (sauf si tu coupes après coup).

Donc, primo, calculer les coordonnées limites (par calcul de la rotation des sommets, puis min/max des (x,y) pour ces 4 points.

Secondo, il est plus pratique de faire une fonction qui effectue la rotation.

Tertio, par conséquent, il faut écrire, pour effectuer une rotation Angle de l'image originale IM1, pour un résultat dans IM2 :

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
 
/*
 * Fonction de rotation
 */
static void RotateInteger ( int Xc, int Yc, int Xin, int Yin, double Angle, 
                                     int *Xout, int *Yout ) 
{
  *Xout = Xc + (int)(((Xin - Xc) * cos(Angle)) + ((Yin - Yc) * sin(Angle))) ;
  *Yout = Yc + (int)(- ((Xin - Xc) * sin(Angle)) + ((Yin - Yc) * cos(Angle))) ;
}
 
/* 
 * Rotation d'une image
 */
int RotateImage ( unsigned char *IM1, int Dimx1, int Dimy1, double Angle,
                         unsigned char **IM2, int *Dimx2, int *Dimy2 )
{
int                  i, j ; /* Indices de boucle */
int                  x1, y1 ; /* Pour les coordonnées dans l'image initiale */
int                  x[4], y[4] ;  /* Pour calculer les limites de la nouvelle image */
int                  xc1, yc1, xc2, yc2 ;  /* Coordonnées du centre */
int                  xmin, xmax=0, ymin, ymax=0 ;
 
 
/* Calcul du centre */
 
xc1 = Dimx1/2 ;
yc1 = Dimy1/2 ;
 
 
/* Calcul des limites */
 
RotateInteger ( xc1, yc1, 0, 0, Angle, &x[0], &y[0] );
RotateInteger ( xc1, yc1, Dimx1, 0, Angle, &x[1], &y[1] );
RotateInteger ( xc1, yc1, 0, Dimy1, Angle, &x[2], &y[2] );
RotateInteger ( xc1, yc1, Dimx1, Dimy1, Angle, &x[3], &y[3] );
 
xmin = Dimx1 ;
ymin = Dimy1 ;
 
for ( i = 0 ; i < 4 ; i++ )
  {
     if ( x[i] < xmin )
        xmin = x[i] ;
     if ( x[i] > xmax )
        xmax = x[i] ;
     if ( y[i] < ymin )
        ymin = y[i] ;
     if ( y[i] > ymaw )
        ymax = y[i] ;
  }
 
*Dimx2 = xmax - xmin + 1 ;
*Dimy2 = ymax - ymin + 1 ;
 
 
/* Allocation du buffer pour l'image resultat */
 
*IM2 = calloc ( ((*Dimx2)*(*Dimy2)), sizeof(unsigned char) );
if ( *IM2 == NULL )
  {
     *Dimx2 = 0 ;
     *Dimy2 = 0 ;
     return ERROR ;  
  }
 
 
/* Calcul du centre image 2 */
 
xc2 = *Dimx2/2 ;
yc2 = *Dimy2/2 ;
 
/* Remplissage du buffer */
 
for ( i = 0 ; i < *Dimy2 ; i++ )
    for ( j = 0 ; j < *Dimx2 ; j++ )
      {
          RotateInteger ( xc2, yc2, j, i, -Angle, &x1, &y1 );
 
 
          /* Elimination des points qui tomberaient en dehors de IM1 */
 
          if ( ((int)fabs((double)(x1-xc)) > xc) || 
               ((int)fabs((double)(y1-yc) > yc) )
             continue ;
 
 
          /* Remplissage */
 
          (*IM2)[i*(*Dimx2)+j] = IM1[y1*Dimx1+x1] ;
      }
 
return SUCCESS ;
}

[romain1986]

Tout d'abord merci à vous deux de votre aide! Et bien mon problème est que nous avons vu pour le moment que tres peu de foncttionalités et methodes pour definir une fonction et algorithme! Pour cela je ne comprends pas du tout le dernier là! Désolé et j'aurais du mal à l'expliquer à mon professeur! :S Mais si la 1ère personnne saurais m'aider d'avantage pour restructurer ma fonction j'en serais tres reconnaissant! MERCI

[diogene]

- Pour une rotation de 90°(sens direct, inverse des aiguilles d'une montre) , le pixel de coordonnées (colonne = col, ligne = lg) doit se déplacer en (colonne = lg, ligne = N-1-col). (N = nombre de colonnes de l'image)
- Pour une rotation de 90°(sens inverse, sens des aiguilles d'une montre) , le pixel de coordonnées (colonne = col, ligne = lg) doit se déplacer en (colonne = M-1-lg, ligne = col). (M = nombre de lignes de l'image)
- L'image après rotation est de dimension M colonnes x N lignes

- Tu utilises un tableau intermédiaire dans ton programme. Ce n'est pas obligatoire : La rotation peut se faire sur place, sans tableau intermédiaire MxN , mais nécessite de traiter simultanément 4 points : En rotation de sens direct

Code :

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

1
2
3
4
5
6
(col,lg) ->  (lg, N-1-col) -> (N-1-col, N-1-lg) -> (N-1-lg, col)
Temp <- Point(col,lg)
Point(col,lg) <- Point(N-1-lg, col)
Point(N-1-lg, col) <- Point(N-1-col, N-1-lg)
Point(N-1-col, N-1-lg) <- Point(lg, N-1-col)
Point(lg, N-1-col) <- Temp

Comme la rotation ne doit pas se produire plusieurs fois pour un même point, col et lg parcourent seulement 1/4 du plan NxN :

Code :

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

1
2
0 <=  col < (N+1)/2 (division entière)
0 <= lg < Minimum ((N+1)/2, M)

[kromartien]

En algèbre linéaire on parle de 'matrice transposée', c'est ce qui correspond à une rotation de 90 degrés dans le sens horaire, additionnée d'un retournement 'miroir' horizontal (symétrie horizontale). Voilà pour la recherche google 'théorie'