Image en courbure

Version imprimable

Image en courbure

Bonjour,
J'ai comme mission de créer une image courbure, j'ai déjà l'algo que j'ai implementé mais apparemment y'a une erreur, j'aimerai bien que vous me corrigiez

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
 
 
public courbure(){
	 try {
		   File input = new File("d:/CC.JPG");
		   monImage = ImageIO.read(input);
		   int width = monImage.getWidth();
		   int height = monImage.getHeight();
		   BufferedImage outImg = new BufferedImage(width, height, monImage.getType());
		   for (int i = 1; i < width-1; i++) {
			   for (int j = 1; j < height-1; j++) {
 
			      float[] currenthsv = getHSB(monImage.getRGB(i,j));
				  float bo = currenthsv[0]*360;
				float courb = 0f;
				if (bo<32 || bo>224)
			    	   courb = Math.abs(getHSB(monImage.getRGB(i-1,j))[0]-getHSB(monImage.getRGB(i+1,j))[0]);
			       else if (bo>=32 || bo<96)
			    	   courb = Math.abs(getHSB(monImage.getRGB(i-1,j+1))[0]-getHSB(monImage.getRGB(i+1,j-1))[0]);
			       else if (bo>=96 || bo<160)
			    	   courb = Math.abs(getHSB(monImage.getRGB(i,j-1))[0]-getHSB(monImage.getRGB(i,j+1))[0]);
			       else if (bo>=160 || bo<224)
			    	   courb = Math.abs(getHSB(monImage.getRGB(i-1,j-1))[0]-getHSB(monImage.getRGB(i+1,j+1))[0]);
 
				outImg.setRGB(i,j, Color.getHSBColor(courb, currenthsv[1], currenthsv[2]).getRGB());
 
		   }
		}
 
		   File ouptut = new File("d:/courbure.jpg");
		   ImageIO.write(outImg, "jpg", ouptut);
 
		  } 
	 	catch (Exception e) {
		   e.printStackTrace();
		  }}
 
		  public float[] getHSB(int color)
		  {
		  	float hsv[] = new float[3];
		  	Color c = new Color(color);
		  	Color.RGBtoHSB(c.getRed(),c.getGreen(),c.getBlue(), hsv);
		  	return hsv;
		  }
 
		 static public void main(String args[]) throws Exception {
		  courbure obj = new courbure();
		 }
		}

Le résultat doit être comme ça à gauche y'a l'image de depart puis la 3eme image à droit doit être le resultat
Pièce jointe 215383

Merci,

14/07/2016, 23h14
tchize_

Ce serait peut être bien que tu nous dise ce que tu dois avoir, ce que tu obtiens et les images associée en piece jointe. Parce qu'imprimer les images, rouler la feuille et en prendre un photo avec un smartphone, on comprendre rien à ce que tu essaie de faire :aie:

Sinon, fais au moins ça dans les règles, met la photo imprimée sur une table en bois, prends la en photo photo, faxe là, scanne là et met là dans un document word.
15/07/2016, 10h13
wax78

Citation:

Envoyé par tchize_

Sinon, fais au moins ça dans les règles, met la photo imprimée sur une table en bois, prends la en photo photo, faxe là, scanne là et met là dans un document word.

Je pense que tu as oublié l'étape avec le pigeon voyageur _Tchize :ptdr:
15/07/2016, 12h46
YOUHANA

1 pièce(s) jointe(s)

Bonjour,

Désolé pour la photo désagréable mais je pouvais vraiment pas faire mieux.
du coup je vous réexplique, la première etape etais de calculer une image bord orienté qui était le résulat d'un atan, puis maintenant je dois calculer une image courbure qui prend la valeur de cette image (bo) dans mon code et quand par exemple le pixel est horizontale il fait la soustraction des deux pixels voisins horzontalement, même chose pour vertical... les conditions que j'ai mis dans mon code du coup le résultat normalement devais être quand par exemple l'image est un carré on affiche que ça (les 4 bords du carré) pas plus.

