KeyboardEvaluator

KeyboardEvaluator est un outil écrit en java par Rémi Emonet contenant différents systèmes d'évaluation pour les dispositions de clavier :

• un évaluateur basé sur le modèle de Klay
• un évaluateur basé sur les coûts des ditouches (frappe successives de deux touches)
• d'autres outils

Il est présent sous subversion à l'adresse :

svn://svn.tuxfamily.org/svnroot/dvorak/svn/KeyboardEvaluator/trunk

Propositions de règles pour les coûts des di-touches

L'évaluateur basé sur les coûts des ditouches sera décrit ici, pour l'instant il est décrit uniquement sur la liste de diffusion. À faire :

• décrire le principe ici
• lister les outils ($1.row(), $1.isI(), ...)
• illustrer la numérotation des doigts, des colonnes et des lignes

Voici un exemple de jeu de règles utilisé pour se faire une idée de ce que peut donner la méthode. Toute proposition d'affinage, de correction ou de nouveau jeu de règle est la bienvenue.

FADE 0.5 0.1 0

....
// variables de configuration pour la suite des règles
var distanceToHomeRowMalus = 1.0;
var exteriorMalus = 0.5;
var rowChangeMalus = 3.0;
var sameFingerMultiplier = 1.5;

// coût de base
value = 0.5;

///////////////////////////
if (!($1.isI() || $2.isI())) { // pas de pouce en jeu

   // Math.abs => valeur absolue
  
   // malus quand on est hors de la home row (pour la première touche)
   value += distanceToHomeRowMalus * Math.abs($1.row());
   
   // malus si le ditouche est vers l'extérieur (mais pas avec le même doigt)
   if ($2.fingerNumber() > $1.fingerNumber()) value += exteriorMalus;
   
   // malus pour le changement de ligne
   // basé aussi sur la distance entre les doigts (plus les numéros de doigts sont proches plus c'est difficile)
   var divider = 0. + Math.abs($1.fingerNumber() - $2.fingerNumber());
   if ($1.fingerNumber() == $2.fingerNumber()) divider = 1.0;
   value += rowChangeMalus * Math.abs($1.row() - $2.row()) / divider;


///////////////////////////
} else { // cas avec un pouce
   
   // ditouches avec espace (ou altgr)
   if ($1.isI() && $2.isV()) value += 2.5;
   if ($2.isI() && $1.isV()) value += 2.5;
   if ($1.isI() && $2.isIV()) value += 2;
   if ($2.isI() && $1.isIV()) value += 2;
   if ($1.isI() && $2.isIII()) value += 1.3;
   if ($2.isI() && $1.isIII()) value += 1.3;
   if ($1.isI() && $2.isII()) value += 1;
   if ($2.isI() && $1.isII()) value += 1;
 
///////////////////////////
}

// ditouche avec un seul doigt (on multiplie le coût calculé)
if ($1.fingerNumber() == $2.fingerNumber()) value *= sameFingerMultiplier;


// légende/outils (À faire : illustration)
//$1.isLeftHand()
//$1.isRightHand()
//$1.row() // access row as defined before in this file
//$1.column() // access column as defined before in this file
//$1.isKey("1C") //e.g. return key
//$1.fingerNumber() // access integer version for finger's roman number (I->1, II->2, ...)
//$1.isI()   // Finger I (Thumb)
//$1.isII()  // Finger II (index)
//$1.isIII() // Finger III ...
//$1.isIV()  // Finger IV ...
//$1.isV()   // Finger V (little finger)
..

Commentaires

La règle :

// malus pour le changement de ligne
// fondée aussi sur la distance entre les doigts (plus les numéros de doigts sont proches plus c'est difficile)

Doit être nuancée voici des exemples : les digrammes [FE], [FZ], [JI] et [JO], dans les deux sens sont équivalents, il me semble. De même (mais un peu moins faciles) [QZ], [QE], [MO] et [MI]. Un peu moins facile encore : [:K] ou [KO]. Ces digrammes ne peuvent pas être notés de la même façon qu'un [KU], un [;L] ou un [LP].