Discussion :

[pingoui]

Bonjour,

J'ai un composant électrique



Celui-ci est composer différentes lignes

J'aimerai réaliser un resize de mon composant.(width et height)
Pour faire un resize d'un simple rectangle, je fais:

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
  /**
   * Equipment resize state. This states manages the resizing of a equipment.
   */
  private class EquipmentResizeState extends ControllerState {
    private float                deltaXToResizeVertex;
    private float                deltaYToResizeVertex;
    private SlipEquipment	 selectedPiece;
    private float                oldX;
    private float                oldY;
    private float                oldWidth;
    private float                oldHeight;
    private String               centimerResizeToolTipFeedback;
    private String               inchResizeToolTipFeedback;

    @Override
    public Mode getMode() {
      return Mode.SELECTION;
    }
    
    @Override
    public void enter() {
      this.centimerResizeToolTipFeedback = resource.getString("centimerResizeToolTipFeedback");
      this.inchResizeToolTipFeedback = resource.getString("inchResizeToolTipFeedback");
      this.selectedPiece = (SlipEquipment)slip.getSelectedItems().get(0);
      float [] resizePoint = this.selectedPiece.getGraphicEquipment().getPoints() [2];
      this.deltaXToResizeVertex = getXLastMousePress() - resizePoint [0];
      this.deltaYToResizeVertex = getYLastMousePress() - resizePoint [1];
      this.oldX = this.selectedPiece.getX();
      this.oldY = this.selectedPiece.getY();
      this.oldWidth = this.selectedPiece.getWidth();
      this.oldHeight = this.selectedPiece.getHeight();
      PlanComponent planView = (PlanComponent)getView();
      planView.setResizeIndicatorVisible(true);
      planView.setToolTipFeedback(getToolTipFeedbackText(this.oldWidth, this.oldHeight), 
          getXLastMousePress(), getYLastMousePress());
    }
    
    @Override
    public void moveMouse(float x, float y) {
      // Compute the new location and dimension of the piece to let 
      // its bottom right point be at mouse location
      float angle = this.selectedPiece.getAngle();
      double cos = Math.cos(angle); 
      double sin = Math.sin(angle); 
      float [] topLeftPoint = this.selectedPiece.getGraphicEquipment().getPoints() [0];
      float deltaX = x - this.deltaXToResizeVertex - topLeftPoint[0];
      float deltaY = y - this.deltaYToResizeVertex - topLeftPoint[1];
      float newWidth =  (float)(deltaY * sin + deltaX * cos);
      float newHeight =  (float)(deltaY * cos - deltaX * sin);

      newWidth = Math.max(Math.round(newWidth * 10f) / 10f, 0.1f);
      newHeight = Math.max(Math.round(newHeight * 10f) / 10f, 0.1f);

      // Update piece new location
      float newX = (float)(topLeftPoint [0] + (newWidth * cos - newHeight * sin) / 2f);
      float newY = (float)(topLeftPoint [1] + (newWidth * sin + newHeight * cos) / 2f);
      slip.setEquipmentLocation(this.selectedPiece, newX, newY);
      // Update piece new dimension
      slip.setEquipmentDimension(this.selectedPiece, newWidth, newHeight);


      PlanComponent planView = (PlanComponent)getView();
      // Ensure point at (x,y) is visible
      planView.makePointVisible(x, y);
      planView.setToolTipFeedback(getToolTipFeedbackText(newWidth, newHeight), x, y);
    }

    @Override
    public void releaseMouse(float x, float y) {
      postEquipmentResize(this.selectedPiece, this.oldX, this.oldY, 
          this.oldWidth, this.oldHeight);
      setState(getSelectionState());
    }

    @Override
    public void escape() {
      slip.setEquipmentLocation(this.selectedPiece, this.oldX, this.oldY);
      slip.setEquipmentDimension(this.selectedPiece, 
              this.oldWidth, this.oldHeight);
      setState(getSelectionState());
    }

    @Override
    public void exit() {
      PlanComponent planView = (PlanComponent)getView();
      planView.setResizeIndicatorVisible(false);
      planView.deleteToolTipFeedback();
      this.selectedPiece = null;
    }  
  }

Hors mon composant est un peu plus complexe qu'un simple rectangle.

