Discussion :

[Dia972]

Bonjour amis développeurs.

Je réalise un composant qui permettra de dessiner des formes prédéfinies dans un panel. On doit également pouvoir déplacer les formes sur une grille et zoomer (in/out).

Après quelques jours de recherches,de tutos, de tests,..(et de café), je me suis débrouillé comme un grand pour arriver à avoir le comportement que je souhaite pour mon composant. Malheureusement il y a un point que je n'arrive pas a résoudre.

En background du panel de dessin j'ai une grille, et je souhaite que cette grille grandisse/rétrécisse quand je zoom/dézoom.



Je récupère donc la transformée affine de mon espace graphique en fonction du zoom et je dessine la grille puis les formes.
Le comportement de la grille et des formes quand je zoom est conforme à ce à quoi je m'attends, c'est à dire que les points grossissent et l'espace affiché est plus petit :



Par contre quand je dézoom rien ne se passe comme je l'ai imaginé (d'ou mon message). Dans l'image ci dessous on voit le résultat après plusieurs zoom out à la molette.



Sur l'image on ne voit pas le curseur de la souris mais il est place en bas a droite de la grille de points. Les coordonnées correspondent à la taille mise à l'échelle du panel.

Je comprends donc le soucis, j'applique la transformée affine avant le dessin de la grille (sinon elle ne sera pas grossie) mais donc le dessin s'effectue aussi dans les coordonnées transformées.
J'ai essayé de sauvegarder la transformée affine au début, et de la restaurer juste avant de redessiner la grille

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
...
 
final AffineTransform initialTransform = g2.getTransform();
final AffineTransform tx = getCurrentTransform();
tx.concatenate(g2.getTransform());
g2.setTransform(tx);
 
// Dessin de la grille (après transformation affine pour qu'elle soit à l'échelle)
g2.setPaint(texture);
g2.setTransform(initialTransform);
g2.fillRect(0, 0, scaledPanelWidth, scaledPanelHeight);
g2.setPaint(null);
...

mais ça n'a pas été concluant.

Si j'applique la transformée après avoir dessiné la grille elle prend bien toute la taille du panel, mais elle ne change pas en fonction du zoom.
J'ai également essayé d'inverser la transformée actuelle et de l'appliquer au moment du dessin de la grille uniquement aussi mais sans succès.

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
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
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
 
public class GraphView extends JPanel implements MouseListener, MouseMotionListener, MouseWheelListener, KeyListener, GraphModelListener
{
	private static final long serialVersionUID = 1L;
 
	final static float dash[] = { 5.0f };
	final static BasicStroke dashed = new BasicStroke(1.0f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL, 10.0f, dash, 0.0f);
 
	public final int PANEL_WIDTH = 3960;
	public final int PANEL_HEIGHT = 2048;
 
	public int scaledPanelWidth = 3960;
	public int scaledPanelHeight = 2048;
 
	private final GraphModel graphModel;
	private final GraphPanel parent;
 
	private final Rectangle mouseRect;
	private final Point correctedMousePt;
 
	private final Point mousePt;
	private int zoomCenterX;
	private int zoomCenterY;
 
	private TexturePaint texture;
	private final int gap = 5;
	private double zoom = 1.0d;
	private final double minScale = 0.3;
	private final double maxScale = 5.0;
 
	private boolean debug = false;
	private boolean waitingNewComponentPosition;
	private boolean selecting;
 
	public GraphView(final GraphPanel _parent, final GraphModel _graphModel)
	{
		super();
 
		parent = _parent;
		graphModel = _graphModel;
 
		mouseRect = new Rectangle();
		mousePt = new Point();
		correctedMousePt = new Point();
 
		selecting = false;
		waitingNewComponentPosition = false;
 
		graphModel.addGraphModelListener(this);
 
		initGUI();
		requestFocusInWindow();
		requestFocus();
	}
 
	private void initGUI()
	{
		setFocusable(true);
		setFocusCycleRoot(true);
		setBackgroundTexture();
		setOpaque(true);
 
		addMouseListener(this);
		addMouseMotionListener(this);
		addMouseWheelListener(this);
		addKeyListener(this);
	}
 
	@Override
	public Dimension getPreferredSize()
	{
		return new Dimension(scaledPanelWidth, scaledPanelHeight);
	}
 
	@Override
	public void paintComponent(final Graphics g)
	{
		final Graphics2D gDebug = (Graphics2D)g.create();
		final Graphics2D g2 = (Graphics2D)g;
 
		// On efface le contenu
		//		g2.clearRect(0, 0, getWidth(), getHeight());
		g2.clearRect(0, 0, scaledPanelWidth, scaledPanelHeight);
 
		final AffineTransform initialTransform = g2.getTransform();
 
		final AffineTransform tx = getCurrentTransform();
		tx.concatenate(g2.getTransform());
		g2.setTransform(tx);
 
		// Dessin de la grille (après transformation affine pour qu'elle soit à l'échelle)
		g2.setPaint(texture);
		g2.fillRect(0, 0, scaledPanelWidth, scaledPanelHeight);
		g2.setPaint(null);
 
 
                //  Si j'applique la transformée après avoir dessiné la grille celle ci ne se redimensionne pas
		//		final AffineTransform tx = getCurrentTransform();
		//		tx.concatenate(g2.getTransform());
		//		g2.setTransform(tx);
 
		// Dessin des liens
		for (final Link link : graphModel.getLinkSet().getLinks())
		{
			link.draw(g2);
		}
 
		// Dessin des formes
		for (final GraphicElement shape : graphModel.getNodeSet().getNodes())
		{
			shape.draw(g2);
		}
 
		if (selecting)
		{
			g2.setColor(Color.DARK_GRAY);
			g2.setStroke(dashed);
			g2.drawRect(mouseRect.x, mouseRect.y, mouseRect.width, mouseRect.height);
		}
 
		if (waitingNewComponentPosition)
		{
			g2.setColor(Color.DARK_GRAY);
			g2.setStroke(dashed);
			g2.drawRect(correctedMousePt.x - 10, correctedMousePt.y - 10, 20, 20);
		}
 
		if (debug)
		{
			// On utilise un autre composant de dessin
			// indépendant de la transformation affine pour afficher des informations en haut à gauche du panel.
			gDebug.setColor(Color.RED);
			showDebugInfo(gDebug);
		}
		g2.dispose();
	}
 
