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).
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
|
Où
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
|
Où
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.
Dossier env
Contenant:
*.h: fichiers de configuration d´anyflo.
*.rota: fichiers matrice décrivant des mouvements.
Java scrypte de lancement en format vidéo.
initb.h
Fichier de configuration dans le dossier
env de la racine
distribution.
Fonction en langage anyflo.
mouv_gen.htm
Ce fichier.
Java scrypte de lancement de l´application.
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.
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.
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").