Réduction d'images en C

**O( N )** · 22/09/2006, 02h05

Bonjour a tous,

Je réalise actuellement un logiciel perso sur le traitement des images et j'essaie de faire de la réduction d'images,
mais voilà le problème, lorsque je réduis de deux (ou plus)
l'image sur la hauteur, elle est réduite des deux côtés et est mise bout à bout
avec le nombre de réduction demandée 3 images pour une réduction de 3.

exemple1 - Image Originale (avec 2):

////////\\\\\\\\
////////\\\\\\\\
JJJJJJJJIIIIIIII
JJJJJJJJIIIIIIII

exemple2 - Image Originale : (avec 3)

/////////\\\\\\\\
/////////\\\\\\\\
/////////\\\\\\\\
JJJJJJJJJIIIIIIIII
JJJJJJJJJIIIIIIIII
JJJJJJJJJIIIIIIIII
/////////\\\\\\\\\
/////////\\\\\\\\\
/////////\\\\\\\\\

deviennent
1)
////\\\\////\\\\
JJJJIIIIJJJJIIII

2)
///\\\///\\\///\\\
JJJIIIJJJIIIJJJIII
///\\\///\\\///\\\

au lieu de

1)
////////\\\\\\\\
JJJJJJJJIIIIIIII

2)
/////////\\\\\\\\
JJJJJJJJJIIIIIIIII
/////////\\\\\\\\

Est-ce un problème fréquent d'avoir ceci,
car je me suis trompé quelque part , mais ceci est encore frais et la je ne vois pas du tout, même avec des exercices papiers

Voici un bout du code :

**********************************************

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
 
Image_PPM* Reduire_La_Taille(Image_PPM* im, int reduc_X, int reduc_Y, Pix* f(unsigned char*, int, int, int, int, int, int)) {
  if (im != NULL) {
    long max = im->NbColonne * im->NbLigne * 3,
         maxNouveau = max / (reduc_X*reduc_Y);
    unsigned char* matrice = (unsigned char*) malloc(sizeof(unsigned char) * 
    maxNouveau);
    if (matrice == NULL) return NULL; // gestion d'erreur à mettre ici
    // envoyer un message windows à afficher ...
 
    long i = 0, j = 0, cpt = 0,
         nbc = im->NbColonne/reduc_X, nbl = im->NbLigne/reduc_Y;
    Pix* p = NULL;
 
    for (cpt = 0; cpt < maxNouveau; cpt+=3) {
      i = ((cpt / 3) % nbc);// X
      j = ((cpt / 3) / nbc);// Y      
      p = f(im->Couleur, im->NbColonne, im->NbLigne, nbc, nbl, i, j);
      matrice[cpt] = p->Rouge;
      matrice[cpt+1] = p->Vert;
      matrice[cpt+2] = p->Bleu;
      LibererPix(p);
    }
    LibererDonnees(im);
    im->NbColonne = nbc;
    im->NbLigne = nbl;
    im->Couleur = matrice;
 
    return im;    
  }
  return NULL;
}
 
Pix* Prendre_Max_Du_Groupe(unsigned char* mat, int t_X, int t_Y, int nt_X, int nt_Y, int pos_X, int pos_Y) {
  if (mat != NULL) {
    long //i = 0 , j = 0,
         avance_X = t_X / nt_X,
         avance_Y = t_Y / nt_Y;
    Pix* p = CreerPix3(mat[(pos_X*avance_X*3)+(pos_Y*avance_Y*t_X*3)],
                       mat[(pos_X*avance_X*3)+(pos_Y*avance_Y*t_X*3)+1],
                       mat[(pos_X*avance_X*3)+(pos_Y*avance_Y*t_X*3)+2]);
/*
    for (i = 0; i < avance_X; i++) {
      for(j = 0; j < avance_Y; j++) {
        if ((p->Bleu + p->Rouge + p->Vert) < 
            (mat[((pos_X+i)*avance_X*3)+((pos_Y+j)*avance_Y*t_X*3)] + 
             mat[((pos_X+i)*avance_X*3)+((pos_Y+j)*avance_Y*t_X*3)+1] +
             mat[((pos_X+i)*avance_X*3)+((pos_Y+j)*avance_Y*t_X*3)+2])) {
          p->Rouge = mat[((pos_X+i)*avance_X*3)+((pos_Y+j)*avance_Y*t_X*3)];
          p->Vert = mat[((pos_X+i)*avance_X*3)+((pos_Y+j)*avance_Y*t_X*3)+1];
          p->Bleu = mat[((pos_X+i)*avance_X*3)+((pos_Y+j)*avance_Y*t_X*3)+2];
        }
      }
    }*/
    return p;
  }
  return NULL;
}

