Tracer une ligne par des Bitmaps

**lass7** · 18/03/2015, 15h56

Bonjour,

J'effectue actuellement une application android qui me permet de tracer une ligne avec ces coordonnées de départ (x,y) et une longueur. Je dessine cela sur un canvas à l'aide de bitmap du coup je ne peux tracer seulement des lignes horizontales ou verticales. Mon problème est donc que j'aimerai pouvoir dessiner dans le meilleur des cas des lignes en diagonale en effectuant un premier toucher sur la tablette indiquant la position de départ et un deuxième toucher en diagonale indiquant le point d'arriver et la longueur, mais je n'arrive pas a voir comment faire. Ou alors essayer d'effectuer une rotation de ma ligne si cela est possible.

Je suis à l'écoute de toutes propositions

Merci

**wax78** · 18/03/2015, 16h06

Tu traces des lignes a l'"aide de bitmap" ? Pourquoi ne pas tracer simplement une ligne avec drawLine(), quelques chose m'échappe la

**lass7** · 18/03/2015, 16h17

Oui effectivement çà serait beaucoup plus simple car j'aurais mon point initial et final, seulement je reprend la suite d'un code et je ne peux pas me permettre de tout refaire cela engendrer beaucoup trop de changement, donc si je peux faire autre chose avant d'en arriver là çà serait préférable

Voici ma classe ligne :

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
 
public class Ligne extends EltPlan {
	private static final int epaisseur = 10;
	private int a, b;
 
 
	private Ligne(double x, double y, int pixelthickness,
			int pixellength) {
 
		super(x, y, pixelthickness, pixellength);
		setPixelsLength(pixellength);
		setPixelsThickness(pixelthickness);
	}
 
	private Ligne(double x, double y, float thickness,
			float length,) {
 
		super(x, y, thickness, length);
 
		setPixelsLength((int) (length));
		setPixelsThickness((int) (thickness));
	}
 
 
 
	/**
         * Retourne une ligne horizontal 
         */
	public static Ligne LigneHorizontal(double x, double y, int lgr) {
		return new Ligne(x, y, lgr, epaisseur);
	}
 
	/**
         * Retourne une ligne vertical 
         */
	public static Ligne LigneVertical(double x, double y, int lgr) {
		return new Ligne(x, y, epaisseur, lgr);
	}
 
 
	@Override
	public void doBitmap() {
 
 
		if (isSelected()) {
			setBitmap(Bitmap.createBitmap(getPixelsThickness() + 10,
					getPixelsLength() + 10, Config.ARGB_8888));
			for (b = 5; b < getBitmap().getHeight() - 5; b++) {
				for (a = 5; a < getBitmap().getWidth() - 5; a++)
					getBitmap().setPixel(a, b, Color.GRAY);
			}
			for (a = 0; a < getBitmap().getWidth(); a++)
				getBitmap().setPixel(a, 0, Color.RED);
			for (a = 0; a < getBitmap().getWidth(); a++)
				getBitmap().setPixel(a, getBitmap().getHeight() - 1, Color.RED);
			for (b = 0; b < getBitmap().getHeight(); b++)
				getBitmap().setPixel(0, b, Color.RED);
			for (b = 0; b < getBitmap().getHeight(); b++)
				getBitmap().setPixel(getBitmap().getWidth() - 1, b, Color.RED);
		} else {
			setBitmap(Bitmap.createBitmap(getPixelsThickness(),
					getPixelsLength(), Config.ARGB_8888));
			for (b = 0; b < getBitmap().getHeight(); b++) {
				for (a = 0; a < getBitmap().getWidth(); a++)
					getBitmap().setPixel(a, b, Color.GRAY);
			}
 
		}
 
	}
 
	public static int getEpaisseur() {
		return epaisseur;
	}
 
}

**UbuntuMan** · 18/03/2015, 16h46

un truc comme ça en TP d'algo c'est un coup à prendre des points négatifs

.

- 1 : reprendre les bases de l'Algorithmie.
- 2 : se documenter sur la doc et les Api Java et Android. Line a été évoqué plus haut.

