Contenu | Rechercher | Menus

Annonce

Si vous rencontrez des soucis à rester connecté sur le forum (ou si vous avez perdu votre mot de passe) déconnectez-vous et reconnectez-vous depuis cette page, en cochant la case "Me connecter automatiquement lors de mes prochaines visites".
Test de l'ISO d'Ubuntu francophone : nous avons besoin de testeurs pour la version francophone d'Ubuntu 14.04. Liens et informations ici.
nombre réponses : 25

#1 Re : -1 »  reconnaissance vocale » Le 13/09/2014, à 16:48

benoitfra
Réponses : 87

Je tests depuis peu la librairie sphinx et notamment pocketsphinx. J'obtiens de bon résultats.

#2 Re : -1 »  reconnaissance vocale » Le 14/09/2014, à 16:23

benoitfra
Réponses : 87

Si ça intéresse des gens, Il est très facile d'utiliser le dictionnaire, modèle acoustique et modèle de langage du site CMU sphinx.

Par aileurs, il est également possible (et c'est très bien expliqué sur le site de CMUphinx ) cmuclmtk pour générer un modèle de langage.

Je suis en train de déveloper quelque chose en C je repasserai ici poser une vidéo très rapidement
le temps de la faire et de l'uploader

#3 Re : -1 »  reconnaissance vocale » Le 14/09/2014, à 16:41

benoitfra
Réponses : 87

Bon bah voici ce que j'ai fait on en est au début je viens de comprendre comment utiliser pocketsphinx.

Ici la vidéo du projet utilisant Pocketsphinx, Gstreamer, Libnotify, GLib/Gobject, Espeak.

Le projet se nomme pocketVox et il est développé en C, l'url du projet sur Github:
PocketVox sur Github
et la vidéo:
PocketVox

#4 Re : -1 »  [Script] reconnaissance vocale avec google » Le 22/01/2014, à 22:51

benoitfra
Réponses : 484

Je reviens bientôt avec une version épurée.... Je bosse dessus en ce moment avant mon stage. Une page github verra le jour bientôt. La version sera beaucoup plus light.

#6 Re : -1 »  [Script] reconnaissance vocale avec google » Le 24/01/2014, à 16:56

benoitfra
Réponses : 484

Bonjour

Le but est de simplifier la tâche de celui qui veut utiliser la reconnaissance vocale de Google sur son pc. J'ai donc continué l'application en tachant de la rendre le plus simple possible. Il y a maintenant un gui développé en gtk3 dont voici un aperçu:

1390590195.png

J'ai également corrigé quelques problèmes. Tout est dispo sur la page Github.

Une vidéo du projet est disponible ici:
Vidéo google2ubuntu

#7 Re : -1 »  [Script] reconnaissance vocale avec google » Le 25/01/2014, à 20:17

benoitfra
Réponses : 484

1390673400.png
1390673152.png 1390673197.png 1390673223.png

Salut

J'ai normalement terminé ce que je devais faire (suppression de la dep en gtk2 et faire en sorte de pouvoir installer le programme dans des dossiers root). J'en ai profité pour apporter des améliorations à l'interface.
On peut maintenant choisir d'ajouter un module, une commande interne ou externe.

Le processus d'ajout de module est assisté. Il suffit de sélectionner le fichier du module et on test si le fichier de config du module est présent, l'appli pré-remplie la ligne de commande afin que l'utilisateur n'ait rien à faire si ce n'est mettre la phrase d'appel. Le programme est livré pour l'instant avec 2 modules: weather, search placé dans .config/google2ubuntu/modules.

L'archive est situé ici:
https://github.com/benoitfragit/google2 … master.zip

J'ai ajouté des scripts d'installation et désinstallation. L'installateur place les fichiers dans  /usr/share/google2ubuntu et un lanceur dans /usr/share/applications. Il installe pour l'instant les dépendances suivantes (je sais pas si il en faut plus, chez moi ça marche): libnotify-dev et python-gi

La procédure d'installation est la suivante :

wget https://github.com/benoitfragit/google2ubuntu/archive/master.zip
unzip master.zip
cd google2ubuntu-master
chmod +x INSTALL
./INSTALL

Depuis le menu, vous pouvez accéder au gui en cherchant google2ubuntu. Ajoutez quelques commandes notamment vers les deux modules par défaut, ex de commande vers un de ces modules:

[Q/q]uelle*météo=/modules/weather/weather.sh

Le gui prenant tout en charge, il vous suffira d'aller cliquer sur weather.sh afin d'ajouter le module.

Attribuez ensuite un raccourci à la commande suivante:
python /usr/share/google2ubuntu/google2ubuntu.py

Lancez le et voila.

#8 Re : -1 »  [Script] reconnaissance vocale avec google » Le 26/01/2014, à 18:37

benoitfra
Réponses : 484

De multiples mises à jours ont eu lieu aujourd'hui. Des bugs on été corrigés.

La procédure d'ajout de module en images:
1390721059.png

1390721157.png

1390721205.png

1390721260.png

On peut ensuite ajouter une commande interne:
1390721314.png

Une nouvelle vidéo a été faite.

#10 Re : -1 »  [Script] reconnaissance vocale avec google » Le 27/01/2014, à 18:27

benoitfra
Réponses : 484
benoitfra a écrit :

http://pix.toile-libre.org/upload/img/1390835962.png
google2ubuntu

Voilà pas mal de temps que le projet avait été lancé (2012) mais je n'avais pas les compétences et le temps pour amener le projet là où je le désirais. J'ai donc repris tout le projet à 0 afin de fournir un système beaucoup plus souple et rapide de prise en main.

Principe

google2ubuntu a pour but de fournir un utilitaire qui va utiliser la reconnaissance de Google pour transcrire ce que vous dîtes en texte. google2ubuntu acquiert donc votre jolie voix pendant 5 secondes et l'envoie à Google. Celui-ci retourne alors le résultat et google2ubuntu trouve la commande que vous avez associée à ces quelques mots.

Comparer à la précédente version, la gestion des actions possibles est beaucoup plus simple. Plutôt que de devoir gérer des actions "codées", c'est à dire programmer certaines actions par défaut. google2ubuntu laisse la possibilité à l'utilisateur de faire ce qu'il veut et de choisir les commande qu'il veux exécuter. Ainsi, l'utilisateur va créer un "dictionnaire" liant des mots à des actions.

Installation

Le projet est disponible sur Github.
Pour installer le projet, il suffit de taper ces quelques lignes de commande:

wget https://github.com/benoitfragit/google2ubuntu/archive/master.zip
unzip master.zip
cd google2ubuntu-master
chmod +x INSTALL
./INSTALL

Fonctionnement de la reconnaissance

Le fonctionnement de google2ubuntu est très simple, on lance l'application, on parle quand la notification nous le dit et on attend que l'action s'exécute. Le tout est vraiment plaisant lorsque l'on associe un raccourci à l'application.


Structure des commandes

Une commande est une ligne de ce type:

[O/o]uvre*documents=xdg-open ~/Documents

La première partie est la "phrase clé", les termes entre [] permettent de prendre en compte à la fois les majuscules et minuscules en début de mot. les * permettent de remplacer les espaces et mots inutiles. La seconde partie de la ligne est la commande à exécuter.


Gestion des commandes
http://pix.toile-libre.org/upload/img/1390836889.png

Afin de gérer au mieux l'ensemble des commandes entrées par l'utilisateur, un gestionnaire graphique a été écrit en Python + Gtk3. Celui-ci se veut aussi très simple et fonctionnel. Par défaut, un fichier d'action est inclut et permet à l'utilisateur de se familiariser avec les commandes et l'interface.


Ajouter des commandes
http://pix.toile-libre.org/upload/img/1390721059.png

L'utilisateur peut en cliquant sur la petite flèche ajouter différents types de commandes via un menu.


http://pix.toile-libre.org/upload/img/1390721157.png

Des commandes externes
Ce sont des commandes que l'utilisateur ajoute dans le gui ci dessus. On voit par exemple, la demande pour ouvrir la messagerie. Toute commande peut être ajoutée.
Pour ajouter une commande basique, il suffit de cliquer sur "ajouter" et remplir la ligne qui apparait en remplaçant <votre clé> par le texte que vous allez prononcer et <votre commande> par la commande qui sera appelée.

Des commandes internes
Les commandes internes sont des commandes qui font appel à des fonctions codées au sein de google2ubuntu le but étant d'en avoir le moins possible. Pour l'instant, il y en a que 2, obtenir l'heure et la batterie. Voici un exemple d'appel à la commande interne permettant de dire l'heure:

[Q/q]uelle*heure=interne/heure

http://pix.toile-libre.org/upload/img/1390721314.png

Ainsi, dans le gui, quand la ligne apparaît, l'utilisateur doit modifier <phrase clé> par la phrase qu'il va proconcer pour demander l'heure et interne/<mot> en interne/heure. Pour l'instant, on peut appeler les commandes :

interne/heure
interne/batterie

Des modules
Les modules sont des scripts qui vont recevoir une partie du texte que vous prononcé en argument. Tout script shell, python,... peut être ajouté. Un module est aussi constitué d'un fichier nommé "args" permettant de distinguer l'appel à un module des paramètres à lui envoyer. Il permet également de savoir si l'on doit remplacer les espaces en + dans le texte à envoyer au module.

Lors de l'ajout un fenêtre de sélection s'ouvre et il suffit de cliquer sur l'exécutable du module

http://pix.toile-libre.org/upload/img/1390721205.png

Le programme se charge alors de vérifier si le fichier "args" existe. Si oui, il copie le dossier du module dans :

~/.config/google2ubuntu/modules

Si non, il vous accompagne pour créer ce fichier et le place au bon endroit.

http://pix.toile-libre.org/upload/img/1390839438.png


Ensuite, une nouvelle ligne apparait dans les commandes, il suffit de modifier la phrase clé.

http://pix.toile-libre.org/upload/img/1390721260.png

Vidéo

google2ubuntu 1

#11 Re : -1 »  [Script] reconnaissance vocale avec google » Le 19/06/2014, à 18:28

benoitfra
Réponses : 484

Salut lucas8100 effectivement tu as bien cerné la ligne qui ne fonctionne plus. Google a stoppé la v1 de sa web api speech 2 text. La version 2 existe mais chaque utilisateur doit demander une clé d'utilisation  à googe.

Pas de chance

#12 Re : -1 »  [Script] reconnaissance vocale avec google » Le 20/06/2014, à 18:32

benoitfra
Réponses : 484

Google2ubuntu ne mourra pas ! (I will be back !)

Je suis en stage en ce moment donc pas trop le temps de refaire une version.
Je dois juste modifier quelques trucs pour refaire une version viable. 

Sinon, pour obtenir une clé:
http://www.chromium.org/developers/how-tos/api-keys

#13 Re : -1 »  Voyager 13.10 » Le 09/01/2014, à 21:04

benoitfra
Réponses : 575

J'ai testé voyager par le passé et j'ai aimé l'ergonomie et la personnalisation effectuée. Je ne l'ai néanmoins pas gardé sur mon pc car je ne voulais pas réinstaller une nouvelle version de voyager pour mettre à jours mon pc. Maintenant, je suis frustré car j'aimerai  disposé de cette belle interface, de ces fonds d'écrans, de ces personnalisations...sans avoir voyager. Doit on installer une distribution pour bénéficier d'une personnalisation. Est-ce le meilleurs moyen de distribuer cette vision du bureau linux ? Bien sur, vous êtes libre de ce que vous nous proposer et ceci n'est qu'une requête parmi les centaines qui peuvent vous êtes proposées. Que diriez-vous de créer un script/paquet d'installation permettant à partir d'une xubuntu/debian de disposer de l'esprit de voyager. Ce script pourrait n'être qu'un plus quelque chose supplémentaire pour tous ceux qui on déjà xubuntu 1x.xx/debian installé et qui ne veulent pas ré-installer voyager.

#14 -1 »  [RÉSOLU] Besoin d'aide internationalisation » Le 28/01/2014, à 13:31

benoitfra
Réponses : 7

Bonjour

J'ai récemment repris un de  mes projet google2ubuntu. J'aimerai l'internationaliser sachant qu'il se compose principalement de deux scripts Python.

Avant de venir ici, j'ai lu et tenté d'implémenter ceci sur chacun des scripts:
http://www.framasoft.net/article4328.html
http://blog.nicolargo.com/2012/11/inter … ython.html

La première méthode n'a rien donné, la seconde me chargeait toujours les locales en anglais, même quand mon système était en français.

Du coups, je suis revenu à un projet propre et je cherche comment faire. Si quelqu'un pouvait me souffler une méthode claire et rapide ça serait géniale.

Merci d'avance.

#15 Re : -1 »  [RÉSOLU] Besoin d'aide internationalisation » Le 28/01/2014, à 15:03

benoitfra
Réponses : 7

Pardon j'ai oublié un mot, j'ai corrigé

#16 Re : -1 »  [RÉSOLU] Besoin d'aide internationalisation » Le 29/01/2014, à 12:59

benoitfra
Réponses : 7

j'ai finalement continué avc la méthode 2, et j'ai réussi mais il y a des petits problèmes avec les caractère utf-8

#17 Re : -1 »  [RÉSOLU] Besoin d'aide internationalisation » Le 29/01/2014, à 14:07

benoitfra
Réponses : 7

En fait les chaines qui ont un accent ne sont pas traduites.

ps: ok donc c'est mieux de mettre toutes les chaînes de caractère en anglais et je traduis.
Je vais faire ça et je reviens

#18 Re : -1 »  [RÉSOLU] Besoin d'aide internationalisation » Le 29/01/2014, à 16:43

benoitfra
Réponses : 7

Merci à toi tout roule maintenant.

#19 Re : -1 »  Projet de reconnaissance vocale google2voice » Le 27/01/2014, à 18:27

benoitfra
Réponses : 4

Salut, j'ai repris mon projet il y a peu et j'aurais besoin d'aide pour l'internationalisation, je poste un lien vers le post de présentation

Merci d'avance

#20 -1 »  magnfier » Le 26/12/2013, à 22:01

benoitfra
Réponses : 0

1388087195.png

Je viens vous présenter "magnifier" un petit outil qui permet d'inverser les couleurs et de zoomer. Les fonctions de zoom et d'inversion des couleurs sont écrites en bash. L'interface a été faite en Python. Pour l'instant, les niveaux de zoom accessibles sont : 1,6, 2, 3.2, 4, 6.4, 8, 12.8, 16

Le projet dispose d'une page sur Github:
magnifier sur Github

Le projet est "né" sur dans la catégorie accessibilité du forum et sur le forum d'Handylinux
Page catégorie accessibilité
Page sur Handylinux

Pour télécharger le projet, il suffit de cliquer sur le lien suivant:

Télécharger l'archive ZIP

Une fois téléchargée, il vous suffit d'extraire son contenu et d'exécuter dans un terminal le script INSTALL après l'avoir rendu exécutable. Lors de l'installation les paquets suivant seront éventuellement installés: python-notify, xcalib et xrandr.

L'utilisation du programme est très simple, pour lancer l'interface graphique, il suffit de chercher dans le dash/menu l'application magnifier. Certaines commandes peuvent être associées à des raccourcis:

magnifier -i // Inverser les couleurs
magnifier -p // Augmenter le niveau de zoom
magnifier -m // Diminuer le niveau de zoom
magnifier -s <nbr> // Régler le niveau de zoom a nbr
magnifier -d // Restaurer le zoom à sa valeur par défaut

#21 -1 »  Un screen magnifier maison » Le 21/12/2013, à 20:42

benoitfra
Réponses : 5

J'ai posté une manière de disposer d'un screen magnifier facilement et rapidement sous linux. La solution est située ici :
fil sur handylinux

xrandr + xcalib

#22 Re : -1 »  Un screen magnifier maison » Le 24/12/2013, à 00:20

benoitfra
Réponses : 5

Salut

J'ai repris mon script de façon à le rendre utilisable.  Voici la nouvelle version améliorée:

#!/bin/bash
# on obtient le nom de l'interface connectee
DEVICE=$(xrandr | grep " connected" | awk '{print $1}');
# on obtient la résolution 
PANNING=$(xrandr | grep " connected" | awk '{print $3}' | cut -f1 -d+);
# Fichier de configuration
CONFIG="/tmp/.magnifier.conf"; 


SELECT_ZOOM(){
	if [[ -f $CONFIG ]]; then
		# Chargement du fichier de config
		. $CONFIG
	else
		# zoom minimum
		CURRENT_ZOOM=1;
	fi
	
	# Définition des niveaux de zoom
	for level in 1 2 4 8 16
	do
		if test $level -eq $CURRENT_ZOOM; then
			var="$(echo $var) TRUE $(echo $level)" 
		else
			var="$(echo $var) FALSE $(echo $level)" 
		fi		
	done;
	
	# On demande à l'utilisateur de choisir le zoom level	
	ZOOM_LEVEL=$(zenity  --width=380 --height=260 --list  --radiolist  --title="Magnifier" --text="Choisir le niveau de zoom désiré" --column " x " --column "Zoom possible" $var)	
	
	if [[ $ZOOM_LEVEL != "1"  && $ZOOM_LEVEL != CURRENT_ZOOM && $ZOOM_LEVEL != "" ]];then	
		# On calcul les nouvelles résolutions
		WIDTH=$(echo $PANNING | cut -f1 -dx);
		HEIGHT=$(echo $PANNING | cut -f2 -dx);
		MODE_WIDTH=$(echo "$WIDTH/$ZOOM_LEVEL" | bc);
		MODE_HEIGHT=$(echo "$HEIGHT/$ZOOM_LEVEL" | bc);		
		NEW_MODE_NAME="$(echo $MODE_WIDTH)x$(echo $MODE_HEIGHT)_60.00"

		
		# On liste les modes déjà créé pendant cette cession
		LIST=$(xrandr | grep "  " | awk '{print $1}'),
		
		# On cherche à savoir si le mode a déjà été créé
		SEARCH=0;
		for lines in $LIST
		do
			if [[ $lines == $NEW_MODE_NAME ]]; then
				# Le mode est déjà créé
				SEARCH=1;
				break;
			fi
		done

		# On modifie la résolution
		if test $SEARCH -eq 0; then
			xrandr --newmode $(gtf $MODE_WIDTH $MODE_HEIGHT 60 | sed -ne 's/"//g;s/ Modeline //p');		
			xrandr --addmode $DEVICE $NEW_MODE_NAME;
		fi
		
		xrandr --output $DEVICE --panning $PANNING --mode $NEW_MODE_NAME		
		echo "CURRENT_ZOOM=$ZOOM_LEVEL" > $CONFIG;	
		notify-send "Magnifier" "Niveau de zoom : $ZOOM_LEVEL"; 
		
	elif [[ $ZOOM_LEVEL == "1" ]]; then
		xrandr --output $DEVICE --panning $PANNING --mode $PANNING		
		echo "CURRENT_ZOOM=$ZOOM_LEVEL" > $CONFIG;	
		notify-send "Magnifier" "Niveau de zoom : $ZOOM_LEVEL"; 	
	fi
}

INCREASE_ZOOM(){
	if [[ -f $CONFIG ]]; then
		# Chargement du fichier de config
		. $CONFIG
		ZOOM_LEVEL=$(echo "$CURRENT_ZOOM*2" | bc);
	else
		# zoom minimum à 2 car on n'a jamais lancé
		ZOOM_LEVEL=2;
	fi	
	
	if test $ZOOM_LEVEL -le "16"; 
	then
		# On calcul les nouvelles résolutions
		WIDTH=$(echo $PANNING | cut -f1 -dx);
		HEIGHT=$(echo $PANNING | cut -f2 -dx);
		MODE_WIDTH=$(echo "$WIDTH/$ZOOM_LEVEL" | bc);
		MODE_HEIGHT=$(echo "$HEIGHT/$ZOOM_LEVEL" | bc);		
		NEW_MODE_NAME="$(echo $MODE_WIDTH)x$(echo $MODE_HEIGHT)_60.00"
	
		# On liste les modes déjà créé pendant cette cession
		LIST=$(xrandr | grep "  " | awk '{print $1}'),
	
		# On cherche à savoir si le mode a déjà été créé
		SEARCH=0;
		for lines in $LIST
		do
			if [[ $lines == $NEW_MODE_NAME ]]; then
				# Le mode est déjà créé
				SEARCH=1;
				break;
			fi
		done

		# On modifie la résolution
		if test $SEARCH -eq 0; then
			xrandr --newmode $(gtf $MODE_WIDTH $MODE_HEIGHT 60 | sed -ne 's/"//g;s/ Modeline //p');		
			xrandr --addmode $DEVICE $NEW_MODE_NAME;
		fi
		
		xrandr --output $DEVICE --panning $PANNING --mode $NEW_MODE_NAME	
		echo "CURRENT_ZOOM=$ZOOM_LEVEL" > $CONFIG;	
		notify-send "Magnifier" "Niveau de zoom : $ZOOM_LEVEL";			
	else
		notity-send "Magnifier" "Niveau de zoom max atteint";
	fi
}

DECREASE_ZOOM(){
	if [[ -f $CONFIG ]]; then
		# Chargement du fichier de config
		. $CONFIG
		ZOOM_LEVEL=$(echo "$CURRENT_ZOOM/2" | bc);
	else
		# zoom minimum à 2 car on n'a jamais lancé
		ZOOM_LEVEL=1;
	fi	
	
	if test $ZOOM_LEVEL -ge "2"; then
		# On calcul les nouvelles résolutions
		WIDTH=$(echo $PANNING | cut -f1 -dx);
		HEIGHT=$(echo $PANNING | cut -f2 -dx);
		MODE_WIDTH=$(echo "$WIDTH/$ZOOM_LEVEL" | bc);
		MODE_HEIGHT=$(echo "$HEIGHT/$ZOOM_LEVEL" | bc);		
		NEW_MODE_NAME="$(echo $MODE_WIDTH)x$(echo $MODE_HEIGHT)_60.00"
	
		# On liste les modes déjà créé pendant cette cession
		LIST=$(xrandr | grep "  " | awk '{print $1}'),
	
		# On cherche à savoir si le mode a déjà été créé
		SEARCH=0;
		for lines in $LIST
		do
			if [[ $lines == $NEW_MODE_NAME ]]; then
				# Le mode est déjà créé
				SEARCH=1;
				break;
			fi
		done

		# On modifie la résolution
		if test $SEARCH -eq 0; then
			xrandr --newmode $(gtf $MODE_WIDTH $MODE_HEIGHT 60 | sed -ne 's/"//g;s/ Modeline //p');		
			xrandr --addmode $DEVICE $NEW_MODE_NAME;
		fi
		
		xrandr --output $DEVICE --panning $PANNING --mode $NEW_MODE_NAME	
		echo "CURRENT_ZOOM=$ZOOM_LEVEL" > $CONFIG;	
		notify-send "Magnifier" "Niveau de zoom : $ZOOM_LEVEL";			
	elif test $ZOOM_LEVEL -eq 1; then
		RESTORE_DEFAULT_ZOOM;
	fi
}

RESTORE_DEFAULT_ZOOM(){
	xrandr --output $DEVICE --panning $PANNING --mode $PANNING
	notify-send "Magnifier" "Niveau de zoom minimum";
	echo "CURRENT_ZOOM=1" > $CONFIG;	
}

case $1 in
	-p ) INCREASE_ZOOM ;;
	-m ) DECREASE_ZOOM ;;
	-d ) RESTORE_DEFAULT_ZOOM ;;
	* ) SELECT_ZOOM ;;
