Dessin d'une image dans un GeneralPath

**seiryujay** · 07/09/2006, 15h44

Bonjour,

J'ai un petit souci.
J'aimerai dessiner une image dans une Shape. Cette Shape est en fait un GeneralPath.
Pour l'instant j'utilise cette méthode :

Code :

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

1
2
 
g2d.setPaint(new TexturePaint(img, generalPath.getBounds2D()));

où vous l'aurez deviné, img est mon image et generalPath est mon GeneralPath...

J'aimerai que dans le cas où mon GeneralPath est un rectangle, l'image se dessine dans le rectangle (qui peut être tourné d'un angle alpha), et non pas dans le rectangle circonscrit à mon rectangle tourné.

Du coup, comment puis-je faire pour savoir si mon GeneralPath est un rectangle?

Merci d'avance!

**seiryujay** · 07/09/2006, 17h07

Bon en fait, je suis bête puisqu'un Rectangle est toujours droit... Si on lui applique une rotation, ça devient un GeneralPath

Du coup, je ne peux pas faire ce que je veux, tout du moins pas avec un TexturePaint.
Quelqu'un connaîtrait-il une autre solution pour arriver à ce que je veux?
Siouplé...

**bouye** · 08/09/2006, 05h24

Le Rectangle passe en parametre du constructeur de la TexturePaint sert a indiquer les dimensions de l'image de la texture (au cas ou on veut faire une texture qui ne commence pas a (0,0) ou qui soit aggrandie/retrecie par rapport a l'image source), il n'est pas en rapport direct avec la forme dessinee a l'ecran).

Note que la transformation utilisee affecte egalement les Paint, donc si tu utilises une TexturePaint plutot qu'une image directe, elle sera affichee dans le bon sens (voir image jointe)... si tu t'y prend correctement. Le simple fait de faire un fill() de la Shape avec ce Paint fera que la texture apparaitra a travers une "fenetre" ayant la bonne forme.

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
package test;
 
import java.awt.*;
import java.awt.geom.*;
import java.awt.image.*;
import java.io.*;
import javax.swing.*;
import javax.imageio.*;
 
public class Test2D extends JFrame {
  public static final TexturePaint THE_PAINT = createPaint();
 
  public Test2D() {
    super("Test");
    setLayout(new BorderLayout());
    add(new RenderPanel(), BorderLayout.CENTER);
  }
 
  private static TexturePaint createPaint() {
    try {
      BufferedImage image = ImageIO.read(new File("fbavatar.png"));
      return new TexturePaint(image, new Rectangle(0, 0, image.getWidth(), image.getHeight()));
    }
    catch (Exception e) {
      e.printStackTrace();
    }
    return null;
  }
 
  public static void main(String ...args) {
    SwingUtilities.invokeLater(new Runnable() {
      public void run() {
        Test2D dialog = new Test2D();
        dialog.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        dialog.setVisible(true);
        dialog.pack();
      }
    });
  }
 
  private static class RenderPanel extends JPanel {
    private static Stroke STROKE = new BasicStroke(5);
    private static Paint FILL_GRADIENT = new GradientPaint(50, 0, Color.RED, 50, 350, Color.YELLOW);
    private static Paint PAINT_GRADIENT = new GradientPaint(50, 0, Color.YELLOW, 50, 350, Color.RED);
    private Shape circle = new Ellipse2D.Float(50, 50, 350, 350);
 
    public RenderPanel() {
      super();
      setPreferredSize(new Dimension(500, 500));
    }
 
    /** {@inheritDoc}
     */
    @Override protected void paintComponent(Graphics graphics) {
      super.paintComponent(graphics);
      Graphics2D g2d = (Graphics2D) graphics.create();
      try {
        Dimension size = getSize();
        //g2d.rotate(Math.PI/2.0, size.width/2.0, size.height/2.0);
        g2d.shear(0.5, 0);
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        //g2d.setPaint(FILL_GRADIENT);
        g2d.setPaint(THE_PAINT);
        g2d.fill(circle);
        g2d.setStroke(STROKE);
        //g2d.setPaint(PAINT_GRADIENT);
        g2d.draw(circle);
      }
      finally {
        g2d.dispose();
      }
    }
  }
}

