problème pour créer interface Shape

Version imprimable

Bonjour,

Je cherche à créer un classe complexe drawable. Pour cela, il me semble qu'il faut implémeter une interface Shape. Mais je n'y arrive pas. (précision : je travaille avec java1.5 par obligation - cela m'est imposé. D'après le tuto de sun, cela semble plus simple avec 1.6)

Voici mon code, si quelqu'un voit mon erreur ou mes oublis...

1ère classe : cercle implémenté Shape, l'objet que je voudrai pouvoir dessiner avec un draw

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package ObjetPrDessiner;
 
import java.awt.geom.Ellipse2D;
import java.awt.geom.Point2D;
 
public class Cercle implements Shape  {
	private double radius;
	private Ellipse2D.Double circle;
	private Point2D.Double centreCercle;
 
	public Cercle(Point2D.Double control){
		centreCercle = control;
		radius = 50;
	}
	public void draw() {
	      circle = new Ellipse2D.Double(centreCercle.x - radius, centreCercle.y - radius, 2.0 * radius,
	              2.0 * radius);
	}
}

2e fichier : l'interface Shape

Code:

1
2
3
public interface Shape {
	public void draw();
}

3e fichier : le panel où dessiner le cercle

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
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.geom.Point2D;
import javax.swing.JPanel;
 
public class DessinerCercle extends JPanel{
	private Point2D.Double centreC;
	private Cercle cercle1;
	/** espace graphique pour le dessin */
	private Graphics2D g2D;
	/** epaisseur des traits  */
	private BasicStroke bs;
 
	public DessinerCercle(Point2D.Double centre){
		// création des variables
		centreC = centre;
		init();
 
	}
	// création du cercle
	public void init(){
		cercle1 = new Cercle(centreC);
		bs = new BasicStroke(2,BasicStroke.CAP_SQUARE,BasicStroke.JOIN_ROUND);				
	}
	// dessin
	public void paint(Graphics g){
		g2D = (Graphics2D) g;
		g2D.setColor (Color.red);
		g2D.setStroke(bs);
		g2D.drawLine((int)centreC.x -50,(int) centreC.y, (int)centreC.x +50, (int)centreC.y);
    	g2D.draw(cercle1);		
	}
 
}

*** c'est "g2D.draw(cercle1);" qui n'est pas reconnu

Merci de votre aide

18/08/2008, 14h10
omlip

Salut

comme indiqué dans la javadoc ICI.

L'objet en paramètre de la méthode "draw" sur l'objet Graphics2D est de type "java.awt.Shape" or il semble ici que l'interface Shape dont tu parles soit une crée par tes soins.

Tes classes Cercle, etc.... doivent implémenter java.awt.Shape

Bonjour esperal

Il ne faut pas réinventer la roue...:? !
Ellipse2D.Double EST déjà une implémentation toute faite de l'interface Shape.
Donc pour ton cercle:
Code:

1 2 3 4 5 6 7 8 9 10 class Cercle extends Ellipse2D.Double { public Cercle(Point2D.Double control,double radius) { super(control.x-radius,control.y-radius,radius*2,radius*2); } public Cercle(Point2D.Double control){ this(control,50); } }
Il y a des exemples à profusion sur le net ... En voici un http://www.roseindia.net/java/exampl...-in-java.shtml

20/08/2008, 11h09
esperal

Bonjour,
Bien sûr dans mon exemple avec un cercle, ce n'est pas nécessaire de réinventer l'interface Shape. Mais je veux pouvoir déplacer des objets complexes sans avoir à faire la translation ou la rotation sur chaque composant. Je suppose que c'est possible...
si je cherche à définir l'interface Shape, c'est aussi qu'en mettant simplement "implements Shape", cela ne marche pas avec java 1.5 (avec java 1.6 si).
Comme vous avez remarqué je suis débutante, merci pour votre aide.

Citation:

si je cherche à définir l'interface Shape, c'est aussi qu'en mettant simplement "implements Shape", cela ne marche pas avec java 1.5 (avec java 1.6 si).

L'interface "Shape" existe depuis la version 1.2 !
Si tu écris "class MyShape implements Shape", TU DOIS écrire toutes les méthodes de cette interface:

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
import java.awt.*;
import java.awt.geom.*;
 
 
public class MyShape implements Shape {
 
	public boolean contains(Point2D p) {
		// TODO Auto-generated method stub
		return false;
	}
 
	public boolean contains(Rectangle2D r) {
		// TODO Auto-generated method stub
		return false;
	}
 
	public boolean contains(double x, double y) {
		// TODO Auto-generated method stub
		return false;
	}
 
	public boolean contains(double x, double y, double w, double h) {
		// TODO Auto-generated method stub
		return false;
	}
 
	public Rectangle getBounds() {
		// TODO Auto-generated method stub
		return null;
	}
 
	public Rectangle2D getBounds2D() {
		// TODO Auto-generated method stub
		return null;
	}
 
	public PathIterator getPathIterator(AffineTransform at) {
		// TODO Auto-generated method stub
		return null;
	}
 
	public PathIterator getPathIterator(AffineTransform at, double flatness) {
		// TODO Auto-generated method stub
		return null;
	}
 
	public boolean intersects(Rectangle2D r) {
		// TODO Auto-generated method stub
		return false;
	}
 
	public boolean intersects(double x, double y, double w, double h) {
		// TODO Auto-generated method stub
		return false;
	}
 
}