	@Override
	public void mouseDragged(final MouseEvent e)
	{
		if (!waitingNewComponentPosition || debug)
		{
			final Point2D correctedOldPoint = getTranslatedPoint(mousePt.x, mousePt.y);
			final Point2D correctedNewPoint = getTranslatedPoint(e.getX(), e.getY());
 
			if (selecting)
			{
				mouseRect.setBounds((int)Math.min(correctedOldPoint.getX(), correctedNewPoint.getX()), (int)Math.min(correctedOldPoint.getY(), correctedNewPoint.getY()), (int)Math.abs(correctedOldPoint.getX() - correctedNewPoint.getX()), (int)Math.abs(correctedOldPoint.getY() - correctedNewPoint.getY()));
				GraphicElement.selectRect(graphModel.getNodeSet(), mouseRect);
			}
			else
			{
				// On calcule la distance entre le clic et le déplacement de la souris
				final Point delta = new Point();
				delta.setLocation((correctedNewPoint.getX() - correctedOldPoint.getX()), correctedNewPoint.getY() - correctedOldPoint.getY());
 
				GraphicElement.updatePosition(graphModel.getNodeSet(), delta);
 
				mousePt.setLocation(e.getPoint());
			}
			repaint();
		}
	}
 
	@Override
	public void mouseMoved(final MouseEvent e)
	{
		final Point2D correctedCoordonates = getTranslatedPoint(e.getPoint().x, e.getPoint().y);
		correctedMousePt.setLocation(correctedCoordonates.getX(), correctedCoordonates.getY());
		if (waitingNewComponentPosition || debug)
		{
			mousePt.setLocation(e.getPoint());
			repaint();
		}
	}
 
	@Override
	public void mouseClicked(final MouseEvent e)
	{
		if (waitingNewComponentPosition)
		{
			final Point2D correctedCoordonates = getTranslatedPoint(e.getPoint().x, e.getPoint().y);
			final NewShapeAction action = parent.getCurrentAction();
			action.setLocation(correctedCoordonates);
			action.startAction(new ActionEvent(this, ActionEvent.ACTION_PERFORMED, null));
 
			waitingNewComponentPosition = false;
		}
	}
 
	@Override
	public void mousePressed(final MouseEvent e)
	{
		if (!waitingNewComponentPosition)
		{
			mousePt.setLocation(e.getPoint());
 
			final Point2D correctedCoordonates = getTranslatedPoint(mousePt.x, mousePt.y);
			correctedMousePt.setLocation(correctedCoordonates.getX(), correctedCoordonates.getY());
 
			// Shift + Clic Gauche
			if (e.isShiftDown())
			{
				GraphicElement.selectToggle(graphModel.getNodeSet(), correctedMousePt);
			}
			// Clic droit
			else if (e.isPopupTrigger())
			{
				GraphicElement.selectOne(graphModel.getNodeSet(), correctedMousePt);
				showPopup(e);
			}
			// Clic sur un objet
			else if (GraphicElement.selectOne(graphModel.getNodeSet(), correctedMousePt))
			{
				selecting = false;
			}
			else
			{
				GraphicElement.selectNone(graphModel.getNodeSet());
				selecting = true;
			}
		}
		repaint();
	}
 
	@Override
	public void mouseReleased(final MouseEvent e)
	{
		selecting = false;
		mouseRect.setBounds(0, 0, 0, 0);
		if (e.isPopupTrigger())
		{
			showPopup(e);
		}
 
		repaint();
	}
 
	@Override
	public void mouseWheelMoved(final MouseWheelEvent e)
	{
		if (e.isControlDown())
		{
			//			final Point2D correctedCoordonates = getTranslatedPoint(e.getPoint().x, e.getPoint().y);
 
			mousePt.setLocation(e.getPoint());
			//						System.out.println("1: ( " + zoomCenterX + "; " + zoomCenterY + " )");
			//			zoomCenterX = (int)(correctedCoordonates.getX());
			//			zoomCenterY = (int)(correctedCoordonates.getY());
			zoomCenterX = 0;
			zoomCenterY = 0;
 
			//			System.out.println("2 : ( " + zoomCenterX + "; " + zoomCenterY + " ) \n");
 
			// Zoom
			if (e.getWheelRotation() < 0)
			{
				zoom += .2 * -e.getWheelRotation();
				zoom = Math.min(maxScale, zoom);
 
				scaledPanelWidth = (int)(PANEL_WIDTH * zoom) > 0 ? (int)(PANEL_WIDTH * zoom) : PANEL_WIDTH;
				scaledPanelHeight = (int)(PANEL_HEIGHT * zoom) > 0 ? (int)(PANEL_HEIGHT * zoom) : PANEL_HEIGHT;
			}
			// Dezoom
			else
			{
				zoom += .2 * -e.getWheelRotation();
				zoom = Math.max(minScale, zoom);
 
				scaledPanelWidth = (int)(PANEL_WIDTH * zoom) > 0 ? (int)(PANEL_WIDTH * zoom) : PANEL_WIDTH;
				scaledPanelHeight = (int)(PANEL_HEIGHT * zoom) > 0 ? (int)(PANEL_HEIGHT * zoom) : PANEL_HEIGHT;
			}
			setPreferredSize(new Dimension(scaledPanelWidth, scaledPanelHeight));
			repaint();
		}
	}
 
	@Override
	public void mouseEntered(final MouseEvent e)
	{
	}
 
	@Override
	public void mouseExited(final MouseEvent e)
	{
	}
 