**wax78** · 20/03/2015, 13h54

Franchement, je te dirai de reprendre ce qui ne va pas parce que franchement pour dessiner une ligne, ta méthode est totalement inefficace.

En plus tu dis 2 choses opposées :

- Permier click pour avoir le premier point puis deuxieme click pour le deuxieme (ce qui te donne la longueur et l'ange ce qui me semble bien correct).
- Un click puis ensuite une longueur (bonne chance sans 2 eme click) sans angle (ce qui franchement n'est pas ultra ergonomique).

Pour mois y'a déjà un truc qui n'est pas cohérent.

**lass7** · 20/03/2015, 14h12

Oui je ne sais pas trop comment me sortir de là, oui mon premier click donne le point de départ et mon deuxième m'indique jusqu’où je veut aller, donc ma longueur. Et c'est vrai que dans ce cas il n'y a pas d'angle. il y a un autre souci c'est que j'ai besoin de faire pixel par pixel car j'effectue ensuite une simulation avec un algorithme de calcul COST qui calcule pixel par pixel. Sinon je voulais savoir si avec drawline() on peut choisir une épaisseur ou pas ?

Merci à vous

**wax78** · 20/03/2015, 14h27

"Un algorithme de calcul COST qui calcule pixel par pixel" -> qui calcul quoi ?

Pour l'épaisseur je dirais que setStrokeWidth() pourrait marcher (je présume).

**Flodelarab** · 20/03/2015, 14h31

Bonjour,

Le titre de cette discussion n'a rien à voir avec son contenu.

En plus, quelle idée de vouloir réinventer (en pire) ce qui existe déjà ?

**wax78** · 20/03/2015, 14h40

Oui donc je ne vois toujours pas pourquoi s'amuser à calculer pixel/pixel...

Tu peux très bien faire comme pour les lanceurs de rayon avec calcul d'intersection entre un rayon, des segments de droites et des cercles et autres ça ça sera efficace (mais la je suppute...)

**lass7** · 20/03/2015, 14h46

Je dois changer de model d'algorithme et utiliser le'algorithme de bresenham et si j'ai bien compris le calcul se fait avec des pixels ?

**wax78** · 20/03/2015, 14h49

Absolument pas. Bresenham c'est pour dessiner soi meme des lignes, cercles et autres a la main, pixel par pixel. Ce qui ne se fait plus depuis des lustres.

Ta demande n'est plus claire du tout et je ne vois plus comment t'aider sur ce coup la.

**wax78** · 20/03/2015, 15h07

Perso "COST" je ne sais toujours pas ce que c'est... jamais vu, google ne me donne rien de bon... bref... ca va être difficile de comparer COST a bresenham

Quoiqu'il en soit ca restera surement tojours plus "chère" que le drawLine, mais evidémment si l'exercice est de refaire le drawLine() pixel/pixel, ce que je crois comprendre au final... c'est une autre affaire...

**lass7** · 20/03/2015, 15h12

c'est Model COST-231 pour la propagation. Oui voila je suis d'accord pour le drawline ...

**lass7** · 26/03/2015, 15h14

En faite je dois utiliser le modèle de Bresenham pour que mon calcul soit plus rapide. Je dois calculer la distance entre mon point d'accès et les pixels qui encadrent mon plan comme çà normalement je devrais pouvoir calculer toute la surface. Le modèle COST lui calcul pixel par pixel, de tous mon plan du coup il est plus précis mais beaucoup plus lent

**Feanorin** · 02/04/2015, 18h36

Oui effectivement çà serait beaucoup plus simple car j'aurais mon point initial et final, seulement je reprend la suite d'un code et je ne peux pas me permettre de tout refaire cela engendrer beaucoup trop de changement, donc si je peux faire autre chose avant d'en arriver là çà serait préférable

Par expérience c'est souvent ce genre de pensée qui te ou vraiment dans la merde plus tard.. Car ca deviendra inmaintenable ton truc et tu finiras par pleurer ou en dépression..

Tracer une ligne par des Bitmaps

Android

Discussions similaires

Partager

Partager