Pièce jointe 215484

Merci et Bien cordialement,
15/07/2016, 13h17
tchize_

attache tes 2 .jpg que tu utilise dans ton code qu'on puisse voir le problème. Une photo de l'image imrpimée, c'est ridicule et inutilisable pour nous.
15/07/2016, 13h22
tchize_

Au passage, ta description laisse supposer qu'il y a deux image: l'image de dont on doit calculer la courbure et l'image d'orientation, qui est la CC.jpg, mais dans ton code, il n'y a qu'une image source.

Donc donne nous une image source et l'image destination que tu veux.
15/07/2016, 13h22
YOUHANA

1 pièce(s) jointe(s)

Pièce jointe 215487
15/07/2016, 13h30
YOUHANA

L'image de départ c'est celle que je viens de vous envoyer, le résultat normalement doit être l'affichage que des 4 bords comme je vous ai montré dans l'image de mauvaise qualité
15/07/2016, 13h58
tchize_

ton code tel que tu nous le montre, pour le moment fait ça: il prend la couleur (hue) d'un point, en fonction de cette couleur il va calculer une moyenne de points environnant. Ton image de départ que tu nous montre, c'est du noir et du blanc, donc le hue vaut toujours 0 à priori, donc ton algo se content de faire une différence entre la gauche et la droite. Comme ton image de départ est très uniforme, cette différence est donc de 0. Donc une image noire à l'arrivée.

Tu nous parle d'un calcul atan pour calculer l'orientation, mais il n'est nulle part dans ton code.

Edit: apparement tu viens de modifier ton post, tout à l'heure c'était un carré noir sur fond blanc, maitenant c'est un truc tout colorié. Donc décidément, je comprends rien à ce qu'il y a au départ et ce que tu dois avoir à l'arrivée.
15/07/2016, 14h22
YOUHANA

Bonjour,
Merci pour votre retour, evidemment ma question est est-ce que je peux calculer la valeurs des pixels voisin sans utiliser les getHSB (je suis vraiment débutante)
et pour la atang c'est l'image que je vous ai montré qui est calculer avec une fonction atan , et en allant de cette image que je dois calculer l'image courbure qui est la difference entre les pixels voisins !!!!
15/07/2016, 14h24
YOUHANA

Oui désole tte à l'heure je me suis trompé, c'est en allant de cette image (la colorié) que l'affichage doit être presque tout noir et que les bords qui sont affichés !
15/07/2016, 15h14
tchize_

tu peux nous décrire concrètement l'algorithme que tu essaie d'implémenter, la procédure qu'il doit suivre? Parce que pour le moment la description que tu donne et le résultat sont tout à fait cohérent entre eux: noir plus noir = noir
15/07/2016, 15h18
YOUHANA

L'algorithme est :

Il parcourt l'image, pour chaque pixel il regarde sa position (vu que c'est un atang) si la position du pixel est horizontal <32 et >224 on met dans la même position la valeur de le difference des deux pixels voisins horizontaux, si ce dernier et vertical >96 et <160 on met dans la même position la valeur de le difference des deux pixels voisins vertical...
15/07/2016, 17h45
tchize_

oui ça c'est ce que ton programme fait, mais visiblement ce n'est pas ce que tu veux réaliser puisque l'image finale ne te convient pas :weird:
15/07/2016, 17h56
YOUHANA

2 pièce(s) jointe(s)

Oui vous pouvez regarder ici le résultat qu'il met les valeurs que je veux qu'il affiche en jaune, et laisse tout l'autre en rouge, du coup si vous arrivez à m'aide à faire en sorte qu'il affiche que les partie jaune ça sera super et je serais rès reconnaissante.

Pièce jointe 215514
25/07/2016, 12h12
YOUHANA

2 pièce(s) jointe(s)

Bonjour,

je reposte ma question on esperant que j'expliquerai mieux. J'ai une image de départ qui est cette image
Pièce jointe 216294

