Discussion :

[lass7]

Bonjour,

Mon problème est le suivant j'effectue une application android ou grâce à un algorithme j'effectue le dessin de rectangle a une position bien précise (x, y) sur mon plan quadrillé. Je définis mon Canvas c et ensuite je fais c.drawRec..., j'aimerai savoir comment faire pour mémoriser à chaque fois que je trace un rectangle, car j'ai certain rectangle qui se dessine plusieurs fois à la même position donc j'aimerai faire un test dessus pour éviter de les tracer si il existe déjà.

Je vous remercie

[wax78]

Tu peux très bien mettre chacun des nouveaux rectangle créés dans une liste tout simplement. Après tu cherchera dans ta liste si un rectangle n'est pas en collision avec le nouveau que tu veux insérer dans la liste.

[lass7]

D'accord, je vous remercie. Mais je mets çà dans une liste de quoi, parce que je voulais faire une liste de coordonnées pour voir par rapport à la position mais ca ne sera pas tres bien je pense

[Arislas]

Je pense que tu peut créer une liste de rectangle et faire tes calculs de collisions sur eux.

[lass7]

voici mon code :

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
 
public void test(int x1, int y1, int x2, int y2) {
		int x, y, dx, dy, xincr, yincr, erreur, i, coordX, coordY;
		double scalePixel = (Plan.getScale() / 2);
 
		Canvas c = new Canvas(simu);
		Paint paint = new Paint();
 
		dx = Math.abs(x2 - x1);
		dy = Math.abs(y2 - y1);
 
		if (x1 < x2) {
			xincr = 1;
		} else {
			xincr = -1;
		}
 
		if (y1 < y2) {
			yincr = 1;
		} else {
			yincr = -1;
		}
 
		x = x1;
		y = y1;
 
		if (dx > dy) {
			erreur = dx / 2;
			for (i = 0; i < dx; i++) {
				x = x + xincr;
				erreur = erreur + dy;
				if (erreur > dx) {
					erreur = erreur - dx;
					y = y + yincr;
				}
 
				c.drawRect(x, y, (int) (x + scalePixel),
						(int) (y + scalePixel), paint);
 
			}
		} else {
			erreur = dy / 2;
			for (i = 0; i < dy; i++) {
				y = y + yincr;
				erreur = erreur + dx;
 
				if (erreur > dy) {
					erreur = erreur - dy;
					x = x + xincr;
				}
 
				c.drawRect(x, y, (int) (x + scalePixel),
						(int) (y + scalePixel), paint);
 
			}
 
		}
	}

Par rapport a mon code la, je déclare une liste de rectangle comme ceci :

Code :

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

1
2
 
List <Rect> list_Rec = new ArrayList<Rect>();

et je déclare également :

Code :

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

1
2
 
Rect rectangle;

ou j'effectue cela :

Code :

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

1
2
 
rectangle = new Rect(x,y...);

et du coup j'ajoute mon rectangle a ma liste de rectangle, une fois que je fais çà je pense que çà devrait être bon

[lass7]

j'ai donc effectué cela et par la suite ajouter ce code :

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
 
/** Creation du rectangle **/
				rectangle = new Rect(x, y,
						(int) (x+ scalePixel),
						(int) (y+ scalePixel));
 
 
				if (listRect.contains(rectangle)) {
 
				} else {
 
					listRect.add(rectangle);
 
 
					c.drawRect(rectangle, paint);
				}

Mais ca ne marche pas, j'ai toujours des rectangles dessiné au même endroit

[Arislas]

Test ton programme en debug pour voir s'il passe bien au bon endroit, je ne suis pas sur que ton contains marche.

Tes rectangles sont exactement au même endroit ou ils peuvent être décalé de quelque pixels ?

[lass7]

en faite c'est parce que j'avais déclaré ma list dans ma méthode et non pas dans ma classe comme variable globale, seulement lorsque je fais contains c'est hyper long le traitement, je ne comprend pas pourquoi

[Arislas]

Tu test sur tout tes rectangles de ta liste ton rectangle, du coup à chaque fois que tu rajoute un rectangle, ça rallonge le temps de test...

Il doit y avoir un autre moyen de faire ces tests mais je ne les connait pas, Avis à ceux qui s'y connaisse ^^

[wax78]

Tu as commis un grosse erreur ici :

Code :

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

if (listRect.contains(rectangle))

Il faut tester les collision de rectangle, pas savoir si un rectangle est contenu dans la liste... ce qui n'as aucun sens dans ton cas.

[lass7]

Ben ça marche mais c trop lent. Comment çà les collisions ? Parce que moi ce que je veux savoir c'est si un rectangle est présent déjà et si jamais il n'est pas présent on le dessine sinon on ne fait rien.

[Arislas]

Wax78 : Il ne cherche pas à savoir s'il y a collision mais si le rectangle à dessiner n'existe pas déjà, même si le nouveau rectangle est à 1 pixels de différence de l'autre, il sera dessiné

[wax78]

Pourtant quand je lis la phrase

car j'ai certain rectangle qui se dessine plusieurs fois à la même position donc j'aimerai faire un test dessus pour éviter de les tracer si il existe déjà.

c'est ce que je comprenais
Mais bon, savoir qu'un rectangle existe avec contains, ... ca ne fait que verifier si l'instance d'un objet dans la liste existe. (Sans jouer avec ses coordonnes ou quoique ce soit d'autres) et donc logiquement a chaque creation d'un rectangle, forcement il n'existera pas dans la liste. Mais bon j'ai dut mal comprendre alors...

[lass7]

Pourtant quand je parcours ma liste avec contains, il vérifie bien qu'il existe et donc ne le dessine pas, çà marche en faisant comme çà mais c'est trop long le temps de traitement, il faudrait que je trouve une autre solution

[Arislas]

Ca prend combien de temps à ce faire ?

[lass7]

Çà doit prendre 1min a peu près

[Arislas]

Je ne suis pas sur que ce soit plus rapide mais essaie de vérifier les valeurs à la main dans une boucle for.

Sinon, combien tu as de rectangle pour que ça prenne un minute un 20ène ?

[lass7]

En faite je travail sur une tablette, ou j'ai un plan quadrillé et je colorie les pixels de mon quadrillage suivant leur position. Du coup il y en a 17000 a peu pres

[Arislas]

Du coup pour 17000 va falloir trouvé une solution comme une tache asynchrone et autre pour faire de l'optimisation.

Je pense qu'une vérification manuelle avec plusieurs tâche asynchrone devrait pouvoir amélioré le temps de recherche mais sur 17000 rectangle, ça va quand même prendre du temps.

Je ne sais pas si il y a une autre façon plus simple d'accélérer le processus de vérification

[lass7]

j'essaye de faire avec une hashmap la et le rendu est mieux mais ce n'est pas encore çà...