J'ai essayé, dans ma classe permettant la modification, de modifier seulement les coordonnées de fin de mes différentes lignes (xEnd et yEnd)

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
 
	   /**
            * Sets the width of this equipment.
            * This method should be called from {@link Slip}, which
            * controls notifications when a equipment changed.
                 */	    	   
	   void setWidth(float width) {
		     this.width = width;		     
	        for (EquipmentLine equipmentLine : this.getEquipmentLines()) {
	            equipmentLine.setXEnd(width);
	        }
	        this.shapeCache = null;
		   }
 
	   /**
            * Sets the height of this equipment.
            * This method should be called from {@link Slip}, which
            * controls notifications when a equipment changed.
            */
	   void setHeight(float height) {
	     this.height = height;
	        for (EquipmentLine equipmentLine : this.getEquipmentLines()) {
	            equipmentLine.setYEnd(height);
	        }
	        this.shapeCache = null;
	   }

Mais le résultat est catastrophique
Comment feriez-vous pour faire un resize d'un composant comme le mien?
Pour la rotation, je poserai ma question après
Merci de votre aide

[corseb]

salut!
Tu m'a lair detre balaise, tu veut pas m'aider sur ma question>
http://www.developpez.net/forums/sho...d.php?t=522318

Au passage regarde mon code la bas il taidera pour la rotation!
(il faudra mettre un bounding sphere et c un truc genre rotatorinterpoleur)

Pour le "resize", moi quand je creer ma forme basique genre:

Code :

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

 Bird.addChild(new com.sun.j3d.utils.geometry.Box(.25f,.22f,.45f, primflagsx,apx));

il suffit simplement que je divsie .25f (laxe des x) par deux par example... si je divise tout par 2 genre 12,11,22 en gros, cela me fait un cube identique mais 2 fois plus petit...

[pingoui]

"Balaise" Certainement pas
Désolé, je ne peux t'aider

[sinok]

Pour moi l'idée serait de prévoir la fonctionnalité de redimensionnement au moment du dessin de tes composants, c'est à dire de prévoir un ration qui sera appliqué à toutes les opérations de dessin, qui est fixé par défaut à 1 mais peut augmenter/diminuer selon le besoin, une sorte de facteur de zoom en quelque sorte.
Enfin pour me donner une idée serait il possible d'avoir une Image de ce que tu cherches à redimensionner, (car bon, un composant électrique çà peut dire beaucoup de choses)....

[bouye]

Pour moi l'idée serait de prévoir la fonctionnalité de redimensionnement au moment du dessin de tes composants, c'est à dire de prévoir un ration qui sera appliqué à toutes les opérations de dessin, qui est fixé par défaut à 1 mais peut augmenter/diminuer selon le besoin, une sorte de facteur de zoom en quelque sorte.

Je dirais meme plus d'avoir une Transform associe a chaque equipement pour son affichage graphique.

Une idee jetee comme ca...
Note : je n'ai pas trop d'idee en ce moment pour ce genre de chose, alors j'espere ne pas trop dire de betises.

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
 
/** The reference point (may be the center point or the top left point).
*/
private Point2D refPoint;
 
/** The handle box shape.
*/
private Shape handleBox;
 
/** Calculate initial handle shape based on the shape of the component.
* Calculate initial ref point based on the shape of the component.
*/
private void initialize() {
  [...]
}
 
/** The bounding box of the componant.
* <br>Useful for graphics optimizations, partial redraws, search on click and collision detection.
*/
Public Rectangle getBounds2D() {
  return getHandleBox().getBounds();
}
 
/** The bounding box of the componant.
* <br>Useful for graphics optimizations, partial redraws, search on click and collision detection.
*/
Public Rectangle2D getBounds2D() {
  return getHandleBox().getBounds2D();
}
 
/** A 4 side shape that allows to handle the component.
* It's PathIterator will be followed to draw each handle separatly.
*/
public Shape getHandleBox() {
  [...]
}
 
/** Resets the component to its initial transformation.
*/
public void reset() {
  transform.setToIdentity();
  // transform handle box.
  // Recalculate connection points to the component.
  // Recalculate position.
}
 
public rotate(double theta) {
  transform.rotate(theta, refPoint.getX(), refPoint.getY());
  // transform handle box.
  // Recalculate connection points to the component.
  // Recalculate position.
}
 
public shear(double sx, double sy) {
  transform.shear(sx, sy));
  // transform handle box.
  // Recalculate connection points to the component.
  // Recalculate position.
}
 
public scale(double sx, double sy) {
  transform.scale(sx, sy));
  // transform handle box.
  // Recalculate connection points to the component.
  // Recalculate position.
}
 
public move(double dx, double dy) {
  transform.translate(dx, dy));
  // transform handle box.
  // Recalculate connection points to the component.
  // Recalculate position.
}
 
