Mouvements génétiques



Certains liens peuvent ne pas être actifs (si cette application n´est pas dans le dossier env/applications/mouv_gen de la version distribuée).


download
Principe
Contenu
Les menus
Le programme
Utilisations


















































Principe



Cette application montre:

1) Comment construite des populations génétiques

de mouvements et comment les croiser en optimisant une certaine fonction FITNESS.

2) Comment construire des trajectoires

selon 2 modes:

1) des rotations définies par:
       angle an et un axe xr,yr,zr
       donnant lieu à 2 types de trajectoires de rotation et d´axe.

2) des quaternions de la forme w,x,y,z, avec:
       an=2*acos(w)
       x,y,z tels que module(x,y,z)=sin(a/2) constituée par une liste
       le quaternion w,x,y,z étant un vecteur 4D unitaire (c´est à dire que: a2+x2+y2+z2=1).
Le mouvement d´un volume i est dé:fini par une trajectoire de quaternions obtenue en interpolant sphériquement une liste:
       qi,1 qi,2 ... qi,nq de nq quaternions.
Pour plusieurs volumes Épaule,Humerus,Radius,Poignet,Doigts on aura autant de trajectoires.

On pourra constater que les quaternions donnent de meilleurs résultats que les rotations:
meilleure convergence
mouvements plus "naturels": cliquer sur EXPL puis sur MOUV puis sur AUTO(), modifier les 2 quaternions pour obtenir des mouvements clés variés, recliquer sur AUTO(), cliquer gauche dans le cadre blanc pour changer de point de vue.

3)Comment écrire une fonction FITNESS d´optimisation

Celle-ci ne sera active que si on provoque les comparaisons des particules de la génétique (codant les mouvements aléatoires initiaux) avec les mouvements lus (par LIRE) ou définis interactivement (par INTER), auquel cas un message l´indiquera. On utilise pour celà la commande dist de 2 chaines de caractères.

4) Comment utiliser ces fonctionnalités

pour programmer un bras pouvant:
       imiter interactivement la capture d´un bras réel.
       interagir "intelligemment" avec un acteur réel dont il apprend les postures (en cours de développement dans l´application mouv_neur).

Remarque:

Pour programmer en C cette application hors anyflo il sera nécessaire de:
1) programmer les algorithmes génétiques.
2) programmer les quaternions et leur interpollation sphérique.
3) programmer une interface temps réel pour l´interaction.
4) éventuellement programmer les réseaux neuronaux pour une meilleure reconnaissance.

Définition des mouvements

Les mouvements de rotations sont définis dans un fichier .rota de la forme:

r1,1 r1,2 ... r1,nq
r2,1 r2,2 ... r2,nq
...
rnv,1 rnv,2 ... rnv,nq

ri,j=a,x,y,z est une rotation définie par son angle a et son axe x,y,z.
Les mouvements de quaternions sont définis dans un fichier .quat de la forme:

q1,1 q1,2 ... q1,nq
q2,1 q2,2 ... q2,nq
...
qnv,1 qnv,2 ... qnv,nq

qi,j=w,x,y,z est un quaternion.

Ces fichiers de mouvements pourront être construits à partir de la capture de ceux d´un acteur réel.

Une interaction en temps réel exigera que soient interfacées la capture et son interprétation.

Contenu

Dossier env

Contenant:
*.h: fichiers de configuration d´anyflo.
*.rota: fichiers matrice décrivant des mouvements.

anyflo_video.js

Java scrypte de lancement en format vidéo.

initb.h

Fichier de configuration dans le dossier env de la racine distribution.

mouv_gen.fonc

Fonction en langage anyflo.

mouv_gen.htm

Ce fichier.

mouv_gen.js

Java scrypte de lancement de l´application.

Les menus


Menu principal
EXPL: sous menu des explications.
CREER: sous menu des créations
GEN: génération d´une génétique.
LIRE: sous menu de lecture de fichiers de mouvements.
INTER: interaction.
INI: initialisation
COL: oui/non col.
PEAU: oui/non affichage de la peau.
EXT: oui/non ext.
FONC: affiche les noms des fonctions, cliquer sur l´un d´eux en affiche le texte.
PASaPAS: mode pas à pas, cliquer sur CONTINUE (vert) avance d´une image, cliquer sur X (rouge) sort de ce mode.
Attention: ne pas cliquer sur RETURN, ce qui aurait pour effet de relancer le programme...

Un message clignotant indique chaque fois la marche à suivre, la case du menu qu´il faut cliquer pulse pendant environ 4 secondes.
EXIT: pour quitter le programme.

EXPL: sous menu des explications

HEL: help de ce sous menu.

ROTA: cliquer sur un nom d'os (Épaule, Humerus, Radius, etc...) puis modifier l´angle de rotation rota et l´axe, le bras bouge en conséquence.
Cliquer sur TOUS() sélectionne tous les os.
Cliquer dans le cadre vert change l'oeil.