esac;

exit 0;

DÉPENDANCES:
- bc
- notify-send
- xrandr

POSSIBILITÉS:
- zoom x1 x2 x4 x8 x16 (x32 possible mais pas implémenté)
- sélection du zoom via une fenetre zenity
- fonction pour augmenter le zoom
- fonction pour réduire le zoom
- fonction pour revenir au zoom x1
- Mémorisation du niveau de zoom

TUTORIEL:
Copiez le script ci-après et enregistrez sous le nom de "magnifier"
rendez le exécutable :

chmod +x magnifier

placez le où vous voulez (le plus pratique)

sudo cp magnifier /usr/bin

Pour lancer l'interface de choix, il suffit d'utiliser la commande

magnifier

Ensuite, il faut attribuer des raccourcis au fonction de zoom et dézoom
Pour le zoom attribuer un raccourci à la commande

magnifier -p

Pour le dézoom, attribuer un raccourci à la commande

magnifier -m

Pour la fonction de retour au zoom x1, attribuer un raccourci à la commande

magnifier -d

Voilà.

JOYEUX NOEL

#23 Re : -1 »  Un screen magnifier maison » Le 24/12/2013, à 09:53

benoitfra
Réponses : 5

Je poste une version améliorée (encore). Rien à changer niveau commande, le tutoriel mentionné plus haut est donc toujours valable.