Enfin si tu prefere manipuler des Image plutot que des TexturePaint, tu dois mettre la zone de clip du graphics2D a la forme que tu utilises (le Rectangle, le GeneralPath...) avant de dessiner ton image. Genre (code pas teste) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
try {
  g2d.setTransform(transform);
 Shape oldClip = g2d.getClip();
 g2d.setClip(shape);
 g2d.drawImage(....);
 g2d.setClip(oldClip);
 g2d.draw(shape);
 g2d.setTransform(transform.createInverse());
}
catch (NoninvertibleTransformException nite) {
  ...
}

**seiryujay** · 08/09/2006, 09h36

Effectivement, ta méthode fonctionne, mais manipule directement l'objet Graphics pour obtenir la rotation.

Dans mon programme, les formes sont déformées à l'aide d'une AffineTransform. Du coup, j'ai du mal à voir comment coupler les 2...

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
 
public void draw(Graphics2D g2d, AffineTransform aff, Color shapeBackground, Color shapeOutline, float shapeTransparency, float shapeThickness, float[] shapeStyle, String texturePath, Color splitBackground, Color splitOutline, float splitTransparency) {
 
	g2d.setStroke(new BasicStroke(getThickness(), BasicStroke.CAP_ROUND, 
	BasicStroke.JOIN_MITER, 10.0f, getStyle(), 1));
	g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, getTransparency()));
 
	Shape rat = aff.createTransformedShape(shape);
 
	// Gestion de la texture
	if (getTexturePath() != null && getTexturePath().length() > 0) {
		BufferedImage img;
		img = ImageFilesReader.read(getTexturePath());
 
		if (img != null) {
			g2d.setPaint(new TexturePaint(img, rat.getBounds2D()));	
			g2d.fill(rat);
		}
	}
	else {
		g2d.setColor(new Color(getBackgroundColorCode()));
		g2d.fill(rat);
	}
 
	g2d.setColor(new Color(getOutlineColorCode()));
	g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1.0f));
	g2d.draw(rat);
}

**bouye** · 08/09/2006, 13h46

Si tu veux que ta texture soit transformée par ta transfo, il va falloir modifier ton code.

Par contre si j'étais toi, j'éviterai de charger l'image de la texture à chaque boucle de dessin.

**seiryujay** · 08/09/2006, 14h41

Envoyé par bouye

Si tu veux que ta texture soit transformée par ta transfo, il va falloir modifier ton code.

C'est ça le problème...
Parce qu'en fait, la forme à dessiner peut être tournéer et/ou zoomée. Or si je veux modifier le Graphics, il aut juste que je le tourne, donc il faut que je récupère l'angle, ce qui n'est pas possible il me semble, ou alors que j'applique l'AffineTransform de la Shape au Graphics, et que j'applique l'inverse du zoom, etc...
Ou tout changer.
Donc à voir.

Envoyé par bouye

Par contre si j'étais toi, j'éviterai de charger l'image de la texture à chaque boucle de dessin.

Effectivement...

**bouye** · 10/09/2006, 23h50

Hum, en esperant que ce w-e ne m'aura pas trop rouille.
J'imagine que tu as un objet conteneur qui contient la TexturePaint et une Shape transformee. Ne pourrais-tu pas egalement y stocker la transformation et faire quelque chose dans le genre :

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
package test;
 
import java.awt.*;
import java.awt.geom.*;
import java.awt.image.*;
import java.io.*;
import javax.swing.*;
import javax.imageio.*;
 
public class Test2D extends JFrame {
  public static final TexturePaint THE_PAINT = createPaint();
 
