Discussion :

[robert_trudel]

salut,


je fais afficher deux rectangle en java, je voudrais obtenir le rectangle qu'il y a entre les deux rectangle

on voit que le rectangle entre les deux rectangle est décallé sur la première photo, alors qu'il est correct sur la deuxième photo

pour les deux rectangles je connais leur position (centre du rectangle)

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
 //prendre la position du premier l'objet
                Point p1 = rect1.getPosition();
 
                //prendre la position du deuxième  l'objet
                Point p2 = rect2.getPosition();
 
                int widthNewRect = rect1.getRectangle().width/2 +rect2.getRectangle().width/2;
                Dimension dimRelation = new Dimension();
 
                //calcul pour l'équation d'une droite
                int x = p1.x - p2.x;
                int y = p1.y- p2.y;
 
                int m = (p2.y - p1.y) / (p2.x - p1.x);
                int b = p2.y - m * p2.x;
 
                Point relationPos = new Point();
                if(Math.abs(x) > Math.abs(y)){
                    relationPos.x = Math.abs(x);
                    relationPos.y = m * relationPos.x + b;
                    dimRelation.setSize(Math.abs(x) - widthNewRect,30);
                }

la dimension du rectangle dessiné semble ok, c'est plutôt ça position qui n'est pas toujours bonne

une idée du problème?

je gère pour le moment qu'un ca, soit celui ou les deux rectangles sont aligné de façon horizontale... il resterais à gérer de façon verticale....

s'il y a un moyen plus simple je suis preneur

merci

[Cbonniot]

Bonjour, j'ai peut être mal compris ton problème mais est ce que ca conviendrait à ce que tu cherches ? Ca ne fonctionne qu'a condition que les deux rectangles ne s'intersectent pas.

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
 
Rectangle r1;
Rectangle r2;
Rectangle r3; // Rectangle entre r1 et r2
 
// Placement et taille horizontale
if (r1.x < r2.x) { // r1 à gauche de r2
	r3.x = r1.x + r1.width;
	r3.width = r2.x - (r1.x + r1.width);
} else { // r2 à gauche de r1
	r3.x = r2.x + r2.width;
	r3.width = r1.x - (r2.x + r2.width);
}
 
 
// Placement et taille verticale
if (r1.y < r2.y) { // r1 plus haut que r2
	r3.y = r1.y;
	r3.height = r2.y + r2.height;
} else { // r2 plus haut que r1
	r3.y = r2.y;
	r3.height = r1.y + r1.height;
}

Sachant que les attributs x et y correspondent au point en haut à gauche des rectangles. Si tu ne connais que les points centraux, dans ce cas soit tu utilises des variables intermédiaires auxquelles tu additionnes ou soustrait la moitié de la taille du rectangle, soit tu modifies directement le code.

[robert_trudel]

je vais regarder ça, mais il y a un soucis quelques part... car j'obtiens ce qu'il y a sur l'image

[Cbonniot]

Autant pour moi, je n'avais pas testé et j'avais oublié beaucoup de cas.

Voici ce que j'ai refais.

Je privilégie, lorsque r1 et r2 ne se chevauche (sur une dimension, peut importe laquelle), le rectangle entre les deux en fonction des x.

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
 
Rectangle r1 = new Rectangle(90, 50, 20, 20);
Rectangle r2 = new Rectangle(80, 80, 20, 20);
Rectangle tmp;
Rectangle r3 = new Rectangle(0, 0, 0, 0); // Rectangle entre r1 et r2
 
if (r1.x > r2.x) {
	tmp = r2;
	r2 = r1;
	r1 = tmp;
} // Ca me permet d'être sur que r1.x est à gauche de r2.x
 
r3.width = Math.max(r2.x + r2.width - r1.x, r3.width);
r3.width = Math.max(r1.width, r3.width);
r3.width = Math.max(r2.width, r3.width); // Je récupère la plus grande largeur en fonction de tous les cas possibles.
if (r1.x + r1.width < r2.x) { // Si les deux rectangles se chevauchent sur x, si oui je retire la longueur des deux rectangles et je cale r3 sur la fin de r1
	r3.width -= r1.width + r2.width;
	r3.x = r1.x + r1.width;
} else { // Sinon je cale r3 sur r1
	r3.x = r1.x;
}
 
if (r1.y > r2.y) {
	tmp = r2;
	r2 = r1;
	r1 = tmp;
}
r3.height = Math.max(r2.y + r2.height - r1.y, r3.height);
r3.height = Math.max(r1.height, r3.height);
r3.height = Math.max(r2.height, r3.height);
// Je récupère la plus grande hauteur possible
if (((r1.x <= r2.x) && (r1.x + r1.width >= r2.x)) || ((r1.x >= r2.x) && (r2.x + r2.width >= r1.x))) { // Je regarde si r1 et r2 se chevauchent sur x, si oui je retire la hauteur des deux rectangles et je cale r3 sur la fin de r1
	r3.height -= r1.height + r2.height;
	r3.y = r1.y + r1.height;
} else { // Sinon je cale r3 sur r1
	r3.y = r1.y;
}

Ce n'est pas forcément très optimisé, je te laisse faire ca

J'ai testé et ca devrait fonctionner, après ce n'est peut être pas la méthode la plus simple.

[bouye]

Alors les methodes contains() et intersects() de l'interface Shape permettent de detecter s'il y a inclusion ou collision tandis que la classe Area te permet de faire des operation arithmetiques sur des formes (addition, soustraction) ce qui retourne une forme mais comme c'est un rectangle il suffit de faire getBounds() ou getBounds2D() sur la forme resultat pour avoir le rectangle appropriee.