Discussion :

[DiabolO]

Bonjour,

Dans mon programme je fais 4 appels à une fonction creerForme (...) qui me renvoie un objet de type GeneralPath. (creerForme() fabrique une courbe)
Soit ch1 = creerForme (...);
ch2 = creerForme (...);
ch3 = creerForme (...);
ch4 = creerForme (...);

J'aimerais connecter ces 4 courbes entre elles de façon à ce que l'ensemble forment un plan.

Exemple: (ici j'ai remplacé les courbes par des segments)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
                       courbe1
                            |
                            v
                     +-----------+  
    courbe4  --->    |             |  <--- courbe2
                     |             |
                     +------------+
                            ^ 
                            |
                         courbe3

la fonction append n'a pas donné le résultat que je voulais !
Biensur je pourrais creer mes 4 courbes dans la fonction creerForme (...) et relier le dernier point au premier, mais j'aimerais que creerForme (...) me renvoie juste un chemin dessinant une courbe !

Comment puis-je m'en sortir ?

[Heimdal]

A quoi ressemble ton objet Courbe?

[DiabolO]

ma courbe est faite comme ça :

Si ch est un objet GeneralPath :

Code :

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

1
2
3
4
5
ch.quadTo ()
ch.quadTo ()
ch.curveTo ()
ch.quadTo ()
ch.quadTo ()

C'est pour représenter le "puit" d'une pièce de puzzle !

[Heimdal]

?
envoie du code

[DiabolO]

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
 
public GeneralPath creerAreteHB (int xdeb, int xfin, int y, int height) {
	int width = xfin - xdeb;
	int blank = (int)(1.0/10 * width);
	int mids = xdeb + width/2 - blank, mide = xfin - width/2 + blank; 
	int mmids = xdeb + (mids - xdeb)/2, mmide = xfin - (xfin - mide)/2;
	int hcurveg = (int)(1.0/20 * height);
	int hcurved = (int)(1.0/20 * height);
	int wcurveg = (int)(1.0/7.9 * width);
	int wcurved = (int)(1.0/6.5 * width);
	int hpuitg = (int)(1.0/2.7 * height);
	int hpuitd = (int)(1.0/2.3 * height);
	int hbcl = (int)(1.0/10 * height);
	int [] xPoints = {xdeb,mids,mids,mide,mide,xfin};
	int [] yPoints = {y,y,y+hbcl,y+hbcl,y,y};
	GeneralPath ch = new GeneralPath (GeneralPath.WIND_EVEN_ODD, 
					  xPoints.length);
	ch.moveTo (xPoints[0],yPoints[0]);
	ch.quadTo (mmids,y-hcurveg,xPoints[1], yPoints[1]);
	ch.quadTo (mids+hcurveg,y+hcurveg,xPoints[2],yPoints[2]);
	ch.curveTo (mmids-wcurveg, y+hpuitg, 
		    mmide+wcurved, y+hpuitd, xPoints[3],yPoints[3]);
	ch.quadTo (mide-hcurved,y+hcurved,xPoints[4],yPoints[4]);
	ch.quadTo (mmide,y-hcurved,xPoints[5], yPoints[5]);
 
	return ch;
    }

Ca ne te parlera pas beaucoup car j'ai pris les points de manière empirique !
Ce qu'il faut savoir c'est :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
              curveTo
                  |
                  v
             +--------+
quadTo --->  |        |  <--quadTo
debut +-------+       +------------+fin
           ^                    ^ 
           |                    |
      quadTo                  quadTo

Je sais c'est pas super clair mais c'est difficile à expliquer !
Je peux te montrer mon code entier si tu veux !

[bouye]

Vi c'est normal de vouloir utiliser des fonctions separees si on veut pouvoir generer les pieces adjacents.

J'imagine que tu as essaye de mettre le parametre connect de la methode append() a true ?

Sinon tu as une autre solution : recuperer le PathIterator de chacun des 4 courbes et les parcourir de maniere a creer une nouveau GeneralPath. Un truc du 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
float[] buffer = new float[6]
GeneralPath result = new GeneralPath();
for (subPath : pathes) {
  PathIterator it = subPath.getPathIterator(null, ?); // Note: je ne sais jamais trop quoi mettre comme flatness, faire des essais.
  for( ; ! it.isDone(); it.next()) {
      int seg = it.currentSegment(buffer);
      switch (sg) {
           case PathIterator.SEG_MOVETO:
              // A remplacer par un lineTo ou ignorer sur les chemins 2, 3 et 4.
              result.lineTo(buffer[0], buffer[1]);
           break; 
           case PathIterator.SEG_LINETO:
              result.lineTo(buffer[0], buffer[1]);
           break; 
           case PathIterator.SEG_QUADTO:
              result.quadTo(buffer[0], buffer[1], buffer[2], buffer[3);
           break; 
           case PathIterator.SEG_CUBICTO:
              result.curveTo(buffer[0], buffer[1], buffer[2], buffer[3], buffer[4], buffer[5]);
           break; 
           case PathIterator.SEG_CLOSE:
           default:
               // Error! Pas de fermeture de path normalement.
      }
  }
}
result.closePath();