	@Override
	public void graphChanged()
	{
		repaint();
	}
 
	@Override
	public void keyTyped(final KeyEvent e)
	{
	}
 
	@Override
	public void keyPressed(final KeyEvent e)
	{
	}
 
	@Override
	public void keyReleased(final KeyEvent _e)
	{
		// Si on a appuyé sur la touche échap
		if (_e.getKeyCode() == KeyEvent.VK_ESCAPE)
		{
			// Juste après avoir cliqué sur new on annule la création
			if (waitingNewComponentPosition)
			{
				waitingNewComponentPosition = false;
			}
			// Ou on annule la sélection
			else
			{
				GraphicElement.selectNone(graphModel.getNodeSet());
			}
			repaint();
		}
 
		if (_e.getKeyCode() == KeyEvent.VK_ENTER)
		{
			zoom = 1.0d;
			scaledPanelWidth = (int)(PANEL_WIDTH * zoom) > 0 ? (int)(PANEL_WIDTH * zoom) : PANEL_WIDTH;
			scaledPanelHeight = (int)(PANEL_HEIGHT * zoom) > 0 ? (int)(PANEL_HEIGHT * zoom) : PANEL_HEIGHT;
 
			repaint();
		}
	}
 
	private void showPopup(final MouseEvent e)
	{
		parent.showPopup(e);
	}
 
	/**
         * @return the waitingClicPosition
         */
	public boolean isWaitingNewComponentPosition()
	{
		return waitingNewComponentPosition;
	}
 
	/**
         * @param waitingClicPosition
         *            the waitingClicPosition to set
         */
	public void setWaitingNewComponentPosition(final boolean _waitingComponentPosition)
	{
		// On met le focus sur la grille
		requestFocus();
		waitingNewComponentPosition = _waitingComponentPosition;
	}
 
	/**
         * @param debug
         *            the debug to set
         */
	public void enableDebugInfo(final boolean _debug)
	{
		debug = _debug;
	}
 
	private void setBackgroundTexture()
	{
		// Création de la texture pour le background
		final BufferedImage bi = new BufferedImage(gap, gap, BufferedImage.TYPE_INT_RGB);
		final Graphics2D big = bi.createGraphics();
		big.setColor(Color.white);
		big.fillRect(0, 0, gap, gap);
		big.setColor(Color.blue);
		big.drawLine(0, 0, 0, 0);
		final Rectangle2D r = new Rectangle(0, 0, gap, gap);
		texture = new TexturePaint(bi, r);
		big.dispose();
	}
 
	private AffineTransform getCurrentTransform()
	{
		final AffineTransform tx = new AffineTransform();
 
		tx.translate(zoomCenterX, zoomCenterY);
		tx.scale(zoom, zoom);
		tx.translate(-zoomCenterX, -zoomCenterY);
 
		return tx;
	}
 
	private void incrementZoom(final double amount)
	{
		zoom += amount;
		zoom = Math.max(minScale, zoom);
		repaint();
	}
 
	/**
         * Convert pixel coordonate to drawing coordonate according to affine transform
         *
         * @param _panelX
         * @param _panelY
         * @return
         */
	private Point2D getTranslatedPoint(final int _panelX, final int _panelY)
	{
		final AffineTransform tx = getCurrentTransform();
		final Point2D point2d = new Point2D.Double(_panelX, _panelY);
		try
		{
			return tx.inverseTransform(point2d, null);
		}
		catch (final NoninvertibleTransformException ex)
		{
			ex.printStackTrace();
			return null;
		}
	}
 
	private void showDebugInfo(final Graphics2D _g2)
	{
		_g2.setColor(Color.RED);
		final int x = 10;
		int y = 20;
		_g2.drawString("Panel size: " + scaledPanelWidth + ", " + scaledPanelHeight, x, y);
		y += 15;
		_g2.drawString("Mouse Coord in panel: " + correctedMousePt, x, y);
		y += 15;
		_g2.drawString("Mouse Coord pixel: " + mousePt, x, y);
		y += 15;
		int i = 0;
		for (final GraphicElement n : graphModel.getNodeSet().getNodes())
		{
			if (n.isSelected())
			{
				_g2.drawString("Shape" + i + " coord: " + n.getLocation(), x, y + (i * 15));
				i++;
			}
		}
		_g2.drawString("test", x, y + (i * 15));
	}
}

Je cherche à comprendre comment pouvoir mettre la grille à l'échelle et à la redessiner sur tous l'espace en utilisant le système de coordonnées initial.

Note : Pour l'instant le zoom se fait sur le point (0,0) normalement il se fait en fonction de la position du curseur de la souris.

Je joint les sources si besoin.

Merci d'avoir pris le temps de lire mon pavé . Et a bientôt pour vos idées

[joel.drigo]

Salut,

Le problème vient de ces formules, et du fait que tu utilises les mêmes variables pour la taille du graphe, et l'étendue à remplir d'une grille :

Code :

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

1
2
scaledPanelWidth = (int)(PANEL_WIDTH * zoom) > 0 ? (int)(PANEL_WIDTH * zoom) : PANEL_WIDTH;
scaledPanelHeight = (int)(PANEL_HEIGHT * zoom) > 0 ? (int)(PANEL_HEIGHT * zoom) : PANEL_HEIGHT;

Déjà, un facteur de "zoom" ne peut être que strictement positif :

• supérieur à 1, on aggrandit (zoom=2, tout est 2 fois plus grand)
• inférieur à 1, on réduit ; zoom=0.8, tout distance est affichée à 80 % de sa taille réelle

Si tu as un segment qui fait 100 pixels de long, avec un zoom de 0.8, il sera affiché avec une longueurde 80 pixels à l'écran (100 pixels multiplié par 0.8 donc). Donc si tu veux afficher un segment de 100 pixels de long, alors que le zoom est de 0.8, alors tu dois afficher un segment de 125 pixels, parce 125 * 0.8 = 100, soit 100 / 0.8.

