Image en courbure

**joel.drigo** · 01/08/2016, 17h46

getRGB() ça renvoit un int, pas un tableau. Maintenant, si tu as un algorithme qui utilise la couleur HSB, tu ne peux pas la remplacer comme ça par la couleur RGB. Mais si ta question est de supprimer le passage par la couleur HSB, oui tu peux : il suffit de manipuer getRGB() comme un int, pas comme un int[] :

Code :

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

courb = Math.abs(outImgbonb.getRGB(i-1,j))-(outImgbonb.getRGB(i+1,j)));

Mais ça risque de donner n'importe quoi comme résultat. Parce que ce int, ce n'est pas vraiment un nombre provenant d'un ensemble ordonné, comme l'est la teinte (hue) du modèle HSB, mais une combinaison de plusieurs données codées sur 4 octets (Alpha, Rouge, Bleu, Vert). Cela n'a donc pas vraiment de sens d'en faire une différence, tel quel en tout cas, sans parler du résultat qui risque d'être n'importe quoi (à cause des l'encodage sur 4 octets, du signe en bit de poids fort, etc).

**YOUHANA** · 01/08/2016, 19h38

Oui , c'est exactement ce que je voulais, j'ai eu mon résultat mais du coup je veux faire un test

Code :

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

1
2
3
4
5
6
7
8
9
if (courb>=128)
						courb=255-courb;
					if (courb>64) //Limitation courbure entre 2 pixels
					{
						//on affiche pas
 
					courb=courb*4; //Mise à echelle
 
					}

Mon problème, c'est que pour ne pas afficher je fais courb=0 mais après quand je fais une mise à echelle courb*4, il fait 0*4 = 0. Du coup, je me demande s'il y a un moyen pour ne pas afficher les valeurx inferieur à zero sans passer par cette etape de courb=0 ?

**joel.drigo** · 01/08/2016, 19h54

Je ne suis pas sûr d'avoir tout compris. Avec du code, ce serait probablement plus clair. J'ai l'impression que ton problème est que tu utilises une seule variable pour stocker 2 concepts différents et que tu te retrouves bloquer à un moment parce que tu as besoin de distinguer ces deux concepts. Si tel est le cas, une seule solution : utiliser 2 variables. C'est d'ailleurs toujours à éviter d'utiliser une même variable pour gérer deux notions différentes, même si elles ont un lien, ou encore si elles sont identiques pendant une période.

**joel.drigo** · 01/08/2016, 20h58

Si je comprends bien, il s'agit de cette portion du code :

Code :

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

1
2
3
4
5
6
7
8
9
10
if (courb>64) //Limitation courbure entre 2 pixels
					{
						//on affiche pas, ici je dois faire tous les valeurs qui sont inferieurs à 64 ne sont pas affichés
 
 
						courb=0;
 
					courb=courb*4; //Mise à echelle
 
					}

Forcément, avec courb=0;, courb*4 va être égale à 0 ! Déjà, je ne comprends pas : le commentaire parle de valeurs inférieures à 64, et la condition du test est courb>64 ! Il y a un problème de logique ici.

Ensuite, ton problème est que tu ne veux pas afficher lorsque courb<64 (ou >, peu importe) : au lieu d'utiliser une valeur bidon, utilise un booléen qui sert à indiquer qu'on affiche ou pas. Tu l'initialise au début à true, et tu la passes à false lorsque tu as une condition où tu ne veux pas afficher. Et au moment d'afficher, tu testes si le booléen est vrai.

Ensuite, je suppose que l'affichage c'est :

Code :

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

1
2
 Color c=new Color(hue,hue,hue); 
				outImgc.setRGB(i,j,c.getRGB());

Si ton image est vierge (une nouvelle image) et de type ARGB, elle est au début complètement transparente : il suffit donc de ne pas exécuter ces deux lignes lorsque le booléen est faux (ou de les exécuter quand il est vrai).
Si ton image est du type ARGB et non vierge, tu peux forcer le point pour qu'il soit transparent en lui affectant la couleur : new Color(0,true).
Si ton image est du type RGB, il faudra lui affecter la couleur du background du composant.

Le cas 1 étant le plus simple.

**YOUHANA** · 01/08/2016, 21h04

Oui enfaite c'est exatement mon problème c'est que je dois faire un test boolean mais j'arrive pas à le mettre en oeuvre !!!

**joel.drigo** · 01/08/2016, 21h36

Qu'est-ce que tu veux que je réponde à ça hors contexte ?

A part : pour tester un booléen :

Code :

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

1
2
3
4
boolean variable = methodeQuiDetermineLaValeurDuBooleen();
if (  variable ) {
   // faire un truc
}

**YOUHANA** · 02/08/2016, 09h32

Bonjour,
Merci pour votre retour, oui enfaite c'est ce que j'ai pas reussi à faire et non la déclaration du boolean "la methode qui determine que la valeur du pixel est valide ou pas" (genre pour ne pas afficher cette valeur du pixel) !!!

**joel.drigo** · 02/08/2016, 09h36

Je t'ai demandé du code... C'est quoi le code qui affiche ton pixel ou je ne sais (toujours pas) quoi.

**YOUHANA** · 02/08/2016, 09h37

C'est ça le code qui affiche mon pixel

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
 for (int i = 1; i < width-1; i++) {
			   for (int j = 1; j < height-1; j++) {
 
 
			      int boo = outImgbonb.getRGB(i,j);
			      int bo = (boo >> 16) & 0xff;
				float courb = 0f;
				if (bo<32 || bo>224)
			    	   courb = (float) Math.abs((outImgbonb.getRGB(i-1,j)&0xff-outImgbonb.getRGB(i+1,j)&0xff));
			       else if (bo>=32 && bo<96)
			    	   courb = (float) Math.abs((outImgbonb.getRGB(i-1,j+1)&0xff)-(outImgbonb.getRGB(i+1,j-1)&0xff));
			       else if (bo>=96 && bo<160)
			    	   courb = (float) Math.abs(((outImgbonb.getRGB(i,j-1))&0xff-outImgbonb.getRGB(i,j+1)&0xff));
			       else if (bo>=160 && bo<224)
			    	   courb = (float) Math.abs((outImgbonb.getRGB(i-1,j-1)&0xff-outImgbonb.getRGB(i+1,j+1)&0xff));
 
					if (courb>=128)
						courb=255-courb;
					if (courb>64) //Limitation courbure entre 2 pixels
					{
						//on affiche pas
						//courb=0f;
 
					courb=courb*4; //Mise à echelle
 
					}
 
				float hue = courb/255.0f;
 
			     Color c=new Color(hue,hue,hue); 
				outImgc.setRGB(i,j,c.getRGB()); 
			   }}

**joel.drigo** · 02/08/2016, 09h53

Je ne vois rien qui affiche un pixel dans ce code. On y parcourt des pixels d'une image visiblement, on récupère leur couleur RVB, on fait un traitement dessus pour obtenir une autre couleur RVB et on affeste cette couleur à une autre image à priori.

Donc, si tu appelles "affichage", cette affectation de couleur, comme je te l'ai déjà dit, il suffit de faire ce code d'affectation dans un if :

Code :

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

1
2
3
if ( condition ) {
     outImgc.setRGB(i,j,c.getRGB()); 
}

Avec condition, une condition qui est vraie quand on veut affecter la couleur c, et fausse quand on ne veut pas.

Mais comme je te l'ai déjà dit, comme ceci affecte une couleur à un pixel d'une image, qui en a possiblement déjà une, il faut adapter pour le pixel en question ne s'affiche pas (ce qui se traduit par une couleur particulière, selon les cas que j'ai déjà exposé dans un précédent message).