  public Test2D() {
    super("Test");
    setLayout(new BorderLayout());
    add(new RenderPanel(), BorderLayout.CENTER);
  }
 
  private static TexturePaint createPaint() {
    try {
      BufferedImage image = ImageIO.read(new File("fbavatar.png"));
      return new TexturePaint(image, new Rectangle(0, 0, image.getWidth(), image.getHeight()));
    }
    catch (Exception e) {
      e.printStackTrace();
    }
    return null;
  }
 
  public static void main(String ...args) {
    SwingUtilities.invokeLater(new Runnable() {
      public void run() {
        Test2D dialog = new Test2D();
        dialog.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        dialog.setVisible(true);
        dialog.pack();
      }
    });
  }
 
  private static class RenderPanel extends JPanel {
    private AffineTransform transform = AffineTransform.getRotateInstance(Math.PI / 3, 150, 150);
    private Shape clipArea = transform.createTransformedShape(new Rectangle(50, 50, 320, 200));
 
    public RenderPanel() {
      super();
      setPreferredSize(new Dimension(500, 500));
    }
 
    /** {@inheritDoc}
     */
    @Override protected void paintComponent(Graphics graphics) {
      super.paintComponent(graphics);
      Graphics2D g2d = (Graphics2D) graphics.create();
      try {
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
        Dimension size = getSize();
        g2d.setClip(clipArea);
        g2d.setTransform(transform);
        g2d.setPaint(THE_PAINT);
        // We paint over the entire panel area using the clip zone.
        Shape area = new Rectangle(0, 0, size.width, size.height);
        // But first we do need to transform the area using the reverse transformation so our texture has a proper alignement.
        area = transform.createInverse().createTransformedShape(area);
        g2d.fill(area);
      }
      catch (Exception e) {
        e.printStackTrace();
      }
      finally {
        g2d.dispose();
      }
    }
  }
}

L'astuce dans cette histoire c'est que la zone de clip n'est pas affectee par les transformations appliquees au Graphics. Elle reste donc sur la forme precedement transformee. La transformation de l'aire de peinture en utilisant la transformation inverse est necessaire car sinon la texture est mal alignee puisque la zone de peinture (du panel) est transformee par la premiere transformation.
Ceci dit je trouve cette solution un peu bancale.

**seiryujay** · 11/09/2006, 09h52

Le problème, c'est que chacune de mes formes peut avoir une texture qui lui est propre, donc je ne peux pas appliquer la texture à tout le panel, sinon toutes mes formes auront le même motif (enfin, il me semble...).

Ce qu'il faudrait, c'est que j'arrive à retrouver le rectangle droit correspondant à un GeneralPath orienté, mais je pense que ça doit être un peu ardu, ou alors il faut que je revois mon système de dessin, mais j'ai pô envie