Donc les formules devraient être :

Code :

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

1
2
scaledPanelWidth = (int)(PANEL_WIDTH / zoom);
scaledPanelHeight = (int)(PANEL_HEIGHT / zoom);

et ce quelque soit la variation du zoom d'ailleurs.

Mais evidemment, ça ne va plus fonctionner en ce qui concerne le scrolPane, parce que tu utilises également scaledPanelWidth et scaledPanelHeight comme preferred size. En effet, le zoom agrandit le graph, donc la zone à prendre en compte dans le scroll pane s'agrandi. Mais justement, en corrolaire de ce que je viens d'expliquer, la partie visible du graphe est plus petite, d'où une multiplication pour déterminer la taille du graphe affectée par le zoom, mais une division (en fait une multiplication par 1/zoom), pour déterminer la taille utile de ce qu'il est nécessaire et suffisant d'afficher pour remplir la partie de graphe visible dans le scroll pane.

Il te faudrait donc juste des variables supplémentaires pour stocker la taille de la grille à afficher, que tu modifies à chaque variation du zoom. D'ailleurs, tu devrait aussi les calculer en fonction de la taille de la zone affichée (viewport), qui varie lorsqu'on change la taille de la fenêtre (voir ComponentListener). Par ailleurs, au sujet de l'adaptation du scrollpane aux changements de preferred size, tu devrais faire un revalidate() avant le repaint().

En fait, le plus simple serait de laisser le clipping faire ce travail pour toi, ce qui est bien plus simple. Il te suffit d'afficher la grille toujours de la même façon, sans te poser de question : c'est l'avantage des transformées affines affectées au contexte graphique, et au clipping qui va se charger lui de ne pas afficher en dehors de la zone visible. Il faut bien entenu continuer à faire les adaptions necéssaires pour le scrollpane.

[Dia972]

Salut joel.drigo,

Bon ben le problème de zoom est résolu avec tes indications. J'ai pris le temps de bien tester et me creuser la tête un peu pour bien comprendre avant de poster d'autres messages, c'est pour ça que je n'ai pas répondu avant.

Solution :
J'ai changé les formules :

Code :

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

1
2
3
 
scaledPanelWidth = (int)(PANEL_WIDTH / zoom);
scaledPanelHeight = (int)(PANEL_HEIGHT / zoom);

Ajouté 2 nouvelles variables

Code :

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

1
2
3
4
5
6
7
8
 
// initialisées à la taille initiale du panel.
private int panelWidth = 3960; 
private int panelHeiht = 2048;
 
// Qui évoluent quand on zoom
panelWidth = (int)(DEFAULT_PANEL_WIDTH * zoom);
panelHeiht = (int)(DEFAULT_PANEL_HEIGHT * zoom);

Et que je renvoie dans getPreferedSize();

Et je dessine la grille tout le temps avec les taille du panel par défaut.

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
 
@Override
	public void paintComponent(final Graphics g)
	{
		final Graphics2D gDebug = (Graphics2D)g.create();
		final Graphics2D g2 = (Graphics2D)g;
 
		// On efface le contenu
		g2.clearRect(0, 0, scaledPanelWidth, scaledPanelHeight);
 
		final AffineTransform tx = getCurrentTransform();
		tx.concatenate(g2.getTransform());
		g2.setTransform(tx);
 
		// Dessin de la grille (après transformation affine pour qu'elle soit à l'échelle)
		g2.setPaint(texture);
		g2.fillRect(0, 0, DEFAULT_PANEL_WIDTH, DEFAULT_PANEL_HEIGHT);
		g2.setPaint(null);
 
		// Dessin des liens
		for (final Link link : graphModel.getLinkSet().getLinks())
		{
			link.draw(g2);
		}
 
		// Dessin des formes
		for (final GraphicElement shape : graphModel.getNodeSet().getNodes())
		{
			shape.draw(g2);
		}
 
		if (selecting)
		{
			g2.setColor(Color.DARK_GRAY);
			g2.setStroke(dashed);
			g2.drawRect(mouseRect.x, mouseRect.y, mouseRect.width, mouseRect.height);
		}
 
		if (waitingNewComponentPosition)
		{
			g2.setColor(Color.DARK_GRAY);
			g2.setStroke(dashed);
			g2.drawRect(correctedMousePt.x - 50, correctedMousePt.y - 50, 100, 100);
		}
 
		if (debug)
		{
			// On utilise un autre composant de dessin
			// indépendant de la transformation affine pour afficher des informations en haut à gauche du panel.
			gDebug.setColor(Color.RED);
			showDebugInfo(gDebug);
		}
		g2.dispose();
	}

Merci bien .

[Dia972]

Re-bonjour,

J'ai constaté deux nouveaux problèmes qui sont liés à la transformée affine certainement. Les deux concernent l'affichage de la grille.

1. Quand le zoom est à sa valeur initiale (1.0), et que je déplace les scrollBars j'ai constaté que la grille n'est pas dessinée sur la totalité du panel et je ne comprend pas pourquoi.

Je dessine la grille comme ceci sur tout le panel :

Code :

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

1
2
 
g2.fillRect(0, 0, DEFAULT_PANEL_WIDTH, DEFAULT_PANEL_HEIGHT);

J'ai vérifié la valeur de la transformation affine et elle est bien égale à une matrice Identité, donc logiquement les points devraient être affichés sur tout le panel mais au lieu de ça j'ai ça:



On voit bien que les points s’arrêtent. Et si je met le curseur de la souris sur le point en bas à gauche, ses corrigées en prenant en compte la transformée sont proches de la taille du panel, sauf que je ne comprend pas pourquoi puisque pour l'instant il n'y a pas de transformée d'appliquée.