**YOUHANA** · 02/08/2016, 10h06

Bien entendu !
Du coup j'ai fais

Code :

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

1
2
3
4
5
6
7
8
9
if (courb>64) //Limitation courbure entre 2 pixels
					{
						Color c1=new Color(0,true);
						     outImgc.setRGB(i,j,c1.getRGB()); 
 
 
					courb=courb*4; //Mise à echelle
 
					}

Mais en faisant ça on neglige pas ses valeurs là qui sont supérieurs à 64 !! Parceque moi le but c'est de ne pas les afficher et ne pas les calculer non plus

**joel.drigo** · 02/08/2016, 10h29

Ce que tu me montres là, c'est un if avec une condition qui dit "si courb est supérieur à 64" faire le truc entre accolades. Donc, en aucun cas tu "négliges" (on ignore en fait), les cas où courb est supérieur à 64.

Pour ignorer les cas où courb est supérieur à 64, on fait :

Code :

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

1
2
3
if ( courb<=64 ) {
    // faire ce qu'on veut quand courb n'est pas supérieur 64
}

Maintenant, tu parles de ne pas faire le calcul : le problème c'est que la seule référence de calcul que j'ai c'est le code que tu me montres. Et ce calcul consiste à évaluer courb. Donc, ne pas le faire veut dire changer potentiellement sa valeur et donc le résultat de la condition. Donc, il faut faire le calcul pour savoir qu'il ne faut pas le faire : en résumé, on est obligé de le faire. Ou alors cette condition doit être appliquée dès l'initialisation de courb, mais ça pose un problème de logique par rapport à if (courb>=128). Si on ne doit traiter que les pixels tels que courb<=64, alors ce test ne sert à rien, parce que courb ne sera jamais >=128. Ou alors, il faut le faire après ce test et donc ça donnerait :

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
 for (int i = 1; i < width-1; i++) {
			   for (int j = 1; j < height-1; j++) {
 
 
			      int boo = outImgbonb.getRGB(i,j);
			      int bo = (boo >> 16) & 0xff;
				float courb = 0f;
				if (bo<32 || bo>224)
			    	   courb = (float) Math.abs((outImgbonb.getRGB(i-1,j)&0xff-outImgbonb.getRGB(i+1,j)&0xff));
			       else if (bo>=32 && bo<96)
			    	   courb = (float) Math.abs((outImgbonb.getRGB(i-1,j+1)&0xff)-(outImgbonb.getRGB(i+1,j-1)&0xff));
			       else if (bo>=96 && bo<160)
			    	   courb = (float) Math.abs(((outImgbonb.getRGB(i,j-1))&0xff-outImgbonb.getRGB(i,j+1)&0xff));
			       else if (bo>=160 && bo<224)
			    	   courb = (float) Math.abs((outImgbonb.getRGB(i-1,j-1)&0xff-outImgbonb.getRGB(i+1,j+1)&0xff));
 
					if (courb>=128)
						courb=255-courb;
					if (courb<=64) //Limitation courbure entre 2 pixels
					{
 
					courb=courb*4; //Mise à echelle
 
				float hue = courb/255.0f;
 
			     Color c=new Color(hue,hue,hue); 
				outImgc.setRGB(i,j,c.getRGB()); 
 
					}
                                        else {
 
                                               // on ne veut pas affiche ce pixel au final quand on affichera l'image
 
                                               // hors une image c'est une matrice 2D de pixels : tout pixel de cette image existe et doit avoir une couleur._
 
                                               // il y a donc quelque chose à faire du type outImgc.setRGB(i,j, couleur) ici !!!
 
                                               // donc voir/lire ce que je t'ai déjà écrit à ce sujet, parce que je ne peux pas deviner comment est ton image 
 
                                        }
 
			   }}