public void draw(Graphics2D g) {
  Shape handleBox = getHandleBox();
  // Draw handle box and handles.
  Transform oldTransform = g.getTransform();
  g.setTransform(transform);
  // Draw component shape at theta = 0, sx = 0, sy = 0, dx = 0, dy = 0, etc...
  render(g);
  g.setTransform(oldTransform);
}
 
/** Draw component shape at theta = 0, sx = 0, sy = 0, dx = 0, dy = 0, etc...
*/
private void render(Graphics2D d) {
}

[Alec6]

Franchement si ta rotation peut être quelconque tu devrais vraiment regarder comment ils font dans la 3D, avec le système d'arbre de scène.

Car tu vas avoir de sérieux soucis, à commencer par le calcul des coordonnées à cause des arrondies de calculs.

[pingoui]

Salut sinok,

Le composant ressemble à ça :

[fnobb]

Bonjour,

d'après ce que j'ai vue la rotation est mise en oeuvre pour le cadre

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
	  /**
           * Renvoie la forme qui entoure l'équipement
           */
	  public Shape getShape() {
		   if (this.shapeCache == null) {
			   System.out.println("GraphicEquipment getShape");
		      //Crée un rectangle de dimension
		      Rectangle2D pieceRectangle = new Rectangle2D.Float(
		    		  getAreaX() /*- this.width / 2*/,
		    		  getAreaY() /*- this.height / 2*/,
		          getWidth(), getHeight());
		      // Applique la rotation du rectangle
		      AffineTransform rotation = new AffineTransform();
		      rotation.setToRotation(this.angle, this.x, this.y);
		      PathIterator it = pieceRectangle.getPathIterator(rotation);
		      GeneralPath pieceShape = new GeneralPath();
		      pieceShape.append(it, false);
		      // Cache shape
		      this.shapeCache = pieceShape;
		    }
		    return this.shapeCache;
		  }

pourquoi ne pas faire la même chose pour le contenu

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
	  /**
           * Création d'un chemin qui relie le premier
           * point au autres point.
           */
	  private Shape getShape(float [][] points) {
		GeneralPath path = new GeneralPath();
		path.moveTo(points [0][0], points [0][1]);
	    for (int i = 1; i < points.length; i++) {
	    	path.lineTo(points [i][0], points [i][1]);
	    }
	    path.closePath();//fermeture du chemin
	    return path;
	  }

deviendrait quelque chose comme (a tester )

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
	  /**
           * Création d'un chemin qui relie le premier
           * point au autres point.
           */
	  private Shape getShape(float [][] points) {
		GeneralPath path = new GeneralPath();
		path.moveTo(points [0][0], points [0][1]);
	    for (int i = 1; i < points.length; i++) {
	    	path.lineTo(points [i][0], points [i][1]);
	    }
	    path.closePath();//fermeture du chemin
        AffineTransform rotation = new AffineTransform();
        rotation.setToRotation(this.angle, this.x, this.y);
        PathIterator it = path.getPathIterator(rotation);
        GeneralPath pieceShape = new GeneralPath();
        pieceShape.append(it, false);
	    return pieceShape;
	  }

à premiere vue la rotation s'effectue (mal mais s'effectue) cela peut-être une direction de solution (plutôt que modifier les coordonnées des traits il est peut-être préférable de transformer sa représentation)

[pingoui]

Effectivement, cela fonctionne mais de façon hanarchique
Je ne sais par où commencer pour debuger vu que cela part dans tout les sens

Une solution plus jolie serait que la classe GraphicEquipment correspond au bloc Equipement constituer des lignes . ces lignes devrait idéalement être définie de façon relative par rapport au groupe => quand on change x du groupe cela change automatiquement le x de chacune des lignes....

Je me demande si cette solution ne simplifierai pas mes problèmes de resize et de rotation mais je ne vois pas trop comment y arriver
De plus mon resize, devra me permettre de garder les proportions pour éviter de déformer mon composant électrique

[fnobb]

Je connais rien en java2D, mais l'idée est peut être de mémoriser la représentation initiale des traits du composant et par la suite ne faire que des transformations en fonction de l'angle et|ou de la translation (comme si s'était une simple image)

Il doit y avoir des docs (avec des exemples)

[pingoui]

J'ai l'impression que j'ai un problème de coordonnées d'origine !
Lorsque je fais un glisser-déposer d'un équipement celui-ci se dépose aux coordonnées (x,y) en dessous du point de lâché

De plus, le rectangle englobant mon équipement ne tourne pas avec la même origine que mon équipement !!! Les 2 sont décalés



L'erreur vient peut être de là car pour moi la rotation comme tu l'as écrit est bonne