J'ai ajouté le support pour des facteurs de zoom flottants:
x 1.6
x 3.2
x 6.4
x 12.8

#!/bin/bash
# zoom possibles
POSSIBLE_ZOOM=( "1" "1.6" "2" "3.2" "4" "6.4" "8" "12.8" "16" );
# on obtient le nom de l'interface connectee
DEVICE=$(xrandr | grep " connected" | awk '{print $1}');
# on obtient la résolution 
PANNING=$(xrandr | grep " connected" | awk '{print $3}' | cut -f1 -d+);
# Fichier de configuration
CONFIG="/tmp/.magnifier.conf"; 

INTEGER_ZOOM(){
	# On calcul les nouvelles résolutions
	WIDTH=$(echo $PANNING | cut -f1 -dx);
	HEIGHT=$(echo $PANNING | cut -f2 -dx);
	MODE_WIDTH=$(echo "$WIDTH/$ZOOM_LEVEL" | bc);
	MODE_HEIGHT=$(echo "$HEIGHT/$ZOOM_LEVEL" | bc);		
	NEW_MODE_NAME="$(echo $MODE_WIDTH)x$(echo $MODE_HEIGHT)_60.00"

		
	# On liste les modes déjà créé pendant cette cession
	LIST=$(xrandr | grep "  " | awk '{print $1}'),
		
	# On cherche à savoir si le mode a déjà été créé
	SEARCH=0;
	for lines in $LIST
	do
		if [[ $lines == $NEW_MODE_NAME ]]; then
			# Le mode est déjà créé
			SEARCH=1;
			break;
		fi
	done

	# On modifie la résolution
	if test $SEARCH -eq 0; then
		xrandr --newmode $(gtf $MODE_WIDTH $MODE_HEIGHT 60 | sed -ne 's/"//g;s/ Modeline //p');		
		xrandr --addmode $DEVICE $NEW_MODE_NAME;
	fi
		
	xrandr --output $DEVICE --panning $PANNING --mode $NEW_MODE_NAME		
	echo "CURRENT_ZOOM=$ZOOM_LEVEL" > $CONFIG;	
	notify-send "Magnifier" "Niveau de zoom : $ZOOM_LEVEL"; 	
}