**********************************************

le code du main est :
Reduire_La_Taille(_imageDeTravail, 2, 1, Prendre_Max_Du_Groupe); // réduction de la hauteur par 2

Merci déjà à ceux qui ont eu le courage de lire ceci

et j'espère que mon C ne vous a pas fait trop horreur

.

Si quelqu'un voit le truc, ce sera mieux que moi ce soir

**Emmanuel Delahaye** · 22/09/2006, 07h21

Envoyé par O( N )

Je réalise actuellement un logiciel perso sur le traitement des images et j'essaie de faire de la réduction d'images,

C'est un problème d'algorithme, pas de C...

http://www.developpez.net/forums/forumdisplay.php?f=60

Ca devient un problème de C (réalisation) une fois que tu es sûr d'avoir le bon algorithme (conception).

**ToTo13** · 22/09/2006, 10h24

Bonjour,

est ce que tu as regardé les discussions sur ce forum traitant des problèmes de zoom ?

Cela te permettrai d'avoir une idée du bon algorithme à utiliser.

**Ti-R** · 22/09/2006, 11h19

Je crois qu’il y a plein de truc qui ne vont pas.

Va falloir que tu arranges ton code et réfléchisse dessus encore.

Quelques indices.

LibererDonnees(im); // libération des données bien placé ?
maxNouveau = max / (reduc_X*reduc_Y); // reduc_X et reduc_Y, pourquoi c’est une mauvaise idée de les utiliser ici et de travailler ensuite avec ?

Optimisation :

LibererPix(p); // es ce bien utile pour chaque pixel ?
CreerPix3 // idem
(pos_X*avance_X*3)+(pos_Y*avance_Y*t_X*3) // à chaque fois ?

Allé hop au travail

On fera un check ensuite des avancés,
et essaie de ne pas poster le code en commentaire que tu n'utilises pas...

**O( N )** · 22/09/2006, 11h19

Merci à tous deux

En fait (Emmanuel) j'ai écrit sur papier les tests et sur le papier cela fonctionne

,
c'est pour cela que je l'ai posté sur le forum 'C'
( Je suis un croyant

, car je crois que mon algorithme fonctionne,
mais DIEU Ordinateur me fait comprendre que NON

).

(ToTo13) Je ne savais pas qu'il y avait un post sur les problèmes de zoom,
mais de toute façon je n'aurai pas regardé, car le but est de trouvé

pas d'avoir à lire.

Merci en tout cas, je vais lire ce post maintenant que j'ai fait,je crois, l'essentiel du code.

**Ti-R** · 22/09/2006, 11h23

A oui j'aime bien aussi le long et commentaire

Code :

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

1
2
3
 long //i = 0 , j = 0,
         avance_X = t_X / nt_X,
         avance_Y = t_Y / nt_Y;

ps: à relier aussi à ce que j'ai dis précédemment

// reduc_X et reduc_Y, pourquoi c’est une mauvaise idée de les utiliser ici et de travailler ensuite avec ?

**O( N )** · 22/09/2006, 11h35

Merci Ti-R (voila mes explications

)

- LibérerDonnees(im) = libère la place prise par les anciennes données

- maxNouveau est fait pour clarifier la lecture.
(qui sera entièrement reprise apres fonctionnement de la fonction)
C'est sur dans ces cas là que nbc (nombre de Colonne) et nbl (nombre de ligne) sont dans le même cas que maxNouveau.

Pour reduc_X et reduc_Y j'utilise les nouveaux formats générés par eux, c'est il me semble pareil ( voir le code PrendreLeMaxDuGroupe(...) )

J'ai commenter ce code car, je voulais vous montrer le code final, mais l'erreur ne vient pas de la fonction Prendre...
mais il me semble plutot vers la premiere fonction, au vue des résultats dans le fait que j'ai de nouveau une sélection d'anciennes positions (puisque répétées)

**O( N )** · 22/09/2006, 11h42

Le truc drôle que j'ai trouvé , c'est qu'en changeant certaines lignes de code comme suit :

p = f(im->Couleur, im->NbColonne, im->NbLigne, nbc, nbl, i, j);

par

p = f(im->Couleur, im->NbLigne, im->NbColonne, nbl, nbc, j, i);

puis

im->NbColonne = nbc;
im->NbLigne = nbl;

par

im->NbColonne = nbl;
im->NbLigne = nbc;

J'obtiens la solution avec une rotation d'angle 90 (normal puisque j'inverse hauteur et largeur)
avec un effet mirroir (que je n'avais pourtant pas encore développé)

Réduction d'images en C

C

Vue hybride

Discussions similaires

Partager

Partager