L'image de sortie doit être toute noir sauf les coins (des portes et des fenetres). L'algo a implémenté etait :
calculer une image courbure qui prend la valeur "bo" dans mon code et quand par exemple le pixel est horizontale il fait la soustraction des deux pixels voisins horizontalement, même chose pour vertical ( si le pixel est vertical il doit faire la difference des deux voisins verticaux) ... Quand j'ai implémenté ce code j'ai eu cette image comme résultat
Pièce jointe 216296
Ce qui est correct mais on m'a dit qu'il me manque une condition pour faire disparaitre les lignes (orange dans mon image) et laissé que les zones jaunes.

Cordialement
25/07/2016, 12h18
joel.drigo

Salut,

C'est quoi un pixel vertical ou un pixel horizontal, d'après toi ? Un pixel, c'est un point : il n'y a pas de notion de verticalité ou d'horizontalité.

Pour avoir l'image de départ que je vous ai montré dans le mssgs précédents, c'etais un calcul de bord en utilisant une formule de atang

Code:

bo = (int) (180*(Math.atan(sommeX/sommeY))/Math.PI)

du coup le pixel a un degré non ? et en allant de cette formule que j'ai fais les conditions

Code:

1
2
3
4
5
6
7
8
if (bo<32 || bo>224) //PIXEL HORIZANTAL
			    	   courb = Math.abs(getHSB(monImage.getRGB(i-1,j))[0]-getHSB(monImage.getRGB(i+1,j))[0]);
			       else if (bo>=32 || bo<96)
			    	   courb = (float) ((Math.abs(getHSB(monImage.getRGB(i-1,j+1))[0]-getHSB(monImage.getRGB(i+1,j-1))[0]))/1.414);
			       else if (bo>=96 || bo<160) //PIXEL VERTICAL
			    	   courb = Math.abs(getHSB(monImage.getRGB(i,j-1))[0]-getHSB(monImage.getRGB(i,j+1))[0]);
			       else if (bo>=160 || bo<224)
			    	   courb = (float) ((Math.abs(getHSB(monImage.getRGB(i-1,j-1))[0]-getHSB(monImage.getRGB(i+1,j+1))[0]))/1.414);

Citation:

Envoyé par YOUHANA

Pour avoir l'image de départ que je vous ai montré dans le mssgs précédents, c'etais un calcul de bord en utilisant une formule de atang

Code:

bo = (int) (180*(Math.atan(sommeX/sommeY))/Math.PI)

Non. Tu a évoqué cette histoire de atan au début, on t'a posé la question de savoir où tu l'utilisais, mais tu n'a jamais répondu précisément où cette artangeante intervenait.

Citation:

Envoyé par YOUHANA

du coup le pixel a un degré non ? et en allant de cette formule que j'ai fais les conditions

Je ne vois pas le rapport entre le fait que bo soit calculé par atan et le fait qu'un pixel puisse avoir un degré : ça n'a strictement aucun sens.
Ensuite, dans le code que tu nous montres, bo est calculé par la formule
Code:

1 2 3 float[] currenthsv = getHSB(monImage.getRGB(i, j)); float bo = currenthsv[0] * 360;
Alors, effectivement, la première composante de la couleur dans le modèle HSB correspond à un angle en degré dans un cercle de teintes. Mais le pixel n'a pas d'angle pour autant.