FLOATING_ZOOM(){
	# On calcul les nouvelles résolutions
	WIDTH=$(echo $PANNING | cut -f1 -dx);
	HEIGHT=$(echo $PANNING | cut -f2 -dx);
	MODE_WIDTH=$(echo "$WIDTH/$ZOOM_LEVEL" | bc);
	MODE_HEIGHT=$(echo "$HEIGHT/$ZOOM_LEVEL*3/4" | bc);		
	NEW_MODE_NAME="$(echo $MODE_WIDTH)x$(echo $MODE_HEIGHT)_60.00"

	# On liste les modes déjà créé pendant cette cession
	LIST=$(xrandr | grep "  " | awk '{print $1}'),
		
	# On cherche à savoir si le mode a déjà été créé
	SEARCH=0;
	for lines in $LIST
	do
		if [[ $lines == $NEW_MODE_NAME ]]; then
			# Le mode est déjà créé
			SEARCH=1;
			break;
		fi
	done

	# On modifie la résolution
	if test $SEARCH -eq 0; then
		xrandr --newmode $(gtf $MODE_WIDTH $MODE_HEIGHT 60 | sed -ne 's/"//g;s/ Modeline //p');		
		xrandr --addmode $DEVICE $NEW_MODE_NAME;
	fi
		
	xrandr --output $DEVICE --panning $PANNING --mode $NEW_MODE_NAME		
	echo "CURRENT_ZOOM=$ZOOM_LEVEL" > $CONFIG;	
	notify-send "Magnifier" "Niveau de zoom : $ZOOM_LEVEL"; 	
}

