Discussion :

[Bjorn29]

Bonjour,

je suis en train de chercher à créer une carte avec des vecteurs qui se déplacent, un peu comme une carte d'une ville avec les voitures etc représentées sous formes de vecteurs direction/vitesses.

Le calcul de distance entre les mobiles, les vitesses je pense que je les ai sur le papier.

Ce qu'il me manque se sont les outils pour créer le repère dans lequel vont se déplacer les vecteurs.

Quelqu'un pourrait-il m'aider concernant les outils/méthodes à utiliser svp ?

Je vous remercie par avance de toute information me faisant progresser.

[joel.drigo]

Salut,

Ce que tu voudrais, je suppose, c'est représenter graphiquement tes objets ? Dans quel environnement graphique ? En Desktop (Swing/AWT/Java2D, JavaFX, JFace/SWT/Draw2D...?), en Web ?

[Bjorn29]

Oui c'est ca, (et merci de votre réponse) dans un environnement swing/AWT/Java2D je voudrais dans un premier temps réussir à obtenir un point de référence dans une fenêtre Jpanel par exemple et ensuite réussir à y afficher des vecteurs avec angle, longueur et point de référence/départ (a,b). Après je pense qu'une fois que j'ai mon point de référence (x=0,y=0) il faut que n'affiche les vecteurs en relatifs par rapport à ce point.

Après je n'ai pas forcément la solution la plus optimale et si ca se trouve qui ne marche pas car j'ai des notions de base en maths et physique mais je débute en programmation. Je pense avoir le principe mais pas l'outil le plus adapté

[joel.drigo]

Dans tous les composants Swing, dont le JPänel, la référence est le point en haut à gauche, de coordonnées (0,0), le repère étant avec le x horizontaux croissants de gauche à droite, et y verticaux croissants de haut en bas. Tu peux déplacer le repère en utilisant une transformer affine (translation, rotation...).

Le principe de base pour dessiner dans le JPanel :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
public class DemoVector extends JPanel {
 
	private List<Vector> vectors = new ArrayList<>();
 
	@Override
	protected void paintComponent(Graphics g) {
		super.paintComponent(g);
		Graphics2D g2d = (Graphics2D) g; // éventuellement selon les besoin
 
                // ici on dessine via g ou g2d
 
	}

On peut dessiner directement, en utilisant des coordonnées. Par exemple, g.drawLine(x1,y1,x2,y2); ou utiliser des formes (Shape) :

Code :

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

Shape line = new Line2D.Double(x1,y1,x2,y2);

et

Code :

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

g2d.draw(line);

On peut appliquer une transformer affine au contexte graphique (g ou g2d), ou à une forme, ce qui te permettra facilement de dessiner un vecteur à partir d'un point de départ, avec une longueur, et selon un angle (en dessinant ça en horizontal par exemple, et en appliquant une transformée affine qui fait la rotation).

[Bjorn29]

Merci de votre réponse et de sa rapidité
Malheureusement pour moi je ne suis pas un as de la programmation et je n'arrive pas encore à intégrer ce code dans mon Jpanel (je n'arrive pas à l'afficher).
J'ai du travail encore

[joel.drigo]

Montre-nous ton code si tu as des problèmes pour le faire fonctionner.

Sinon voici un exemple :

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
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Paint;
import java.awt.RenderingHints;
import java.awt.Shape;
import java.awt.Stroke;
import java.awt.geom.AffineTransform;
import java.awt.geom.Area;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Path2D;
import java.awt.geom.Rectangle2D;
import java.util.HashSet;
import java.util.Set;
 
import javax.swing.JFrame;
import javax.swing.JPanel; 
 
public class DemoVector extends JPanel {
 
	private Set<Vector> vectors = new HashSet<>(); // stocke tous les vecteurs à dessiner (un set permet d'éviter d'avoir deux fois le même vecteur (en terme d'instance) à dessiner
	private Rectangle2D bounds = new Rectangle2D.Double(); // l'emplacement global pris par tous les vecteurs (à calculer)
 
	private void JPanel() {
		updateBounds(); // on initalise l'emplacement global
	}
 
	public void add(Vector vector) {
		// on ajoute un vecteur
		if ( vector!=null ) { // pour éviter les NullPointerException en amont, on ignore les null en aval
			vectors.add(vector); // on stocke le vecteur
			updateBounds(); // on recalcule l'emplacement globale puisqu'on a ajouter une vecteur
			repaint(); // on redessine puisqu'on a ajouter un vecteur
		}
	}
 
	private void updateBounds() {
		// on met à jour la taille du JPanel par rapport à son contenu (les vecteurs)
		bounds = new Rectangle2D.Double(-32,-32,64,64); // un emplacement minimum de 64x64 (centré sur 0,0)
		for(Vector vector : vectors) { // l'emplacement total est l'union des emplacements de chaque vecteur
			bounds = bounds.createUnion(vector.getBounds());
		}
		double d = 1.5; // on compense le fait qu'on dessine centré
		bounds = AffineTransform.getScaleInstance(d,d).createTransformedShape(bounds).getBounds2D();
		setPreferredSize(new Dimension((int)bounds.getWidth(), (int)bounds.getHeight()));
	}
 