(c'est ultra complexe...)

**seiryujay** · 11/09/2006, 13h19

Ouf! J'ai réussi!

Voici mon code :

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
 
public void draw(Graphics2D g2d, AffineTransform aff, 
	Color shapeBackground, Color shapeOutline, float shapeTransparency, 
	float shapeThickness, float[] shapeStyle, String texturePath, 
	Color splitBackground, Color splitOutline, float splitTransparency) {
 
	/** On affecte la transparence. */
	g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, getTransparency()));
 
        /** On crée la rotation permettant de ramener la Shape à une forme droite... */
        double angle = getAngle360(); // retourne l'angle de la forme...
        AffineTransform affInverseRotation = new AffineTransform();
        affInverseRotation.rotate(-angle, getBounds2D().getCenterX(), getBounds2D().getCenterY());
        Shape staightShape = affInverseRotation.createTransformedShape(shape); // shape est la forme à dessiner : celle-ci est déjà tournée mais pas scalée...
 
	/** On crée la Shape modifiée. */
	Shape modifiedShape = aff.createTransformedShape(shape); // on applique le scale à la forme déjà tournée (c'est le contour que l'on va dessiner par la suite)
 
	/** Transformation à appliquer au Graphics : rotation + scale */
	AffineTransform affPlusRotate = new AffineTransform();
	affPlusRotate.concatenate(aff);
	affPlusRotate.rotate(angle, getBounds2D().getCenterX(), getBounds2D().getCenterY());
 
	/** Gestion de la texture. */
	if (getTexturePath() != null && getTexturePath().length() > 0) {
 
    		/** On transforme le Graphics. */
	        	g2d.transform(affPlusRotate);
 
    		/** On affecte la texture. */
    		BufferedImage img;
    		img = ImageFilesReader.read(getTexturePath());
 
	            if (img != null) {
             	            	g2d.setPaint(new TexturePaint(img, staightShape.getBounds2D())); // forme non-tournée, non-scalée!
 
        			/** On remplit la forme non-transformée! */
	            		g2d.fill(staightShape);
	            }
	            else {
            			System.out.println("img == null");
	            }
	}
	else {
	            g2d.setColor(new Color(getBackgroundColorCode()));
		g2d.fill(modifiedShape);
	}
 
	/** On affecte la couleur, la transparence et l'épaisseur du trait */
	g2d.setColor(new Color(getOutlineColorCode()));
	g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1.0f));
	g2d.setStroke(new BasicStroke(getThickness(), BasicStroke.CAP_ROUND, 
              BasicStroke.JOIN_MITER, 10.0f, getStyle(), 1));
 
	/** On applique la transformation inverse, pour revenir dans la configuration initiale. */
	try {
		g2d.transform(affPlusRotate.createInverse());
	} catch (NoninvertibleTransformException e) {
		e.printStackTrace();
	}
 
	/** On dessine la Shape transformée! */
	g2d.draw(modifiedShape); // g2d est dans sa configuration initiale => on doit dessiner la shape totalement transformée
}

C'est pas ultra bien géré, mais au moins ça m'évite d'avoir à recoder tout le mécanisme de dessin des formes qui est relativement complexe (surtout la rotation et le redimmensionnement de formes groupées entre-elles...)

Merci pour l'aide! Ca m'a bien servi!

**bouye** · 12/09/2006, 00h49

Envoyé par seiryujay

Le problème, c'est que chacune de mes formes peut avoir une texture qui lui est propre, donc je ne peux pas appliquer la texture à tout le panel, sinon toutes mes formes auront le même motif (enfin, il me semble...).

Non, grace a la zone de clip, seule la partie dans la forme sera peinte. Rien n'empêche d'appliquer d'autres textures dans d'autres formes de manière similaire. De manière similaire on pouvait également peindre la bordure en générant la Shape du contour en fonction du stroke du Graphics, en utilisant cette forme comme zone de clip et en faisant un fill() après transformation inverse de la zone de peinture.

Cependant c'était du code assez (voir très très) rapidement tapé il doit être possible de faire mieux. Mais tu sembles t'en être bien sortit.

**seiryujay** · 12/09/2006, 11h48

Envoyé par bouye

Non, grace a la zone de clip, seule la partie dans la forme sera peinte. Rien n'empêche d'appliquer d'autres textures dans d'autres formes de manière similaire. De manière similaire on pouvait également peindre la bordure en générant la Shape du contour en fonction du stroke du Graphics, en utilisant cette forme comme zone de clip et en faisant un fill() après transformation inverse de la zone de peinture.

Effectivement je n'avais pas poussé le raisonnement assez loin.

Envoyé par bouye

Mais tu sembles t'en être bien sortit.

Ouais, ça a l'air de fonctionner. Je l'ai modifié de manière à ne charger l'image qu'une seule fois, et pas à chaque appel à la méthode draw(), comme tu me l'avais conseillé. Et on gagne en fluidité lorsque beaucoup d'images ont été chargées.

Encore merci!

Dessin d'une image dans un GeneralPath

AWT/Swing Java

Discussions similaires

Partager

Partager