Génération partielle d'une BufferedImage

Version imprimable

1 pièce(s) jointe(s)

Dans le cadre d'un projet pour la spécialité ISN en terminale, je me suis lancé dans la programmation d'un jeu avec une interface graphique:
Pièce jointe 202785

J'ai crée des actionListener pour chaque boutons dans lesquels j'ai des actions de dessins sur la bufferedImage. J'aimerais maintenant faire en sorte de re-générer la bufferedImage que j'ai généré (les cases colorées donc) de manière aléatoire plus tôt (via la class Cases), mais seulement sur certaines parties de l'image. Existe t-il une méthode permettant de générer une BufferedImage en excluant certaines parties de l'image ?

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
import javax.swing.*;
 
import java.io.*;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.util.Random;
 
 
 
@SuppressWarnings("serial")
 
public class Cases extends JPanel {
 
	final static BufferedImage image = 
            new BufferedImage(706, 750, BufferedImage.TYPE_INT_RGB);
			Graphics g = (Graphics)image.createGraphics();
 
		  int x1=0,y1=0,x4=1,y4=1,x5=1;
 
	public Cases() {
			  g.setColor(Color.BLACK);
			  while (x1<=706) {
			  g.drawLine(x1, 0, x1, 600);
			  x1+=25;
			  }
			  while (y1<=600) {
			  g.drawLine(0, y1, 707, y1);
			  y1+=25;
			  }
			  while (x5<=706) {
			  paintAleat(g, x4, y4, 23, 23);
			  x4+=25;
			  x5+=25;
			  }
			  g.dispose();
}
	public void paintComponent(Graphics g) {
        g.drawImage(image, 0, 0, null);
}
 
	   public static BufferedImage getImage() {
	       return image;
	   }
 
 
	public static void paintAleat(Graphics g, int x2, int y2, int x3, int y3) {
		while (y2<600) {
			Random r = new Random();
			int valeurMin = 1, valeurMax = 6;
			int nr = valeurMin + r.nextInt(valeurMax - valeurMin);
			if (nr==1) {
				g.setColor(Color.blue);
			}
			if (nr==2) {
				g.setColor(Color.red);
			}
			if (nr==3) {
				g.setColor(Color.yellow);
			}
			if (nr==4) {
				g.setColor(Color.green);
			}
			if (nr==5) {
				g.setColor(new Color( 213, 128, 0));
			}
	    	g.drawRect(x2, y2, x3, y3);
	    	g.fillRect(x2, y2, x3, y3);
	    	y2+=25;
		}
    }	
}

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
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
import javax.swing.*;
import java.awt.Point;
import java.io.*;
import java.util.ArrayList;
import java.awt.Color;
import java.awt.Graphics;
import java.util.List;
import java.awt.image.BufferedImage;
 
public class ListenerBleuC extends JPanel{
 
    private final BufferedImage image;
	  int xp1=1, xp2=1;
	  int xpg1=1, xph1=1, xpb1=1, xpd1=1, xpg2=1, xpd2=1, xph2=1, xpb2=1;
	  int xg1=xpg1-25, xg2=xpg2;
	  int xd1=xpd1+25, xd2=xpd2;
	  int xh1=xph1, xh2=xph2-25;
	  int xb1=xpb1, xb2=xpb2+25;
      List<Point> tabcp = new ArrayList<>();
	  int cppd = -16776961;
 
    public ListenerBleuC(BufferedImage image) {
        this.image=image;
        System.out.println("HelloB");
        tabcp.clear();
        eerc();
        for(int i=0; i<tabcp.size(); i++) {
            System.out.print(tabcp.get(i).x+" "+tabcp.get(i).y+" ");       
        }
        System.out.println();
	}
 
	public void paintComponent(Graphics g) {
        g.drawImage(image, 0, 0, null);
	}
 
	public static int detectB; {
 
	}
 
	public void eerc() {
        Graphics g = (Graphics)image.getGraphics();
        tabcp.add(new Point(xp1,xp2));
 
        Color cpp= new Color(image.getRGB(xp1, xp2));
		 int pr=cpp.getRed();
	     int pg=cpp.getGreen();
	     int pb=cpp.getBlue();
		 int cpp1 = new Color(pr,pg,pb).getRGB();
 
		 if (xg1 >=0) {
			 Color cpg = new Color(image.getRGB(xg1, xg2));
			 int pr2=cpg.getRed();
			 int pg2=cpg.getGreen();
			 int pb2=cpg.getBlue();
			 int cpg1 = new Color(pr2,pg2,pb2).getRGB();
 
		 while (cpg1 == cppd) {
		 Color cpgg = new Color(image.getRGB(xg1, xg2));
		 int pr22=cpgg.getRed();
		 int pg22=cpgg.getGreen();
		 int pb22=cpgg.getBlue();
		 int cpg11 = new Color(pr22,pg22,pb22).getRGB();
		 if (cpg11 != cppd) {
			 break;
		 }
	 	 g.setColor(new Color(pr2,pg2,pb2));
	 	 g.fillRect(xpg1, xpg2, 24, 24);
	 	 g.fillRect(xg1, xg2, 24, 24);
		 tabcp.add(new Point(xg1, xg2));
	 	 xpg1-=25;
	 	 xg1-=25;
	 	 cpg1=cpg11;
		 }
		 }
 
		 if (xh2 >=0) {
			 Color cph = new Color(image.getRGB(xh1, xh2));
			 int pr3=cph.getRed();
			 int pg3=cph.getGreen();
			 int pb3=cph.getBlue();
			 int cph1 = new Color(pr3,pg3,pb3).getRGB();
 
			 while (cph1 ==cppd) {
				 Color cphh = new Color(image.getRGB(xh1,xh2));
				 int pr33=cphh.getRed();
				 int pg33=cphh.getGreen();
				 int pb33=cphh.getBlue();
				 int cph11 = new Color(pr33,pg33,pb33).getRGB();
 
				 if (cph11 != cppd) {
					 break;
				 }
			 		g.setColor(new Color(pr3,pg3,pb3));
			 		g.fillRect(xph1, xph2, 24, 24);
			 		g.fillRect(xh1, xh2, 24, 24);
					tabcp.add(new Point(xh1, xh2));
			 		xph2-=25;
			 		xh2-=25;
			 		cph1=cph11;
			 }
		 }
 
		 if (xb2 >=0) {
			 Color cpb = new Color(image.getRGB(xb1, xb2));
			 int pr4=cpb.getRed();
			 int pg4=cpb.getGreen();
			 int pb4=cpb.getBlue();
			 int cpb1 = new Color(pr4,pg4,pb4).getRGB();
 
			 while (cpb1== cppd) {
				 Color cpbb = new Color(image.getRGB(xb1, xb2));
				 int pr44=cpbb.getRed();
				 int pg44=cpbb.getGreen();
				 int pb44=cpbb.getBlue();
				 int cpb11 = new Color(pr44,pg44,pb44).getRGB();
 
				 if (cpb11 != cppd) {
					 break;
				 }
					 g.setColor(new Color(pr4,pg4,pb4));
					 g.fillRect(xpb1, xpb2, 24, 24);
					 g.fillRect(xb1, xb2, 24, 24);
					 tabcp.add(new Point(xb1, xb2));
					 xpb2+=25;
					 xb2+=25;
					 cpb1=cpb11;
			 }
		 }
 
		 Color cpd = new Color(image.getRGB(xd1, xd2));
		 int pr1=cpd.getRed();
	     int pg1=cpd.getGreen();
	     int pb1=cpd.getBlue();
		 int cpd1 = new Color(pr1,pg1,pb1).getRGB();
 
		 while (cpd1==cppd) {
			 Color cpdd = new Color(image.getRGB(xd1, xd2));
			 int pr11=cpdd.getRed();
		     int pg11=cpdd.getGreen();
		     int pb11=cpdd.getBlue();
			 int cpd11 = new Color(pr11,pg11,pb11).getRGB();
 
			 if (cpd11 != cppd) {
				 break;
			 }
				 g.setColor(new Color(pr1,pg1,pb1));
				 g.fillRect(xp1, xpd2, 24, 24);
				 g.fillRect(xd1, xd2, 24, 24);
				 tabcp.add(new Point(xd1, xd2));
				 xpd1+=25;
				 xd1+=25;
				 cpd1=cpd11;
		 }
	}
 
}

Merci d'avance.

03/03/2016, 20h48
joel.drigo
Salut,

Premièrement, tu peux toujours redessiner sur une image existante. Il suffit de créer un contexte graphique et de dessiner dedans :
Code:

1 2 3 4 5 6 Graphics2D graphics = image.createGraphics(); // ici tu dessines par dessus ce qu'il y avait dans l'image graphics.draw... graphics.dispose();
Ensuite, si tu dessines que sur une partie, tu ne redessines que cette partie bien sûr. Si tu veux être sûr de ne pas risquer de dessiner en dehors d'une certaine zone, tu peux utiliser le clipping.

Code:

graphics.setClip(50,50,100,100);