C'est plus long à écrire...
Par exemple getPathIterator doit donner un itérateur sur la séquence des segments de ta forme...

Java t'offre déjà des implémentations réutilisables de cette interface:

Polygon pour créer des polygones
GeneralPath pour créer des formes courbes (courbes de Bézier) selon une série de points
Area pour créer des formes par additions/soustraction (géométrie constructive) de plusieurs formes.
...

Voici un mini exemple d'utilisation de Polygon pour dessiner des étoiles:

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
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Polygon;
import java.awt.Shape;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.ArrayList;
import java.util.List;
 
public class TestShape {
 
	/**
         * Test: Génère une série d'étoile...
         */
	public static void main(String[] args) {
 
		List<Shape> shapes=new ArrayList<Shape>();
 
		/*
		 * Génèrer une liste d'étoiles
		 */
		for (int i=3;i<=8;i++) {
			shapes.add(new Etoile(i,new Point(5*(i*i),200),i*4,i*2));
		}
 
		/*
		 * ...Et les afficher
		 */
		MyFrame frame=new MyFrame(shapes);
		frame.addWindowListener(new WindowAdapter(){
		    public void windowClosing(WindowEvent we){
		        System.exit(0);
		      }
		    });
		frame.setSize(400, 400);
		frame.setVisible(true);
	}
 
	/**
         * Frame qui représente une liste de formes
         */
	static 
	public class MyFrame extends Frame {
 
		private List<Shape> shapes;
 
		public MyFrame(List<Shape> shapes) {
			this.shapes=shapes;
		}
 
		public void paint(Graphics g) {
		    Graphics2D ga = (Graphics2D)g;
		    for (Shape shape:shapes) {
		    	ga.draw(shape);
		    }  
		}
	}
 
 
	/**
         * Nouveau Shape...Etoile 
         */
	static 
	public class Etoile extends Polygon {
 
		public Etoile(int nombrePointes,Point centre,int rayonExterne,int rayonInterne) {			
			double offsetAngle=2*Math.PI/nombrePointes;
			double angleExterne=0;
			double angleInterne=offsetAngle/2;
 
			for (int i=0;i<nombrePointes;i++) {
				Point p=getPoint(centre, angleExterne,rayonExterne);
				addPoint(p.x, p.y);
				p=getPoint(centre, angleInterne,rayonInterne);
				addPoint(p.x, p.y);
				angleInterne+=offsetAngle;
				angleExterne+=offsetAngle;
			}
		}
 
		private Point getPoint(Point centre,double angle, double rayon) {
			int x=(int) Math.round(centre.x +rayon*Math.cos(angle));
			int y = (int) Math.round(centre.y + rayon*Math.sin(angle));
			return new Point(x,y);
		}
	}
}

26/08/2008, 03h17
bouye

Note : GeneralPath (1.2+) et Path2D (1.6+) permettent bien sur non-seulement de faire des courbes (splines) bicubiques ou bilieaires mais peuvent egalement servir a faire des polygones de maniere bien plus precise que Polygon (qui reste limite a des int).
17/09/2008, 18h43
esperal

merci, cela répond tout à fait à mon problème.
15/04/2009, 20h20
esperal

Pour faire des dessins complexes il fallait utiliser Area
débutant en java, j'étais partie sur une fausse piste pour résoudre mon problème. Ce sont les Area qui permettent de combiner des formes et de les déplacer facilement.
Exemple:
Code:

1 2 area1 = new Area(new Ellipse2D.Double(100, 100, 150, 100)); area2 = new Area(new Rectangle2D.Double(150, 150, 150, 100));
on peut ensuite les transformer en les additionnant, ex :

Code:

area1.add(area2);

ou les soustraire

Code:

area1.subtract(area2);

ou faire des translations.
Comme la couleur est définie au moment du paint, il faut autant d'Area que de couleurs.

Les Line2D.Double ne peuvent pas être des Area mais j'ai trouvé une façon de contourner cette limite en prenant une CubicCurve dont les directions sont très proches des points de début et de fin :
Code:

1 2 droite = new CubicCurve2D.Double(x1n,y1n,x1n+1,y1n+1,x2n,y2n,x2n+1,y2n+1); area3 = new Area(droite);
(sans les +1 cela ne peut pas être une Area)
15/04/2009, 23h48
bouye

Pour les lignes horizontales et verticales elles peuvent egalemet etre approximees par un rectangle d'epaisseur egale a la taille du stroke*. Pour les non-horizontales : dessiner un rectangle dont la longueur est a la norme du segment puis appliquer une rotation/translation appropriee.

*Ce qui est, apres tout, ce que fait l'interface Stroke quand on dessine une ligne.

Attention avec area, parfois le resultat d'operations arithmetiques (nottament des soustractions*) est loin d'etre graphiquement optimal. Donc parfois c'est bien de dessiner sa forme complexe dans un logiciel de dessin/vectoriel/svg et de noter les points de controle puis de dessiner un Path2D plutot qu'une combinaison d'aire.

*Un truc a ne pas faire par exemple est de soustraire 2 secteurs de meme angle et meme centre (mais pas meme rayon), le resultat peut etre assez moche compte tenu des imprecisions des double et float. Il faut que le second secteur (celui de plus petit rayon, celui qu'on soustrait) depasse de part et d'autre du premier.