Discussion :

[l'unique]

bonjour, j'aimerais avoir quelques informations concernant la direction à prendre concernant la programmation en java d'un lanceur graphique d'application.

Merci.

[Ivelios]

A tous hasard : tuto

[l'unique]

En fait c'est le fait de lancer une commande en dessinant le première lettre de cette commande dans une Jframe
exemple :
- E veut dire /usr/bin/emacs
- V veut dire /usr/bin/vim

Au lancement de l'application, le programme se met automatiquement en mode de reconnaissance de symbole préalablement enregistré. Ici l'utilisateur dessine un symbole dans une fenêtre de saisi des actions souris. Si ce symbole est automatiquement reconnu, l'application exécute la commande associée. Après exécution de celle-ci, l'application est de nouveau prête à saisir un autre symbole.

[Deadpool]

Et sur quoi porte la question?

[l'unique]

la question est : quel sont les démarches a prendre pour la conception en java d'un lanceur graphique d'application ?

cette application a pour but la reconnaissance des caractères, afin de lancer directement une application associé à un caractère.

[nicolofontana12]

Tu veux quand tu tape A l'application reagit?

[l'unique]

En fait c'est le fait de lancer une commande en dessinant le première lettre de cette commande dans une Jframe
exemple :
- E veut dire /usr/bin/emacs
- V veut dire /usr/bin/vim

Au lancement de l'application, le programme se met automatiquement en mode de reconnaissance de symbole préalablement enregistré. Ici l'utilisateur dessine un symbole dans une fenêtre de saisi des actions souris. Si ce symbole est automatiquement reconnu, l'application exécute la commande associée. Après exécution de celle-ci, l'application est de nouveau prête à saisir un autre symbole.

[dinobogan]

Tout d'abord, inutile de copier/coller ton message, car en informatique le copier/coller c'est le mal
Commence par créer une interface ou tu peux dessiner des formes à la souris.
Ensuite, transforme chaque trait dessiné par un code. exemple : 0=droite, 1=bas-droite, 2=bas, 3=bas-gauche, 4=gauche, 5=haut-gauche, 6=haut, 7=haut-droit.
Ton dessin est donc transformé en code. Il te suffit ensuite de rechercher la correspondance entre le code construit et la liste des codes pré-établis suivant la distance de Hamming (si les codes sont de même longueur, simple à mettre en oeuvre) ou selon la distance de Levenshtein qui fonctionne dans tous les cas.

[l'unique]

Tout d'abord, excusez moi de mon copier/coller de mon message.
J'ai créé une interface où je peux dessiner des formes à la souris.
Cependant je ne trouve pas d'approche, de méthode pour transformer chaque trait dessiné par un code, d'après votre exemple : 0=droite, 1=bas-droite, 2=bas, 3=bas-gauche, 4=gauche, 5=haut-gauche, 6=haut, 7=haut-droit.
Pouvez vous m'éclaircir à ce niveau de conception?

[dinobogan]

Le mouvement du pointeur n'est jamais rectiligne. Tu dois donc faire un échantillonnage, c'est-à-dire ne pas prendre en compte tous les points. Par exemple, tu ne vas prendre en compte la nouvelle position que si elle est à au moins X distance de l'ancienne position.
Un peu de code, c'est toujours plus clair :

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
public void mousePressed( MouseEvent event )
{
  oldX = event.getX();
  oldY = event.getY();
}
public void mouseDragged( MouseEvent event )
{
  if( Math.abs( oldX - event.getX() ) + Math.abs( oldY - event.getY() ) > 40 )
  {
    //calcul de la direction entre les points (oldX, oldY) et event
    //placer la nouvelle direction dans le tableau de sauvegarde
 
    oldX = event.getX();
    oldY = event.getY();
  }
}

Ensuite, on peut imaginer que la nouvelle direction est ajoutée au tableau en construction que si la dernière direction entrée est différente de la nouvelle. Ca t'évitera d'avoir plusieurs dizaines de fois de suite une même direction. Ca permet de faire un premier filtre et de diminuer la masse d'information à traiter.

[l'unique]

Donc si j'ai bien compris,je dois récupérer des coordonnées de la souris dans un tableau.
Dois-je les comparer avec des coordonnées prédéfinis?
le role du tableau sert a stocker les coordonnées de la souris?
Quel role dois avoir le tableau dans la suite au niveau de la conception?
ai-je bien compris le rôle du tableau?
"la nouvelle direction est ajoutée au tableau en construction que si la dernière direction entrée est différente de la nouvelle."
je n'ai pas trop compris lorsque vous dite "le tableau en construction".

[tchize_]

tu trouvera pas de réponse toute cuite ici. On t'as expliqué comment suivre la souris et filtrer un peu. Après c'est à toi de faire des recherches sur l'algorithme que tu compte appliquer. Tu parle de reconnaitre des lettre. Sache que la reconnaissance de caractères dessisnés à la souris, même si plus facile que la reconnaissance par OCR sur un document scanné, reste un domaine complexe! On va pas faire les recherches et les tests à ta place.

[dinobogan]

Donc si j'ai bien compris,je dois récupérer des coordonnées de la souris dans un tableau.

Non, tu n'as rien compris
C'est le sens de déplacement de la souris que tu dois récupéré, calculé à partir de l'ancienne position. Tu t'en fou de savoir que le pointeur de souris est aux coordonnées (345, 2311). Tu veux juste savoir que le pointeur s'est déplacé vers la gauche par exemple.

Dois-je les comparer avec des coordonnées prédéfinis?

Pas avec les coordonnées prédéfinies, mais avec une liste de directions prédéfinies.

le role du tableau sert a stocker les coordonnées de la souris?

Il stocke les déplacements de la souris. Par exemple, il pourrait contenir :
"droite", "haut", "gauche", "bas"
ce qui défini un carré.
Ou encore : "bas", "droite", ce qui défini un L

Quel role dois avoir le tableau dans la suite au niveau de la conception?
ai-je bien compris le rôle du tableau?

Ton tableau va contenir les différentes directions suivies par la souris. Une fois le déplacement terminé (par exemple le bouton droit est relaché) tu vas utiliser la distance de Levenshtein par exemple pour trouver le mouvement le plus ressemblant dans ta liste de mouvements prédéfinis, enregistrés à l'avance.

"la nouvelle direction est ajoutée au tableau en construction que si la dernière direction entrée est différente de la nouvelle."
je n'ai pas trop compris lorsque vous dite "le tableau en construction".

C'est le tableau temporaire qui va stocker les différents mouvements de la souris.

[l'unique]

bonjour, j'ai quelques difficultés dans la conception, j'essaye de calculer la direction d'un trait (vertical/horizontale), en calculant les coordonnées, sachant que la différence entre l'abscisse du point de début d'un trait vertical soustrait à l'abscisse du point d'arrivé, donne 0 ... j'ai mis que la différence peut être dans un intervalle de [-3,3] vue que l'utilisateur peut bouger.

Je fais de même avec l'ordonnée pour un trait vertical.
En gros, j'essaye de reconnaitre un L. (Trait vertical suivi d'un trait horizontal)
Cependant, je n'arrive pas à voir comment faire autrement que l'utilisateur doive à chaque trait relaché puis repressé le bouton..
Globalement, faudrait qu'il trace un trait horizontal + vertical (pour former un L) sans relacher la souris, et là je bloque.

Voilà le 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
[...]
    private int Xsave=0;
    private int Ysave=0;
    private int resultX = 0;
    private int resultY = 0;   
    [...]
 
   public void mousePressed(final MouseEvent e) 
   {
        lastPoint = e.getPoint();
        Xsave = e.getX();
        Ysave = e.getY();
        draw(lastPoint);
    }
 
    public void mouseDragged(final MouseEvent e) 
    {
        [...]
        resultX = Xsave - e.getX();
        resultY = Ysave - e.getY();
        if(resultX >= 0 && (resultX < 3 || resultX > -3))
        {
            System.out.println("verti\n\n");
            if(resultY >= 0 && (resultY < 3 || resultY > -3))
            {
                System.out.println("c'est un L \n\n");
            }
        }
        [...]
    }

[dinobogan]

Tu n'as pas compris ce que j'ai déjà posté. Je recommence : tu ne dois pas prendre chaque nouveau point. Tu dois uniquement prendre un point s'il est éloigné d'au moins X (c'est l'explication sur l'échantillonnage dans un post précédent).
Tu calcules la direction entre l'ancien point sauvé et le nouveau point traité. Tu vas donc trouver une nouvelle direction. Si cette nouvelle direction est identique à l'ancienne direction, tu l'ignores, sinon tu l'ajoutes à ton tableau en construction.
L'utilisateur n'aura pas à lâcher le bouton de la souris pour dessiner son "L".
De plus, la reconnaissance de la forme ne se fait qu'au lâché de bouton de souris.

[l'unique]

Par contre, l'inconvénient de cette technique, c'est qu'elle ne permet pas de dessiner des traits en diagonal par exemple pour le "V". D'où ma question comment dessiner des traits en diagonal?

[dinobogan]

Bien sûr que c'est possible de détecter une diagonale !
Bon, allez, une fois n'est pas coutume, voici une solution possible qui détecte 8 directions :

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
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
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.ComponentEvent;
import java.awt.event.ComponentListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.image.BufferedImage;
import java.util.ArrayList;
 
import javax.swing.JFrame;
import javax.swing.JPanel;
 
public class GuiGesture extends JPanel implements MouseMotionListener, MouseListener, ComponentListener
{
	public static void main( String[] arg )
	{
		GuiGesture gui = new GuiGesture();
		JFrame frame = new JFrame();
		frame.getContentPane().add( gui );
		frame.setSize( 800, 600 );
		frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
		frame.setVisible( true );
	}
 
	private boolean mode_dessin;
	private Coordonnee old_point;
	private ArrayList<Integer> tab_point;
	private BufferedImage image;
	private Graphics graph;
 
	public GuiGesture()
	{
		mode_dessin = false;
		old_point = new Coordonnee();
		tab_point = new ArrayList<Integer>();
		addMouseListener( this );
		addMouseMotionListener( this );
		addComponentListener( this );
		image = null;
		graph = null;
	}
 
	@Override
	public void paintComponent( Graphics g )
	{
		if( image != null )
		{
			g.drawImage( image, 0, 0, this );
		}
	}
 
	@Override
	public void mouseDragged( MouseEvent event )
	{
		if( ! mode_dessin )
		{
			old_point.x = event.getX();
			old_point.y = event.getY();
			mode_dessin = true;
		}
		else
		{
			int horizontal = event.getX() - old_point.x;
			int vertical = event.getY() - old_point.y;
			if( Math.abs( horizontal ) + Math.abs( vertical ) > 20 )
			{
				graph.setColor( Color.BLACK );
				graph.drawLine( old_point.x, old_point.y, event.getX(), event.getY() );
 
				int sens = 0;
 
				if( Math.abs( horizontal ) * 2 >= Math.abs( vertical ) )
				{
					 if( horizontal > 0 ) { sens = 1; }
					 else { sens = 4; }
				}
 
				if( Math.abs( vertical ) * 2 >= Math.abs( horizontal ) )
				{
					if( vertical > 0 ) { sens = sens | 2; }
					else { sens = sens | 8; }
				}
				old_point.x = event.getX();
				old_point.y = event.getY();
				if( tab_point.size() <= 0 || tab_point.get( tab_point.size() - 1 ) != sens )
				{
					tab_point.add( sens );
					afficheSens( sens, event.getX(), event.getY() );
				}
			}
		}
 
		repaint();
	}
 
	private void afficheSens( int sens, int x, int y )
	{
		String chaine = "";
		if( ( sens & 1 ) == 1 ) { chaine = "droite "; }
		else if( ( sens & 4 ) == 4 ) { chaine = "gauche "; }
		if( ( sens & 2 ) == 2 ) { chaine += "bas"; }
		else if( ( sens & 8 ) == 8 ) { chaine += "haut"; }
 
		System.out.println( chaine );
	}
 
	@Override
	public void mouseReleased( MouseEvent event )
	{
		mode_dessin = false;
		tab_point.clear();
		graph.setColor( Color.WHITE );
		graph.fillRect( 0, 0, image.getWidth(), image.getHeight() );
		repaint();
	}
 
	@Override
	public void componentResized( ComponentEvent event )
	{
		if( graph != null ) { graph.dispose(); }
		image = new BufferedImage( this.getWidth(), this.getHeight(), BufferedImage.TYPE_INT_ARGB );
		graph = image.getGraphics();
	}
 
	@Override
	public void mouseMoved( MouseEvent arg0 ){}
	@Override
	public void mouseClicked( MouseEvent arg0 ){}
	@Override
	public void mouseEntered( MouseEvent arg0 ){}
	@Override
	public void mouseExited( MouseEvent arg0 ){}
	@Override
	public void mousePressed( MouseEvent arg0 ){}
	@Override
	public void componentHidden( ComponentEvent arg0 ){}
	@Override
	public void componentMoved( ComponentEvent arg0 ){}
	@Override
	public void componentShown( ComponentEvent arg0 ){}
}

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
public class Coordonnee
{
	public int x;
	public int y;
 
	public Coordonnee()
	{
		this( 0, 0 );
	}
 
	public Coordonnee( int x, int y )
	{
		this.x = x;
		this.y = y;
	}
}

[l'unique]

bonjour, je n'ai pas trop compris certains points ,j'ai 2 questions en voyant le programme :

1)

Sur ces 2 bouts de code :

" if( Math.abs( vertical ) * 4 >= Math.abs( horizontal ) )
if( Math.abs( horizontal ) * 2 >= Math.abs( vertical ) ) "

Je ne vois pas quel est le raisonnement qui est mis en place pour calculer la direction.
Je comprends que c'est pour regarder si le trait est vertical ou horizontal (et qu'ensuite on regarde si c'est en partant de la droite, de la gauche, du bas ou du haut)... mais je ne vois pas la manière dont vous avez pensée pour faire cette condition.


2)

Il y a des opérateurs que je n'ai jamais vu : " & " et " | ".
Après m'être renseigné, j'ai vu qu'il s'agissait d'opérateur d'opérateur bit à bit. (ET et OU, ici)
Mais je ne comprends pas ce que veulent dire ces opérateurs dans du code.
Par exemple :
"if (sens & 8) == 8"
Je comprends qu'on fait un ET bit à bit entre la variable sens et 8, mais je ne vois pas pourquoi on le fait, ni même son sens.


Si vous pouviez m'expliquer brièvement ces deux points, ça m'aiderait beaucoup. Pour le reste, je comprends tout à fait votre code.

Merci d'avance.

[dinobogan]

1)Sur ces 2 bouts de code :

" if( Math.abs( vertical ) * 4 >= Math.abs( horizontal ) )
if( Math.abs( horizontal ) * 2 >= Math.abs( vertical ) ) "

Je ne vois pas quel est le raisonnement qui est mis en place pour calculer la direction.
Je comprends que c'est pour regarder si le trait est vertical ou horizontal (et qu'ensuite on regarde si c'est en partant de la droite, de la gauche, du bas ou du haut)... mais je ne vois pas la manière dont vous avez pensée pour faire cette condition.

C'est une approximation. J'ai considéré qu'on pouvait tracer un carré avec l'équation "x + y = 20" alors qu'on trace un losange (rotation de 45° d'un carré). Mais c'était pour faire rapide. Ces tests permettent d'accepter une marge d'erreur selon que l'on souhaite tracé un trait vertical, horizontal ou diagonal.

2) Il y a des opérateurs que je n'ai jamais vu : " & " et " | ".
Après m'être renseigné, j'ai vu qu'il s'agissait d'opérateur d'opérateur bit à bit. (ET et OU, ici)
Mais je ne comprends pas ce que veulent dire ces opérateurs dans du code.
Par exemple :
"if (sens & 8) == 8"
Je comprends qu'on fait un ET bit à bit entre la variable sens et 8, mais je ne vois pas pourquoi on le fait, ni même son sens.

La problématique de départ : comment mettre une information qui peut avoir 8 valeurs différentes ("droite", "gauche", "haut", "bas", "droite haut", "droite bas", "gauche haut", "gauche bas").
Solution : il suffit de coder chaque valeur primitive sur un bit particulier. Un bit à zéro désactive la primitive :

• bit 1 : droite (2^1 = 1)
• bit 2 : bas (2^2 = 2)
• bit 3 : gauche (2^3 = 4)
• bit 4 : haut (2^4 = 8)

Il faut raisonner en binaire. "sens" est un entier sur 32 bits. "sens & 8" vaut 0 si le 4eme bit vaut zéro, et 8 si le 4eme bit vaut 1.
Ainsi, grâce à un seul entier, on est capable de coder les 8 directions différentes.

[l'unique]

Bonjour dinobogan, je tiens à vous remercier, de vos explications, de votre patience.
J'ai enfin terminé mon programme.