Récupérer les coordonnées d'une image sur JPanel

Version imprimable

Bonjour,

J'ai inséré dans un JPanel un nombre d'images :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public static  JPanel paneLevel(int l){
        switch(l){
        case 1:
            pan=new JPanel();
            pan.setSize(200, 200);
            //car l' image est commune
            img=new ImageIcon("C:\\Users\\Desktop\\ImgJeux\\31-13.png");
            //----img1---
            /*l1=new JLabel();
            l1.setIcon(img);
            pan.add(l1);
            */
            for(int i=0;i<20;i++){
                tabLab[i]=new JLabel();
                tabLab[i].setIcon(img);
                pan.add(tabLab[i]);
            }
            break;            
        }
        return pan;
    }

et j'aimerais récupérer les coordonées de chaque image.

Quelqu'un saurait-il m'indiquer comment faire ?

Merci d'avance pour votre aide.

02/11/2014, 11h58
joel.drigo

Salut,

Tu peux récupérer les coordonnées de n'importe quel composant par la méthode getLocation(), sous forme de Point, et relativement à son conteneur parent. Lorsque le conteneur est agencé par un LayouManager, cela ne pourra pas être fait avant le premier layout, donc pas avant que cela soit affiché. On peut obtenir les 2 mêmes coordonnées séparément avec getX() et getY(). On peut également obtenir les coordonnées dans l'écran par getLocationOnScreen(), ou relativement à un autre composant (par exemple la fenêtre) par SwingUtilities.convertPoint(Component source, Point location, Component destination).

merci joel pour la réponse mais il m'affiche toujours que des 0.0.
pour bien clarifier, voila le code complet :

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
import javax.swing.*;
 
import java.awt.*;
import java.awt.image.BufferedImage;
import java.util.Vector;
 
public class Brick extends JFrame {
  public  int lev;
  public static JPanel pan;
  public static ImageIcon img,img1;
  private static JLabel[] tabLab=new JLabel[20];
  private static JLabel[] tab=new JLabel[20];
  public static JLabel l1,l2,l3,l4,l5,l6,l7,l8,l9;
  public static Component[] cmp;
 
	public Brick(int level){
		lev=level;
	}
 
	public static  JPanel paneLevel(int l){
		switch(l){
		case 1:
			pan=new JPanel();
			pan.setSize(200, 200);
                           //car l' image est commune
			img=new ImageIcon("C:\\Users\\HAMDANE\\Desktop\\ImgJeux\\31-13.png");
			//----img1---
			/*l1=new JLabel();
			l1.setIcon(img);
			pan.add(l1);
			*/
			for(int i=0;i<20;i++){
				tabLab[i]=new JLabel();
				tabLab[i].setIcon(img);
				pan.add(tabLab[i]);
				//tab[i]=tabLab[i];
			}
			break;			
		}
		return pan;
				//tab;
	}
 
	public static void getSizeOfElements(){
 
		pan=paneLevel(1);
		cmp=pan.getComponents();
		for(int i=0;i<cmp.length;i++){
 
			System.out.println("width de"+i+":"+cmp[i].getLocation().getX());
			System.out.println("height de"+i+":"+cmp[i].getLocation().getY());
	}
	}
 
	public static void main(String []args){
		JFrame f=new JFrame("Brick Test");
		f.setSize(300, 300);
		JPanel p=new JPanel();
		p=Brick.paneLevel(1);
		f.setContentPane(p);
		getSizeOfElements();
 
		f.setVisible(true);
	}
}

merci encore une fois :)

Premièrement, j'ai dit :

Citation:

Envoyé par joel.drigo

cela ne pourra pas être fait avant le premier layout, donc pas avant que cela soit affiché.

Donc, il faut aller getSizeOfElements() après avoir appelé f.setVisible(true).