2. Quand je zoom out , la grille disparait, ou est incomplète, à certain niveau de zoom. Je pense que cela vient de la taille des points. Et que à cause de la transformée affine ils deviennent trop petits pour pouvoir être affichés. Dans la méthode pour créer grille j'ai augmenté la taille du point :

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
 
	private void setBackgroundTexture()
	{
		// Création de la texture pour le background
		final BufferedImage bi = new BufferedImage(gap, gap, BufferedImage.TYPE_INT_RGB);
		final Graphics2D big = bi.createGraphics();
		big.setColor(Color.white);
		big.fillRect(0, 0, gap, gap);
		big.setColor(Color.blue);
		big.fillRect(0, 0, 5, 5); // ici
 
		final Rectangle2D r = new Rectangle(0, 0, gap, gap);
		texture = new TexturePaint(bi, r);
 
		big.dispose();
	}

Le comportement semble correct, mais ce n'est pas la solution qu'il me faut, parce que je ne veux pas avoir des points aussi gros.

Je pensais avoir compris mais visiblement il y a quelque chose qui m'a échappé.

Merci pour vos suggestions.

A Bientôt.

Le code complet :

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
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
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
 
public class GraphView extends JPanel implements MouseListener, MouseMotionListener, MouseWheelListener, KeyListener, GraphModelListener
{
	private static final long serialVersionUID = 1L;
 
	final static float dash[] = { 5.0f };
	final static BasicStroke dashed = new BasicStroke(1.0f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL, 10.0f, dash, 0.0f);
 
	public final int DEFAULT_PANEL_WIDTH = 3960;
	public final int DEFAULT_PANEL_HEIGHT = 2048;
 
	public int scaledPanelWidth = 3960;
	public int scaledPanelHeight = 2048;
 
	private int panelWidth = 3960;
	private int panelHeight = 2048;
 
	private final GraphModel graphModel;
	private final GraphPanel parent;
 
	private final Rectangle mouseRect;
	private final Point correctedMousePt;
 
	private final Point mousePt;
	private int zoomCenterX;
	private int zoomCenterY;
 
	private final int gap = 10;
	private TexturePaint texture;
 
	private final double minScale = 0.2;
	private final double maxScale = 4.0;
	private double zoom = 1.0d;
 
	private int verticalShift;
	private int horizontalShift;
 
	private boolean debug = false;
	private boolean waitingNewComponentPosition;
	private boolean selecting;
 
	public GraphView(final GraphPanel _parent, final GraphModel _graphModel)
	{
		super();
 
		parent = _parent;
		graphModel = _graphModel;
 
		mouseRect = new Rectangle();
		mousePt = new Point();
		correctedMousePt = new Point();
 
		selecting = false;
		waitingNewComponentPosition = false;
 
		graphModel.addGraphModelListener(this);
 
		verticalShift = 0;
		horizontalShift = 0;
 
		initGUI();
 
		requestFocusInWindow();
		requestFocus();
	}
 
	private void initGUI()
	{
		setBackgroundTexture();
 
		setOpaque(true);
 
		addMouseListener(this);
		addMouseMotionListener(this);
		addMouseWheelListener(this);
		addKeyListener(this);
	}
 
	@Override
	public Dimension getPreferredSize()
	{
		return new Dimension(panelWidth, panelHeight);
	}
 
	@Override
	public void paintComponent(final Graphics g)
	{
		final Graphics2D gDebug = (Graphics2D)g.create();
		final Graphics2D g2 = (Graphics2D)g;
 
		// On efface le contenu
			g2.clearRect(0, 0, scaledPanelWidth, scaledPanelHeight);
 
		final AffineTransform tx = getCurrentTransform();
		tx.concatenate(g2.getTransform());
		g2.transform(tx);
 
		// Dessin de la grille (après transformation affine pour qu'elle soit à l'échelle)
		g2.setPaint(texture);
		g2.fillRect(0, 0, DEFAULT_PANEL_WIDTH, DEFAULT_PANEL_HEIGHT);
		g2.setPaint(null);
 
		// Dessin des liens
		for (final Link link : graphModel.getLinkSet().getLinks())
		{
			link.draw(g2);
		}
 
		// Dessin des formes
		for (final GraphicElement shape : graphModel.getNodeSet().getNodes())
		{
			shape.draw(g2);
		}
 
		if (selecting)
		{
			g2.setColor(Color.DARK_GRAY);
			g2.setStroke(dashed);
			g2.drawRect(mouseRect.x, mouseRect.y, mouseRect.width, mouseRect.height);
		}
 
		if (waitingNewComponentPosition)
		{
			g2.setColor(Color.DARK_GRAY);
			g2.setStroke(dashed);
			g2.drawRect(correctedMousePt.x - 50, correctedMousePt.y - 50, 100, 100);
		}
 
		if (debug)
		{
			// On utilise un autre composant de dessin
			// indépendant de la transformation affine pour afficher des informations en haut à gauche du panel.
			gDebug.setColor(Color.RED);
			showDebugInfo(gDebug);
		}
		g2.dispose();
	}
 
	@Override
	public void mouseDragged(final MouseEvent e)
	{
		if (!waitingNewComponentPosition || debug)
		{
			final Point2D correctedOldPoint = getTranslatedPoint(mousePt);
			final Point2D shiftedOldPoint = new Point((int)correctedOldPoint.getX() + horizontalShift, (int)correctedOldPoint.getY() + verticalShift);
 
			final Point2D correctedNewPoint = getTranslatedPoint(e.getPoint());
			final Point2D shiftedNewPoint = new Point((int)correctedNewPoint.getX() + horizontalShift, (int)correctedNewPoint.getY() + verticalShift);
 
			if (selecting)
			{
				mouseRect.setBounds((int)Math.min(shiftedOldPoint.getX(), shiftedNewPoint.getX()), (int)Math.min(shiftedOldPoint.getY(), shiftedNewPoint.getY()), (int)Math.abs(shiftedOldPoint.getX() - shiftedNewPoint.getX()), (int)Math.abs(shiftedOldPoint.getY() - shiftedNewPoint.getY()));
				GraphicElement.selectRect(graphModel.getNodeSet(), mouseRect);
			}
			else
			{
				// On calcule la distance entre le clic et le déplacement de la souris
				final Point delta = new Point();
				delta.setLocation((shiftedNewPoint.getX() - shiftedOldPoint.getX()), shiftedNewPoint.getY() - shiftedOldPoint.getY());
 
				GraphicElement.updatePosition(graphModel.getNodeSet(), delta);
 
				mousePt.setLocation(e.getPoint());
			}
 
			repaint();
		}
	}
 
