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é)

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

Le gros problème déjà avec ton algo, c'est que si tu demandes une réduction de 5 sur une image de 47 pixels -> problème.
En tout cas même si tu arrives à ne pas avoir de bug dans le programme, l'image finale ne sera pas bien réduite.

Il ne faut pas penser que l'espace de ton image est discret mais qu'il est continue. Donc il faut prévoir une fonction qui permet un accès dans cet espace continue.

Essaie d’y repenser et de réécrire un algo.

Donc ton image ne doit pas être vue comme une série de pixels, mais comme un espace continue.

Ne perd pas courage, allé hop au travail

**O( N )** · 22/09/2006, 13h51

Ce que tu me demandes Ti-R,
c'est de trouver une fonction de N*N dans R*R

(Car je suis d'accord sur le fait que je n'ai pas géré les divisions qui donnerait une allure bizarre comme résultat,
même si je l'avais prévu au départ d'essayer de faire simple d'abord

)

Le but ici est de trouver un algorithme acceptable que je pourrais, ultérieurement, mettre en ligne pour un site de
vulgarisation sur le thème de l'image, avec, pourquoi pas, le logiciel fournit (sans bogues

).

Mon chti prog commence à réaliser des trucs, un peu d'animations, c'est déjà çà

.
Il me reste une liste d'une cinquantaine de fonctions à réaliser je pense avant d'avoir un truc acceptable

Je ne perd pas courage, j'ai réussi dernièrement à venir à bout de la rotation simple
(donc la encore pas de fonction, comme tu me le demandes),
je pense que pour de futurs néophytes,
il serait intéressant de voir les différences
entre les versions simples et leurs manques et
les versions plus générales et plus mathématiques et donc sans manques.

Cela fait pas mal de temps que je suis dessus

sujet vaste et trés intéressant.

Je vais bientôt m'attaquer aux filtres,
faire de la détection de contours,
faire de la segmentation,
dès que j'aurai du temps essayer mon algo de compression
(sujets déjà abordés précédemment, donc pas de perte de temps à étudier,
plus du temps à perdre pour le faire proprement et simplement

)

J'ai découpé les possibilités d'actions comme suit :

- fonctions sur matrices
- fonctions sur positions
- fonctions sur couleurs

et est déjà réalisé tout plein de fonctions pas trop compliquées, pour commencer ...

J'ai rangé le problème de la réduction sur la partie fonctions sur matrices.
( voilà ...

)

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

Je vois que je ne t'avais pas répondu entièrement tout a l'heure Ti-R oups

1) LibererPix(p); // est-ce bien utile pour chaque pixel ?

En fait , il me semble que le la variable retour de f(...) qui est de type Pix*
va être automatiquement libérer par le 'système' donc effectivement LibérerPix(p) ici n'est pas utile !
( Il reste une indication pour des néophytes de ce qui devrait être fait,
cependant cela devient du moins bon code voire pire, je suis d'accord, voila déjà une optimisation

)
Peut-être ai-je un code un peu trop sécuritaire ?

2) CreerPix3 // idem

Est mis la pour avoir un code lisible pour autruis. (ie on voit que l'on créé un pixel)

J'ai indiqué dans ma fonction un type de retour Pix* et c'est pour cette raison que je créé un Pix* donc autre utilité de cette fonction ici. Je peux cependant mettre un Pix* en argument et le remplir uniquement dans cette fonction pour le retourner ensuite c'est peut-être mieux qu'en créer un à chaque appel

3) (pos_X*avance_X*3)+(pos_Y*avance_Y*t_X*3) // à chaque fois ?

Il serait déjà intéressant de créer une ou deux petites variables permettant
d'éviter certaines répétitions comme par exemple :
long Calcul_X = (avance_X*3), // pour la boucle
Calcul_Y = (avance_Y*t_X*3), //pour la boucle aussi
Valeur_X = Calcul_X*Pos_X, // pour l'initialisation
Valeur_Y = Calcul_Y*Pos_Y;// pour l'initialisation aussi

Voilà

**Ti-R** · 22/09/2006, 14h34

Envoyé par O( N )

Je vois que je ne t'avais pas répondu entièrement tout a l'heure Ti-R oups

1) LibererPix(p); // est-ce bien utile pour chaque pixel ?

En fait , il me semble que le la variable retour de f(...) qui est de type Pix*
va être automatiquement libérer par le 'système' donc effectivement LibérerPix(p) ici n'est pas utile !
( Il reste une indication pour des néophytes de ce qui devrait être fait,
cependant cela devient du moins bon code voire pire, je suis d'accord, voila déjà une optimisation

)
Peut-être ai-je un code un peu trop sécuritaire ?

non c'était bien codé, c'est pas la réponse que j'attendais