Donc quand la teinte est 0 ou 360, on a du rouge. Rien à voir avec une notion de verticalité par ailleurs. La teinte à 180° est le cyan. La verticale, c'est quoi ? 0°, 360°, ou 180° ? Et encore, ça dépend de l'orientation du cercle (0° pourrait correspondre à l'horizontal vers la droite, ou vers la gauche), et le sens trigonométrique ou inverse.
Et quid des autres angles ? Selon ta définition, je traduis que horizontal, c'est 90, ou 240, ou les deux : que vient faire le 60° (le jaune) et le 160° (un vert, mais pas le primaire), dans cette histoire ?

Par ailleurs, il y a une erreur dans tes tests :
Citation:
Code:

1 2 3 4 5 6 7 8 if (bo<32 || bo>224) //PIXEL HORIZANTAL courb = Math.abs(getHSB(monImage.getRGB(i-1,j))[0]-getHSB(monImage.getRGB(i+1,j))[0]); else if (bo>=32 || bo<96) courb = (float) ((Math.abs(getHSB(monImage.getRGB(i-1,j+1))[0]-getHSB(monImage.getRGB(i+1,j-1))[0]))/1.414); else if (bo>=96 || bo<160) //PIXEL VERTICAL courb = Math.abs(getHSB(monImage.getRGB(i,j-1))[0]-getHSB(monImage.getRGB(i,j+1))[0]); else if (bo>=160 || bo<224) courb = (float) ((Math.abs(getHSB(monImage.getRGB(i-1,j-1))[0]-getHSB(monImage.getRGB(i+1,j+1))[0]))/1.414);
Il faut des && (sauf pour le premier), parce que tout ce n'est pas inférieur à 32 et supérieur à 224, et forcément supérieur ou égal à 32 et inférieur ou égale à 224, donc au moins supérieur ou égale à 32, donc traité par le deuxième if, les troisième et quatrième n'étant jamais atteint.

Par ailleurs, je remarque que tu a ajouté une division par 1.414 (racine carrée de 2, je suppose ?). Quand tu modifies ton code, ce serait pas mal de nous indiquer ce nouveau code, de manière à ce qu'on évite de casser la tête à déterminer où sont les erreurs dans un code qui n'existe plus.

Maintenant, ta question semble plus algorithmique que Java.

01/08/2016, 16h57
YOUHANA
Bonjour,
Est ce qu'il y'a moyen d'ecrire mon algorithme sans utiliser le getHSB ?
Genre comme ça par exemple
Code:

1 2 int bo = outImgbonb.getRGB(x,y); courb = Math.abs(outImgbonb.getRGB(i-1,j))[0]-(outImgbonb.getRGB(i+1,j))[0]);
Mais ici j'ai cet erreur "The type of the expression must be an array type but it resolved to int"
01/08/2016, 17h46
joel.drigo

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:

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).
01/08/2016, 19h38
YOUHANA
Oui , c'est exactement ce que je voulais, j'ai eu mon résultat mais du coup je veux faire un test
Code:

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 ?
01/08/2016, 19h54
joel.drigo

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.

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

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:

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.

01/08/2016, 21h04
YOUHANA

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 !!!
01/08/2016, 21h36
joel.drigo
Qu'est-ce que tu veux que je réponde à ça hors contexte ?

A part : pour tester un booléen :
Code:

1 2 3 4 boolean variable = methodeQuiDetermineLaValeurDuBooleen(); if ( variable ) { // faire un truc }
02/08/2016, 09h32
YOUHANA

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) !!!
02/08/2016, 09h36
joel.drigo

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

C'est ça le code qui affiche mon pixel

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
 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()); 
			   }}

02/08/2016, 09h53
joel.drigo
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:

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).
02/08/2016, 10h06
YOUHANA
Bien entendu !
Du coup j'ai fais
Code:

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

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:

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:

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 
 
                                        }
 
			   }}

02/08/2016, 10h42
YOUHANA

1 pièce(s) jointe(s)

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:

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

Pièce jointe 216990
02/08/2016, 11h22
joel.drigo
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:

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

1 pièce(s) jointe(s)

Citation:

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 :

Pièce jointe 216998

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:

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.

02/08/2016, 11h45
YOUHANA

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 :roll: ?
02/08/2016, 12h03
joel.drigo

3 pièce(s) jointe(s)

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 ?

Pièce jointe 217000

Et dans celle-là :

Pièce jointe 217003

Ou encore dans celle-là :

Pièce jointe 217002

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.