COMPLEX: isomorphisme des rotations planes et des nombres complexes:
Modifier les composantes a et b du nombre complexe unitaire z=a+i*b, le point rouge affiché sur le cercle de rayon 1 représente l´angle correspondant de cosinus a et de sinus b.

QUAT: isomorphisme des rotations de l´espace et des quaternions:
Modifier l´angle de rotatiuon rota et l´axe du nombre quaternion unitaire q=w+i*a+j*b+k*c, le point rouge P affiché sur la sphère de rayon 1 représente la rotation d´angle 2*acos(w) et d´axe OP.
Cliquer dans le cadre vert change l'oeil.

MOUV: interpolation sphérique de 2 quaternions:
Deux quaternions q1=w1,x1,y1,z1 et q2=w2,x2,y2,z2 sont représentés par deux points P1(rouge) et P2 (vert) de la sphère de rayon unité.
Modifier le coefficient d´interpolation u, le point P représentant le quaternion interpolé entre q1 et q2 s´affiche sur la sphère entre P1 et P2.
Modifier les quaternions sur les échelles.
La formule d´interpolation est sphérique:
c1=(sin((1-u)*a))/sin(a) c2=(sin(u*a))/sin(a) q=c1*q1+c2*q2
AUTO(): interpolation automatique.
Cliquer dans le cadre vert change l'oeil.

MOUVS:
Une POSITION ets représentée par un quaternion.
un MOUVEMENT Élémentaire est représenté par une liste de quaternions interpolés. et de sinus b.
Un MOUVEMENT MULTIPLE (par exemple des os constituant le bras) est représenté par une suite de telles listes c´est à dire par une matrice de quaternions.
On a stocké sur le disque un tel mouvement par un fichier .rota

COD: codage:
Modifier le flotant x de l´intervalle [-1,1]
L´entier e=ent(255*(x+1)/2) varie dans l´intervalle [0,255]
Son écriture binaire (faite de 0 et de 1) est codée sur un octet (8 bits).
On les transforme en un génomes de 8 caract&ehrave;res 0 et 1 pouvant être traités par un algorithme génétique.

ALGOGEN: algorithme génétique:
Choisir un nombre n de caractères de codage.
Cliquer sur ALEA() pour générer aléatoirement 2 mots de n caractères.
Choisir un indice de cassure, les 2 mots sont partagés à cet indice, la 1ère partie du premier et la deuxième partie du second sont assemblés pour formar le troisième.

CREER: sous menu des créations

HEL: help de ce sous menu.
ROTA: ROTATIONS (an,xr,yr,zr)
Les trajectoires sont des rotations définies par un angle an et un axe x,y,z.
QUAT: QUATERNIONS (w,x,y,z)
Les trajectoires sont des quaternions w,x,y,z.
Un message s´affiche indiquant le mode choisi (ROTA par défaut), les numéros des mémoires actives et INTER si cette case a été activée.