SELECT_ZOOM(){
	if [[ -f $CONFIG ]]; then
		# Chargement du fichier de config
		. $CONFIG
	else
		# zoom minimum
		CURRENT_ZOOM=1;
	fi
	
	# Définition des niveaux de zoom
	# ${#POSSIBLE_ZOOM[*]}
	for idx in 0 1 2 3 4 5 6 7 8 
	do
		if [[ ${POSSIBLE_ZOOM[$idx]} == $CURRENT_ZOOM ]]; then
			var="$(echo $var) TRUE $(echo ${POSSIBLE_ZOOM[$idx]})" 
		else
			var="$(echo $var) FALSE $(echo ${POSSIBLE_ZOOM[$idx]})" 
		fi		
	done;
	
	# On demande à l'utilisateur de choisir le zoom level	
	ZOOM_LEVEL=$(zenity  --width=380 --height=260 --list  --radiolist  --title="Magnifier" --text="Choisir le niveau de zoom désiré" --column " x " --column "Zoom possible" $var)	
	
	case $ZOOM_LEVEL in
		1 ) RESTORE_DEFAULT_ZOOM ;;
		"" | $CURRENT_ZOOM ) ;;
		1.6 | 3.2 | 6.4 | 12.8 ) FLOATING_ZOOM ;;
		* ) INTEGER_ZOOM;;
	esac;
}