	@Override
	public void mouseMoved(final MouseEvent e)
	{
		if (!hasFocus())
		{
			requestFocus();
		}
 
		// On recupere les coordonnées du point en fonction de la transformée affine
		final Point2D correctedCoordonates = getTranslatedPoint(e.getPoint());
 
		// On ajoute le décalage éventuel des scroll bars
		correctedMousePt.setLocation(correctedCoordonates.getX() + horizontalShift, correctedCoordonates.getY() + verticalShift);
 
		if (waitingNewComponentPosition || debug)
		{
			mousePt.setLocation(e.getPoint());
			repaint();
		}
	}
 
	@Override
	public void mouseClicked(final MouseEvent e)
	{
		if (waitingNewComponentPosition)
		{
			// On recupere les coordonnées du point en fonction de la transformée affine
			final Point2D correctedCoordonates = getTranslatedPoint(e.getPoint());
 
			// On ajoute le décalage éventuel des scroll bars
			correctedCoordonates.setLocation(correctedCoordonates.getX() + horizontalShift, correctedCoordonates.getY() + verticalShift);
 
			final NewShapeAction action = parent.getCurrentAction();
			action.setLocation(correctedCoordonates);
			action.startAction(new ActionEvent(this, ActionEvent.ACTION_PERFORMED, null));
 
			waitingNewComponentPosition = false;
		}
	}
 
	@Override
	public void mousePressed(final MouseEvent e)
	{
		if (!waitingNewComponentPosition)
		{
			mousePt.setLocation(e.getPoint());
 
			final Point2D correctedCoordonates = getTranslatedPoint(mousePt);
			correctedMousePt.setLocation(correctedCoordonates.getX() + horizontalShift, correctedCoordonates.getY() + verticalShift);
 
			// Shift + Clic Gauche
			if (e.isShiftDown())
			{
				GraphicElement.selectToggle(graphModel.getNodeSet(), correctedMousePt);
			}
			// Clic droit
			else if (e.isPopupTrigger())
			{
				GraphicElement.selectOne(graphModel.getNodeSet(), correctedMousePt);
				showPopup(e);
			}
			// Clic sur un objet
			else if (GraphicElement.selectOne(graphModel.getNodeSet(), correctedMousePt))
			{
				selecting = false;
			}
			else
			{
				GraphicElement.selectNone(graphModel.getNodeSet());
				selecting = true;
			}
		}
		repaint();
	}
 
	@Override
	public void mouseReleased(final MouseEvent e)
	{
		selecting = false;
		mouseRect.setBounds(0, 0, 0, 0);
		if (e.isPopupTrigger())
		{
			showPopup(e);
		}
 
		repaint();
	}
 
	@Override
	public void mouseWheelMoved(final MouseWheelEvent e)
	{
		if (e.isControlDown())
		{
			mousePt.setLocation(e.getPoint());
 
			// Zoom IN
			final int rotate = e.getWheelRotation();
			if (rotate < 0)
			{
				zoom += .1 * -rotate;
				zoom = Math.min(maxScale, zoom);
 
				scaledPanelWidth = (int)(DEFAULT_PANEL_WIDTH / zoom);
				scaledPanelHeight = (int)(DEFAULT_PANEL_HEIGHT / zoom);
			}
			// Zoom OUT
			else
			{
				zoom += .1 * -rotate;
				zoom = Math.max(minScale, zoom);
 
				scaledPanelWidth = (int)(DEFAULT_PANEL_WIDTH / zoom);
				scaledPanelHeight = (int)(DEFAULT_PANEL_HEIGHT / zoom);
			}
 
			panelWidth = (int)(DEFAULT_PANEL_WIDTH * zoom);
			panelHeight = (int)(DEFAULT_PANEL_HEIGHT * zoom);
 
			revalidate();
			repaint();
		}
	}
 
	@Override
	public void mouseEntered(final MouseEvent e)
	{
	}
 
	@Override
	public void mouseExited(final MouseEvent e)
	{
	}
 
	@Override
	public void graphChanged()
	{
		repaint();
	}
 
	@Override
	public void keyTyped(final KeyEvent e)
	{
	}
 
	@Override
	public void keyPressed(final KeyEvent e)
	{
	}
 
	@Override
	public void keyReleased(final KeyEvent _e)
	{
		// Si on a appuyé sur la touche échap
		if (_e.getKeyCode() == KeyEvent.VK_ESCAPE)
		{
			// Juste après avoir cliqué sur new on annule la création
			if (waitingNewComponentPosition)
			{
				waitingNewComponentPosition = false;
			}
			// Ou on annule la sélection
			else
			{
				GraphicElement.selectNone(graphModel.getNodeSet());
			}
			revalidate();
			repaint();
		}
 
		if (_e.getKeyCode() == KeyEvent.VK_ENTER)
		{
			zoom = 1.0d;
			scaledPanelWidth = (int)(DEFAULT_PANEL_WIDTH / zoom);
			scaledPanelHeight = (int)(DEFAULT_PANEL_HEIGHT / zoom);
 
			panelWidth = (int)(DEFAULT_PANEL_WIDTH * zoom);
			panelHeight = (int)(DEFAULT_PANEL_HEIGHT * zoom);
			revalidate();
			repaint();
		}
	}
 
	public void setHorizontalShift(final int _horizontalShift)
	{
		horizontalShift = _horizontalShift;
	}
 
