Dessiner une courbe point par point

**lestat_2706** · 23/06/2009, 11h12

Bonjour tous le monde,
j'ai un petit problème : je veux dessiner une courbe point par point, c'est-à-dire chaque fois je donne les coordonnées du point et ça se dessine sur mon panel. Mais j'ai pas pu réaliser ça, comment pourrais-je le faire s'il vous plait ?

Merci beaucoup.

**Djobird** · 23/06/2009, 14h21

Ah bah si c'est urgent, vite vite vite ! Dire que c'est urgent n'apportera rien d'autre qu'énerver les autres posteurs

Sinon, tu prend une liste de point, à chaque fois que tu donnes un point ca le rajoute dans cette liste. Dans le même temps, à chaque fois qu'un point est rajoutée dans ta liste, ca dessine la courbe allant du point 0 au 1, du point 1 au 2, du point 2 au 3 et ainsi de suite.
Et ca devrait marcher.

**lestat_2706** · 24/06/2009, 14h25

bon j'ai avancé un peux, j'ai réussi a tracer une courbe a partir d'un tableau (Jtable) de données, mon problème maintenant est de remplir le tableau automatiquement( X,Y), a partir d'un point initial en utilisant une boucle for, mais j'ai pas pu le faire
par exemple si le point initial est (0, h1)

Code :

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

1
2
3
4
5
for (i=1,i< d,i++)
{
x=i;
y=f(i);
}

je voulais faire ainsi, mais ça n'a pas marché

**looclooc** · 25/06/2009, 14h14

Bonjour lestat_2706,

Voici un petit ensemble de 3 calsses que je viens de t'implementer vite fait... (Il y a surement mieux a faire, mais c'est déja ça!)