INCREASE_ZOOM(){
	if [[ -f $CONFIG ]]; then
		# Chargement du fichier de config
		. $CONFIG
	else
		# zoom minimum à 1 car on n'a jamais lancé
		CURRENT_ZOOM=1;
	fi	
	
	for idx in 0 1 2 3 4 5 6 7 8
	do
		if [[ $CURRENT_ZOOM == ${POSSIBLE_ZOOM[$idx]} ]]; then
			if test $idx -le 7; then
				indice=$(echo "$idx+1" | bc);
				echo $indice
				ZOOM_LEVEL=${POSSIBLE_ZOOM[$indice]};	
			fi
			break;
		fi
	done

	case $ZOOM_LEVEL in
		"" ) ;;
		1.6 | 3.2 | 6.4 | 12.8 ) FLOATING_ZOOM;;
		* ) INTEGER_ZOOM;;
	esac	
}

DECREASE_ZOOM(){
	if [[ -f $CONFIG ]]; then
		# Chargement du fichier de config
		. $CONFIG
	else
		# zoom minimum à 1 car on n'a jamais lancé
		$CURRENT_ZOOM=1;
	fi	

	for idx in 0 1 2 3 4 5 6 7 8
	do
		if [[ $CURRENT_ZOOM == ${POSSIBLE_ZOOM[$idx]} ]]; then
			if test $idx -ge 1; then
				indice=$(echo "$idx-1" | bc);
				ZOOM_LEVEL=${POSSIBLE_ZOOM[$indice]};
			fi
			break;
		fi
	done
		
	case $ZOOM_LEVEL in
		"" ) ;;
		1.6 | 3.2 | 6.4 | 12.8 ) FLOATING_ZOOM;;
		* ) INTEGER_ZOOM;;
	esac
}

RESTORE_DEFAULT_ZOOM(){
	xrandr --output $DEVICE --panning $PANNING --mode $PANNING
	notify-send "Magnifier" "Niveau de zoom minimum";
	echo "CURRENT_ZOOM=1" > $CONFIG;	
}

case $1 in
	-p ) INCREASE_ZOOM ;;
	-m ) DECREASE_ZOOM ;;
	-d ) RESTORE_DEFAULT_ZOOM ;;
	* ) SELECT_ZOOM ;;
esac;

exit 0;

#24 Re : -1 »  Un screen magnifier maison » Le 25/12/2013, à 15:24

benoitfra
Réponses : 5

Voila comme promis, après quelques heures...j'apporte le cadeau. J'ai modifié un peu la loupe. J'ai fait un GUI en python assez simple. La porte est ouverte à l'internationalisation. Une page github est disponible:

https://github.com/benoitfragit/magnifier

Un tutoriel est contenu dans le fichier README.txt. J'ai également ajouté un installateur et un désinstallateur.



Voici un petit screen:
1387977690.png