	public void setVerticalShift(final int _verticalShift)
	{
		verticalShift = _verticalShift;
	}
 
	private void showPopup(final MouseEvent e)
	{
		parent.showPopup(e);
	}
 
	/**
         * @return the waitingClicPosition
         */
	public boolean isWaitingNewComponentPosition()
	{
		return waitingNewComponentPosition;
	}
 
	/**
         * @param waitingClicPosition
         *            the waitingClicPosition to set
         */
	public void setWaitingNewComponentPosition(final boolean _waitingComponentPosition)
	{
		// On met le focus sur la grille
		requestFocus();
		waitingNewComponentPosition = _waitingComponentPosition;
	}
 
	/**
         * @param debug
         *            the debug to set
         */
	public void enableDebugInfo(final boolean _debug)
	{
		debug = _debug;
	}
 
	private void setBackgroundTexture()
	{
		// Création de la texture pour le background
		final BufferedImage bi = new BufferedImage(gap, gap, BufferedImage.TYPE_INT_RGB);
		final Graphics2D big = bi.createGraphics();
		big.setColor(Color.white);
		big.fillRect(0, 0, gap, gap);
		big.setColor(Color.blue);
		big.fillRect(0, 0, 1, 1);
 
		final Rectangle2D r = new Rectangle(0, 0, gap, gap);
		texture = new TexturePaint(bi, r);
 
		big.dispose();
	}
 
	private AffineTransform getCurrentTransform()
	{
		final AffineTransform tx = new AffineTransform();
 
		tx.translate(zoomCenterX, zoomCenterY);
		tx.scale(zoom, zoom);
		tx.translate(-zoomCenterX, -zoomCenterY);
 
		return tx;
	}
 
	private Point2D getTranslatedPoint(final Point2D point)
	{
		return getTranslatedPoint((int)point.getX(), (int)point.getY());
	}
 
	private Point2D getTranslatedPoint(final Point point)
	{
		return getTranslatedPoint((int)point.getX(), (int)point.getY());
	}
 
	/**
         * Convert pixel coordonate to drawing coordonate according to affine transform
         *
         * @param _panelX
         * @param _panelY
         * @return
         */
	private Point2D getTranslatedPoint(final int _panelX, final int _panelY)
	{
		final AffineTransform tx = getCurrentTransform();
		final Point2D point2d = new Point2D.Double(_panelX, _panelY);
		try
		{
			return tx.inverseTransform(point2d, null);
		}
		catch (final NoninvertibleTransformException ex)
		{
			ex.printStackTrace();
			Debug.logEvent(EventType.ERROR, "Vision.SystemModeler.Error.NonInvertible");
			return null;
		}
	}
 
	private void showDebugInfo(final Graphics2D _g2)
	{
		_g2.setColor(Color.RED);
		final int x = 10 + horizontalShift;
		int y = 20 + verticalShift;
		_g2.drawString("Panel size: " + panelWidth + ", " + panelHeight, x, y);
		y += 15;
		_g2.drawString("Scaled Panel size: " + scaledPanelWidth + ", " + scaledPanelHeight, x, y);
		y += 15;
		_g2.drawString("Panel Mouse Coord: " + mousePt, x, y);
		y += 15;
		_g2.drawString("Corrected Mouse Coord: " + correctedMousePt, x, y);
		y += 15;
		int i = 0;
		for (final GraphicElement n : graphModel.getNodeSet().getNodes())
		{
			if (n.isSelected())
			{
				_g2.drawString("Shape" + i + " coord: " + n.getLocation(), x, y + (i * 15));
				i++;
			}
		}
		_g2.drawString("zoom= " + zoom, x, y + (i * 15));
		i++;
		_g2.drawString("test", x, y + (i * 15));
	}
}

[joel.drigo]

Re-bonjour,

J'ai constaté deux nouveaux problèmes qui sont liés à la transformée affine certainement. Les deux concernent l'affichage de la grille.

1. Quand le zoom est à sa valeur initiale (1.0), et que je déplace les scrollBars j'ai constaté que la grille n'est pas dessinée sur la totalité du panel et je ne comprend pas pourquoi.

En fait, c'est parce que tu donnes une taille fixe à ta grille. La grille devrait toujours être dessiné au moins dans la taille de ce qui est visible. En fait, il est plus simple de la dessiner la taille du composant qui dans le scrollpane.
En plus, le dessin est influencé par la transformée affine.

Mettons, pour simplifier qu'on a un composant de 100x100, donc on se dit je vais afficher une grille de 100x100. On dessine ça dans un scrollpane qui fait 50x50.

Au début, on voit donc le quart de notre grille visible : on pourrait afficher notre grille par un fillRect(0,0,50,50). Bien sûr si on se déplace de 10 à droite, on affiche la zone de coordonnées (10,0,50,50) : comme on dessine la grille sur la zone (0,0,50,50), on a une zone non dessiné à droite de 10 de large. Le dessin de la grille est bien impacté par la transformée affine.

Bien sûr, le fait qu'on dessine la grille à la taille du composant fait qu'une translation (dans les bonnes limites) ne fait jamais apparaître cette zone non dessinée. Tant qu'on ne zoom pas.

En effet, supposons que je zoome de manière à avoir un facteur /2 sur chaque axe : lorsque je dessine ma grille en (0,0,100,100), elle se dessine en (0,0,50,50). Mais le composant lui fait toujours la taille de 100x100. Donc on peut scroller sur la partie non peinte. Tu as compensé ce problème on redimensionnant dynamiquement dans le viewport. Ce qui fait dans notre exemple, le scrollpane affiche toujours la zone 0,0,50,50 (au départ, sans scroll), pour un composant qui fait 0,0,50,50. Donc on remplit bien tout l'espace visible.