Premiere classe: Point (elle existe dans l'API standard sauf qu'elle ne prend que des int en parametres, du coup, j'en ai fait une qui prend des double)

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
 
public class Point {
 
	private double x;
	private double y;
 
 
	public Point(double x, double y){
		this.x=x;
		this.y=y;
	}
 
	public double getX(){
		return this.x;
	}
 
	public double getY(){
		return this.y;
	}
}

Deuxieme classe: Courbe , c'est la classe principale de ce que tu cherche. c'est un JPanel dans lequel se dessine ta courbe a chaque ajout de point.
Deux remarques:
- Les calculs se font dans la méthode paint() par choix, pour qu'au redimensionnement de la fenetre d'affichage, la courbe s'ajuste! peut etre qu'il y a mieux a faire...
- Certains calculs pour centrer ta courbe de sorte qu'elle occupe toute l'aire de ta fenetre d'affichage (min/max sur les deux axes + origine au centre de la fenetre et non dans le coins haut-gauche comme par defaut).

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
 
public class Courbe extends JPanel{
 
	private Vector<Point> listePoints=new Vector<Point>();
	private double xMin=Double.MAX_VALUE;
	private double yMin=Double.MAX_VALUE;
	private double xMax=Double.MIN_VALUE;
	private double yMax=Double.MIN_VALUE;
 
	private int largeur=0;
	private int hauteur=0;
	private int left=10;
	private int top=10;
 
	public Courbe(){
 
	}
 
	public void ajouterPoint(Point p){
		if(p.getX()<this.xMin)
			this.xMin=p.getX();
		else if(p.getX()>this.xMax)
			this.xMax=p.getX();
 
		if(p.getY()<this.yMin)
			this.yMin=p.getY();
		else if(p.getY()>this.yMax)
			this.yMax=p.getY();
 
		this.listePoints.add(p);
 
		this.repaint();		
	}
 
	public void paint(Graphics g){
		super.paint(g);
 
		this.largeur=this.getWidth()-20;
		this.hauteur=this.getHeight()-20;
		this.left=10;
		this.top=10;
 
		g.setColor(Color.WHITE);
		g.fillRect(this.left, this.top, this.largeur, this.hauteur);
 
		g.setColor(Color.RED);
		if(this.listePoints.size()==1){
			int x=this.left+(this.largeur/2);
			int y=this.top+(this.hauteur/2);
			g.drawLine(x-2, y, x+2, y);
			g.drawLine(x, y-2, x, y+2);	
		}
		else{
			for(int i=0; i<this.listePoints.size()-1; i++){
				Point p1=this.convertirPointSurReferenciel(this.listePoints.get(i));
				Point p2=this.convertirPointSurReferenciel(this.listePoints.get(i+1));
				int x1=(int)p1.getX();
				int y1=(int)p1.getY();
				int x2=(int)p2.getX();
				int y2=(int)p2.getY();
 
				g.setColor(Color.BLUE);
				g.drawLine(x1, y1, x2, y2);
 
				g.setColor(Color.RED);
				g.drawLine(x1-4, y1, x1+4, y1);
				g.drawLine(x1, y1-4, x1, y1+4);
			}	
 
			Point p1=this.convertirPointSurReferenciel(this.listePoints.get(this.listePoints.size()-1));
			int x1=(int)p1.getX();
			int y1=(int)p1.getY();
			g.drawLine(x1-4, y1, x1+4, y1);
			g.drawLine(x1, y1-4, x1, y1+4);
		}		
	}
 
	public Point convertirPointSurReferenciel(Point p){
		double amplitudeX=this.xMax-this.xMin;
		double amplitudeY=this.yMax-this.yMin;
 
		double rapportX=this.largeur/amplitudeX;
		double rapportY=this.hauteur/amplitudeY;
 
		double x=(p.getX()-this.xMin)*rapportX;
		double y=(p.getY()-this.yMin)*rapportY;
 
		y=this.hauteur-y;
 
		x=x+this.left;
		y=y+this.top;
 
		return new Point(x, y);
	}	
}

Enfin, la troisieme classe, qui n'est rien d'autre qu'une JFrame pour afficher ta courbe, et aussi pour faire un teste en ajoutant des valeurs:

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
 
public class TraceurCourbes extends JFrame{
 
	private Courbe courbe;
 
	public TraceurCourbes(){
		super("Courbe");
		this.setSize(500, 500);
 
		this.courbe=new Courbe();
 
		this.courbe.ajouterPoint(new Point(   5, 6681.8929));
		this.courbe.ajouterPoint(new Point(10, 11834.3456));
		this.courbe.ajouterPoint(new Point(20, 37059.7267));
		this.courbe.ajouterPoint(new Point(30, 32249.5167));
		this.courbe.ajouterPoint(new Point(40, 11503.6712));
		this.courbe.ajouterPoint(new Point(50, 7485.3936));
		this.courbe.ajouterPoint(new Point(60, 5720.6952));
		this.courbe.ajouterPoint(new Point(70, 4762.9483));
		this.courbe.ajouterPoint(new Point(80, 4207.3249));
		this.courbe.ajouterPoint(new Point(90, 3880.5546));
 
		this.getContentPane().add(this.courbe);
 
		this.setVisible(true);
 
		this.addWindowListener(new WindowAdapter(){
			public void windowClosing(WindowEvent we){
				System.exit(0);
			}
		});
	}
 
}

Il ne te reste plus qu'a faire un appel a "new TraceurCourbes();" a partir de ton main() ...
Biensure, c'est un code implementé vite fait, donc a réamenager selon tes besoins reels, en plus, il y a surement plus facile a faire que certaines choses que j'ai fait, mais si tu as d'autres question, n'hesite pas

**--flow--** · 30/06/2009, 10h00

Bonjour, vouloir faire des courbes c'est bien beau mais ton soft sera plus performant si tu utilise OpenGl.

D'un autre coté, il existe plein de type de courbes utilisant les points de controles en informatique. Tout dépends si tu veux interpoller tes points de controles ou non. Regarde du côté des courbs de Bezier (Algo de De Casteljau simple à mettre en place ou Algorithme de Chaikin). Si tu veux interpoller tes points de controles, il doit y avoir l'algorithme 4 points qui n'est pas trop dur a mettre en place. tu peux aussi chercher du coté des Splines.

Bon courrage.

**looclooc** · 30/06/2009, 10h44

Bonjour --flow--,
Je ne crois pas que ce soit ce qu'il cherche si j'ai bien compris, mais si je me trompe, il peut aussi voir le polynome de Lagrange qui est trop facile a implementer et qui donne une courbe passant exactement par tout ses points! Sinon, ce que tu as suggéré est tres interessant aussi