réfléchi sur l'allocation/destruction de mémoire pour chaque pixel pour n pixels....

Envoyé par O( N )

2) CreerPix3 // idem

Est mis la pour avoir un code lisible pour autruis. (ie on voit que l'on créé un pixel)

J'ai indiqué dans ma fonction un type de retour Pix* et c'est pour cette raison que je créé un Pix* donc autre utilité de cette fonction ici. Je peux cependant mettre un Pix* en argument et le remplir uniquement dans cette fonction pour le retourner ensuite c'est peut-être mieux qu'en créer un à chaque appel

donc c'est très relié à la question 1, pourquoi recréer un pixel à chaque fois ?

Envoyé par O( N )

3) (pos_X*avance_X*3)+(pos_Y*avance_Y*t_X*3) // à chaque fois ?

Il serait déjà intéressant de créer une ou deux petites variables permettant
d'éviter certaines répétitions comme par exemple :
long Calcul_X = (avance_X*3), // pour la boucle
Calcul_Y = (avance_Y*t_X*3), //pour la boucle aussi
Valeur_X = Calcul_X*Pos_X, // pour l'initialisation
Valeur_Y = Calcul_Y*Pos_Y;// pour l'initialisation aussi

Voilà

Et pourquoi ne pas avoir
p.valuevi(mat[(pos_X*avance_X*3)+(pos_Y*avance_Y*t_X*3)]);

?

Ce qui répondrais au 3 questions.

**Ti-R** · 22/09/2006, 14h36

Le but ici est de trouver un algorithme acceptable que je pourrais, ultérieurement, mettre en ligne pour un site de
vulgarisation sur le thème de l'image, avec, pourquoi pas, le logiciel fournit (sans bogues ).

Autant coder la fonction dont je te parle qui sert aussi bien à faire du zoom in/out, du redimensionnement, de la rotation etc etc....
Et ce n’est pas super méga compliqué loin de la.
Autant partir sur des bonnes bases

**O( N )** · 22/09/2006, 14h59

D'abord faisons les choses dans l'ordre.

1) p.valuevi(...) je ne connais pas ceci

(ou j'ai oublié ce que cela fait)

2) Effectivement d'un point de vue algo créer n pixels pour les effacer c'est pas top.
C'est plus apparent apres coup qu'il reste préférable de créer un Pix* avant boucle,
de lui changer ses valeurs pendant la boucle
et de l'effacer après la boucle, certes ...

Je programme peut-être bizarrement, mais j'ai plutot tendance à écrire avant un programme
qui marche et le plus simple possible et effectivement penser optimisation après !

3) Un machin qui fait tout ? (même le café waow)
Je ne pensais pas qu'il existait un lien entre rotation, redimensionnement et zoom (à part peut-être les matrices),
mais il faut dire à ma décharge que je ne suis pas assez matheux au départ

**Ti-R** · 22/09/2006, 15h22

Code :

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