Deuxièment, il y a un problème dans ta façon de stocker et de créer pan : lors de l'appel de Brick.paneLevel(1), tu créées une instance de JPanel, que tu mets dans ta JFrame avec f.setContentPane(p);. Ensuite, quand tu appelles getSizeOfElements(), ça appelle une seconde fois Brick.panelLevel(1), ce qui créé un nouveau JPanel, qui n'est pas mis dans la JFrame, donc jamais affiché : donc tu auras toujours 0, que cela soit pour les positions, comme pour les tailles.
De toute manière, tu devrais éviter d'utiliser des static pour stocker tes composants. A part pour des static final, n'utilise jamais de static. Tu les utiliseras peut-être plus tard quand tu auras bien compris ce qu'ils impliquent. En plus, dans ton cas, il y a pleins de variables inutiles : dans tous les cas, il n'y a pas besoin de stocker les éléments dans des variables. Ensuite, comme tu es censé appeller panelLevel(int) avec des paramètres différents, il faudra en théorie stocker plusieurs panels, puisque tu peux en créer plusieurs différents, ou alors il faut supprimer le paramètre et le switch..

Ensuite, la taille ce n'est pas les coordonnées : pour avoir la taille, on appelle soit getSize(), soit getWidth(), soit getHeight().

Au lieu d'écrire :

Code:

System.out.println("width de"+i+":"+cmp[i].getLocation().getX());

autant écrire :

Code:

System.out.println("width de"+i+":"+cmp[i].getX());

Enfin, dans ton cas, ce serait :

Code:

System.out.println("width de"+i+":"+cmp[i].getWidth());

Accessoirement, si c'est la taille de l'image que tu veux, tu peux l'obtenir directement sur l'instance d'ImageIcon, par getIconWitdh() et getIconHeight(). La taille du JLabel qui contient l'image peut être différente de la taille de l'image, selon le LayoutManager.

Je ne parle pas du chemin absolu vers l'image qui te posera des problèmes pour diffuser le programme, tu auras l'occasion de voir ça plus tard.