Tout ce qui sera dessiné, après cette ligne, en dehors du rectangle 50,50 100,100 ne sera pas visible. Tu peux même faire une ligne de 140,0 à 160 200, elle sera coupée aux extrémitées (seule la partie qui superpose le rectangle sera dessinée).
Il y a d'autres variantes de setClip (voir setClipRect pour cliper sur un Rectangle, ou setClip(Shape) pour clipper sur n'importe quelle forme (un disque, une étoile, peu importe, même des formes avec un "trou" au besoin, une lettre de l'alphabet...,). Il y'a moyen également de faire du clipping avec les Composites si tu as besoin de le faire très vite, mais c'est un peu moins intuitif.

Tu peux également dessiner la partie qui t'intéresse dans une autre image, puis dessiner cette image par dessus la première. En utilisant le type BufferedImage.TYPE_ARGB tu pourras même faire une image transparent, et donc dessiner une image non rectangulaire par dessus l'autre image.

Merci pour ta réponse.

J'ai donc suivis la piste que tu m'a donné sur le setClip, seulement quand j'ai définis le setClip une première fois, je ne vois pas comment ajouter une autre zone à celle que j'ai déjà définie. Je souhaite définir ma zone de dessin sur une première zone + une autre zone que j'aurai définie plus tard, est-ce que c'est possible ?

Voici ce que j'ai actuellement:

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
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
import javax.swing.*;
 
import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.awt.*;
import java.awt.geom.Area;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
 
public class ListenerVertC extends JPanel {
 
	private final BufferedImage image;
	  int xp1=1, xp2=1;
	  int xpg1=1, xph1=1, xpb1=1, xpd1=1, xpg2=1, xpd2=1, xph2=1, xpb2=1;
	  int xg1=xpg1-25, xg2=xpg2;
	  int xd1=xpd1+25, xd2=xpd2;
	  int xh1=xph1, xh2=xph2-25; 
	  int xb1=xpb1, xb2=xpb2+25;
	  List<Point> tabcp = new ArrayList<>();
	  Shape rectangleEntier = new Rectangle2D.Float(0,0,706,600);
	  int cppd = -16711936;
 
	public ListenerVertC(BufferedImage image) {
		this.image=image;
		System.out.println("HelloV");
		tabcp.clear();
        eerc();
        for(int i=0; i<tabcp.size(); i++) {
            System.out.print(tabcp.get(i).x+" "+tabcp.get(i).y+" ");       
        }
        System.out.println();
	}
 
	public void paintComponent(Graphics g) {
		g.drawImage(image,0,0,null);
	}
 
 
	public void eerc() {
		Graphics g = (Graphics)image.getGraphics();
		final Graphics2D g2 = image.createGraphics();
        tabcp.add(new Point(xp1,xp2));
	 	Shape rectangle = new Rectangle2D.Float(xp1,xp2,25,25);
	 	Area outsidep = OutsideRect((Rectangle2D) rectangle);
	 	g2.setClip(outsidep);
 
 
        Color cpp= new Color(image.getRGB(xp1, xp2));
		 int pr=cpp.getRed();
	     int pg=cpp.getGreen();
	     int pb=cpp.getBlue();
		 @SuppressWarnings("unused")
		int cpp1 = new Color(pr,pg,pb).getRGB();
 
		 if (xg1 >=0) {
			 Color cpg = new Color(image.getRGB(xg1, xg2));
			 int pr2=cpg.getRed();
			 int pg2=cpg.getGreen();
			 int pb2=cpg.getBlue();
			 int cpg1 = new Color(pr2,pg2,pb2).getRGB();
 
		 while (cpg1 == cppd) {
		 Color cpgg = new Color(image.getRGB(xg1, xg2));
		 int pr22=cpgg.getRed();
		 int pg22=cpgg.getGreen();
		 int pb22=cpgg.getBlue();
		 int cpg11 = new Color(pr22,pg22,pb22).getRGB();
		 if (cpg11 != cppd) {
			 break;
		 }
	 	 g.setColor(new Color(pr2,pg2,pb2));
	 	 g.fillRect(xpg1, xpg2, 24, 24);
	 	 g.fillRect(xg1, xg2, 24, 24);
		 tabcp.add(new Point(xg1, xg2));
	 	 Shape rectangleg = new Rectangle2D.Float(xg1,xg2,24,24);
	 	 Area outsideg = OutsideRect((Rectangle2D) rectangleg);
	 	 //g2.setClip(outsideg);
	 	 xpg1-=25;
	 	 xg1-=25;
	 	 cpg1=cpg11;
		 }
		 }
 
		 if (xh2 >=0) {
			 Color cph = new Color(image.getRGB(xh1, xh2));
			 int pr3=cph.getRed();
			 int pg3=cph.getGreen();
			 int pb3=cph.getBlue();
			 int cph1 = new Color(pr3,pg3,pb3).getRGB();
 
			 while (cph1 ==cppd) {
				 Color cphh = new Color(image.getRGB(xh1,xh2));
				 int pr33=cphh.getRed();
				 int pg33=cphh.getGreen();
				 int pb33=cphh.getBlue();
				 int cph11 = new Color(pr33,pg33,pb33).getRGB();
 
				 if (cph11 != cppd) {
					 break;
				 }
			 		g.setColor(new Color(pr3,pg3,pb3));
			 		g.fillRect(xph1, xph2, 24, 24);
			 		g.fillRect(xh1, xh2, 24, 24);
					tabcp.add(new Point(xh1, xh2));
				 	Shape rectangleh = new Rectangle2D.Float(xh1,xh2,24,24);
				 	Area outsideh = OutsideRect((Rectangle2D) rectangleh);
				 	//g2.setClip(outsideh);
			 		xph2-=25;
			 		xh2-=25;
			 		cph1=cph11;
			 }
		 }
 
		 if (xb2 >=0) {
			 Color cpb = new Color(image.getRGB(xb1, xb2));
			 int pr4=cpb.getRed();
			 int pg4=cpb.getGreen();
			 int pb4=cpb.getBlue();
			 int cpb1 = new Color(pr4,pg4,pb4).getRGB();
 
			 while (cpb1== cppd) {
				 Color cpbb = new Color(image.getRGB(xb1, xb2));
				 int pr44=cpbb.getRed();
				 int pg44=cpbb.getGreen();
				 int pb44=cpbb.getBlue();
				 int cpb11 = new Color(pr44,pg44,pb44).getRGB();
 
				 if (cpb11 != cppd) {
					 break;
				 }
					 g.setColor(new Color(pr4,pg4,pb4));
					 g.fillRect(xpb1, xpb2, 24, 24);
					 g.fillRect(xb1, xb2, 24, 24);
					 tabcp.add(new Point(xb1, xb2));
				 	 Shape rectangleb = new Rectangle2D.Float(xb1,xb2,24,24);
				 	 Area outsideb = OutsideRect((Rectangle2D) rectangleb);
				 	 //g2.setClip(outsideb);
					 xpb2+=25;
					 xb2+=25;
					 cpb1=cpb11;
			 }
		 }
 
		 Color cpd = new Color(image.getRGB(xd1, xd2));
		 int pr1=cpd.getRed();
	     int pg1=cpd.getGreen();
	     int pb1=cpd.getBlue();
		 int cpd1 = new Color(pr1,pg1,pb1).getRGB();
 
		 while (cpd1==cppd) {
			 Color cpdd = new Color(image.getRGB(xd1, xd2));
			 int pr11=cpdd.getRed();
		     int pg11=cpdd.getGreen();
		     int pb11=cpdd.getBlue();
			 int cpd11 = new Color(pr11,pg11,pb11).getRGB();
 
			 if (cpd11 != cppd) {
				 break;
			 }
				 g.setColor(new Color(pr1,pg1,pb1));
				 g.fillRect(xp1, xpd2, 24, 24);
				 g.fillRect(xd1, xd2, 24, 24);
				 tabcp.add(new Point(xd1, xd2));
			 	 Shape rectangled = new Rectangle2D.Float(xd1,xd2,24,24);
			 	 Area outsided = OutsideRect((Rectangle2D) rectangled);
			 	 //g2.setClip(outsided);
				 xpd1+=25;
				 xd1+=25;
				 cpd1=cpd11;
		 }
	}
    private Area OutsideRect(Rectangle2D r) {
    	Area outside = new Area(rectangleEntier);
    	outside.subtract(new Area(r));
    	return outside;
    }
}

J'ai sélectionné toute la zone de dessin, puis j'ai retiré la zone que je ne veut pas dessiner, pour ensuite définir la zone de dessin avec setClip. Au début, j'ai mis un premier setClip sur l'area "outsidep" mais lorsque que je veut définir un second setClip, la zone de dessin est toujours celle définie en dernier.

setClip() définit une zone qui limite le dessin dans celle-ci. Si tu appelles setClip() une seconde fois, ça définit une autre zone. Tu peux dessiner dans la première zone avant de définir la seconde, puis dessiner dans la seconde. Tu peux refaire ça autant de fois que nécessaire.

Exemple :
Code:

1 2 3 4 5 6 7 graphics.setClip(0,0,50,50); //on dessine ici dans le carré 0,0,50,50 graphics.setClip(50,0,50,50; //on dessine ici dans le carré à la droite du premier graphics.setClip(100,0,50,50; //on dessine ici dans le carré à la droite du second // etc
Si tu as besoin de définir des zones non rectangulaires, il faut construire ces zones à part. Il y a différents moyens de le faire (Path2D par exemple pour faire un polygone quelconque). Un moyen assez simple est d'utiliser la classe java.awt.geom.Area, qui permet de combiner des formes, par ajout ou par différence.

Par exemple, pour dessiner partout dans le carré 0,0,100,100, sauf dans un carré au milieu de celui-ci :
Code:

1 2 3 Area area = new Area(new Rectangle(0,0,100,100)); area.subtract(new Area(new Rectangle(25,25,50,50))); graphics.setClip(area);
Pour dessiner dans une croix :
Code:

1 2 3 Area area = new Area(new Rectangle(0,25,100,50)); area.add(new Area(new Rectangle(0,25,100,50))); graphics.setClip(area);
Tu as la possiblité de connaitre le clipping actuel du contexte graphique par la méthode getClip(). Ainsi, tu peux écrire :
Code:

1 2 3 Area area = new Area( graphics.getClip() ); area.add(new Area(new Rectangle(0,25,100,50))); graphics.setClip(area);
Ce qui ajoute un rectangle au clipping actuel.

Sinon, il y a également la méthode clipRect() (ou clip()) de la classe Graphics2D, qui permet de faire une intersection entre le clipping actuel et un nouveau clipping.

04/03/2016, 00h06
KoupaXII

Au vu de l'heure, je m'y pencherai demain et je répondrai ici en cas de problème.

Merci pour ta réponse encore une fois.

J'ai réussi à obtenir ce que je voulais grâce aux Area, merci !

J'aurais une dernière question:

J'ai une class nommée Cases VV

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
import javax.swing.*;
 
import java.io.*;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.util.Random;
 
 
 
@SuppressWarnings("serial")
 
public class Cases extends JPanel {
 
	final static BufferedImage image = 
            new BufferedImage(706, 750, BufferedImage.TYPE_INT_RGB);
			Graphics g = (Graphics)image.createGraphics();
 
		  int x1=0,y1=0,x4=1,y4=1,x5=1;
 
	public Cases() {
			  g.setColor(Color.BLACK);
			  while (x1<=706) {
			  g.drawLine(x1, 0, x1, 600);
			  x1+=25;
			  }
			  while (y1<=600) {
			  g.drawLine(0, y1, 707, y1);
			  y1+=25;
			  }
			  while (x5<=706) {
			  paintAleat(g, x4, y4, 23, 23);
			  x4+=25;
			  x5+=25;
			  }
			  g.dispose();
}
	public void paintComponent(Graphics g) {
        g.drawImage(image, 0, 0, null);
}
 
	   public static BufferedImage getImage() {
	       return image;
	   }
 
 
	public static void paintAleat(Graphics g, int x2, int y2, int x3, int y3) {
		while (y2<600) {
			Random r = new Random();
			int valeurMin = 1, valeurMax = 6;
			int nr = valeurMin + r.nextInt(valeurMax - valeurMin);
			if (nr==1) {
				g.setColor(Color.blue);
			}
			if (nr==2) {
				g.setColor(Color.red);
			}
			if (nr==3) {
				g.setColor(Color.yellow);
			}
			if (nr==4) {
				g.setColor(Color.green);
			}
			if (nr==5) {
				g.setColor(new Color( 213, 128, 0));
			}
	    	g.drawRect(x2, y2, x3, y3);
	    	g.fillRect(x2, y2, x3, y3);
	    	y2+=25;
		}
    }	
}

J'aimerais faire appel à cette class avec les graphics2D g2 que j'ai crée pour l'image plus tôt pour refaire tous les dessins de la class Cases dans mon action Listener sachant que j'ai définit la zone de dessin de g2 avec setclip (donc sans écraser une partie du dessin actuel). Comment devrait-je m'y prendre ?

Tout d'abord, la façon correcte d'écrire la classe Cases est (il me semble l'avoir déjà indiqué dans une autre discussion) :
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 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 @SuppressWarnings("serial") public class Cases extends JPanel { final static BufferedImage IMAGE = createImage(); private static BufferedImage createImage() { BufferedImage image = new BufferedImage(706, 750, BufferedImage.TYPE_INT_RGB); Graphics g = (Graphics) image.createGraphics(); try { int x1 = 0, y1 = 0, x4 = 1, y4 = 1, x5 = 1; g.setColor(Color.BLACK); while (x1 <= 706) { g.drawLine(x1, 0, x1, 600); x1 += 25; } while (y1 <= 600) { g.drawLine(0, y1, 707, y1); y1 += 25; } while (x5 <= 706) { paintAleat(g, x4, y4, 23, 23); x4 += 25; x5 += 25; } } finally { g.dispose(); } return image; } public Cases() { } public void paintComponent(Graphics g) { g.drawImage(IMAGE, 0, 0, null); } public static BufferedImage getImage() { return IMAGE; } public static void paintAleat(Graphics g, int x2, int y2, int x3, int y3) { while (y2 < 600) { Random r = new Random(); int valeurMin = 1, valeurMax = 6; int nr = valeurMin + r.nextInt(valeurMax - valeurMin); if (nr == 1) { g.setColor(Color.blue); } if (nr == 2) { g.setColor(Color.red); } if (nr == 3) { g.setColor(Color.yellow); } if (nr == 4) { g.setColor(Color.green); } if (nr == 5) { g.setColor(new Color(213, 128, 0)); } g.drawRect(x2, y2, x3, y3); g.fillRect(x2, y2, x3, y3); y2 += 25; } } }
Ce qui évite de conserver des variables qui ne servent à rien en mémoire. Ensuite il est absurde d'initialiser une variable statique dans le constructeur d'une classe : le constructeur est exécuté pour chaque instance de la classe alors que la variable statique n'existe qu'en un seul exemplaire et est initialisée avant même toute exécution de constructeur. Par ailleurs, le contexte graphique (g) étant disposé, une seconde exécution est exclue.

Ensuite, au sujet de ta question, je ne comprends pas très bien :

de quelle image s'agit-il quand tu parles d'image créée plus tôt ?
où se trouve l'ActionListener dont tu parles ? Quels sont les liens entre l'instance d'ActionListener et la ou les instances de Cases ?
Où est créé le Graphics2D dont tu parles ? Est-ce que c'est celui que tu créés pour faire le dessin partiel de la question initiale ?
Quelle est au juste la question ? Qu'est ce que tu cherches à faire ?
Si le but est qu'un code dans un ActionListener modifie l'image de la classe Cases, fait une méthode dans la classe Cases, et appelle cette méthode dans l'ActionListener. Cette méthode crééra le Graphics2D et dessinera dedans. Au besoin, passer des paramètres à cette méthode.

2 pièce(s) jointe(s)

Effectivement, tu avait déjà fait la remarque pour les variables, j'ai du oublier de la modifier, c'est chose faite désormais.
Pour ce qui est de la question, j'aimerais en fait ré-éxecuter le code pour la génération aléatoire des cases et des couleurs situé dans la class Cases dans un de mon actionListener afin que lorsque l'utilisateur appuie sur le bouton associé à cet actionListener, le code de l'actionListener s'effectue, puis qu'il re-génère l'image de départ (de la class Cases) tout en limitant la zone de dessin à certaines cases.
Concrètement avec un exemple:

Si j'ai ce pattern dans une image:
Pièce jointe 202943

Je souhaite re-générer une image aléatoire tout en gardant ce pattern dans l'autre code:
Pièce jointe 202944

Voici le code d'un des actionListener d'un bouton (où est situé le Graphics2D, je veut m'en servir pour re-générer des cases de façon aléatoire en tout en limitant certaines zones avec le setClip):

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
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
import javax.swing.*;
 
import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.awt.*;
import java.awt.geom.Area;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
 
public class ListenerVertC extends JPanel {
 
	private final BufferedImage image;
	  int xp1=1, xp2=1;
	  int xpg1=1, xph1=1, xpb1=1, xpd1=1, xpg2=1, xpd2=1, xph2=1, xpb2=1;
	  int xg1=xpg1-25, xg2=xpg2;
	  int xd1=xpd1+25, xd2=xpd2;
	  int xh1=xph1, xh2=xph2-25; 
	  int xb1=xpb1, xb2=xpb2+25;
	  List<Point> tabcp = new ArrayList<>();
	  int cppd = -16711936;
 
	public ListenerVertC(BufferedImage image) {
		this.image=image;
		Graphics g = (Graphics)image.getGraphics();
		Graphics2D g2 = image.createGraphics();
		System.out.println("HelloV");
		tabcp.clear();
        eerc(g2);
        for(int i=0; i<tabcp.size(); i++) {
            System.out.print(tabcp.get(i).x+" "+tabcp.get(i).y+" ");       
        }
        System.out.println();
	}
 
	public void paintComponent(Graphics g) {
		g.drawImage(image,0,0,null);
	}
 
 
	public void eerc(Graphics g2) {
		Graphics g = (Graphics)image.getGraphics();
        tabcp.add(new Point(xp1,xp2));
	 	Shape rectangledepart = new Rectangle2D.Float(xp1,xp2,25,25);
		Shape rectangleEntier = new Rectangle2D.Float(0,0,706,600);
	 	Area outside = new Area(rectangleEntier);
    	outside.subtract(new Area(rectangledepart));
 
        Color cpp= new Color(image.getRGB(xp1, xp2));
		 int pr=cpp.getRed();
	     int pg=cpp.getGreen();
	     int pb=cpp.getBlue();
		 @SuppressWarnings("unused")
		int cpp1 = new Color(pr,pg,pb).getRGB();
 
		 if (xg1 >=0) {
			 Color cpg = new Color(image.getRGB(xg1, xg2));
			 int pr2=cpg.getRed();
			 int pg2=cpg.getGreen();
			 int pb2=cpg.getBlue();
			 int cpg1 = new Color(pr2,pg2,pb2).getRGB();
 
		 while (cpg1 == cppd) {
		 Color cpgg = new Color(image.getRGB(xg1, xg2));
		 int pr22=cpgg.getRed();
		 int pg22=cpgg.getGreen();
		 int pb22=cpgg.getBlue();
		 int cpg11 = new Color(pr22,pg22,pb22).getRGB();
		 if (cpg11 != cppd) {
			 break;
		 }
	 	 g.setColor(new Color(pr2,pg2,pb2));
	 	 g.fillRect(xpg1, xpg2, 24, 24);
	 	 g.fillRect(xg1, xg2, 24, 24);
		 tabcp.add(new Point(xg1, xg2));
	 	 Shape rectangleg = new Rectangle2D.Float(xg1,xg2,24,24);
	 	 outside = OutsideRect((Rectangle2D) rectangleg, outside);
	 	 xpg1-=25;
	 	 xg1-=25;
	 	 cpg1=cpg11;
		 }
		 }
 
		 if (xh2 >=0) {
			 Color cph = new Color(image.getRGB(xh1, xh2));
			 int pr3=cph.getRed();
			 int pg3=cph.getGreen();
			 int pb3=cph.getBlue();
			 int cph1 = new Color(pr3,pg3,pb3).getRGB();
 
			 while (cph1 ==cppd) {
				 Color cphh = new Color(image.getRGB(xh1,xh2));
				 int pr33=cphh.getRed();
				 int pg33=cphh.getGreen();
				 int pb33=cphh.getBlue();
				 int cph11 = new Color(pr33,pg33,pb33).getRGB();
 
				 if (cph11 != cppd) {
					 break;
				 }
			 		g.setColor(new Color(pr3,pg3,pb3));
			 		g.fillRect(xph1, xph2, 24, 24);
			 		g.fillRect(xh1, xh2, 24, 24);
					tabcp.add(new Point(xh1, xh2));
				 	Shape rectangleh = new Rectangle2D.Float(xh1,xh2,24,24);
				 	outside = OutsideRect((Rectangle2D) rectangleh, outside);
			 		xph2-=25;
			 		xh2-=25;
			 		cph1=cph11;
			 }
		 }
 
		 if (xb2 >=0) {
			 Color cpb = new Color(image.getRGB(xb1, xb2));
			 int pr4=cpb.getRed();
			 int pg4=cpb.getGreen();
			 int pb4=cpb.getBlue();
			 int cpb1 = new Color(pr4,pg4,pb4).getRGB();
 
			 while (cpb1== cppd) {
				 Color cpbb = new Color(image.getRGB(xb1, xb2));
				 int pr44=cpbb.getRed();
				 int pg44=cpbb.getGreen();
				 int pb44=cpbb.getBlue();
				 int cpb11 = new Color(pr44,pg44,pb44).getRGB();
 
				 if (cpb11 != cppd) {
					 break;
				 }
					 g.setColor(new Color(pr4,pg4,pb4));
					 g.fillRect(xpb1, xpb2, 24, 24);
					 g.fillRect(xb1, xb2, 24, 24);
					 tabcp.add(new Point(xb1, xb2));
				 	 Shape rectangleb = new Rectangle2D.Float(xb1,xb2,24,24);
				 	 outside = OutsideRect((Rectangle2D) rectangleb, outside);
					 xpb2+=25;
					 xb2+=25;
					 cpb1=cpb11;
			 }
		 }
 
		 Color cpd = new Color(image.getRGB(xd1, xd2));
		 int pr1=cpd.getRed();
	     int pg1=cpd.getGreen();
	     int pb1=cpd.getBlue();
		 int cpd1 = new Color(pr1,pg1,pb1).getRGB();
 
		 while (cpd1==cppd) {
			 Color cpdd = new Color(image.getRGB(xd1, xd2));
			 int pr11=cpdd.getRed();
		     int pg11=cpdd.getGreen();
		     int pb11=cpdd.getBlue();
			 int cpd11 = new Color(pr11,pg11,pb11).getRGB();
 
			 if (cpd11 != cppd) {
				 break;
			 }
				 g.setColor(new Color(pr1,pg1,pb1));
				 g.fillRect(xp1, xpd2, 24, 24);
				 g.fillRect(xd1, xd2, 24, 24);
				 tabcp.add(new Point(xd1, xd2));
			 	 Shape rectangled = new Rectangle2D.Float(xd1,xd2,24,24);
			 	 outside = OutsideRect((Rectangle2D) rectangled, outside);
				 xpd1+=25;
				 xd1+=25;
				 cpd1=cpd11;
		 }
		 g2.setClip(outside);
	}
    private Area OutsideRect(Rectangle2D r, Area c) {
    	c.subtract(new Area(r));
    	return c;
    }
}

Pour le lien entre l'actionListener et Cases, c'est dans un autre fichier class dans lequel je définis la fenêtre et les boutons/ActionListener:

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
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
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener; 
import java.awt.image.BufferedImage;
import javax.swing.*;
import java.io.*;
import java.awt.*;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JButton;
 
@SuppressWarnings("serial")
public class Fenetre extends JFrame {
 
	Cases cases = new Cases();
	public Fenetre(){
		this.setTitle("Colonisation");
	    this.setSize(706, 750);
	    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	    this.setLocationRelativeTo(null);
	    this.setResizable(false);
 
	    JButton bleu = new BB("Bleu");
	    JButton vert = new BV("Vert");
	    JButton orange = new BO("Orange");
	    JButton rouge = new BR("Rouge");
	    JButton jaune = new BJ("Jaune");
	    JPanel content = new JPanel(new BorderLayout());
	    JPanel contentSouth = new JPanel();
 
 
 
	    bleu.addActionListener(new ListenerBleu());
	    vert.addActionListener(new ListenerVert());
	    orange.addActionListener(new ListenerOrange());
	    rouge.addActionListener(new ListenerRouge());
	    jaune.addActionListener(new ListenerJaune());
 
	    contentSouth.add(rouge);
	    contentSouth.add(bleu);
	    contentSouth.add(vert);
	    contentSouth.add(jaune);
	    contentSouth.add(orange);
	    content.add(contentSouth,BorderLayout.SOUTH);
	    content.add(cases,BorderLayout.CENTER);
 
 
	    this.add(content);
	    this.setVisible(true);
  }
 
	class ListenerBleu extends JFrame implements ActionListener {
 
		public void actionPerformed(ActionEvent arg0) {
			ListenerBleuC LB = new ListenerBleuC(Cases.getImage());
			cases.repaint();
		}
	}
 
	class ListenerVert extends JFrame implements ActionListener {
 
		public void actionPerformed(ActionEvent arg0) {
			ListenerVertC LV = new ListenerVertC(Cases.getImage());
			cases.repaint();
		}
	}
 
	class ListenerOrange extends JFrame implements ActionListener {
 
		public void actionPerformed(ActionEvent arg0) {
			ListenerOrangeC LO = new ListenerOrangeC(Cases.getImage());
			cases.repaint();
		}
	}
 
	class ListenerJaune extends JFrame implements ActionListener {
 
		public void actionPerformed(ActionEvent arg0) {
			ListenerJauneC LJ = new ListenerJauneC(Cases.getImage());
			cases.repaint();
		}
	}
 
	class ListenerRouge extends JFrame implements ActionListener {
 
		public void actionPerformed(ActionEvent arg0) {
			ListenerRougeC LR = new ListenerRougeC(Cases.getImage());
			cases.repaint();
		}
	}
 
}

Merci de prendre le temps de m'aider

En résumé, tu as une image de base, et sur différentes actions, tu veux dessiner un truc dessus, mais en repartant toujours de l'image de base. Il te suffit de dessiner sur une copie de l'image. Dans ton panel, tu affiche toujours la copie (au début, ou pour réafficher l'image de base, tu fais une simple copie sans rien dessiner en plus,).
Pour faire une copie, tu peux simplement créer une nouvelle image de même taille et dessiner l'image de base dessus (on peut aussi copier les rasters et colormodel, c'est plus rapide, plus générique mais plus complexe, et je ne pense pas que tu aies besoin de rapidité et encore moins de généricité puisque tu pars d'une image unique que tu as créée).

Par exemple :

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
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
public class Exemple extends JPanel {
 
	private static final int BASE_WIDTH = 20;
	private static final int WIDTH = 9*BASE_WIDTH;
	private static final int B_WIDTH = BASE_WIDTH/3;
	private static final int BUTTON_WIDTH = B_WIDTH*3;
 
	final BufferedImage baseImage; // l'image de base (qu'on ne modifiera jamais)
	BufferedImage image; // la copie de l'image de base
 
	public Exemple() {
		baseImage = new BufferedImage(WIDTH, WIDTH, BufferedImage.TYPE_INT_RGB);
		final Graphics2D g2d = baseImage.createGraphics();
		try {
			draw(g2d, 0, WIDTH, 0, WIDTH, Color.BLACK, Color.WHITE);
		} finally {
			g2d.dispose();
		}
		image = copy(baseImage);
	}
 
	private BufferedImage copy(BufferedImage image) {
 
		final BufferedImage copy = new BufferedImage(image.getWidth(), image.getHeight(), image.getType());
		final Graphics2D g2d = copy.createGraphics();
		try {
			g2d.drawImage(image, 0, 0, null);
		}
		finally {
			g2d.dispose();
		}
		return copy;
	}
 
	private void draw(Graphics2D g2d, int istart, int iend, int jstart, int jend, Color even, Color odd) {
		for (int i = istart; i < iend; i += BASE_WIDTH) {
			for (int j = jstart; j < jend; j += BASE_WIDTH) {
                		if ( i/BASE_WIDTH%2==j/BASE_WIDTH%2 ) { // formule pour alterner les couleurs en damier
                			g2d.setColor(even);
                		}
                		else {
                			g2d.setColor(odd);
                		}
                		g2d.fillRect(i, j, BASE_WIDTH, BASE_WIDTH);
			}
		}
	}
 
	public void action(int x, int y, Color color) {
		final BufferedImage newImage = copy(baseImage);
		final Graphics2D g2d = newImage.createGraphics();
		try {
			draw(g2d, x*BASE_WIDTH*3, x*BASE_WIDTH*3+BASE_WIDTH*3, y*BASE_WIDTH*3, y*BASE_WIDTH*3+BASE_WIDTH*3, color, Color.WHITE);
		}
		finally {
			g2d.dispose();
		}
		image = newImage;
		repaint();
	}
 
	@Override
	public Dimension getPreferredSize() {
		return new Dimension(WIDTH, WIDTH);
	}
 
	@Override
	protected void paintComponent(Graphics g) {
		super.paintComponent(g);
		g.drawImage(image, 0, 0, null);
	}
 
	private static JButton createJButton(int x, int y, Color color, Exemple exemple) {
		BufferedImage image = new BufferedImage(BUTTON_WIDTH,BUTTON_WIDTH,BufferedImage.TYPE_INT_ARGB);
		Graphics2D g2d = image.createGraphics();
		try {
			g2d.setColor(Color.BLACK);
			g2d.drawRect(0, 0, BUTTON_WIDTH-1, BUTTON_WIDTH-1);
			g2d.fillRect(x*B_WIDTH, y*B_WIDTH, B_WIDTH, B_WIDTH);
		}
		finally {
			g2d.dispose();
		}
		Action action = new AbstractAction("") {
 
			private static final long serialVersionUID = 1L;
 
			@Override
			public void actionPerformed(ActionEvent arg0) {
				exemple.action(x, y, color);
			}
 
		};
		JButton button = new JButton(action);
		button.setIcon(new ImageIcon(image));
		return button;
	}
 
	public static void main(String[] args) {
 
		JFrame frame = new JFrame("Exemple");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setResizable(false);
 
		Exemple exemple = new Exemple();
 
		frame.add(exemple);
 
		final List<Color> colors = new ArrayList<>(Arrays.asList(Color.BLUE, Color.CYAN,Color.GREEN, Color.LIGHT_GRAY, Color.MAGENTA, Color.ORANGE, Color.PINK, Color.RED, Color.YELLOW));
		assert(colors.size()>=9);
		Collections.shuffle(colors);
		JPanel buttonPanel = new JPanel(new GridLayout(0, 3));
		for(int i=0; i<9; i++) {
			buttonPanel.add(createJButton(i%3, i/3, colors.remove(0), exemple));
		}
		frame.add(buttonPanel, BorderLayout.SOUTH);
 
		frame.pack();
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
	}
 
}

Accessoirement, une alternative de copie d'image plus générique :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
	private BufferedImage copy(BufferedImage image) {
 
		final GraphicsConfiguration configuration = GraphicsEnvironment.getLocalGraphicsEnvironment()
	        .getDefaultScreenDevice().getDefaultConfiguration();
		final BufferedImage copy = configuration.createCompatibleImage(image.getWidth(), image.getHeight(), Image.TRANSLUCENT);
		final Graphics2D g2d = copy.createGraphics();
		try {
			g2d.drawImage(image, 0, 0, null);
		}
		finally {
			g2d.dispose();
		}
		return copy;
	}

05/03/2016, 13h34
KoupaXII

Je me suis mal exprimé, désolé.
En fait je ne souhaite pas simplement copier l'image de base, je souhaite qu'à chaque fois que j'utilise mon bouton, les dessins de l'actionListener s'effectue et qu'une fois les dessins effectués, une nouvelle image soit générée aléatoirement. Sauf que j'aimerais garder la portion de l'image sur laquelle j'ai fait des dessins de l'actionListener intacte; c'est pourquoi j'ai crée des Graphics2D g2 dans l'actionListener dans lesquelles j'ai fait un setClip avec la zone que je souhaite dessiner.
05/03/2016, 14h34
joel.drigo

Je ne suis pas sûr de mieux comprendre.

Tu as une image, appelons-là IMAGE_DE_BASE (générée aléatoirement). Sur une action de l'utilisateur, une portion de cette image (IMAGE_DE_BASE donc) est modifiée (on dessine un truc dessus, aléatoirement), puis tu voudrais créer une nouvelle image (NOUVELLE_IMAGE) aléatoirement, telle que la portion d'image dessinée soit la portion correspondante dans l'image IMAGE_DE_BASE, avant qu'on la modifie ? C'est ça ?
Est-ce que NOUVELLE_IMAGE remplace IMAGE_DE_BASE ensuite, ou IMAGE_DE_BASE reste toujours la même, comme base de chaque action ?

Il y a autre chose que j'ai du mal à comprendre : tu as visible à l'écran le JPanel correspondant à la classe Cases. Chaque action crée un nouveau JPanel en modifiant l'image de Cases : à quoi sert ce JPanel ? Il est affiché quelque part à un moment donné, ou ne sert qu'à modifier l'image de Cases (auquel cas, il est inutile que cela soit un JPanel : ça pourrait être juste une méthode de Cases) A priori, je crois comprendre que tu ne souhaites pas modifier justement l'image de base : mais à quoi sert la nouvelle image ? Elle est destinée à s'afficher quelque part ? Parce ce qu'à ce que je comprends après le dessin fait par l'action, tu voudrais afficher une nouvelle image (donc pas celle qui correspond à ce qu'on vient de dessiner).
05/03/2016, 15h05
KoupaXII

Concrètement, si on reprend l'exemple que j'ai fait plus tôt avec les deux images et le pattern.
En fait, une image de base est généré avec des cases de couleurs aléatoires. Imaginons alors qu'en appuyant sur le bouton vert, le pattern de 3x3 carrés est modifié, et donc retiré de la zone de dessin avec le setClip d'un graphic2D crée dans l'actionListener associé à ce bouton. Alors, j'aimerais qu'une fois qu'on ait appuyé sur le bouton et que le dessin ait été fait sur l'image de base, une nouvelle image (ou simplement une modification de l'image de base suffirait) apparaisse à la place de l'image de base mais sans que le pattern qui a été modifié soit remplacé (d'où le setClip).
Pour ce qui est de la class Cases et du JPanel, je n'utilisait pas de BufferedImage il y a quelque temps et j'utilisait le JPanel, mais effectivement maintenant que j'utilise cette imageBuffered je n'ai plus besoin d'étendre la class.

Citation:

Envoyé par KoupaXII

Concrètement, si on reprend l'exemple que j'ai fait plus tôt avec les deux images et le pattern.

Ouais, bon, je vois qu'il y a plein de carrés de couleur, je vois rapidement que ce sont 2 images différentes, sauf les 9 carrés entourés de noir. Maintenant, je ne vais pas passer des heures à analyser les images pour voir les différences ou les non-différences. Habituellement, une image vaut mieux qu'un long discours : pour le coup, c'est l'exception qui confirme la règle tes images.

Citation:

Envoyé par KoupaXII

En fait, une image de base est généré avec des cases de couleurs aléatoires.

Jusque là j'avais suivi.

Citation:

Envoyé par KoupaXII

Imaginons alors qu'en appuyant sur le bouton vert, le pattern de 3x3 carrés est modifié,

Le motif 3x3 est modifié, donc l'image est modifiée (c'est comme sur du papier : si tu as un dessin, et que tu gribouilles avec du feutre dessus, le dessin est gribouiilé).