**YOUHANA** · 02/08/2016, 10h42

Super merci c'est exactement ce que je cherchais je passe en résolu , dernière question si je veux par exemple avant de faire les conditions l'image

Code :

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

 courb = (float) Math.abs((outImgbonb.getRGB(i-1,j)&0xff-outImgbonb.getRGB(i+1,j)&0xff));

l'image qui s'appelle "outimgbonb" par exemple contient un corp et un fond , si je veux par exemple en parcourant l'image ne pas calculer la courb quand il y'a ce fond, et passer au i et j suivant ! Y'a t'il un moyen de faire ça ? MERCI
Image de teste

Nom : Test Courbure.PNG
Affichages : 62
Taille : 14,9 Ko

Nom : Test Courbure.PNG
Affichages : 62
Taille : 14,9 Ko

**joel.drigo** · 02/08/2016, 11h22

Ouf, on n'a franchi un cap, et pas des moindres. Mais avant de répondre à ta nouvelle question, je vais soulever un dernier problème au sujet de ton avant dernière question.

Si courb<=64, alors courb peut être égal à 64. Or on multiplie courb par 4, donc courb peut être égale à 256 ! Patatras : la couleur RGB d'un pixel doit être inférieure ou égale à 255 ! Le fait que tu la transformes en float après n'y change rien : tu vas obtenir une java.lang.IllegalArgumentException: Color parameter outside of expected range: Red Green Blue !