Voici le programme final pour faire exactement ce que tu fais :
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 public class Brick extends JFrame { private final static ImageIcon img = new ImageIcon("C:\\Users\\HAMDANE\\Desktop\\ImgJeux\\31-13.png"); // appelé une fois, donc image chargé une seule fois public static JPanel paneLevel(int level){ JPanel pan=null; switch(level){ case 1: pan=new JPanel(); // inutile : le LayoutManager se charge de lui donner une taille pan.setSize(200, 200); for(int i=0;i<20;i++){ JLabel label = new JLabel(); label.setIcon(img); pan.add(label); } break; } return pan; } public static void getSizeOfElements(JPanel panel) { Component[] components = panel.getComponents(); for (int i=0; i<components.length; i++) { System.out.println("width de" + i + ": " + components[i].getWidth()); System.out.println("height de" + i + ": " + components[i].getHeight()); } } public static void main(String[] args) { JFrame f = new JFrame("Brick Test"); f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // permet à ce que l'application s'arrête lorsqu'on ferme la fenêtre f.setSize(300, 300); JPanel p = new JPanel(); p = Brick.paneLevel(1); f.setContentPane(p); f.setVisible(true); getSizeOfElements(p); } }
Ou si tu veux stocker tes labels dans un tableau pour les parcourir ensuite :
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 public class Brick extends JFrame { private final static ImageIcon img = new ImageIcon("C:\\Users\\HAMDANE\\Desktop\\ImgJeux\\31-13.png"); // appelé une fois, donc image chargé une seule fois private final static int NB_COMPONENT=20; private final JLabel[] labels=new JLabel[NB_COMPONENT]; // labels est propre à chaque instance de Brick private final int level; public Brick(int level) { this.level = level; JPanel panel = new JPanel(); setImages(panel); setContentPane(panel); } public final int getLevel() { return level; } private void setImages(JPanel panel){ switch(level){ case 1: for(int i=0;i<NB_COMPONENT;i++){ JLabel label = new JLabel(); label.setIcon(img); panel.add(label); labels[i]=label; } break; default: throw new IllegalArgumentException("Paramètre level incorrect : " + level); } } public void printSizeOfImages() { for (int i=0; i<labels.length; i++) { System.out.println("width de " + i + ": " + labels[i].getWidth()); System.out.println("height de " + i + ": " + labels[i].getHeight()); } } public static void main(String[] args) { Brick brick = new Brick(1); brick.setTitle("Brick Test"); brick.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // permet à ce que l'application s'arrête lorsqu'on ferme la fenêtre brick.setSize(300, 300); brick.setVisible(true); brick.printSizeOfImages(); } }

02/11/2014, 21h14
abdel_java

merci énormément Joel pour la solution ainsi que les conseils :)
03/11/2014, 15h32
abdel_java
Salut mes amis,
J'ai un problème : j'ai ajouté une image dans un jpanel avec :
Code:

1 2 3 4 private final static ImageIcon img = new ImageIcon("C:\\Users\\HAMDANE\\Desktop\\ImgJeux\\31-13.png"); JLabel label = new JLabel(); label.setIcon(img); panel.add(label);
et je la déplace avec un thread.
Le problème est que cette image se bloque de temps en temps (presque des millisecondes). Est-ce qu'il y a une méthode pour éviter ce problème ?

Merci d'avance :D
03/11/2014, 18h25
joel.drigo

Et c'est quoi le code du thread ?

voila le code du thread ainsi que la methode paint:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
	 public void paint(Graphics g){
		 super.paint(g);
		 Image img=new ImageIcon("C:\\Users\\HAMDANE\\Desktop\\ImgJeux\\ball3.png").getImage();
		 g.drawImage(img, y, x, this);
 
	 }
 
	 public void update(){
		 x=x+a;
		 if(x>=this.getWidth()-45 || x<=25 ) a=-a;
		 y=y+b ;
		 if(y>=this.getHeight()-18 || y<=5) b=-b;
	 }
 
	 public void run(){
		 while(true){
		 try{
			 Thread.sleep(8);
		 }catch(InterruptedException e){}
		 update();
		 repaint();}
	 }

Premièrement, évite de charger ton image dans le thread graphique, pour gagner du temps. Ensuite, tes variables x et y devraient être déclarées volatile (modifiés dans un thread et utilisés dans un autre : sans ça, tu peux avoir des délais dans la mise à jour de la valeur effective de la variable dans l'autre thread).
Utilise également un doublebuffer pour éviter certains effets qu'on peut observer lors d'animations assez rapides.

Par ailleurs, il semble qu'il y ait une erreur d'inversion de x et y dans leur utilisation dans la méthode drawImage. Utilise plus de constantes, et évite les boucles explicitement infinies.

Voici une première version :

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
public class DemoAnim extends JPanel implements Runnable {
 
	private static final Image IMG = new ImageIcon("C:\\Users\\HAMDANE\\Desktop\\ImgJeux\\ball3.png").getImage();
 
	private static final Insets INSETS = new Insets(10, 10, 10, 10);
	private static final int STEP=5;
 
	private static final long TIME = 8;
 
	private volatile boolean running;
	private volatile int x=INSETS.left;
	private volatile int y=INSETS.top;
 
	private int a=STEP;
	private int b=STEP;
 
	public DemoAnim() {
		super(true); // doublebuffered=true
	}
 
	public void paint(Graphics g) {
		super.paint(g);
		g.drawImage(IMG, x, y, this);
 
	}
 
	public void update() {
		int imgwidth = IMG.getWidth(this);
		int imgheight = IMG.getHeight(this);
		x += a;
		int right = this.getWidth() - INSETS.right;
		if (x + imgwidth >= right ) {
			a = -a;
			x = right - imgwidth;
		}
		else if ( x<=INSETS.left ) {
			a = -a;
			x = INSETS.left;
		}
		y += b;
		int bottom = this.getHeight() - INSETS.bottom;
		if (y + imgheight >= bottom ) {
			b = -b;
			y = bottom - imgheight;
		}
		else if (y <= INSETS.top) {
			b = -b;
			y = INSETS.top;
		}
	}
 
	public void run() {
		running = true;
		while (running) {
			try {
				Thread.sleep(TIME);
			} catch (InterruptedException e) {
				break;
			}
			update();
			repaint();
		}
	}
 
	public void stop() {
		running=true;
	}
 
	public static void main(String[] args) {
 
		JFrame frame = new JFrame("test");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		DemoAnim anim = new DemoAnim();
 
		frame.getContentPane().add(anim);
		frame.addWindowListener(new WindowAdapter() {
			private Thread thread;
 
			@Override
			public void windowOpened(WindowEvent e) {
				thread = new Thread(anim);
				thread.start();
			}
 
			@Override
			public void windowClosed(WindowEvent e) {
				anim.stop();
				thread.interrupt();
			}
		});
 
		frame.setSize(Toolkit.getDefaultToolkit().getScreenSize());
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
 
	}
 
}

Il réside un défaut dans cette version : comme le thread graphique peut dessiner à tout moment, on peut dessiner alors que les coordonnées sont en cours d'élaboration (donc un x(t) et un y(t+n), voire un x ou y à moitié élaboré (puisque dans mon code, on modifie potentiellement deux fois x (ou y) dans update()).

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
public class DemoAnim extends JPanel implements Runnable {
 
	private static final Image IMG = new ImageIcon("C:\\Users\\HAMDANE\\Desktop\\ImgJeux\\ball3.png").getImage();
 
	private static final Insets INSETS = new Insets(10, 10, 10, 10);
	private static final int STEP=5;
 
	private static final long TIME = 8;
 
	private volatile boolean running;
	private volatile Point point = new Point(INSETS.left,INSETS.top);
 
	private int a=STEP;
	private int b=STEP;
 
	public DemoAnim() {
		super(true);
	}
 
	public void paint(Graphics g) {
		super.paint(g);
		g.drawImage(IMG, point.x, point.y, this);
 
	}
 
	public void update() {
		int imgwidth = IMG.getWidth(this);
		int imgheight = IMG.getHeight(this);
		int x=point.x;
		int y=point.y;
		x += a;
		int right = this.getWidth() - INSETS.right;
		if (x + imgwidth >= right ) {
			a = -a;
			x = right - imgwidth;
		}
		else if ( x<=INSETS.left ) {
			a = -a;
			x = INSETS.left;
		}
		y += b;
		int bottom = this.getHeight() - INSETS.bottom;
		if (y + imgheight >= bottom ) {
			b = -b;
			y = bottom - imgheight;
		}
		else if (y <= INSETS.top) {
			b = -b;
			y = INSETS.top;
		}
		point=new Point(x,y);
	}
 
	public void run() {
		running = true;
		while (running) {
			try {
				Thread.sleep(TIME);
			} catch (InterruptedException e) {
				break;
			}
			update();
			repaint();
		}
	}
 
	public void stop() {
		running=true;
	}
 
	public static void main(String[] args) {
 
		JFrame frame = new JFrame("test");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		DemoAnim anim = new DemoAnim();
 
		frame.getContentPane().add(anim);
		frame.addWindowListener(new WindowAdapter() {
			private Thread thread;
 
			@Override
			public void windowOpened(WindowEvent e) {
				thread = new Thread(anim);
				thread.start();
			}
 
			@Override
			public void windowClosed(WindowEvent e) {
				anim.stop();
				thread.interrupt();
			}
		});
 
		frame.setSize(Toolkit.getDefaultToolkit().getScreenSize());
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
 
	}
 
}

On pourrait encore gagner du temps, donc de la fluidité, en ne redessinant que la partie qui change dans le panel.