Maintenant, au lieu de zoom 0.5,0.5, zoomons 0.25,0.25 : même principe. Au bout du compte, on affiche dans un scrollpane toujours visualisant 0,0,50,50, mais on a un composant dedans qui fait maintenant 25x25, plus petit que le viewport. Donc il y a une partie qu'on ne peut afficher. La meilleur solution pour moi, est ne pas se baser sur une taille fixe, mais

• en version simple : sur la taille du composant
• en version complexe : sur la taille du viewport (et encore, je commencerais par la version simple, et en cas de problème de perf)

Je dessine la grille comme ceci sur tout le panel :

Code :

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

1
2
 
[...]

Le comportement semble correct, mais ce n'est pas la solution qu'il me faut, parce que je ne veux pas avoir des points aussi gros.

Je pensais avoir compris mais visiblement il y a quelque chose qui m'a échappé.

Merci pour vos suggestions.

A Bientôt.

Le code complet :

Code :

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

1
2
 
[...]

C'est là la limite d'une grille par texture image. Les transformées affines affectent tout. Les tailles des éléments, les images donc les textures basés sur des images, les épaisseurs de traits etc.

On pourrait écrire une texture spéciale (implémenter Paint/PaintContext), parce qu'on peut composer les transformées afficnes (par exemple faire que les points soient toujours en place, comme si la grille se ne se déplaçait pas, même si le dessin se déplace) mais c'est siouxe pour faire le rendu (produire des Raster directement), surtout si on veut faire des textures soignées (Si le sujet t'intéresse, tu peux regarder mon implémentation de textures "hachure" ici).

Il sera bien plus simple de dessiner en directe la grille (éventuellement la dessiner dans une image à part pour faire un cache) : car son dessin ne varie que sur certaines action (scroll, redimensionnement, changement d’échelle).

Déjà, il faut définir comment la grille se comporte par rapport :

• les points ont-il toujours la même taille quelque soit l'echelle (visiblement oui d'après ton dernier message), ou leur taille varie-t-elle dans le sens du zoom (ce que ça fait logiquement par défaut : rappelle-toi, je t'ai dit que tout était affecté par le zoom)
• les points sont-ils en positions relative fixes, par rapport au bord du composant (mais, donc, pas du viewport)
• la distance entre les points doit-elle varier avec l'echelle, ou justement montrer toujours la même distance (mise à l'echelle du zoom).

En gros, a-t-on une grille fixe, comme si elle était dessinée sur la vitre de l'écran, ou une grille mobile qui est liée au dessin. Ou les 2, ou du moins, un compromis des 2.

Un compromis pourrait être : la grille est attachée au dessin (donc les distances et positions varient avec la transformée affine), mais on veut toujours dessiner des points, propres, et visibles (donc pas invisible sur un recul énorme, et pas d'énorme rectangle ou paté dégueu, lorsqu'on grossit à mort. On veut par exemple, qui si on zoom à mort, les points apparaissent comme des disques de 5 px maxi, quand on recule à fond, on voit un point d'1 px, et entre les deux, un dessin de point entre les deux. En dessinant dynamiquement la grille sans appliquer de transformée affine, mais en tenant compte de la transformée (pour afficher des gros point, ou des points minuscules, selon, mais suffisamment grands pour être visibles.

En mode texture, un solution peut être de prévoir une texture vraiment beaucoup plus grande en résolution maxi et d'afficher la texture par défaut avec un zoom de réduction. Ainsi, réduite on verra toujours quelque chose, et en agrandi, on verra les détails dans la résolution de la plus grande (cell de l'image de texture).

[Dia972]

1.

Bien sûr, le fait qu'on dessine la grille à la taille du composant fait qu'une translation (dans les bonnes limites) ne fait jamais apparaître cette zone non dessinée. Tant qu'on ne zoom pas.

Ok.
Donc normalement quand j'exécute mon programme, en dessinant la grille comme ça:

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
 
private final int DEFAULT_PANEL_WIDTH = 3960;
private final int DEFAULT_PANEL_HEIGHT = 2048;
 
private int panelWidth = 3960;
private int panelHeight = 2048;
 
private int scaledPanelWidth = 3960;
private int scaledPanelHeight = 2048;
...
 
@Override
	public void paintComponent(final Graphics g)
	{
		final Graphics2D gDebug = (Graphics2D)g.create();
		final Graphics2D g2 = (Graphics2D)g;
 
		// On efface le contenu
		g2.clearRect(0, 0, scaledPanelWidth, scaledPanelHeight);
 
		final AffineTransform tx = getCurrentTransform();
		tx.concatenate(g2.getTransform());
		g2.transform(tx);
 
		// Dessin de la grille (après transformation affine pour qu'elle soit à l'échelle)
		g2.setPaint(texture);
		g2.fillRect(0, 0, scaledPanelWidth, scaledPanelHeight);
 
		...
	}
 
// Avec 
@Override
public Dimension getPreferredSize()
{
   return new Dimension(panelWidth, panelHeight);
}

Elle devrait remplir tout le panel (au moins si je ne zoom pas).
J'ai dessiné la grille en enlevant la transformation de l'espace de dessin et là elle se dessine bien sur tout le panel.
Du coup j'ai vérifié la matrice de passage qui est appliquée au début sans zoom et c'est bien une matrice Identité (I)

Il me semble que l'espace sans transformée affine et l'espace avec une transformée I devrait être le même. C'est là que je ne comprend pas pourquoi les comportements diffèrent.

2.
Après tes indications il me semble que l'image texture n'est peut être pas la meilleure des solutions pour dessiner ma grille.
Je suis parti dans cette direction parce que c'est la première idée que j'ai eu,et ça me semblait plutôt cohérent que la taille des points varie avec l'échelle. Sauf qu'après réflexion je me dit qu'il serait peut être plus intéressant de faire une grille ou l'espace entre points serait relié à l'échelle tandis que les points seraient eux toujours représentés par 1 pixel.

Bon je vais chercher comment faire. Si tu as des liens je suis preneur.

Merci encore pour les suggestions


A +