1) p.valuevi(...) je ne connais pas ceci  (ou j'ai oublié ce que cela fait)

Oui je sais bien que cela ne correspond à rien pour toi, d'ailleurs je me suis trompé... dsl j'ai été trop vite

Code :

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

p->valuevi(&mat[(pos_X*avance_X*3)+(pos_Y*avance_Y*t_X*3)]);

La fonction Valuevi peut être appelée ValueSetArray ou autre.

Mais autant coder la fonction qui prend un pointeur et qui copie directement les bonnes valeurs dans ton pixel.

Tiens va sur le thread à Millie
Tu vas surement apprendre des choses.

Je ne suis pas non plus un grand matheux... t'inquiète c'est à ta porté.

La fonction à coder dont je parle est.

Code :

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

1
2
3
4
Pix* getPixel(unsigned char* mat, float x, float y)
{
// A toi de remplir
}

C'est bien des float et non des int, car logiquement tu dois pouvoir accès à x=1.5 et y=2.3
Tu vas voir, cela va te changer la vie !

**O( N )** · 22/09/2006, 15h56

Tiens c'est drole je travaille aussi sur une image de papillons

Je vais indiquer ce que j'ai déjà réalisé,
(car peut-être certaines fonctions risquent de disparaître après création de nouvelles qui font tout

)

Sur une Image : - Actions
- Mettre_En_Noir_Et_Blanc
- Mettre_En_Degrade_De_Gris_Version1 (4 versions) (rien de trés compliqué, les formules changent)
- Enlever_La_Couleur_Bleue (rouge ou verte)
- Seulement_La_Couleur_Verte (rouge ou bleue)
- La_Barre (pas trés parlant

l'image se situe entièrement dessus
ou entièrement dessous une valeur donnée, j'ai eu une belle image tout de même)
- Colorimetrie (donne le nombre de pixels sur chaques couleurs)
- Moyenne (de l'image en RGB)
- ReduireLesNuances
- Contraster
- DecalageModulo
- Rotation (simple)
(fonctions appliquer sur les couleurs)
- Syracuse (modifications d'images avece la fonction de syracuse)
- Assombrir/Eclaircir
- MettreEnNoir/ MettreEnBlanc
- SeuillageMinimum/SeuillageMaximum
- Masquer_Aleatoirement
- InverserLesCouleurs (assez simples ceci)

Sur une Image : Animations
- Mettre_En_Noir_Et_Blanc_Anim
- Mettre_En_Gris_Anim
- Morphing_Couleur_Pixel_Anim (pas du vrai morphing cependant

)
- Apparition_Point_Par_Point_Au_Hasard (un genre du PowerPoint pas tres rapide, pas encore optimisé donc)
- Apparition_Progressive (tout les pixels augmente progressivement jusqu'à leur max)
- Deplacement_Continue (l'image se déplace dans son cadre et réapparait de l'autre côté)

Sur deux Images : - Actions
- MaximumCouleur
- MinimumCouleur
- MaximumPixel
- MinimumPixel
- FaireApparaitreParDessus
- Additionner_Deux_Images (et le reste...)

**O( N )** · 22/09/2006, 19h36

En fait, je n'ai pas pensé à du C++ (ton p->valuevi(...))
c'est pour cela que je ne voyais pas ceci en C.

Je vais essayer de modifier mes appels de fonctions, de manière à pouvoir utiliser ta fonction
Pix* getPixel(unsigned char*, float, float)

Donc : (je résume)

Je développe des fonctions de R*R dans R*R auxquelles je renvoi un joli getPixel().

Je rajoute une structure par exemple
typedef struct _PointReel_ {
float x;
float y;
} PointReel;

et je définit des fonctions de signature
PointReel* f (PointReel*);

C'est çà ?

**Ti-R** · 22/09/2006, 19h51

Envoyé par O( N )

En fait, je n'ai pas pensé à du C++ (ton p->valuevi(...))
c'est pour cela que je ne voyais pas ceci en C.

Oui dsl, je suis trop C++...
Enfin tu as compris l'idée, c'est l'essentiel

Envoyé par O( N )

Donc : (je résume)

Je développe des fonctions de R*R dans R*R auxquelles je renvoi un joli getPixel().

Je rajoute une structure par exemple
typedef struct _PointReel_ {
float x;
float y;
} PointReel;

et je définit des fonctions de signature
PointReel* f (PointReel*);

C'est çà ?

PointReel -> ok

Le reste je ne suis pas certain de comprendre.
Enfin ce que j'interprète ne me semble pas ok.... Mais comme je viens de le dire je ne suis pas sur de comprendre.

Pour résumer l'idée
pseudo algo

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
void resizeImg(...)
{ 
…// allocation
img_resize =debut_image_resize; 
img_origine =debut_image_origine;
 
  for(int i=x_resize*y_resize*3;i--;)
  {
	memcpy(img_resize,getPixel(img_origine, calcul du x souhaité dans l’image, calcul du y souhaité dans l’image),nb_color);
            img_resize+= nb_color;
  }
 
}

**O( N )** · 25/09/2006, 18h27

Merci pour ton aide Ti-R

J'ai trouvé l'erreur, l'algorithme fonctionnait depuis le début

En fait le problème se situait au niveau de ma définition entre nombre de colonne et nombre de ligne
(inversion des deux, non apparents clairement dans le programme, en plus

)
depuis la lecture d'un fichier de format PPM (c'est sur ce format que je développe mes diverses idées

)

Je me disais bien que cela était un problème dans le cacul des positions au niveau : redondance des positions.

Donc je lui parlais en Chinois, il me répondait en japonais et mon traducteur ne faisait que dans un seul sens

Je garde sous le coude ton algorithme pour la 'version flottantes', car cela me permettra de montrer deux versions distinctes et
donc de montrer l'intérêt qu'il y a, à développer ta version plutôt que la mienne, à des plus néophytes que moi.

(biensûr lorsque des calculs plus mathématiques et plus puissant seront présent dans le programme

)

Prochaine étape : le Jeu de la vie en mode 'Animations' sur une image PPM.

**Ti-R** · 26/09/2006, 00h15

T'inquiète je te rassure que tu n'es pas le seul à avoir eu des résultats bizarres avec inversion de taille etc...

J'en ai eu ma dose, et c'est pas fini...

D’ailleurs parfois c’est assez « drôle » quand on voit le résultat de ce qu’on vient de coder qui ne correspond pas du tout à ce qu’on souhaite, mais qui donne un effet plutôt esthétique bien qu’inutile…

Réduction d'images en C

C

Discussions similaires

Partager

Partager