Discussion :

[I-DEXX]

Bonjour,

J'ai créer une fenêtre contenant un Canvas dans lequel j'affiche un BufferedImage. J'ai donc une zone faisant x pixels de large et y pixels de haut.

Le problème est que lorsque je clique sur ma zone, le mouseEvent ne me renvoie pas toujours la bonne position.

Par exemple lorsque je clique sur le pixel :

(1;1) le mouseEvent me renvoie bel et bien (1;1).
(1;16) le mouseEvent me renvoie (1;15).
(1;32) le mouseEvent me renvoie (1;30).

et ainsi de suite ...

Est-il possible que la taille des pixel d'un canvas diffère de la taille d'un pixel ?

Y-a-t'il une solution a mon problème ?

merci d'avance.

[wax78]

Tu px poster un bout de code testable et minimaliste pour essayer ? Normalement la taile des pixel ne change pas...

[I-DEXX]

Merci de ta réponse, voici le code :


La classe extends Canvas

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
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
 
public class Core extends Canvas implements Runnable {
 
	private static final long serialVersionUID = 1L;
 
	public static int WIDTH = 332;
	public static int HEIGHT = 332 ;
	public static int SCALE = 2;
 
	private boolean running;
	private Thread thread;
	private JFrame frame;
 
	private BufferedImage image = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);
	private int[] pixels = ((DataBufferInt)image.getRaster().getDataBuffer()).getData(); // Raster of our image
 
	private Mouse mouseEvent;
 
 
	public Core(){
		frame = new JFrame();
 
		Dimension size = new Dimension(WIDTH * SCALE, HEIGHT * SCALE);
		setPreferredSize(size);
 
		mouseEvent = new Mouse(SCALE);
		addMouseListener(mouseEvent);
 
	}
 
	public void tick(){
 
		// Tester ici en faisant un System.out.println par exemple
	}
 
	public void render(){
 
		BufferStrategy bs = getBufferStrategy();
		if(bs == null){
			createBufferStrategy(3);
			return;
		}
 
		for(int x = 0;x<pixels.length;x++){
			pixels[x] = (x%2 == 0) ? 0x000000 : 0xFFFFFF;
		}
 
		Graphics g = bs.getDrawGraphics();
		g.drawImage(image,  0,  0,  getWidth(), getHeight(), null);
		g.dispose();
		bs.show();
	}
 
	public synchronized void start(){
		running = true;
		thread = new Thread(this, "pkmn");
		thread.start();
	}
 
	public synchronized void stop(){
		running = false;
		try {
			thread.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
 
	public void run() {
 
		long first = System.nanoTime();
		final double ns = 1000000000.0/60.0; // number of nano-seconds to have 60 per second
		double delta = 0;
		long timerFirst = System.currentTimeMillis();
		int nbrTicks = 0;
		int nbrFps = 0;
		requestFocus();
		while(running){
			// Ticks 60 times per sec - max render
			long now = System.nanoTime();
			delta += (now - first) /ns;
			first = now;
			while(delta >= 1){
				tick();
				delta -= 1;
				nbrTicks++;
			}
			render();
			nbrFps++;
 
			// second timer
			if((System.currentTimeMillis() - timerFirst) >= 1000){
				timerFirst = System.currentTimeMillis();
 
				System.out.println("fps : " + nbrFps + " ; Ticks : " + nbrTicks);
 
				nbrTicks = 0;
				nbrFps = 0;
			}
		}
		stop();
	}
 
	public static void main(String[] args) {
 
		Core game = new Core();
 
		game.frame.add(game);
		game.frame.setResizable(false);
 
		game.frame.pack();
		game.frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		game.frame.setLocationRelativeTo(null);
		game.frame.setVisible(true);
 
		game.start();
	}
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
public class Mouse implements MouseListener{
 
	private boolean leftDown = false;
	private int leftCounter = 0;
	private int x, y;
        private int scale;
 
	public Mouse(int scale){
		this.scale = scale;
	}
 
	public void mouseClicked(MouseEvent arg0) {
 
	}
 
	public void mouseEntered(MouseEvent arg0) {
 
	}
 
	public void mouseExited(MouseEvent arg0) {
 
	}
 
	public void mousePressed(MouseEvent arg0) {
		if(arg0.getButton() == MouseEvent.BUTTON1){
			leftDown = true;
			x = arg0.getX();
			y = arg0.getY();
		}
	}
 
	public void mouseReleased(MouseEvent arg0) {
		if(arg0.getButton() == MouseEvent.BUTTON1){
			leftDown = false;
			leftCounter++;
			x = arg0.getX();
			y = arg0.getY();
		}
	}
 
 
	public boolean getLeftDown(){
		return leftDown;
	}
	public int getLeftCounter(){
		return leftCounter;
	}
	public int getX(){
		return x;
	}
	public int getY(){
		return y;
	}
	public void reset(){
		leftCounter = 0;
	}
}

[wax78]

Non mais j'avais dit " testable et minimaliste " pas juste " minimaliste " ^^

Sinon a priori je ne vois rien de choquant a priori.

[I-DEXX]

Est-il possible par exemple que la taille d'un canvas soit légèrement plus grand que ce qu'on ai passé en paramètre, et que donc le buffuredImage soit étiré légèrement ?

UPDATE : oups pardon pour le code, je vais modifier cela

[joel.drigo]

Salut,

g.drawImage(image, 0, 0, getWidth(), getHeight(), null);L'image est affichée adaptée sur la taille du composant. Si le composant fait 4 pixels de large et l'image 3, on peut raisonnablement penser qu'un des pixels va être étiré sur 2...

[I-DEXX]

C'est également ce que je pensais, mais le fait est que j'ai initialisé l'image en passant en paramètre les dimensions du canvas, donc normalement il ne devrait pas y avoir de redimensionnement.

Code :

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

1
2
3
 
private BufferedImage image = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);
private int[] pixels = ((DataBufferInt)image.getRaster().getDataBuffer()).getData();

Et c'est donc pour ca que je me demandais si il n'y avait pas un redimensionnement automatique dans le canvas, ou quelque chose qui ferait que les pixels ne correspondent plus (padding? margin ?).

D'autre part le décalage en pixel n'est pas aussi flagrant, je dirait qu'un pixel de canvas doit être environs 1/16 plus petit qu'un pixel normal. Mais a grande échelle c'est très ennuyeux.