Création dessin avec données saisies

Salut,

Est-il possible de générer un dessin à partir de données saisies, par exemple une piece d'une maison avec des cotés de dimenssions différentes, et d'y insérer ensuite à un endroit précis un autre dessin?

Si oui, pouvez-vous me mettre sur la bonne voie SVP?

merci

Oui c'est possible avec Java 2D et l'interface Shape et autres classes associée.

Mais si tu veux un logiciel de style CAD pré-existant en Java il va te falloir fouiller sur le net si qqun a déjà fait qq chose d'équivalent. :arrow: Google.

Sinon il va te falloir créer to propre lib qui crée un GeneralPath, un Polygon2D ou l'un des autres formes en fonction des quotes rentrées.

ok, ca me met deja sur la voie mais apres recherche sur le net, je remarque qu'il n'y a pas grand chose.

Quelqu'un a -t'il des sites intéressants sur le sujet?

Quelqu'un peut-il me mettre sur la voie pour insérer à un endroit précis du dessin, un autre dessin?

D'avance merci

regarde du coté de la classe Graphics.
Pour info tu peut récupérer une instance de cette classe à partir d'un JPanel ... pour pouvoir dessiner sur ce JPanel :D
Il ya des méthodes pour dessiner des rectangle, des lignes, du textes, des images et comme le disait bouye des polygones.

Oui mais la c'est uniquement pour le dessin. Et puis va faire une forme compliquee (style un engrenage) avec les primitives de la classe Graphics...

Pour une manipulation objet mieux vaut creer une Shape ou mieux un objet contenant une ou plusieurs shape si on veut garder d'autres info en memoire. Ex : coord + couleur/peinture d'avant/arriere-plan + stroke + font des sous-path.

Sinon l'interface PathIterator peut-etre utile egalement dans certains cas. Mais en general on l'ignore et on se contente d'un bon gros GeneralPath. Allez un peu de courage c'est pas dur de faire une forme a grand coups de moveTo, lineTo, curveTo, quadTo... a partir des points et traces saisis par un utilisateur.

Allez un petit bout de code pour commencer sur le bon pied.

Note : pas la peine de s'amuser ( :!: ) a re-implementer completement les interfaces List et Shape, on se contente de mettre les seules methodes nous interessant et de deleger aux objects/membres internes.

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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
 
public class VectorObject {
  private Paint background = new Color(128, 128, 128, 128);
  private Paint foreground = Color.BLACK;
  private Stroke stroke = new BasicStroke(1.0f);
  private Font font = new Font("Dialog", Font.PLAIN, 12);
  private Shape delegated;
  private String name;
 
  /** Creates a new instance with the given shape.
  * @param shape The delegated shape.
  * @exception IllegalArgumentException If the given shape is <code>null</code>.
  */
  public VectorObject(Shape shape) {
    if (shape == null) {
      throw new IllegalArgumentException("The given shape is null");
    }
    delegated = shape;
  }
 
  /** Gets the bounding box of this object in double precision.
   * @return A  <code>Rectange2D</code> or never <code>null</code>.
   */
  public Rectangle2D getBounds2D() {
    return delegated.getBounds2D();
  }
 
  /** Draw this object.
   * @param graphics The graphics context in which to paint.
   */
  public void draw(Graphics2D graphics) {
    Shape shape = getShape();
    if (isFilled()) {
      graphics.setPaint(getBackground());
      graphics.fill(shape);
    }
    if (isStroked()) {
      graphics.setPaint(getForeground());
      graphics.setStroke(getStroke());
      graphics.draw(shape);
    }
    ...
  }
}
 
public class VectorGroup {
  private List<VectorObject> objectList = new LinkedList();
  private String name;
...
  /** Creates a new group with given shapes. 
   * @param shapes The initial list of shapes.
   * @exception IllegalArgumentException If one of the given shape is <code>null</code>.
   */
  public VectorGroup(Shape... shapes) throws IllegalArgumentException {
    for (Shape shape : shapes) {
      VectorObject object = new VectorObject(shape);
      objectList.add(object);
    }
  }
 
  /** Creates a new group with given vector objects. 
   * @param objects The initial list of objects.
   */
  public VectorGroup(VectorObject... objects) {
    for (VectorObject : objects) {
      objectList.add(object);
    }
  }
 
  /** Gets the size of this group.
   */
  public int size() {
    return objectList.size();
  }
 
  /** Get object at index.
   * @param index The value index.
   * @return The value at index.
   * @exception IndexOutOfBoundsException If the given index is out of bounds.
   */
  public VectorObject get(int index) throws IndexOutOfBoundsException {
    return objectList.get(index);
  }
 
  /** Add an object to the group. The new value is placed on top of the rendering stack.
   * <br>If the given object is already in the group, it is moved to the top of the rendering stack as well.
   * @param Object The new object.
   * @return The value at index.
   * @exception IllegalArgumentException If given object is <code>null</code>.
   */
  public void add(VectorObject object) throws IllegalArgumentException {
    if (object == null) {
      throw new IllegalArgumentException("The given vector object is null.");
    }
    if (objectList.contains(object)) { 
      objectList.remove(object);
    }
    objectList.add(object);
  }
 
  /** Remove object at index.
   * @param index The value index.
   * @exception IndexOutOfBoundsException If the given index is out of bounds.
   */
  public void remove(int index) throws IndexOutOfBoundsException {
    objectList.remove(index);
 }
 
  /** Gets an object iterator.
   * @return A <code>Vector Object</code> iterator.
   */
  Iterator<VectorObject> iterator() {
    return objectList.iterator();
  } 
 
  /** Gets the bounding box of this object in double precision.
   * @return A  <code>Rectange2D</code> or <code>null</code> if this group is empty.
   */
  public Rectangle2D getBounds2D() {
     Rectangle2D result = null;
     // Compute the union of all objects' bounding boxes.
     for (VectorObject object : objectList) {
       Rectangle2D objectBounds = object.getBounds2D();
       if (result == null) { 
         result = objectBounds;
       }
       else {
         result = result.createUnion(objectBounds);
       }
     }
     return result;
  }
 
 
  /** Draw this group.
   * @param graphics The graphics context in which to paint.
   */
  public void draw(Graphics2D graphics) {
     // Render objects from first to last.
     for (VectorObject object : objectList) {
       object.draw(graphics);
     }
  }
}