Choisir:
1) Le nombre nb de bits de codagee (en fait 2^nb), petit la convergence se fait mieux (puisque les génomes sont petits) mais la précision est faible).
2) Le nombre nb de particules de la génétique (mouvements générés aléatoirement, les angles et les axes sont traduits en chaines binaires par la fonction lire_rota() et constituentles individus de la génétique.

GEN: génération d´une génétique

HEL: help.
Si INTER n'est pas actif le mouvement du bras est regénéré à partir de la meilleura particule.
La commande Muta[2]=generer genetique(1)ajust(Muta[0,2],k) exprime que la génétique est regénérée (en modifiant automatiquement le coefficient de mutation qui apparait donc variable sur l´échelle muta) en croisant (probabilité proba) et en mutant (probabilité muta) pour optimiser la fonction FITNESS().
pend permet de rendre le mouvement pendulaire.
Les individus sont affiché sous forme de chaines de 0 et de 1 et d´échelles rouges représentant leurs évaluations.
AJUST: la mutation est automatiquement ajustée à l´évaluation globale de la génétique.
STOP: stoppe les croisements, la génétique n´évolue plus.

LIRE: sous menu de lecture de fichiers de mouvements

HEL: help.
LIRE cliquer sur nom.rota charge ce fichier en mémoire en effaçant toutes les autres mémoires.
AJOU: cliquer sur nom.rota ajoute ce fichier aux mémoires déjà lues.
SUP: supprime toutes les mémoires.

Le bras est animé en conséquence.

INTER: interaction

Cliquer dans le petit cadre dans lequel s´affiche un petit bras (figurant une possible image de caméra)
ou modifier rota et axe
ou choisir un numéro (sous le message particules)
la particule correspondante est décodée en un mouvement vers lequel vont tendre toutes les particules. Le bras se stabilise dans une position voisine.

Le programme

Les fonctions
Les variables

Les fonctions

Menu principal:
mouv_gen(): fonction principale.
externes(): déclaration des variables externes.
init(): initialisations.
generer_menu(): génération des menus.
MEN(): première fonction du menu principal de nom MEN.
HEL(): fonction help du menu principal.
INI(): réinitialisations.
COL(): oui/non col.
PEAU(): affichage des peaux.
EXT(): oui/non ext.
FONC(): affichage des fonctions.
fonc_FONC(): appelée à chaque image si FONC est validée.
PASaPAS(): mode pas à pas.
EXIT(): sort du programme.
DEUX_POINTS(): désactive les affichages des échelles, des menus, des messages et des textes.

Sous menu EXPL
EXPL(): première fonction du sous menu EXPL.
EXPL_HEL(): help du sous menu EXPL.
fonc_EXPL(): appelée à chaque image si EXPL est validée.
EXPL_ROTA(): explication des rotations.
fonc_EXPL_ROTA(): appelée à chaque image si EXPL_ROTA est validée.
EXPL_COMPLEX(): explication des nombres complexes unitaires associés à aux rotations planes.
fonc_EXPL_COMPLEX(): appelée à chaque image si EXPL_COMPLEX est validée.
EXPL_QUAT(): explication des quaternions unitaires associés aux rotations de l´espace.
fonc_EXPL_QUAT(): appelée à chaque image si EXPL_QUAT est validée.
MOUV(): explication de l´interpolation sphérique des quaternions.
fonc_EXPL_MOUV(): appelée à chaque image si EXPL_MOUV est validée.
AUTO(): interpolation automatique.
EXPL_MOUVS(): explication de plusieurs mouvements.
fonc_EXPL_MOUVS(): appelée à chaque image si EXPL_MOUVS est validée.
EXPL_COD(): explication du codage d'un mouvement.
fonc_EXPL_COD(): appelée à chaque image si EXPL_COD est validée.
EXPL_ALGOGEN(): explication des algorithmes génétiques.
fonc_EXPL_ALGOGEN(): appelée à chaque image si EXPL_ALGOGEN est validée.
ALEA(): génération aléatoire d´ génome.
croiser(): croisement de deux génomes.
aff_mot(): affichage d´un mot (codage d´ float).

Sous menu CREER
CREER():première fonction du sous menu CREER.
CREER_HEL(): help du sous menu CREER.
fonc_CREER(): appelée à chaque image si CREER est validée.
CREER_ROTA(): validation des trajectoires de rotations.
CREER_QUAT(): validation des trajectoires de quaterniuons.

Sous menu GEN
GEN():première fonction du sous menu GEN.
GEN_HEL(): help du sous menu GEN.
fonc_GEN(): appelée à chaque image si GEN est validée.
GEN_AJUST(): ajustement automatique de la mutation.
GEN_STOP(): stoppe les croisements.

Sous menu LIRE
LIRE():première fonction du sous menu LIRE.
LIRE_HEL(): help du sous menu LIRE.
LIRE_LIRE(): validation de lecture par écrasement.
LIRE_AJOU(): validation de lecture par ajout.
fonc_LIRE(): appelée à chaque image si LIRE est validée.

Fonction INTER:
INTER(): validation de l´interaction.
fonc_INTER(): appelée à chaque image si INTER est validée.

Interaction

F0(): appelée une seule fois en début de l´interaction.
F5(): appelée à chaque image aprè l´affichage des volumes, permet l´affichage d´échelles et de textes sur l´image.

Fonctions utilitaires:
dim_ecr(): calcule les dimensions en fonction de la taille de l´écran.
set_message(): initialise un message clignotant.
SET_BIT(): calcul de:
       Nb_Bit=Nb_Bit0[2];Max=(2^Nb_Bit)-1;
       Format=chaine(Nb_Bit),"B";
       Nb_Bit_quat4*Nb_Bit;
coder_bras(): code le mouvement du bras.
lire_rota(): lit un fichier de mouvements nom.rota dans la mémoire courante.
cou_vol(): change la couleur du volume selectionné
TOUS(): sélectionne tous les volumes.
aff_quat(): affiche un quaternion.
aff_genome(): affiche un génome.
ini_mot(): initialise les mots.
rendre_visible(): affiche Vol ou Peaux.
rendre_invisible(): invalide l´affichage.
modif_param(): affiche les échelles de saisie des paramètres.
STOP_PERIODE(): stoppe les menus clignotants.
VOL_QUAT(): retourne l´évaluation de la position du bras par rapport à la mémoire num.
tourner_Vol0(): tourne les volumes Vol0 dans la mémoire -1 (en mode INTER).

Fonctions de construction:
cons_bras(inc): construction d´un bras d´indice inc.
cons_rotule(): construction d´une rotaule (épaule et poignet).
cons_doigt(): construction d´un doigt.
cons_doigt_1(): construction d´une phalange.
cons_peau_main(): construction des peaux.
cons_peau(): construction d´une peau.
regenerer_particules(): regénère les particules lorsque le modèle change (par INTER) ou lorsqu´un fichier est lu (par LIRE) pour déstabiliser la génétique qui aurait pu atteindre une position d´équilibre et n´évoluerait plus (puisque des croisements de particules identiques ne les modifient pas).

Fonction d´évaluation:
FITNESS(): fonction d´évaluation, appeléeacute;e automatiquement pour chaque particule de la génétique et a` chaque image.
note(): retourne la note de la particule p qui est 1-dist(m,p) avec dist(m,p)= distance des chaines m et p = rapport du nombre de caractères différents et de mêmes indices dans les 2 chaines avec le nombre commun de caractères dans les 2 chaines .

Codage te décodage:
CODAGE(): transformation d´une rotation de l´espace (an,xr,yr,zr) en un quatrenion (w,x,y,z) puis codage sur 4*Nb_Bit caracteres 0 et 1.
DECODAGE_ROTA(): décodage d´un génome codant une rotation en une rotation.
DECODAGE_ROTA_QUAT(): décodage d´un génome codant une rotation en un quaternion.
DECODAGE_QUAT_QUAT(): décodage d´un génome codant un quaternion en un quaternion.

Génération des trajectoires:
GEN_TRAJ()
GEN_TRAJ_ROTA(): génération des trajectoires de rotations.
GEN_TRAJ_QUAT(): génération des trajectoires de quaternions par interpolation sphérique.

Les variables

Nb_Bit: nombre de bits du codage d´un float: initialement de 8, son augmentation améliore la convergence mais au détriment du temps de calcul. Les autres constantes sont calculées à partir de sa valeur dans la fonction SET_BIT().
Max=(2^Nb_Bit)-1: valeur maximale du codage.
Format=chaine(Nb_Bit),"B": utilisé par la commande chaine(Format,v); pour coder un entier.
Nb_Bit_quat=4*Nb_Bit: nombre de bits de codage d´une rotation ou d´un quaternion.
Sem_AUTO: interpolation automatiue (1), manuelle (0).
Inc=200: incrément des numéros des volumes d´une description d´un bras à un autre.
Lead,Epaule,Humerus,Radius,Poignet,Pouce,Indexe,Majeur,Annulaire,Petit,Doigts: noms des os.
Peau_Bras,Peau_Main,Peau_Pouce,Peau_Indexe,Peau_Majeur,Peau_Annulaire,Peau_Petit: noms des peaux.
Nb_Part: nombre d´individus (particules) de la génétique.
Nb_Quat: nombre de quaternions composant un mouvement élémentaire.
Nb_Vol: nombre de volumes animés.
Nb_Mem: nombre de mémoires codant des mouvements lus.
Ni: variations du nombre d´images d´une trajectoire.
Num: numéro du volume sélectionné.
Dim_Mot,Cassure,Mot1,Mot2,Mot3,Mot0: mots utilisés par EXPL_ALGOGEN.
Pend: mouvement pendulaire ou non.

Utilisations

Reconnaissance de mouvements
Génération de mouvements
Hybridation

Reconnaissance de mouvements

Il suffit de décrire des mouvements dans des fichiers .rota, la fonction FITNESS() donne l´évaluation d´une particule proportionnellement à la proximité de ce mouvement avec l´un des mouvements de base.
Interactivement il suffit de modifier le modèle (petit bras blanc) en cliquant dans le cadre, ou en modifiant rota et axe, ou en désignant un numéro de particule (sous le message particules). Laisser la génétique se stabiliser (les traits rouges sous les génomes représentent leurs notes et doivent converger vers 1 à droite), s´il n´y a pas convergence on peut:
       Soit augmenter le coefficient muta de mutation puis le diminuer.
       Soit cliquer sur AJUST (ce qui provoque un ajustement automatique de la mutation), puis recliquer sur AJUST pour laisser la génétique converger.
Les
réseaux neuronaux donnent cependant de bien meilleurs résultats: l´application mouv_neur traite du même problème dans une optique connexionniste.

Génération de mouvements

Les croisements des mouvements de base sont de nouveaux mouvements dépendant de la fonction FITNESS de fitness, ils sont d´autant plus variés que le coefficient de
mutation est grand.

Hybridation

Lire plusieurs fichiers nom.rota avec LIRE pour le premier et AJOU pour les autres. La fonction FITNESS() de fitness privilégie les individus capables d´imiter plusieurs mouvements (à des instants différents) et donc de se comporter de façon non univoque ("intelligente").