	@Override
	protected void paintComponent(Graphics g) {
		super.paintComponent(g); // on laisse le composant se dessiner normalement (pour avoir le fond entre autres)
		Graphics2D g2d = (Graphics2D) g;
		g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
 
		// exemple pour avoir le centre du repère au centre du composant: 
		g2d.translate(getWidth()/2d,getHeight()/2d);
		// on inverse le sens du y pour avoir un repère plus "naturel" géométriquement parlant
		g2d.scale(1, -1);
 
		// on dessine le repère
		g.setColor(Color.LIGHT_GRAY);
		g.drawLine(-getWidth()/2, 0, getWidth()/2, 0); // horizontal
		g.drawLine(0, -getHeight()/2, 0, getHeight()/2); // vertical
 
		for(Vector vector : vectors) {
			g.setColor(getForeground()); // couleur de dessin par défaut
			vector.draw(g2d); // on dessine le vecteur
		}
	}
 
	// le programme principal
	public static void main(String[] args) {
 
		JFrame frame = new JFrame("Exemple");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		DemoVector panel = new DemoVector(); // on créé le panel
		panel.setBackground(Color.BLACK); // fond noir
		panel.setForeground(Color.WHITE); // trait par défaut blanc
 
		// on ajoute 4 vecteurs pour l'exemple
		panel.add(new Vector(Color.RED, 0,0,100,0)); // départ 0,0, longueur 100, angle 0°
		panel.add(new Vector(Color.YELLOW.darker(), 10,10,100,45)); // départ 10,10, longueur 100, angle 45*
		panel.add(new Vector(-50,-50,-30,-60)); // départ -50,-50, longueur -30 (je n'ai pas limité volontairement la norme du vecteur à une longueur positive ou nul, mais on pourrait), angle -60*
		panel.add(new Vector(Color.CYAN.darker(),-50,-50,30,-60)); // le même avec la longueur à 30
 
		frame.add(panel);
 
		frame.pack();
		frame.setLocationRelativeTo(null);
		frame.setVisible(true); 
 
	}
 
	// une classe qui représente un vecteur
	public static class Vector {
 
		private static final double POINT_SIZE = 3;
		private static final double ARROW_SIZE = 10;
		private static final Stroke STROKE = new BasicStroke(2); // on va dessiner les vecteurs avec un trait de 2 pixels de large
 
		private final Shape shape; // la flêche
		private final Shape start; // le point de départ
		private final Paint color; // la couleur (ou plus exactement la peinture)
 
		/**
                 * 
                 * @param x
                 * @param y
                 * @param longueur
                 * @param angle en degrés
                 */
		public Vector(double x, double y, double longueur, double angle) { 
			this(null, x, y, longueur, angle);
		}
		/**
                 * 
                 * @param color
                 * @param x
                 * @param y
                 * @param longueur
                 * @param angle en degrés
                 */
		public Vector(Paint color, double x, double y, double longueur, double angle) { 
 
			this.color=color;
 
			// on appliquera l'angle par transformée affine (on converti l'angle en radian et on rectifie le sens pour avoir un sens horaire positif (c'est un choix)	)		
			AffineTransform affineTransform = AffineTransform.getRotateInstance(Math.toRadians(-angle), x, y);
 
			if ( longueur==0 ) {
				shape=null; // on ne dessine pas de flêche si la longueur est 0
			}
			else {
				// on dessine toujours la flêche horizontalement
				Path2D.Double path2D = new Path2D.Double();
				path2D.moveTo(x, y);
				path2D.lineTo(x+longueur, y);
				path2D.lineTo(x+longueur-ARROW_SIZE*Math.signum(longueur), y-ARROW_SIZE);
				path2D.moveTo(x+longueur-ARROW_SIZE*Math.signum(longueur), y+ARROW_SIZE);
				path2D.lineTo(x+longueur, y);
				shape = affineTransform.createTransformedShape(path2D);
			}
                        // on dessine le point comme un disque
			Ellipse2D.Double point = new Ellipse2D.Double(x-POINT_SIZE,y-POINT_SIZE,POINT_SIZE*2,POINT_SIZE*2);
			start = affineTransform.createTransformedShape(point);
		}
 
		public void draw(Graphics2D g2d) {
			g2d.setStroke(STROKE); // on selectionne le trait
			if ( color!=null ) {
				g2d.setPaint(color); // on sélectionne la couleur s'il y en a une (sinon ça se dessinera dans la dernière couleur sélectionée)
			}
			g2d.fill(start); // on dessine le point (rempli)
			if ( shape!=null ) {
				g2d.draw(shape); // on dessine la flêche
			}
		} 
 
		public Rectangle2D getBounds() {
			// on calcule l'emplacement pris par le vecteur, largeur de trait compris
			Area area = new Area(STROKE.createStrokedShape(start));
			if ( shape!=null ) {
				area.add(new Area(STROKE.createStrokedShape(shape)));
			}
			return area.getBounds2D();
		}
 
	}
 
}