Donc soit l'expression de ton besoin était inexacte et ce n'est pas pour les valeurs de courb qui ne sont pas supérieures à 64, mais pour les valeurs de courb qui ne sont pas supérieures ou égales à 64 qu'on doit affecter la couleur du pixel, donc un if (courb<64) à la place du if ( courb<=64) soit il faut borner courb : courb = Math.min(255, courb*4).

Au passage, le constructeur utilisé par new Color(hue,hue,hue) ou hue est une float n'est pas un constructeur qui prend en paramètre une hue (teinte en français). C'est simplement un constructeur qui prend en paramètre des composantes RVB exprimées dans un intervalle [0f,1f] au lieu de [0,255].

Tu aurais donc pu écrire tout simplement :

Code :

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

1
2
int comp = (int)courb;
Color c=new Color(comp ,comp ,comp );

**joel.drigo** · 02/08/2016, 11h40

Envoyé par YOUHANA

l'image qui s'appelle "outimgbonb" par exemple contient un corp et un fond , si je veux par exemple en parcourant l'image ne pas calculer la courb quand il y'a ce fond, et passer au i et j suivant ! Y'a t'il un moyen de faire ça ?

Cela dépend déjà de ton image. Que ton fond soit transparent ou uniforme, il suffit de connaître la valeur ARGB à tester pour exclure les pixels à ne pas traiter. Si malheureusement il y a de l'antialising dans l'image d'origine, ce qui est manifestement le cas si on zoom sur les bords des disques qu'on y voit :

Nom : Capture.PNG
Affichages : 61
Taille : 6,0 Ko

Nom : Capture.PNG
Affichages : 61
Taille : 6,0 Ko

Et là ça peut être plus compliqué, ou pas. Si on néglige cet antialiasing, on peut considérer que tout point n'étant pas de la couleur du fond est à prendre en compte :

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
 
Color exclude = new Color(242,242,242); // c'est la couleur du fond uniforme de ton image
 for (int i = 1; i < width-1; i++) {
			   for (int j = 1; j < height-1; j++) {
 
 
			      int boo = outImgbonb.getRGB(i,j);
 
                              if ( boo != exclude.getRGB() ) {
 
                                     // on ne fait le traitement que pour les points qui ne sont pas du fond (donc tous les points noirs du disque, plus ceux qui sont gris dans la partie due à l'antialiasage
 
   			             int bo = (boo >> 16) & 0xff;
 
                                     /*...*/

Et encore, c'est une approximation : je ne saurais dire s'il n'y a pas par hasard un point dans la zone d'antialiassage qui pourrrait être un gris 242,242,242, mais on peut les négliger je pense.

**YOUHANA** · 02/08/2016, 11h45

Oui c'est pour ça je vous ai demandé est ce possible, parceque moi mnt j'ai cette image de test du coup si par exemple j'avais une autre avec un fond noir ou blanc par exemple, je voulais savoir si y'avait pas une méthode avec laquel on pouvait faire cette difference mais apparemment non on peut pas

?

**joel.drigo** · 02/08/2016, 12h03

Oui, il n'y a pas de moyen générique de déterminer ce qui est le fond d'une image statique (on peut le faire sur des images dynamiques). Mais il y a des heuristiques : on peut par exemple déterminer la couleur la plus présente. Mais ce n'est pas forcément vrai non plus. C'est quoi le fond dans l'image suivante ?

Nom : 1.png
Affichages : 57
Taille : 1,4 Ko

Nom : 1.png
Affichages : 57
Taille : 1,4 Ko

Et dans celle-là :

Nom : 2.png
Affichages : 63
Taille : 548 octets

Ou encore dans celle-là :

Nom : 3.png
Affichages : 63
Taille : 1 018 octets

Le plus simple est d'avoir une valeur de référence. On peut utiliser un seuil en cherchant que les noirs, et les gris "foncés"... On se baser sur la composant L du modèle HSL, ou B du HSB...
Une autre solution simple est d'avoir un masque, ou une image avec transparence.

Image en courbure

2D Java

Discussions similaires

Partager

Partager