Discussion :

[persé]

Bonjour ;


Je suis en 2d je veux avoir un rectangle de sélection , comme celui qu'on trouve sur paint et les autres éditeur de sorte que que tout les points a l’intérieur seront sélectionnés.
une idée et tuto s'il vous plait
merci

[LittleWhite]

Bonjour,

Quelles sont les bibliothèques que vous utilisez ? En Qt, c'est simple (enfin, assez simple). En OpenGL, il faudrait complètement le réimplémenter, mais c'est possible.

[persé]

j'utilise Glut est ce que c'est possible de le faire ?

[LittleWhite]

Oui, vous pouvez le faire, en utilisant GLUT pour récupérer les événements de clic et OpenGL pour dessiner le rectangle avec des GL_LINES en utilisant glLineStipple pour faire les pointillés.

[persé]

je sais dessiner des rectangles avec Glut et récupérer les événements , mais ce que je veux que mon rectangle soit élastique

[LittleWhite]

Fallait le plutôt, au lieu de demander un tutoriel. Une explication précise du problème est toujours bénéfique, afin que les autres ciblent vraiment votre besoin.
Enfin bref.

Avec GLUT, il faut que vous observiez les mouvements de la souris, lorsque le clic est enfoncé. Pour chaque mouvement, vous mettez à jour la position du coin inférieur droit de votre rectangle. La position du coin supérieur gauche de votre rectangle est déterminée par la position de la souris au moment du tout début du clic.
Ensuite, comme vous savez dessiner un rectangle, il suffit d'avoir une fonction de dessin d'un rectangle qui prend deux points : le coin supérieur gauche du rectangle et le coin inférieur droit.

Et le tour est joué.

[persé]

donc je dois utiliser une fonction du plus proche voisins pour sélectionner le coin inférieur droit , mais si je tire le coin inférieur droit les reste du rectangle ne va pas bouger , faut que la fonction modifier les deux coins , mais comment je fait pour tout d'abord positionner mon rectangle ensuite le dilaté

merci

[LittleWhite]

Dans ma tête, il n'y a pas d'histoire de plus proche voisin. Pouvez-vous montrer une vidéo de ce que vous voulez avoir comme fonctionnalité, car je doute que l'on parle de la même chose.
Sinon, les coins sont déterminés par la souris. Le coin supérieur gauche correspond à la position de la souris lors du clic, et il ne change plus. Le coin inférieur droit suit les coordonnées de la souris.

[persé]

oui , exactement comment le premier rectangle qui l'utilise dans cette vidéo :

[LittleWhite]

Donc, c'est exactement ce que je disais.
Il faut garder deux points : le point où l'utilisateur à cliquer (coin supérieur gauche du rectangle), et le point où le curseur de la souris est (coin inférieur droit). Et on dessine les rectangle en utilisant ces deux points et c'est fini.

[persé]

oui mais bon , quand je clic la première fois le coin supérieur gauche prend la valeur de la souris , ensuite pour modifier la taille c'est celui du coin droit inférieur qui prend la valeur de la souris , si le curseur et a l’intérieur du rectangle alors le rectangle modifie sa position on suivant la souris mais sans changer de taille ?

[LittleWhite]

Pour le déplacement, il faut :

• vérifier si le clic est dans le rectangle ;
• sauvegarder la position du clic fait dans le rectangle ;
• lors du déplacement de la souris, faire la différence en X et Y, entre la position du clic initial et la position de la souris actuelle ;
• appliquée la différence appliquée précédemment, sur les coins du rectangle pour le déplacement.

[Mat.M]

bonjour si tu veux dessiner un rectangle de sélection c'est un chouïa pointu
Il y a 3 temps
*l'événement bouton gauche enfoncé : si l'utilisateur enfonce le bouton gauche il faut mémoriser la position du pointeur de souris à l'écran.
*l'événement déplacement souris : il faut faire un test également et voir si le bouton gauche est enfoncé pendant que tu déplaces la souris
Mais attention c'est là où il y a une petite complication supplémentaire: il faut gérer un booléen qui indique que tu modifies le rectangle de sélection
Donc sur cet événement tu vas tracer un rectangle qui aura pour coin gauche-haut les coordonnées du premier clic et comme coin droite-bas la position courante du pointeur de souris
Ensuite dans la boucle de rendu, il faut tester si le booléen de modification est égal à vrai et là il faut dessiner le rectangle
Si ce n'est pas le cas il faut dessiner un rectangle fixe

*l'événement bouton gauche relâché: c'est là où on mémorise le coin droite-bas du rectangle.

Maintenant reste à voir si le rectangle de sélection doit rester à l'écran ou non après avoir effectué la sélection c'est à toi de voir..

[Iradrille]

oui , exactement comment le premier rectangle qui l'utilise dans cette vidéo

Hello,

(Elle est en quelle langue la vidéo exactement, on entend quelques mots en Français de temps en temps, mais pas vraiment de phrases complètes oO.)

Sinon Niveau algo ça doit donner quelques chose 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
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
struct Point {
	int x, y;
	bool isInsideRect(const Point& topLeft, const Rect& bottomRight) const {
		// true si this est dans le rectangle délimité par topLeft et bottomRight, false sinon.
	}
 
	// les operators qui vont bien
};
 
bool hasSelection = false;
bool isSelecting = false;
bool isMoving = false;
Point start, end, moveStart;
 
while(1) {
	// main loop
 
	bool leftButton = getLeftButtonstate(); // true = pressé, false = relaché
	Point mousePos = getMousePos();
 
	if(leftButton) {
		if(!hasSelection) {
			if(! isSelecting) {
				// bouton gauche pressé, pas de selection
				isSelecting = true;
				end = start = mousePos;
			}
			else {
				// on aggrandi la selection, en gardant le point de départ en haut a gauche
				int sx = min(start.x, mousePos.x);
				int sy = min(start.y, mousePos.y);
 
				int ex = max(start.x, mousePos.x);
				int ey = max(start.y, mousePos.y);
 
				start.x = sx;
				start.y = sy;
				end.x = ex;
				end.y = ey;
			}
		}
		else {
			if(!isMoving) {
				if(mousePos.isInsideRect(start, end)) {
					// si la souris est à l'intérieur, on déplace la sélection
					isMoving = true;
					moveStart = mousePos;
				}
				else {
					// sinon on recommence une sélection
					isSelecting = true;
					end = start = mousePos;
					hasSelection = false;
				}
			}
			Point delta = mousePos - moveStart;
			start += delta;
			end += delta;
			// + tests pour garder le rectangle à l'écran éventuellement
		}
	}
	else if(isSelecting) {
		// si on relache le clic gauche, on à une sélection seulement si le rectangle à une aire non nulle
		isSelecting = false;
		hasSelection = start != end;
	}
	else if(isMoving) {
		isMoving = false;
	}
 
	if(isSelecting || hasSelection) {
		drawRect(start, end);
	}
}

[micka132]

c'est un chouïa pointu

j'ai pas compris la complication : l'utilisation d'un booleen?