Citation:

Envoyé par KoupaXII

et donc retiré de la zone de dessin

Donc non, rien n'est retiré.

Citation:

Envoyé par KoupaXII

avec le setClip d'un graphic2D crée dans l'actionListener associé à ce bouton.

Le setClip ne fait que définir une zone dans laquelle les ordres de dessin ont un effet; Avec du papier, on appellerais ça un pochoir. SI tu as un dessin, que tu colles un pochoir par dessus (un papier avec des trous en forme de smiley - les trous c'est ce qui est défini par setClip), et que tu asperges le truc de peinture rouge, tu te retrouves avec le dessin d'origine peint d'un smyley rouge. C'est tout : rien n'est retiré. La seule différence, c'est que sur le papier les couches de peinture ou d'encre se superposent, alors qu'avec une BufferedImage la couleur d'un pixel est remplacée par la nouvelle, dans les rasters de l'image (les rasters = des tableaux de pixels pour simplifier). Il ne faut pas voir un Graphics2D comme une copie de l'image : c'est simplement un moyen de dessiner dans l'image, un peu comme un chevalet pour un dessin sur papier. D'ailleurs, on peut poser un même dessin sur plusieurs chevalets, mais le papier est toujours que sur un chevalet à la fois : on peut créer plusieurs Graphics en même temps sur une même image, même on ne devrait pas (on ne devrait en créé et utilisé un à la fois).

Citation:

Envoyé par KoupaXII

Alors, j'aimerais qu'une fois qu'on ait appuyé sur le bouton et que le dessin ait été fait sur l'image de base, une nouvelle image (ou simplement une modification de l'image de base suffirait) apparaisse à la place de l'image de base mais sans que le pattern qui a été modifié soit remplacé (d'où le setClip).

Là, ça me semble plus clair et moins clair à la fois. Parce que ça correspond à ce que j'ai décris dans mon message précédent, à priori. Et pas besoin de clipping pour faire ça. On peut dessiner une image sur une autre, complètement, ou partiellement. Avec les différentes méthode drawImage, on peut dessiner une image quelconque sur une image, à l'endroit qu'on veut, à la taille qu'on veut. On peut également dessiner une portion de l'image d'origine, sur une portion de l'image.

Si j'ai bien compris, alors c'est quelque chose comme ça que tu voudrais faire :
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 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 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 import java.awt.BasicStroke; import java.awt.BorderLayout; import java.awt.Color; import java.awt.Dimension; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.GridLayout; import java.awt.event.ActionEvent; import java.awt.image.BufferedImage; import java.util.Random; import javax.swing.AbstractAction; import javax.swing.Action; import javax.swing.ImageIcon; import javax.swing.JButton; import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.JPanel; public class Exemple extends JPanel { private final static Color[] COLORS = { Color.BLUE, Color.CYAN, Color.GREEN, Color.MAGENTA, Color.ORANGE, Color.PINK, Color.RED, Color.YELLOW, Color.LIGHT_GRAY }; private final static Random RANDOM = new Random(); private static final int BASE_WIDTH = 20; private static final int WIDTH = 9 * BASE_WIDTH; private static final int B_WIDTH = BASE_WIDTH / 3; private static final int BUTTON_WIDTH = B_WIDTH * 3; private final BufferedImage baseImage; BufferedImage image; public Exemple() { baseImage = new BufferedImage(WIDTH, WIDTH, BufferedImage.TYPE_INT_RGB); final Graphics2D g2d = baseImage.createGraphics(); try { drawImage(g2d, Color.BLACK); } finally { g2d.dispose(); } image = copy(baseImage); } public BufferedImage getBaseImage() { return baseImage; } private BufferedImage copy(BufferedImage image) { final BufferedImage copy = new BufferedImage(image.getWidth(), image.getHeight(), image.getType()); final Graphics2D g2d = copy.createGraphics(); try { g2d.drawImage(image, 0, 0, null); } finally { g2d.dispose(); } return copy; } @Override public Dimension getPreferredSize() { return new Dimension(WIDTH, WIDTH); } @Override protected void paintComponent(Graphics g) { super.paintComponent(g); g.drawImage(image, 0, 0, null); } private static Color COLOR_MASK = new Color(255,255,255,128); public void action(int x, int y, Color color) { final BufferedImage newImage = new BufferedImage(WIDTH, WIDTH, BufferedImage.TYPE_INT_RGB); final Graphics2D g2d = newImage.createGraphics(); try { drawImage(g2d, Color.BLACK); // ça c'est juste pour faire ressortir le carré avec la portion d'image de l'image de base g2d.setColor(COLOR_MASK); g2d.fillRect(0, 0, WIDTH, WIDTH); // on dessine la portion l'image de base : int wimage = BASE_WIDTH * 3; int himage = BASE_WIDTH * 3; int ximage = x * wimage; int yimage = y * himage; g2d.drawImage(baseImage, ximage, yimage, ximage+wimage, yimage+himage, ximage, yimage, ximage+wimage, yimage+himage, null); // on encadre la portion g2d.setColor(Color.WHITE); g2d.setStroke(new BasicStroke(3)); g2d.drawRoundRect(ximage-2, yimage-2, wimage+3, himage+3,3,3); } finally { g2d.dispose(); } image = newImage; // l'image affichée dans le panel est la nouvelle image repaint(); } private static void drawImage(Graphics2D g2d, Color color) { for (int i = 0; i < WIDTH; i += BASE_WIDTH) { for (int j = 0; j < WIDTH; j += BASE_WIDTH) { if (i / BASE_WIDTH % 2 == j / BASE_WIDTH % 2) { g2d.setColor(color); } else { g2d.setColor(COLORS[RANDOM.nextInt(COLORS.length)]); } g2d.fillRect(i, j, BASE_WIDTH, BASE_WIDTH); } } } private static JButton createJButton(int x, int y, Color color, Exemple exemple) { BufferedImage image = new BufferedImage(BUTTON_WIDTH, BUTTON_WIDTH, BufferedImage.TYPE_INT_ARGB); Graphics2D g2d = image.createGraphics(); try { g2d.setColor(Color.BLACK); g2d.drawRect(0, 0, BUTTON_WIDTH - 1, BUTTON_WIDTH - 1); g2d.fillRect(x * B_WIDTH, y * B_WIDTH, B_WIDTH, B_WIDTH); } finally { g2d.dispose(); } Action action = new AbstractAction("") { private static final long serialVersionUID = 1L; @Override public void actionPerformed(ActionEvent arg0) { exemple.action(x, y, color); } }; JButton button = new JButton(action); button.setIcon(new ImageIcon(image)); return button; } public static void main(String[] args) { JFrame frame = new JFrame("Exemple"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setResizable(false); Exemple exemple = new Exemple(); frame.add(exemple); JPanel buttonPanel = new JPanel(new GridLayout(0, 3)); for (int i = 0; i < 9; i++) { buttonPanel.add(createJButton(i % 3, i / 3, COLORS[i], exemple)); } frame.add(buttonPanel, BorderLayout.SOUTH); frame.pack(); frame.setLocationRelativeTo(null); frame.setVisible(true); // on affiche l'image de base dans une autre fenêtre pour comparaison visuelle JFrame frame2 = new JFrame("Image de base"); frame2.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame2.setResizable(false); frame2.add(new JLabel(new ImageIcon(exemple.getBaseImage()))); frame2.pack(); frame2.setLocation(frame.getX()+frame.getWidth(),frame.getY()); frame2.setVisible(true); } }

05/03/2016, 17h01
KoupaXII

Oui, c'est à peu près ça, en gros, le but est le suivant:
J'ai une image de base avec des cases générés aléatoirement, le point de départ du joueur est la case tout en haut à gauche, si le joueur a une case de couleur bleu à côté de sa case par exemple, alors si le joueur appuie sur le bouton bleu, la case de couleur bleu ainsi que toutes celles à côté de cette case de même couleur seront considérés comme "conquise". Quand les cases sont conquises, alors les cases non-conquise changeront de couleur de façon aléatoire mais celles déjà conquise resteront de la même couleur. Cela marque la fin d'un tour et ainsi un nouveau tour peut commencer, sachant que mon but est d'arriver à faire en sorte que lorsque le joueur appuie sur le bouton bleu par exemple, alors toutes les cases bleues adjacentes à celles conquises deviendrons conquises.

J'espère que cette fois-ci c'est compréhensible x)

Ok, c'est beaucoup plus clair comme ça.

En gros, il faut regénérer (tirer des couleur et redessiner) toutes les case, sauf celles conquises. Si le dammier est "pur", pas besoin de clipping : il suffit de parcourir les cases (les coordonnées) et de repeindre, puis de copier la portion d'image (par dessin comme j'ai fait dans mon dernier exemple). A ce que je peux remarquer sur tes images exemples, il semble que les damiers ne soient pas "pur", qu'il y ait pour effet graphique des chevauchements, ce qui nécessite de procéder par copie et clipping. Comme à priori la partie conquise n'est pas un rectangle, mais l'union de plein de carrés, ce clipping va devenir une forme complexe : tout le bénéfice de la recopie d'image va être possiblement plombé par le clipping. Au lieu de procéder avec des recopies d'images et du clipping, on pourrait procéder par tableau de couleurs, qu'on redessine à chaque fois qu'une couleur au moins change. Et ce serait plus simple de connaitre les couleurs des cases (pas besoin d'analyser des pixels). Pour éviter d'avoir à regéner la partie conquise à chaque fois, on peut la stocker dans une image transparente qu'on dessine par dessus.

En gros, ça donnerait un truc comme ça (ce n'est pas vraiment les règles de ton jeu, c'est pour l'exemple : un clique sur une case à côté d'où on se trouve, toutes les cases de même couleur autour sont conquises, les autres changent...)

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
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
public class Exemple extends JPanel {
 
	private final static Color[] COLORS = { Color.BLUE, Color.CYAN, Color.GREEN, Color.MAGENTA, Color.ORANGE,
			Color.PINK, Color.RED, Color.YELLOW, Color.LIGHT_GRAY };
	private final static Random RANDOM = new Random();
 
	private final static int NB = 9;
 
	private static final int BASE_WIDTH = 20;
	private static final int WIDTH = NB * BASE_WIDTH;
 
	private final Color[][] colors = new Color[NB][NB];
	private final BufferedImage image;
	private BufferedImage conqImage;
 
	private Point position = new Point(0,0);
 
	private int nbcases=0;
	private boolean gagne;
	private boolean perdu;
 
	public Exemple() {
		image = new BufferedImage(WIDTH, WIDTH, BufferedImage.TYPE_INT_RGB);
		final Graphics2D g2d = image.createGraphics();
		try {
			generer(g2d);
		} finally {
			g2d.dispose();
		}
		conqImage = new BufferedImage(WIDTH, WIDTH, BufferedImage.TYPE_INT_ARGB);
		addMouseListener(new MouseAdapter() {
 
			@Override
			public void mouseClicked(MouseEvent e) {
				if ( gagne || perdu ) return;
				int x = e.getX()/BASE_WIDTH;
				int y = e.getY()/BASE_WIDTH;
				if ( Math.abs(position.x-x)<=1 && Math.abs(position.y-y)<=1 ) {
					if ( colors[x][y]!= null ) {
						position.x=x;
						position.y=y;
						Color color = colors[x][y];
						Graphics2D conqImageGraphics = conqImage.createGraphics();
						try {
							    int count=0;
								for(int i=-1; i<2; i++) {
									for(int j=-1; j<2; j++) {
										int cx=x+i;
										int cy=y+j;
										if ( cx>=0 && cx<9 && cy>=0 && cy<9 ) {
											if ( colors[cx][cy]==color ) {
												// conquise
												colors[x+i][y+j]=null;
												nbcases++;
												conqImageGraphics.setColor(color);
												conqImageGraphics.fillRect((x+i)*BASE_WIDTH, (y+j)*BASE_WIDTH, BASE_WIDTH, BASE_WIDTH);
												conqImageGraphics.setColor(Color.BLACK);
												conqImageGraphics.drawLine((x+i)*BASE_WIDTH, (y+j)*BASE_WIDTH, (x+i)*BASE_WIDTH+BASE_WIDTH, (y+j)*BASE_WIDTH+BASE_WIDTH);
												conqImageGraphics.drawLine((x+i)*BASE_WIDTH, (y+j)*BASE_WIDTH+BASE_WIDTH, (x+i)*BASE_WIDTH+BASE_WIDTH, (y+j)*BASE_WIDTH);
											}
											if ( colors[cx][cy]==null ) {
												count++;
											}
										}
										else {
											count++;
										}
									}
								}
								if ( count==9 ) {
									perdu=true;
								}
						}
						finally {
							conqImageGraphics.dispose();
						}
						Graphics2D imageGraphics = image.createGraphics();
						try {
							regenerer(imageGraphics);
							imageGraphics.drawImage(conqImage, 0, 0, null);
						}
						finally {
							imageGraphics.dispose();
						}
						if (nbcases>=81) {
							gagne=true;
						}
						repaint();
					}
				}
			}
 
		});
	}
 
	private void generer(Graphics2D g2d) {
		for(int i=0; i<NB; i++) {
			for(int j=0; j<NB; j++) {
				colors[i][j] = COLORS[RANDOM.nextInt(COLORS.length)];
				g2d.setColor(colors[i][j]);
				g2d.fillRect(i*BASE_WIDTH, j*BASE_WIDTH, BASE_WIDTH, BASE_WIDTH);
			}
		}
	}
 
	private void regenerer(Graphics2D g2d) {
		for(int i=0; i<NB; i++) {
			for(int j=0; j<NB; j++) {
				if (colors[i][j]!=null) {
					colors[i][j] = COLORS[RANDOM.nextInt(COLORS.length)];
					g2d.setColor(colors[i][j]);
					g2d.fillRect(i*BASE_WIDTH, j*BASE_WIDTH, BASE_WIDTH, BASE_WIDTH);
				}
			}
		}
	}
 
	@Override
	public Dimension getPreferredSize() {
		return new Dimension(WIDTH, WIDTH);
	}
 
	private final static Font FONT = new Font("Arial",Font.BOLD, 28);
	private final static Color COLOR_MASK = new Color(255,255,255,128);
	@Override
	protected void paintComponent(Graphics g) {
		super.paintComponent(g);
		g.drawImage(image, 0, 0, null);
		g.setColor(Color.BLACK);
		g.fillOval(position.x*BASE_WIDTH, position.y*BASE_WIDTH, BASE_WIDTH, BASE_WIDTH);
		if ( gagne!=perdu ) {
			g.setColor(COLOR_MASK);
			g.fillRect(0, 0, WIDTH, WIDTH);
			g.setFont(FONT);
			g.setColor(Color.BLACK);
			if ( gagne ) {
				Rectangle2D bounds = g.getFontMetrics().getStringBounds("Gagné", g);
				g.drawString("Gagné", (int)(getWidth()-bounds.getWidth())/2, (int)(getHeight()-bounds.getHeight())/2 + g.getFontMetrics().getAscent());
			}
			else if ( perdu ) {
				Rectangle2D bounds = g.getFontMetrics().getStringBounds("Perdu", g);
				g.drawString("Perdu", (int)(getWidth()-bounds.getWidth())/2, (int)(getHeight()-bounds.getHeight())/2 + g.getFontMetrics().getAscent());
			}
		}
	}
 
 
 
	public static void main(String[] args) {
 
		JFrame frame = new JFrame("Exemple");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setResizable(false);
 
		Exemple exemple = new Exemple();
 
		frame.add(exemple);
 
		frame.pack();
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
 
	}
 
}

05/03/2016, 19h18
KoupaXII

Je ne sais pas si c'est du à l'upload de l'image qui compresse le fichier, mais de mon côté je ne vois pas de chevauchements ou autre. Pour être sûr j'ai upload l'image sur un autre site, et voici le résultat :
http://i.imgur.com/NcBL76P.jpg

http://imgur.com/NcBL76P (Je poste le lien pour une une image de meilleure qualité en zoom au cas où)

Donc devrais-je procéder par damier pur ?
05/03/2016, 21h10
joel.drigo

Quand je parlais de chevauchement, je parlais de l'effet d'épaisseurs différentes pour les bordures. Je ne sais pas si c'est fait exprès ou pas, mais je trouvais que ça donnait un petit effet sympa de relief. Si toutes les bordures sont les mêmes, tu peux toujours redessiner tout le damier complet à partir d'un tableau de couleurs (en revanche : comme il n'y a plus moyen de distinguer dans ce tableau les cases conquises des autres, il faudrait un second tableau (de boolean par exemple), ou utiliser une classe qui représente une case (avec un attribut "conquis" et "couleur"). La méthode utilisée dans mon dernier exemple n'est valable que pour un damier pur (pas de copie) de toute manière (pas de copie de l'image d'origine).
05/03/2016, 21h40
KoupaXII

D'acc, je m'y pencherai dans la soirée, merci beaucoup pour toutes tes réponses
06/03/2016, 17h24
KoupaXII

J'ai continué le code ce matin et je me suis heurté à un autre problème: comment faire en sorte qu'une variable soit commune à plusieurs classes tout en faisant en sorte que quand cette variable est modifié dans une des class, elle est alors modifié dans toutes les class. Dans mon code, la variable en question est une List<Point> et j'aimerais que quand un point est ajouté dans une des class, celle-ci soit rajouté dans toutes les class.

Dans l'absolu, on devrait éviter qu'une référence soit partagée par plusieurs classes si cette référence est susceptible de changer (et que l'utilisation de la référence n'est pas uniquement immédiate). On résoud le problème en partageant la référence sur une instance de "fournisseur" de la référence en question. Le cas classique est le nom d'une personne : on ne partage pas le nom, on partage l'instance de personne, et on obtient son nom au moment voulu par le getter approprié. Ensuite, il y a d'autres moyens, notamment dans certains cas particuliers.

Pour une List, justement, au lieu de faire :
Code:

1 2 3 4 5 6 7 8 public class Fournisseur { // la classe qui a la responsabilité de produire ou modifier la liste private List<Truc> list; public List<Truc> getListeDeTrucs() { return list; } }
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 public class Utilisateur { // une classe qui utilise la liste produite par le fournisseur private List<Truc> list; public Utilisateur(List<Truc> list) { this.list=list; } public void methodQuiUtilise() { for(Truc true : list) { // ... } } }
On ferait pour appliquer ce que j'ai dit au début :
Code:

1 2 3 4 5 6 7 8 public class Fournisseur { // la classe qui a la responsabilité de produire ou modifier la liste private List<Truc> list; public List<Truc> getListeDeTrucs() { return list; } }
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 public class Utilisateur { // une classe qui utilise la liste produite par le fournisseur private Fournisseur fournisseur; public Utilisateur(Fournisseur fournisseurDeList) { this.fournisseur=fournisseur; } public void methodQuiUtilise() { for(Truc true : fournisseur.getListeDeTrucs()) { // ... } } }
Dans le cas particulier d'une List, on peut donc procéder aussi ainsi :
Code:

1 2 3 4 5 6 7 8 public class Fournisseur { // la classe qui a la responsabilité de produire ou modifier la liste private List<Truc> list; public List<Truc> getListeDeTrucs() { return Collections.unmodifiableList(list); // on garantit que la liste retournée n'est pas modifiable par une autre instance et que toute modification sur la liste "interne" est répercutée sur la liste "externe" } }
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 public class Utilisateur { // une classe qui utilise la liste produite par le fournisseur private List<Truc> list; public Utilisateur(List<Truc> list) { this.list=list; } public void methodQuiUtilise() { for(Truc true : list) { // ... } } }
Bien sûr, ceci a un inconvénient, en particulier en cas de code multithread (la liste étant partagée, elle pourra être modifiée par un thread dans le fournisseur, et parcourue dans une autre thread dans l'utilisateur, et il faut donc le prendre en compte (ce qui est un autre sujet que tu auras l'occasion de voir plus tard))

Ensuite, il y a d'autres solutions, par exemple, la solution évenementielle : l'utilisateur écoute le fournisseur qui l'averti par évenement que la liste a changé, et l'utilisateur alors fait la mise à jour en question. Ceci est indispensable lorsque l'état d'utilisateur dépend de la liste. Tu peux créer ton propre système d'écouteur (une interface, une liste, une méthode pour ajouter un écouteur, une pour le retirer, une méthode pour diffuser l'évenement), ou t'appuyer sur par exemple SwingPropertyChangeSupport (plustôt prévue pour des propriétés de composants graphiques, mais dans le cas de ta liste de points, ce ne serait pas abscons).

J'ai essayé de prendre exemple sur ton code pour créer ma List, mais j'obtient systématiquement "java.lang.NullPointerException". Il y a sûrement quelque chose que je ne comprends pas...

Voici le code de mon Fournisseur:

Code:

1
2
3
4
5
6
7
8
 
public class Fournisseur {
	private List<Point> tabcq;
 
	public List<Point> getList() {
		return Collections.unmodifiableList(tabcq);
	}
}

Et voici celui de la class qui l'utilise:

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
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
 
public class ListenerVertC extends JPanel {
 
	private final BufferedImage image;
	  int xp1=1, xp2=1;
	  int xpg1=1, xph1=1, xpb1=1, xpd1=1, xpg2=1, xpd2=1, xph2=1, xpb2=1;
	  int xg1=xpg1-25, xg2=xpg2;
	  int xd1=xpd1+25, xd2=xpd2;
	  int xh1=xph1, xh2=xph2-25; 
	  int xb1=xpb1, xb2=xpb2+25;
	  static List<Point> tabcp = new ArrayList<>();
	  private List<Point> tabcq;
	  int cppd = -16711936;
 
	public ListenerVertC(BufferedImage image, List<Point> tabcq) {
		this.image=image;
		this.tabcq=tabcq;
		Graphics g = (Graphics)image.getGraphics();
		Graphics2D g2 = image.createGraphics();
		System.out.println("HelloV");
		tabcp.clear();
        eerc(g2);
        for(int i=0; i<tabcp.size(); i++) {
            System.out.print(tabcp.get(i).x+" "+tabcp.get(i).y+" ");       
        }
        for(int i=0; i<tabcq.size(); i++) {
            System.out.print(tabcq.get(i).x+" "+tabcq.get(i).y+" ");       
        }
        System.out.println();
	}
 
	public void paintComponent(Graphics g) {
		g.drawImage(image,0,0,null);
	}
 
 
	public void eerc(Graphics2D g2) {
		Graphics g = (Graphics)image.getGraphics();
        tabcp.add(new Point(xp1,xp2));
        tabcq.add(new Point(xp1,xp2));
	 	Shape rectangledepart = new Rectangle2D.Float(xp1,xp2,25,25);
		Shape rectangleEntier = new Rectangle2D.Float(0,0,706,600);
	 	Area outside = new Area(rectangleEntier);
    	outside.subtract(new Area(rectangledepart));
 
        Color cpp= new Color(image.getRGB(xp1, xp2));
		 int pr=cpp.getRed();
	     int pg=cpp.getGreen();
	     int pb=cpp.getBlue();
		 @SuppressWarnings("unused")
		int cpp1 = new Color(pr,pg,pb).getRGB();
 
		 if (xg1 >=0) {
			 Color cpg = new Color(image.getRGB(xg1, xg2));
			 int pr2=cpg.getRed();
			 int pg2=cpg.getGreen();
			 int pb2=cpg.getBlue();
			 int cpg1 = new Color(pr2,pg2,pb2).getRGB();
 
		 while (cpg1 == cppd) {
		 Color cpgg = new Color(image.getRGB(xg1, xg2));
		 int pr22=cpgg.getRed();
		 int pg22=cpgg.getGreen();
		 int pb22=cpgg.getBlue();
		 int cpg11 = new Color(pr22,pg22,pb22).getRGB();
		 if (cpg11 != cppd) {
			 break;
		 }
	 	 g.setColor(new Color(pr2,pg2,pb2));
	 	 g.fillRect(xpg1, xpg2, 24, 24);
	 	 g.fillRect(xg1, xg2, 24, 24);
		 tabcp.add(new Point(xg1, xg2));
		 tabcq.add(new Point(xg1, xg2));
	 	 Shape rectangleg = new Rectangle2D.Float(xg1,xg2,24,24);
	 	 outside = OutsideRect((Rectangle2D) rectangleg, outside);
	 	 xpg1-=25;
	 	 xg1-=25;
	 	 cpg1=cpg11;
		 }
		 }
 
		 if (xh2 >=0) {
			 Color cph = new Color(image.getRGB(xh1, xh2));
			 int pr3=cph.getRed();
			 int pg3=cph.getGreen();
			 int pb3=cph.getBlue();
			 int cph1 = new Color(pr3,pg3,pb3).getRGB();
 
			 while (cph1 ==cppd) {
				 Color cphh = new Color(image.getRGB(xh1,xh2));
				 int pr33=cphh.getRed();
				 int pg33=cphh.getGreen();
				 int pb33=cphh.getBlue();
				 int cph11 = new Color(pr33,pg33,pb33).getRGB();
 
				 if (cph11 != cppd) {
					 break;
				 }
			 		g.setColor(new Color(pr3,pg3,pb3));
			 		g.fillRect(xph1, xph2, 24, 24);
			 		g.fillRect(xh1, xh2, 24, 24);
					tabcp.add(new Point(xh1, xh2));
					tabcq.add(new Point(xh1, xh2));
				 	Shape rectangleh = new Rectangle2D.Float(xh1,xh2,24,24);
				 	outside = OutsideRect((Rectangle2D) rectangleh, outside);
			 		xph2-=25;
			 		xh2-=25;
			 		cph1=cph11;
			 }
		 }
 
		 if (xb2 >=0) {
			 Color cpb = new Color(image.getRGB(xb1, xb2));
			 int pr4=cpb.getRed();
			 int pg4=cpb.getGreen();
			 int pb4=cpb.getBlue();
			 int cpb1 = new Color(pr4,pg4,pb4).getRGB();
 
			 while (cpb1== cppd) {
				 Color cpbb = new Color(image.getRGB(xb1, xb2));
				 int pr44=cpbb.getRed();
				 int pg44=cpbb.getGreen();
				 int pb44=cpbb.getBlue();
				 int cpb11 = new Color(pr44,pg44,pb44).getRGB();
 
				 if (cpb11 != cppd) {
					 break;
				 }
					 g.setColor(new Color(pr4,pg4,pb4));
					 g.fillRect(xpb1, xpb2, 24, 24);
					 g.fillRect(xb1, xb2, 24, 24);
					 tabcp.add(new Point(xb1, xb2));
					 tabcq.add(new Point(xb1, xb2));
				 	 Shape rectangleb = new Rectangle2D.Float(xb1,xb2,24,24);
				 	 outside = OutsideRect((Rectangle2D) rectangleb, outside);
					 xpb2+=25;
					 xb2+=25;
					 cpb1=cpb11;
			 }
		 }
 
		 Color cpd = new Color(image.getRGB(xd1, xd2));
		 int pr1=cpd.getRed();
	     int pg1=cpd.getGreen();
	     int pb1=cpd.getBlue();
		 int cpd1 = new Color(pr1,pg1,pb1).getRGB();
 
		 while (cpd1==cppd) {
			 Color cpdd = new Color(image.getRGB(xd1, xd2));
			 int pr11=cpdd.getRed();
		     int pg11=cpdd.getGreen();
		     int pb11=cpdd.getBlue();
			 int cpd11 = new Color(pr11,pg11,pb11).getRGB();
 
			 if (cpd11 != cppd) {
				 break;
			 }
				 g.setColor(new Color(pr1,pg1,pb1));
				 g.fillRect(xp1, xpd2, 24, 24);
				 g.fillRect(xd1, xd2, 24, 24);
				 tabcp.add(new Point(xd1, xd2));
				 tabcq.add(new Point(xd1, xd2));
			 	 Shape rectangled = new Rectangle2D.Float(xd1,xd2,24,24);
			 	 outside = OutsideRect((Rectangle2D) rectangled, outside);
				 xpd1+=25;
				 xd1+=25;
				 cpd1=cpd11;
		 }
		 g2.setClip(outside);
		 BufferedImage image2 = createImage(g2, tabcq);
	}
 
    private Area OutsideRect(Rectangle2D r, Area c) {
    	c.subtract(new Area(r));
    	return c;
    }
 
	public static void paintAleat(Graphics2D g2, int x2, int y2, int x3, int y3) {
		while (y2<600) {
			Random r = new Random();
			int valeurMin = 1, valeurMax = 6;
			int nr = valeurMin + r.nextInt(valeurMax - valeurMin);
			if (nr==1) {
				g2.setColor(Color.blue);
			}
			if (nr==2) {
				g2.setColor(Color.red);
			}
			if (nr==3) {
				g2.setColor(Color.yellow);
			}
			if (nr==4) {
				g2.setColor(Color.green);
			}
			if (nr==5) {
				g2.setColor(new Color( 213, 128, 0));
			}
	    	g2.drawRect(x2, y2, x3, y3);
	    	g2.fillRect(x2, y2, x3, y3);
	    	y2+=25;
		}
    }
 
	private static BufferedImage createImage(Graphics2D g2, List<Point> tabcq) {
        BufferedImage image = new BufferedImage(706, 750, BufferedImage.TYPE_INT_RGB);
		try {
		  int x4=1,y4=1,x5=1;
		  Point position = new Point(x4,y4);
 
		  while (x5<=706) {
		  if (position != tabcp  && position != tabcq)
		  paintAleat(g2, x4, y4, 23, 23);
		  x4+=25;
		  x5+=25;
		  }
	        for(int i=0; i<tabcp.size(); i++) {
	           g2.setColor(Color.GREEN);
	 		   g2.drawRect(tabcp.get(i).x, tabcp.get(i).y, 23, 23);
	        }
		} finally {
		  g2.dispose();
		}
		return image;
}
 
}

Je pense que c'est la manière d'accéder à la list qui pose problème mais je ne vois pas comment m'y prendre.

07/03/2016, 19h41
joel.drigo
Le fournisseur c'est la classe qui remplit la liste, qui ajoute des points dedans.
Ton code de fournisseur ne fonctionne pas parce que la variable n'est même initialisée (pas de new), et forcément encore moins remplie.
Où est créée et remplie cette liste ? Dans Cases ?

Attention, j'ai l'impression que tu modifies toutes les listes dans ListenerVertC :
Code:

1 2 tabcp.add(new Point(xg1, xg2)); tabcq.add(new Point(xg1, xg2));
ou alors il s'agit encore d'une autre liste que tu parles ?
07/03/2016, 21h44
KoupaXII

Je ne comprends pas le principe du fournisseur ici, je pensait que le fournisseur était la class qui contenait la liste (je parle ici de la liste tabcq, tabcp en est une autre) et auquel on faisait appel pour récupérer cette liste. Mais dans ce cas là, si la class fournisseur sert à modifier la liste c'est dans la class "Fournisseur" que je met le code qui ajoute des points à la liste ?
Pour le moment, c'est dans la class "ListenerVertC" que j'ajoute des points à la liste (J'ai posté le code de cette class dans mon message précédent).
Mais même si j'initialise la liste avec le code que j'ai actuellement dans ma class "ListenerVertC", j'ai toujours le même message

Citation:

Envoyé par KoupaXII

Je ne comprends pas le principe du fournisseur ici, je pensait que le fournisseur était la class qui contenait la liste (je parle ici de la liste tabcq, tabcp en est une autre) et auquel on faisait appel pour récupérer cette liste.

C'est bien ça. Dans ton cas, à priori donc, c'est la classe Cases.

Citation:

Envoyé par KoupaXII

Mais dans ce cas là, si la class fournisseur sert à modifier la liste c'est dans la class "Fournisseur" que je met le code qui ajoute des points à la liste ?

Oui, puisqu'à l'extérieur de cette classe elle est non modifiable. Ou alors il ne faut pas qu'elle le soit. Dans tous les cas s'assurer qu'on ne puisse pas la modifier dans plusieurs threads différents (si tout est fait dans l'Event Dispatcher (thread de Swing) c'est bon, bien que cela puisse être problématique si la génération des points est relativement lente (en tout cas, c'est le plus simple).

Citation:

Envoyé par KoupaXII

Pour le moment, c'est dans la class "ListenerVertC" que j'ajoute des points à la liste (J'ai posté le code de cette class dans mon message précédent).
Mais même si j'initialise la liste avec le code que j'ai actuellement dans ma class "ListenerVertC", j'ai toujours le même message

Le message est dû au fait que la variable n'est pas initialisée. Peu importe dans quelle classe la liste est stockée, il faut qu'elle existe.

Tu peux procéder comme ça par exemple :
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 public class Cases { private final List<Point> list; public Cases() { list = new ArrayList<>(); } public List<Point> getPoints() { return Collections.unmodifiableList((list); } public void addPoint(int x, int y) { addPoints(new Point(x,y)); } public void addPoints(Point...points) { for(Point point : points) { list.add(point); } } public void clearPoints() { list.clear(); } }
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 public class ListenerVertC { private final Cases cases; public ListenerVertC(Cases cases) { this.cases=cases; } public void methodJeSaisPasQuoi() { /*...*/ cases.addPoints(new Point(x,y)); /*...*/ cases.addPoint(x,y); } public void autreMethode() { for(Point point : cases.getPoints()) { /*...*/ } } }

J'ai suivis ton exemple, voilà où j'en suis:
Dans ma class Cases, j'ai donc crée la liste et les méthodes:

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
 
public class Cases extends JPanel {
 
[...]
 
private final List<Point> tabcq;
 
public Cases() {
 
[...]
 
	tabcq = new ArrayList<>();
}
 
public List<Point> getPoints() {
    return Collections.unmodifiableList(tabcq);
}
 
public void addPoint(int x, int y) {
    addPoints(new Point(x,y));
}
 
public void addPoints(Point...points) {
    for(Point point : points) {
         tabcq.add(point);
    }
}

Puis j'ai ensuite utilisé ces méthodes dans la class ListenerVertC:

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
 
public class ListenerVertC extends JPanel {
 
	private final Cases cases;
 
        [...]
 
	public ListenerVertC(BufferedImage image, Cases cases) {
        [...]
        Graphics2D g2 = image.createGraphics();
        eerc(g2);
        this.cases=cases;
}
 
	public void eerc(Graphics2D g2) {
 
        [...]
 
        cases.addPoints(new Point(xg1, xg2));
 
        [...]
}
 
}

Le programme bloque encore au même endroit, c'est à dire au moment ou j'ajoute un point à la liste et toujours avec le même message d'erreur..

09/03/2016, 10h30
joel.drigo

La même erreur, c'est bien "java.lang.NullPointerException" ? Tu peux me donner la stacktrace complète ?

Oui, c'est bien ça.

class Cases

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
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
import javax.swing.*;
 
import java.io.*;
import java.util.List;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GridLayout;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.image.BufferedImage;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Random;
 
 
 
@SuppressWarnings("serial")
 
public class Cases extends JPanel {
 
	final static BufferedImage baseImage = createImage();
	static BufferedImage imageCopie;
	private final List<Point> tabcq;
 
 
		private static BufferedImage createImage() {
            BufferedImage image = new BufferedImage(706, 750, BufferedImage.TYPE_INT_RGB);
			Graphics g = (Graphics)image.createGraphics();
			try {
			  int x1=0,y1=0,x4=1,y4=1,x5=1;
			  g.setColor(Color.BLACK);
			  while (x1<=706) {
			  g.drawLine(x1, 0, x1, 600);
			  x1+=25;
			  }
			  while (y1<=600) {
			  g.drawLine(0, y1, 707, y1);
			  y1+=25;
			  }
			  while (x5<=706) {
			  paintAleat(g, x4, y4, 23, 23);
			  x4+=25;
			  x5+=25;
			  }
			} finally {
			  g.dispose();
			}
			return image;
	}
 
public Cases() {
	imageCopie = copy(baseImage);
	tabcq = new ArrayList<>();
}
 
public List<Point> getPoints() {
    return Collections.unmodifiableList(tabcq);
}
 
public void addPoint(int x, int y) {
    addPoints(new Point(x,y));
}
 
public void addPoints(Point...points) {
    for(Point point : points) {
         tabcq.add(point);
    }
}
 
public void clearPoints() {
    tabcq.clear();
}
 
	public void paintComponent(Graphics g) {
        g.drawImage(baseImage, 0, 0, null);
}
 
	public static BufferedImage getImage() {
		return baseImage;
	}
 
	public static BufferedImage getImageCopie() {
		return imageCopie;
	}
 
 
 
	public static void paintAleat(Graphics g, int x2, int y2, int x3, int y3) {
		while (y2<600) {
			Random r = new Random();
			int valeurMin = 1, valeurMax = 6;
			int nr = valeurMin + r.nextInt(valeurMax - valeurMin);
			if (nr==1) {
				g.setColor(Color.blue);
			}
			if (nr==2) {
				g.setColor(Color.red);
			}
			if (nr==3) {
				g.setColor(Color.yellow);
			}
			if (nr==4) {
				g.setColor(Color.green);
			}
			if (nr==5) {
				g.setColor(new Color( 213, 128, 0));
			}
	    	g.drawRect(x2, y2, x3, y3);
	    	g.fillRect(x2, y2, x3, y3);
	    	y2+=25;
		}
    }	
 
	private BufferedImage copy(BufferedImage image) {
 
		final BufferedImage copy = new BufferedImage(image.getWidth(), image.getHeight(), image.getType());
		final Graphics2D g2d = copy.createGraphics();
		try {
			g2d.drawImage(image, 0, 0, null);
		}
		finally {
			g2d.dispose();
		}
		return copy;
	}
}

class ListenerVertC:

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
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
import javax.swing.*;
 
import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.awt.*;
import java.awt.geom.Area;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
 
public class ListenerVertC extends JPanel {
 
	private final BufferedImage image;
	private final Cases cases;
	  int xp1=1, xp2=1;
	  int xpg1=1, xph1=1, xpb1=1, xpd1=1, xpg2=1, xpd2=1, xph2=1, xpb2=1;
	  int xg1=xpg1-25, xg2=xpg2;
	  int xd1=xpd1+25, xd2=xpd2;
	  int xh1=xph1, xh2=xph2-25; 
	  int xb1=xpb1, xb2=xpb2+25;
	  static List<Point> tabcp = new ArrayList<>();
	  int cppd = -16711936;
 
	public ListenerVertC(BufferedImage image, Cases cases) {
		this.image=image;
		this.cases=cases;
		Graphics g = (Graphics)image.getGraphics();
		Graphics2D g2 = image.createGraphics();
		System.out.println("HelloV");
		tabcp.clear();
        eerc(g2);
        for(int i=0; i<tabcp.size(); i++) {
            System.out.print(tabcp.get(i).x+" "+tabcp.get(i).y+" ");       
        }
        System.out.println();
	}
 
	public void paintComponent(Graphics g) {
		g.drawImage(image,0,0,null);
	}
 
 
	public void eerc(Graphics2D g2) {
		Graphics g = (Graphics)image.getGraphics();
        tabcp.add(new Point(xp1,xp2));
 
	 	Shape rectangledepart = new Rectangle2D.Float(xp1,xp2,25,25);
		Shape rectangleEntier = new Rectangle2D.Float(0,0,706,600);
	 	Area outside = new Area(rectangleEntier);
    	outside.subtract(new Area(rectangledepart));
 
        Color cpp= new Color(image.getRGB(xp1, xp2));
		 int pr=cpp.getRed();
	     int pg=cpp.getGreen();
	     int pb=cpp.getBlue();
		 @SuppressWarnings("unused")
		int cpp1 = new Color(pr,pg,pb).getRGB();
 
		 if (xg1 >=0) {
			 Color cpg = new Color(image.getRGB(xg1, xg2));
			 int pr2=cpg.getRed();
			 int pg2=cpg.getGreen();
			 int pb2=cpg.getBlue();
			 int cpg1 = new Color(pr2,pg2,pb2).getRGB();
 
		 while (cpg1 == cppd) {
		 Color cpgg = new Color(image.getRGB(xg1, xg2));
		 int pr22=cpgg.getRed();
		 int pg22=cpgg.getGreen();
		 int pb22=cpgg.getBlue();
		 int cpg11 = new Color(pr22,pg22,pb22).getRGB();
		 if (cpg11 != cppd) {
			 break;
		 }
	 	 g.setColor(new Color(pr2,pg2,pb2));
	 	 g.fillRect(xpg1, xpg2, 24, 24);
	 	 g.fillRect(xg1, xg2, 24, 24);
		 tabcp.add(new Point(xg1, xg2));
		 cases.addPoints(new Point(xg1, xg2));
	 	 Shape rectangleg = new Rectangle2D.Float(xg1,xg2,24,24);
	 	 outside = OutsideRect((Rectangle2D) rectangleg, outside);
	 	 xpg1-=25;
	 	 xg1-=25;
	 	 cpg1=cpg11;
		 }
		 }
 
		 if (xh2 >=0) {
			 Color cph = new Color(image.getRGB(xh1, xh2));
			 int pr3=cph.getRed();
			 int pg3=cph.getGreen();
			 int pb3=cph.getBlue();
			 int cph1 = new Color(pr3,pg3,pb3).getRGB();
 
			 while (cph1 ==cppd) {
				 Color cphh = new Color(image.getRGB(xh1,xh2));
				 int pr33=cphh.getRed();
				 int pg33=cphh.getGreen();
				 int pb33=cphh.getBlue();
				 int cph11 = new Color(pr33,pg33,pb33).getRGB();
 
				 if (cph11 != cppd) {
					 break;
				 }
			 		g.setColor(new Color(pr3,pg3,pb3));
			 		g.fillRect(xph1, xph2, 24, 24);
			 		g.fillRect(xh1, xh2, 24, 24);
					tabcp.add(new Point(xh1, xh2));
					cases.addPoints(new Point(xh1, xh2));
				 	Shape rectangleh = new Rectangle2D.Float(xh1,xh2,24,24);
				 	outside = OutsideRect((Rectangle2D) rectangleh, outside);
			 		xph2-=25;
			 		xh2-=25;
			 		cph1=cph11;
			 }
		 }
 
		 if (xb2 >=0) {
			 Color cpb = new Color(image.getRGB(xb1, xb2));
			 int pr4=cpb.getRed();
			 int pg4=cpb.getGreen();
			 int pb4=cpb.getBlue();
			 int cpb1 = new Color(pr4,pg4,pb4).getRGB();
 
			 while (cpb1== cppd) {
				 Color cpbb = new Color(image.getRGB(xb1, xb2));
				 int pr44=cpbb.getRed();
				 int pg44=cpbb.getGreen();
				 int pb44=cpbb.getBlue();
				 int cpb11 = new Color(pr44,pg44,pb44).getRGB();
 
				 if (cpb11 != cppd) {
					 break;
				 }
					 g.setColor(new Color(pr4,pg4,pb4));
					 g.fillRect(xpb1, xpb2, 24, 24);
					 g.fillRect(xb1, xb2, 24, 24);
					 tabcp.add(new Point(xb1, xb2));
					 cases.addPoints(new Point(xb1, xb2));
				 	 Shape rectangleb = new Rectangle2D.Float(xb1,xb2,24,24);
				 	 outside = OutsideRect((Rectangle2D) rectangleb, outside);
					 xpb2+=25;
					 xb2+=25;
					 cpb1=cpb11;
			 }
		 }
 
		 Color cpd = new Color(image.getRGB(xd1, xd2));
		 int pr1=cpd.getRed();
	     int pg1=cpd.getGreen();
	     int pb1=cpd.getBlue();
		 int cpd1 = new Color(pr1,pg1,pb1).getRGB();
 
		 while (cpd1==cppd) {
			 Color cpdd = new Color(image.getRGB(xd1, xd2));
			 int pr11=cpdd.getRed();
		     int pg11=cpdd.getGreen();
		     int pb11=cpdd.getBlue();
			 int cpd11 = new Color(pr11,pg11,pb11).getRGB();
 
			 if (cpd11 != cppd) {
				 break;
			 }
				 g.setColor(new Color(pr1,pg1,pb1));
				 g.fillRect(xp1, xpd2, 24, 24);
				 g.fillRect(xd1, xd2, 24, 24);
				 tabcp.add(new Point(xd1, xd2));
				 cases.addPoints(new Point(xd1, xd2));
			 	 Shape rectangled = new Rectangle2D.Float(xd1,xd2,24,24);
			 	 outside = OutsideRect((Rectangle2D) rectangled, outside);
				 xpd1+=25;
				 xd1+=25;
				 cpd1=cpd11;
		 }
		 g2.setClip(outside);
		 BufferedImage image2 = createImage(g2, cases);
	}
 
    private Area OutsideRect(Rectangle2D r, Area c) {
    	c.subtract(new Area(r));
    	return c;
    }
 
	public static void paintAleat(Graphics2D g2, int x2, int y2, int x3, int y3) {
		while (y2<600) {
			Random r = new Random();
			int valeurMin = 1, valeurMax = 6;
			int nr = valeurMin + r.nextInt(valeurMax - valeurMin);
			if (nr==1) {
				g2.setColor(Color.blue);
			}
			if (nr==2) {
				g2.setColor(Color.red);
			}
			if (nr==3) {
				g2.setColor(Color.yellow);
			}
			if (nr==4) {
				g2.setColor(Color.green);
			}
			if (nr==5) {
				g2.setColor(new Color( 213, 128, 0));
			}
	    	g2.drawRect(x2, y2, x3, y3);
	    	g2.fillRect(x2, y2, x3, y3);
	    	y2+=25;
		}
    }
 
	private static BufferedImage createImage(Graphics2D g2, Cases cases) {
        BufferedImage image = new BufferedImage(706, 750, BufferedImage.TYPE_INT_RGB);
		try {
		  int x4=1,y4=1,x5=1;
		  Point position = new Point(x4,y4);
 
		  while (x5<=706) {
		  if (position != tabcp  && position != cases.getPoints())
		  paintAleat(g2, x4, y4, 23, 23);
		  x4+=25;
		  x5+=25;
		  }
	        for(int i=0; i<tabcp.size(); i++) {
	           g2.setColor(Color.GREEN);
	 		   g2.drawRect(tabcp.get(i).x, tabcp.get(i).y, 23, 23);
	        }
		} finally {
		  g2.dispose();
		}
		return image;
}
 
}

09/03/2016, 19h12
joel.drigo

Il me faut la stacktrace complète de l'erreur.
09/03/2016, 19h31
KoupaXII

"HelloV
Exception in thread "AWT-EventQueue-0" java.lang.NullPointerException
at ListenerVertC.createImage(ListenerVertC.java:218)
at ListenerVertC.eerc(ListenerVertC.java:177)
at ListenerVertC.<init>(ListenerVertC.java:32)
at Fenetre$ListenerVert.actionPerformed(Fenetre.java:64)
at javax.swing.AbstractButton.fireActionPerformed(Unknown Source)
at javax.swing.AbstractButton$Handler.actionPerformed(Unknown Source)
at javax.swing.DefaultButtonModel.fireActionPerformed(Unknown Source)
at javax.swing.DefaultButtonModel.setPressed(Unknown Source)
at javax.swing.plaf.basic.BasicButtonListener.mouseReleased(Unknown Source)
at java.awt.Component.processMouseEvent(Unknown Source)
at javax.swing.JComponent.processMouseEvent(Unknown Source)
at java.awt.Component.processEvent(Unknown Source)
at java.awt.Container.processEvent(Unknown Source)
at java.awt.Component.dispatchEventImpl(Unknown Source)
at java.awt.Container.dispatchEventImpl(Unknown Source)
at java.awt.Component.dispatchEvent(Unknown Source)
at java.awt.LightweightDispatcher.retargetMouseEvent(Unknown Source)
at java.awt.LightweightDispatcher.processMouseEvent(Unknown Source)
at java.awt.LightweightDispatcher.dispatchEvent(Unknown Source)
at java.awt.Container.dispatchEventImpl(Unknown Source)
at java.awt.Window.dispatchEventImpl(Unknown Source)
at java.awt.Component.dispatchEvent(Unknown Source)
at java.awt.EventQueue.dispatchEventImpl(Unknown Source)
at java.awt.EventQueue.access$500(Unknown Source)
at java.awt.EventQueue$3.run(Unknown Source)
at java.awt.EventQueue$3.run(Unknown Source)
at java.security.AccessController.doPrivileged(Native Method)
at java.security.ProtectionDomain$JavaSecurityAccessImpl.doIntersectionPrivilege(Unknown Source)
at java.security.ProtectionDomain$JavaSecurityAccessImpl.doIntersectionPrivilege(Unknown Source)
at java.awt.EventQueue$4.run(Unknown Source)
at java.awt.EventQueue$4.run(Unknown Source)
at java.security.AccessController.doPrivileged(Native Method)
at java.security.ProtectionDomain$JavaSecurityAccessImpl.doIntersectionPrivilege(Unknown Source)
at java.awt.EventQueue.dispatchEvent(Unknown Source)
at java.awt.EventDispatchThread.pumpOneEventForFilters(Unknown Source)
at java.awt.EventDispatchThread.pumpEventsForFilter(Unknown Source)
at java.awt.EventDispatchThread.pumpEventsForHierarchy(Unknown Source)
at java.awt.EventDispatchThread.pumpEvents(Unknown Source)
at java.awt.EventDispatchThread.pumpEvents(Unknown Source)
at java.awt.EventDispatchThread.run(Unknown Source)"

Sachant que je peut avoir l'erreur aussi sur la ligne 140 ("cases.addPoints(new Point(xb1, xb2));" et sur la ligne 169 "cases.addPoints(new Point(xd1, xd2));"
09/03/2016, 19h36
joel.drigo

Je dirais à priori que c'est cases qui est null. Tu dois créer les instances de ListenerVertC avant de créer Cases et/ou de l'affecter à la variable que tu passes au constructeur de ListenerVertC.

Je ne suis pas sûr d'avoir compris ton message, mais si c'est le cas c'est bien les points que je dois initialiser avant de créer cases ?

J'ai modifié le code de ce que j'ai compris (toujours "java.lang.NullPointerException")

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
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
import javax.swing.*;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.awt.*;
import java.awt.geom.Area;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
 
public class ListenerVertC extends JPanel {
 
	private final BufferedImage image;
	  int xp1=1, xp2=1;
	  int xpg1=1, xph1=1, xpb1=1, xpd1=1, xpg2=1, xpd2=1, xph2=1, xpb2=1;
	  int xg1=xpg1-25, xg2=xpg2;
	  int xd1=xpd1+25, xd2=xpd2;
	  int xh1=xph1, xh2=xph2-25; 
	  int xb1=xpb1, xb2=xpb2+25;
	  static List<Point> tabcp = new ArrayList<>();
	  Point Pg = new Point(xg1,xg2);
	  Point Ph = new Point(xh1,xh2);
	  Point Pd = new Point(xd1,xd2);
	  Point Pb = new Point(xb1,xb2);
	  int cppd = -16711936;
	  private Cases cases;
 
 
	public ListenerVertC(BufferedImage image, Cases cases) {
		this.image=image;
        this.cases=cases;
		Graphics g = (Graphics)image.getGraphics();
		Graphics2D g2 = image.createGraphics();
		System.out.println("HelloV");
		tabcp.clear();
        eerc(g2);
        for(int i=0; i<tabcp.size(); i++) {
            System.out.print(tabcp.get(i).x+" "+tabcp.get(i).y+" ");       
        }
        System.out.println();
	}
 
	public void paintComponent(Graphics g) {
		g.drawImage(image,0,0,null);
	}
 
 
	public void eerc(Graphics2D g2) {
		Graphics g = (Graphics)image.getGraphics();
        tabcp.add(new Point(xp1,xp2));
 
	 	Shape rectangledepart = new Rectangle2D.Float(xp1,xp2,25,25);
		Shape rectangleEntier = new Rectangle2D.Float(0,0,706,600);
	 	Area outside = new Area(rectangleEntier);
    	outside.subtract(new Area(rectangledepart));
 
        Color cpp= new Color(image.getRGB(xp1, xp2));
		 int pr=cpp.getRed();
	     int pg=cpp.getGreen();
	     int pb=cpp.getBlue();
		 @SuppressWarnings("unused")
		int cpp1 = new Color(pr,pg,pb).getRGB();
 
		 if (xg1 >=0) {
			 Color cpg = new Color(image.getRGB(xg1, xg2));
			 int pr2=cpg.getRed();
			 int pg2=cpg.getGreen();
			 int pb2=cpg.getBlue();
			 int cpg1 = new Color(pr2,pg2,pb2).getRGB();
 
		 while (cpg1 == cppd) {
		 Color cpgg = new Color(image.getRGB(xg1, xg2));
		 int pr22=cpgg.getRed();
		 int pg22=cpgg.getGreen();
		 int pb22=cpgg.getBlue();
		 int cpg11 = new Color(pr22,pg22,pb22).getRGB();
		 if (cpg11 != cppd) {
			 break;
		 }
	 	 g.setColor(new Color(pr2,pg2,pb2));
	 	 g.fillRect(xpg1, xpg2, 24, 24);
	 	 g.fillRect(xg1, xg2, 24, 24);
		 tabcp.add(new Point(xg1, xg2));
		 cases.addPoints(Pg);
	 	 Shape rectangleg = new Rectangle2D.Float(xg1,xg2,24,24);
	 	 outside = OutsideRect((Rectangle2D) rectangleg, outside);
	 	 xpg1-=25;
	 	 xg1-=25;
	 	 cpg1=cpg11;
		 }
		 }
 
		 if (xh2 >=0) {
			 Color cph = new Color(image.getRGB(xh1, xh2));
			 int pr3=cph.getRed();
			 int pg3=cph.getGreen();
			 int pb3=cph.getBlue();
			 int cph1 = new Color(pr3,pg3,pb3).getRGB();
 
			 while (cph1 ==cppd) {
				 Color cphh = new Color(image.getRGB(xh1,xh2));
				 int pr33=cphh.getRed();
				 int pg33=cphh.getGreen();
				 int pb33=cphh.getBlue();
				 int cph11 = new Color(pr33,pg33,pb33).getRGB();
 
				 if (cph11 != cppd) {
					 break;
				 }
			 		g.setColor(new Color(pr3,pg3,pb3));
			 		g.fillRect(xph1, xph2, 24, 24);
			 		g.fillRect(xh1, xh2, 24, 24);
					tabcp.add(new Point(xh1, xh2));
					cases.addPoints(Ph);
				 	Shape rectangleh = new Rectangle2D.Float(xh1,xh2,24,24);
				 	outside = OutsideRect((Rectangle2D) rectangleh, outside);
			 		xph2-=25;
			 		xh2-=25;
			 		cph1=cph11;
			 }
		 }
 
		 if (xb2 >=0) {
			 Color cpb = new Color(image.getRGB(xb1, xb2));
			 int pr4=cpb.getRed();
			 int pg4=cpb.getGreen();
			 int pb4=cpb.getBlue();
			 int cpb1 = new Color(pr4,pg4,pb4).getRGB();
 
			 while (cpb1== cppd) {
				 Color cpbb = new Color(image.getRGB(xb1, xb2));
				 int pr44=cpbb.getRed();
				 int pg44=cpbb.getGreen();
				 int pb44=cpbb.getBlue();
				 int cpb11 = new Color(pr44,pg44,pb44).getRGB();
 
				 if (cpb11 != cppd) {
					 break;
				 }
					 g.setColor(new Color(pr4,pg4,pb4));
					 g.fillRect(xpb1, xpb2, 24, 24);
					 g.fillRect(xb1, xb2, 24, 24);
					 tabcp.add(new Point(xb1, xb2));
					 cases.addPoints(Pb);
				 	 Shape rectangleb = new Rectangle2D.Float(xb1,xb2,24,24);
				 	 outside = OutsideRect((Rectangle2D) rectangleb, outside);
					 xpb2+=25;
					 xb2+=25;
					 cpb1=cpb11;
			 }
		 }
 
		 Color cpd = new Color(image.getRGB(xd1, xd2));
		 int pr1=cpd.getRed();
	     int pg1=cpd.getGreen();
	     int pb1=cpd.getBlue();
		 int cpd1 = new Color(pr1,pg1,pb1).getRGB();
 
		 while (cpd1==cppd) {
			 Color cpdd = new Color(image.getRGB(xd1, xd2));
			 int pr11=cpdd.getRed();
		     int pg11=cpdd.getGreen();
		     int pb11=cpdd.getBlue();
			 int cpd11 = new Color(pr11,pg11,pb11).getRGB();
 
			 if (cpd11 != cppd) {
				 break;
			 }
				 g.setColor(new Color(pr1,pg1,pb1));
				 g.fillRect(xp1, xpd2, 24, 24);
				 g.fillRect(xd1, xd2, 24, 24);
				 tabcp.add(new Point(xd1, xd2));
				 cases.addPoints(Pd);
			 	 Shape rectangled = new Rectangle2D.Float(xd1,xd2,24,24);
			 	 outside = OutsideRect((Rectangle2D) rectangled, outside);
				 xpd1+=25;
				 xd1+=25;
				 cpd1=cpd11;
		 }
		 g2.setClip(outside);
		 BufferedImage image2 = createImage(g2, cases);
	}
 
    private Area OutsideRect(Rectangle2D r, Area c) {
    	c.subtract(new Area(r));
    	return c;
    }
 
	public static void paintAleat(Graphics2D g2, int x2, int y2, int x3, int y3) {
		while (y2<600) {
			Random r = new Random();
			int valeurMin = 1, valeurMax = 6;
			int nr = valeurMin + r.nextInt(valeurMax - valeurMin);
			if (nr==1) {
				g2.setColor(Color.blue);
			}
			if (nr==2) {
				g2.setColor(Color.red);
			}
			if (nr==3) {
				g2.setColor(Color.yellow);
			}
			if (nr==4) {
				g2.setColor(Color.green);
			}
			if (nr==5) {
				g2.setColor(new Color( 213, 128, 0));
			}
	    	g2.drawRect(x2, y2, x3, y3);
	    	g2.fillRect(x2, y2, x3, y3);
	    	y2+=25;
		}
    }
 
	private static BufferedImage createImage(Graphics2D g2, Cases cases) {
        BufferedImage image = new BufferedImage(706, 750, BufferedImage.TYPE_INT_RGB);
		try {
		  int x4=1,y4=1,x5=1;
		  Point position = new Point(x4,y4);
 
		  while (x5<=706) {
		  if (position != tabcp  && position != cases.getPoints())
		  paintAleat(g2, x4, y4, 23, 23);
		  x4+=25;
		  x5+=25;
		  }
	        for(int i=0; i<tabcp.size(); i++) {
	           g2.setColor(Color.GREEN);
	 		   g2.drawRect(tabcp.get(i).x, tabcp.get(i).y, 23, 23);
	        }
		} finally {
		  g2.dispose();
		}
		return image;
}
 
}

Non, je parle de l'endroit où tu affectes une variable de type Cases et où tu l'utilises pour créer des "listeners". Dans une de tes autres discussions, tu avais un code comme çà (extrait) :
Code:

1 2 3 4 5 6 7 Cases cases = new Cases(); bleu.addActionListener(new ListenerBleu()); vert.addActionListener(new ListenerVert()); orange.addActionListener(new ListenerOrange()); rouge.addActionListener(new ListenerRouge()); jaune.addActionListener(new ListenerJaune());
Tu dois avoir quelque chose comme ça, dans cette même méthode :
Code:

1 2 3 4 5 Cases cases = new Cases(); BufferedImage image = cases.getImage(); [...]new ListenerVertC(image,cases); // cases est initialisé avant de la passer en paramètre au constructeur de ListenerVertC
Il faut que la variable cases contienne la référence de l'instance de Cases au moment où on invoque le constructeur.

D'après la stacktrace que tu donnes ( ListenerVertC.createImage(ListenerVertC.java:218), l'erreur se situe en ligne 218 du fichier ListenerVertC.java.

A priori c'est cette ligne : if (position != tabcp && position != cases.getPoints()) (peux-tu me confirmer ?). Si c'est bien cette ligne, la seule raison possible d'une NPE est que cases est null). Il s'agit du paramètre passé à la méthode createImage, méthode appelée dans public void eerc(Graphics2D g2) {, qui utilise la variable de classe cases (de la classe ListenerVertC). eerc() est appelée dans le constructeur, après que this.cases soit affectée par le paramètre cases : donc la seule raison que je vois sans avoir la possibilité de déboguer le programme, c'est que le paramètre cases soit null :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 public ListenerVertC(BufferedImage image, Cases cases) { this.image=image; this.cases=cases; Graphics g = (Graphics)image.getGraphics(); Graphics2D g2 = image.createGraphics(); System.out.println("HelloV"); tabcp.clear(); eerc(g2); for(int i=0; i<tabcp.size(); i++) { System.out.print(tabcp.get(i).x+" "+tabcp.get(i).y+" "); } System.out.println(); }

10/03/2016, 18h14
KoupaXII

Citation:

A priori c'est cette ligne : if (position != tabcp && position != cases.getPoints())

Oui, c'est celle-ci, mais j'ai donc suivis ce que tu m'a dis et le tableau fonctionne maintenant, seulement j'ai un autre problème qui que lorsque j'ajoute un Point au tableau, celui-ci ne vérifie pas que celui-ci soit déjà inscrit dans le tableau, j'obtient donc ceci en sorti:

"HelloV
1 1
1 1
------------------------------
HelloV
1 1 1 26
1 1 1 1 1 26
------------------------------
HelloV
1 1 1 26 26 1
1 1 1 1 1 26 1 1 1 26 26 1
------------------------------
HelloV
1 1 1 26 26 1
1 1 1 1 1 26 1 1 1 26 26 1 1 1 1 26 26 1"

(La deuxième ligne correspond au tableau en question "tabcq").
J'aimerais que le point n'apparaisse qu'une seule fois dans le tableau.
Un moyen de contourner ceci ?

Dans l'absolu, tu peux vérifier si un point existe déjà dans la liste, en utilisant la méthode contains() de List qui teste si un élément est déjà dans la liste en utilisant equals() pour comparer. En modifiant addPoints() par exemple comme ceci
Code:

1 2 3 4 5 6 7 public void addPoints(Point...points) { for(Point point : points) { if ( !tabcq.contains(point) ) { // si le point n'est pas déjà dans la liste... tabcq.add(point); // ...on l'ajoute } } }
Ensuite, cela peut dépendre de la raison pour laquelle on ajoute plusieurs fois le même point. Mais ça peut être compliqué à gérer selon les cas. Par exemple, si on a une procédure unique de génération de point qu'on appelle plusieurs fois, on peut vider la liste entre chaque appel (par la méthode clear() de List) : ainsi, à chaque fois on repart d'une liste vide, donc on a pas les éléments en double, sauf si la procédure elle-même génère des poins en double. Mais si tu as plusieurs procédures de génération (et c'est ce que je crois comprendre puisque tu a ListenerVertC, ListenerBleuC... ça devient compliqué de savoir quand faire le clear)

On peut également utiliser un Set au lieu d'une List (donc d'un HashSet au lieu d'une ArrayList), mais on perd l'ordre d'insertion et on ne peut plus accéder à un point dans la liste par son index (on doit toujours parcourir tout le set) : si cet ordre n'a aucune importance, il n'y a même plus besoin du test avec contains().

Une autre question : y'a t-il des points en commun entre ListenerVertC, ListenerBleuC, rouge, etc ? Doit-on garder les différents points en double s'ils ne sont pas générés par les mêmes "couleurs" ou non ?

En fait, avec cette liste, je compte dessiner un rectangle avec les coordonnés du tableau de cette façon:
Code:

1 2 3 4 5 for(int i=0; i<cases.getPoints().size(); i++) { Shape rectangle = new Rectangle2D.Float(cases.getPoints().get(i).x,cases.getPoints().get(i).y, 23, 23); g2.setColor(Color.GREEN); g2.draw(rectangle); }
J'ai utilisé la première méthode que tu a donnée, elle correspond le mieux à ce que je veux faire.

Citation:

Une autre question : y'a t-il des points en commun entre ListenerVertC, ListenerBleuC, rouge, etc ? Doit-on garder les différents points en double s'ils ne sont pas générés par les mêmes "couleurs" ou non ?

Oui, quand je crée des points dans ListenerVertC par exemple, je crée les mêmes dans ListenerBleuC, mais je n'ais pas besoin de les avoir en double dans mon tableau, car celui-ci contient les coordonnées des cases "conquises".

Merci pour ton aide

10/03/2016, 18h50
joel.drigo

Citation:

Envoyé par KoupaXII

Oui, quand je crée des points dans ListenerVertC par exemple, je crée les mêmes dans ListenerBleuC, mais je n'ais pas besoin de les avoir en double dans mon tableau, car celui-ci contient les coordonnées des cases "conquises".

Des points de même coordonnées généré par ListenerVertC et ListenerBleuC représentent donc le même point, donc c'est bien cette solution avec contains() qui te convient (on pourrait utiliser aussi un Set, mais ça va te compliquer et tu vas devoir modifier plein de code : donc laisse la List et le contains(), tu verras plus tard les Set à l'occasion).

1 pièce(s) jointe(s)

Après quelques essais, j'ai finalement encore un problème:
J'ai voulu faire en sorte que le programme crée des rectangles d'une certaine couleur à partir des coordonnées du tableau. J'ai donc utilisé la méthode suivante:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
	private static BufferedImage createImage(Graphics2D g2, Cases cases) {
        BufferedImage image = new BufferedImage(706, 750, BufferedImage.TYPE_INT_RGB);
		try {
		  int x4=1,y4=1,x5=1;
		  Point position = new Point(x4,y4);
 
		  while (x5<=706) {
		  if (position != cases.getPoints()) {
		  paintAleat(g2, x4, y4, 23, 23);
		  x4+=25;
		  x5+=25;
		  	}
		  }
	        for(int i=0; i<cases.getPoints().size(); i++) {
		           Shape rectangle = new Rectangle2D.Float(cases.getPoints().get(i).x,cases.getPoints().get(i).y, 23, 23);
		           g2.setColor(Color.GREEN);
		 		   g2.draw(rectangle);
		        }
		} finally {
		  g2.dispose();
		}
		return image;
}

Seulement, voici ce qui s'affiche dans la fenêtre:
Pièce jointe 203531

Je ne sais pas si c'est dû à la méthode que j'utilise pour le dessin ou la façon d'afficher l'image...
Ne sachant pas quel(s) class est nécessaire pour trouver le problème j'ai mis toutes les class.

La class Listener en entier:

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
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
import javax.swing.*;
 
import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.awt.*;
import java.awt.geom.Area;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
 
public class ListenerVertC extends JPanel {
 
	private final BufferedImage image;
	  int xp1=1, xp2=1;
	  int xpg1=1, xph1=1, xpb1=1, xpd1=1, xpg2=1, xpd2=1, xph2=1, xpb2=1;
	  int xg1=xpg1-25, xg2=xpg2;
	  int xd1=xpd1+25, xd2=xpd2;
	  int xh1=xph1, xh2=xph2-25; 
	  int xb1=xpb1, xb2=xpb2+25;
	  static List<Point> tabcp = new ArrayList<>();
	  int cppd = -16711936;
	  private Cases cases;
 
 
	public ListenerVertC(BufferedImage image, Cases cases) {
		this.image=image;
        this.cases=cases;
		Graphics g = (Graphics)image.getGraphics();
		Graphics2D g2 = image.createGraphics();
		System.out.println("HelloV");
		tabcp.clear();
        eerc(g2);
        for(int i=0; i<tabcp.size(); i++) {
            System.out.print(tabcp.get(i).x+" "+tabcp.get(i).y+" ");       
        }
        System.out.println();
        for(int i=0; i<cases.getPoints().size(); i++) {
            System.out.print(cases.getPoints().get(i).x+" "+cases.getPoints().get(i).y+" ");       
        }
        System.out.println();
	}
 
	public void paintComponent(Graphics g) {
		g.drawImage(image,0,0,null);
	}
 
 
	public void eerc(Graphics2D g2) {
		Graphics g = (Graphics)image.getGraphics();
        tabcp.add(new Point(xp1,xp2));
  	    Point Pp = new Point(xp1,xp2);
		cases.addPoints(Pp);
 
	 	Shape rectangledepart = new Rectangle2D.Float(xp1,xp2,25,25);
		Shape rectangleEntier = new Rectangle2D.Float(0,0,706,600);
	 	Area outside = new Area(rectangleEntier);
    	outside.subtract(new Area(rectangledepart));
 
        Color cpp= new Color(image.getRGB(xp1, xp2));
		 int pr=cpp.getRed();
	     int pg=cpp.getGreen();
	     int pb=cpp.getBlue();
		 @SuppressWarnings("unused")
		int cpp1 = new Color(pr,pg,pb).getRGB();
 
		 if (xg1 >=0) {
			 Color cpg = new Color(image.getRGB(xg1, xg2));
			 int pr2=cpg.getRed();
			 int pg2=cpg.getGreen();
			 int pb2=cpg.getBlue();
			 int cpg1 = new Color(pr2,pg2,pb2).getRGB();
 
		 while (cpg1 == cppd) {
	     Point Pg = new Point(xg1,xg2);
		 Color cpgg = new Color(image.getRGB(xg1, xg2));
		 int pr22=cpgg.getRed();
		 int pg22=cpgg.getGreen();
		 int pb22=cpgg.getBlue();
		 int cpg11 = new Color(pr22,pg22,pb22).getRGB();
		 if (cpg11 != cppd) {
			 break;
		 }
	 	 g.setColor(new Color(pr2,pg2,pb2));
	 	 g.fillRect(xpg1, xpg2, 24, 24);
	 	 g.fillRect(xg1, xg2, 24, 24);
		 tabcp.add(new Point(xg1, xg2));
		 cases.addPoints(Pg);
	 	 Shape rectangleg = new Rectangle2D.Float(xg1,xg2,24,24);
	 	 outside = OutsideRect((Rectangle2D) rectangleg, outside);
	 	 xpg1-=25;
	 	 xg1-=25;
	 	 cpg1=cpg11;
		 }
		 }
 
		 if (xh2 >=0) {
			 Color cph = new Color(image.getRGB(xh1, xh2));
			 int pr3=cph.getRed();
			 int pg3=cph.getGreen();
			 int pb3=cph.getBlue();
			 int cph1 = new Color(pr3,pg3,pb3).getRGB();
 
			 while (cph1 ==cppd) {
				 Point Ph = new Point(xh1,xh2);
				 Color cphh = new Color(image.getRGB(xh1,xh2));
				 int pr33=cphh.getRed();
				 int pg33=cphh.getGreen();
				 int pb33=cphh.getBlue();
				 int cph11 = new Color(pr33,pg33,pb33).getRGB();
 
				 if (cph11 != cppd) {
					 break;
				 }
			 		g.setColor(new Color(pr3,pg3,pb3));
			 		g.fillRect(xph1, xph2, 24, 24);
			 		g.fillRect(xh1, xh2, 24, 24);
					tabcp.add(new Point(xh1, xh2));
					cases.addPoints(Ph);
				 	Shape rectangleh = new Rectangle2D.Float(xh1,xh2,24,24);
				 	outside = OutsideRect((Rectangle2D) rectangleh, outside);
			 		xph2-=25;
			 		xh2-=25;
			 		cph1=cph11;
			 }
		 }
 
		 if (xb2 >=0) {
			 Color cpb = new Color(image.getRGB(xb1, xb2));
			 int pr4=cpb.getRed();
			 int pg4=cpb.getGreen();
			 int pb4=cpb.getBlue();
			 int cpb1 = new Color(pr4,pg4,pb4).getRGB();
 
			 while (cpb1== cppd) {
				 Point Pb = new Point(xb1,xb2);
				 Color cpbb = new Color(image.getRGB(xb1, xb2));
				 int pr44=cpbb.getRed();
				 int pg44=cpbb.getGreen();
				 int pb44=cpbb.getBlue();
				 int cpb11 = new Color(pr44,pg44,pb44).getRGB();
 
				 if (cpb11 != cppd) {
					 break;
				 }
					 g.setColor(new Color(pr4,pg4,pb4));
					 g.fillRect(xpb1, xpb2, 24, 24);
					 g.fillRect(xb1, xb2, 24, 24);
					 tabcp.add(new Point(xb1, xb2));
					 cases.addPoints(Pb);
				 	 Shape rectangleb = new Rectangle2D.Float(xb1,xb2,24,24);
				 	 outside = OutsideRect((Rectangle2D) rectangleb, outside);
					 xpb2+=25;
					 xb2+=25;
					 cpb1=cpb11;
			 }
		 }
 
		 Color cpd = new Color(image.getRGB(xd1, xd2));
		 int pr1=cpd.getRed();
	     int pg1=cpd.getGreen();
	     int pb1=cpd.getBlue();
		 int cpd1 = new Color(pr1,pg1,pb1).getRGB();
 
		 while (cpd1==cppd) {
			 Point Pd = new Point(xd1,xd2);
			 Color cpdd = new Color(image.getRGB(xd1, xd2));
			 int pr11=cpdd.getRed();
		     int pg11=cpdd.getGreen();
		     int pb11=cpdd.getBlue();
			 int cpd11 = new Color(pr11,pg11,pb11).getRGB();
 
			 if (cpd11 != cppd) {
				 break;
			 }
				 g.setColor(new Color(pr1,pg1,pb1));
				 g.fillRect(xp1, xpd2, 24, 24);
				 g.fillRect(xd1, xd2, 24, 24);
				 tabcp.add(new Point(xd1, xd2));
				 cases.addPoints(Pd);
			 	 Shape rectangled = new Rectangle2D.Float(xd1,xd2,24,24);
			 	 outside = OutsideRect((Rectangle2D) rectangled, outside);
				 xpd1+=25;
				 xd1+=25;
				 cpd1=cpd11;
		 }
		 g2.setClip(outside);
		 BufferedImage image2 = createImage(g2, cases);
	}
 
    private Area OutsideRect(Rectangle2D r, Area c) {
    	c.subtract(new Area(r));
    	return c;
    }
 
	public static void paintAleat(Graphics2D g2, int x2, int y2, int x3, int y3) {
		while (y2<600) {
			Random r = new Random();
			int valeurMin = 1, valeurMax = 6;
			int nr = valeurMin + r.nextInt(valeurMax - valeurMin);
			if (nr==1) {
				g2.setColor(Color.blue);
			}
			if (nr==2) {
				g2.setColor(Color.red);
			}
			if (nr==3) {
				g2.setColor(Color.yellow);
			}
			if (nr==4) {
				g2.setColor(Color.green);
			}
			if (nr==5) {
				g2.setColor(new Color( 213, 128, 0));
			}
	    	g2.drawRect(x2, y2, x3, y3);
	    	g2.fillRect(x2, y2, x3, y3);
	    	y2+=25;
		}
    }
 
	private static BufferedImage createImage(Graphics2D g2, Cases cases) {
        BufferedImage image = new BufferedImage(706, 750, BufferedImage.TYPE_INT_RGB);
		try {
		  int x4=1,y4=1,x5=1;
		  Point position = new Point(x4,y4);
 
		  while (x5<=706) {
		  if (position != cases.getPoints()) {
		  paintAleat(g2, x4, y4, 23, 23);
		  x4+=25;
		  x5+=25;
		  	}
		  }
	        for(int i=0; i<cases.getPoints().size(); i++) {
		           Shape rectangle = new Rectangle2D.Float(cases.getPoints().get(i).x,cases.getPoints().get(i).y, 23, 23);
		           g2.setColor(Color.GREEN);
		 		   g2.draw(rectangle);
		        }
		} finally {
		  g2.dispose();
		}
		return image;
}
 
}

La class Cases en entier:

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
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
import javax.swing.*;
 
import java.io.*;
import java.util.List;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GridLayout;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.image.BufferedImage;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Random;
 
 
 
@SuppressWarnings("serial")
 
public class Cases extends JPanel {
 
	final static BufferedImage baseImage = createImage();
	static BufferedImage imageCopie;
	private final List<Point> tabcq;
 
 
		private static BufferedImage createImage() {
            BufferedImage image = new BufferedImage(706, 750, BufferedImage.TYPE_INT_RGB);
			Graphics g = (Graphics)image.createGraphics();
			try {
			  int x1=0,y1=0,x4=1,y4=1,x5=1;
			  g.setColor(Color.BLACK);
			  while (x1<=706) {
			  g.drawLine(x1, 0, x1, 600);
			  x1+=25;
			  }
			  while (y1<=600) {
			  g.drawLine(0, y1, 707, y1);
			  y1+=25;
			  }
			  while (x5<=706) {
			  paintAleat(g, x4, y4, 23, 23);
			  x4+=25;
			  x5+=25;
			  }
			} finally {
			  g.dispose();
			}
			return image;
	}
 
public Cases() {
	imageCopie = copy(baseImage);
	tabcq = new ArrayList<>();
}
 
public List<Point> getPoints() {
    return Collections.unmodifiableList(tabcq);
}
 
public void addPoint(int x, int y) {
    addPoints(new Point(x,y));
}
 
public void addPoints(Point...points) {
    for(Point point : points) {
        if ( !tabcq.contains(point) ) { // si le point n'est pas déjà dans la liste...
            tabcq.add(point); // ...on l'ajoute
        }
    }
}
 
public void clearPoints() {
    tabcq.clear();
}
 
	public void paintComponent(Graphics g) {
        g.drawImage(baseImage, 0, 0, null);
}
 
	public static BufferedImage getImage() {
		return baseImage;
	}
 
	public static BufferedImage getImageCopie() {
		return imageCopie;
	}
 
 
 
	public static void paintAleat(Graphics g, int x2, int y2, int x3, int y3) {
		while (y2<600) {
			Random r = new Random();
			int valeurMin = 1, valeurMax = 6;
			int nr = valeurMin + r.nextInt(valeurMax - valeurMin);
			if (nr==1) {
				g.setColor(Color.blue);
			}
			if (nr==2) {
				g.setColor(Color.red);
			}
			if (nr==3) {
				g.setColor(Color.yellow);
			}
			if (nr==4) {
				g.setColor(Color.green);
			}
			if (nr==5) {
				g.setColor(new Color( 213, 128, 0));
			}
	    	g.drawRect(x2, y2, x3, y3);
	    	g.fillRect(x2, y2, x3, y3);
	    	y2+=25;
		}
    }	
 
	private BufferedImage copy(BufferedImage image) {
 
		final BufferedImage copy = new BufferedImage(image.getWidth(), image.getHeight(), image.getType());
		final Graphics2D g2d = copy.createGraphics();
		try {
			g2d.drawImage(image, 0, 0, null);
		}
		finally {
			g2d.dispose();
		}
		return copy;
	}
}

La class Fenetre en entier:

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
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
95
96
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener; 
import java.awt.image.BufferedImage;
import javax.swing.*;
import java.io.*;
import java.awt.*;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JButton;
 
@SuppressWarnings("serial")
public class Fenetre extends JFrame {
 
	static Cases cases = new Cases();
	private static final BufferedImage image = cases.getImage();
 
	public Fenetre(){
 
		this.setTitle("Colonisation");
	    this.setSize(706, 750);
	    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	    this.setLocationRelativeTo(null);
	    this.setResizable(false);
 
	    JButton bleu = new BB("Bleu");
	    JButton vert = new BV("Vert");
	    JButton orange = new BO("Orange");
	    JButton rouge = new BR("Rouge");
	    JButton jaune = new BJ("Jaune");
	    JPanel content = new JPanel(new BorderLayout());
	    JPanel contentSouth = new JPanel();
 
 
 
	    bleu.addActionListener(new ListenerBleu());
	    rouge.addActionListener(new ListenerRouge());
	    vert.addActionListener(new ListenerVert());
	    orange.addActionListener(new ListenerOrange());
	    jaune.addActionListener(new ListenerJaune());
 
	    contentSouth.add(rouge);
	    contentSouth.add(bleu);
	    contentSouth.add(vert);
	    contentSouth.add(jaune);
	    contentSouth.add(orange);
	    content.add(contentSouth,BorderLayout.SOUTH);
	    content.add(cases,BorderLayout.CENTER);
 
 
	    this.add(content);
	    this.setVisible(true);
  }
 
	class ListenerBleu extends JFrame implements ActionListener {
 
		public void actionPerformed(ActionEvent arg0) {
			ListenerBleuC LB = new ListenerBleuC(image, cases);
			cases.repaint();
		}
	}
 
	class ListenerVert extends JFrame implements ActionListener {
 
		public void actionPerformed(ActionEvent arg0) {
			ListenerVertC LV = new ListenerVertC(image, cases);
			cases.repaint();
		}
	}
 
	class ListenerOrange extends JFrame implements ActionListener {
 
		public void actionPerformed(ActionEvent arg0) {
			ListenerOrangeC LO = new ListenerOrangeC(image, cases);
			cases.repaint();
		}
	}
 
	class ListenerJaune extends JFrame implements ActionListener {
 
		public void actionPerformed(ActionEvent arg0) {
			ListenerJauneC LJ = new ListenerJauneC(image, cases);
			cases.repaint();
		}
	}
 
	class ListenerRouge extends JFrame implements ActionListener {
 
		public void actionPerformed(ActionEvent arg0) {
			ListenerRougeC LR = new ListenerRougeC(image, cases);
			cases.repaint();
		}
	}
 
}

11/03/2016, 10h50
joel.drigo
Je ne suis pas sûr de comprendre quel est ton problème... si c'est le fait que tu voudrais des cases remplies au lieu d'avoir que la bordure, il suffit d'utiliser fill() au lieu de draw() :
Code:

1 2 g2.setColor(Color.GREEN); g2.fill(rectangle);
11/03/2016, 18h32
KoupaXII

Oui, c'est ce que j'essayais de faire, c'est bête comme erreur...

Merci