Some links may be not active (if this application is not in folder
env/applications/mouv_gen).
This application shows:
How to build genetic populations
of movments and how cross them while optimizing a
FITNESS function.
2) How build tyrajectories
2 ways:
rotations trajectories defined by:
angle
an and
axis xr,yr,zr
ghiving rise to 2 trajectories types
rotation and
axis.
quaternions
w,x,y,z, with:
an=2*acos(w)
x,y,z such as
module(x,y,z)=sin(a/2)
made of a list
quaternion
w,x,y,z 4D unit vector (such as:
a2+x2+y2+z2=1).
A volume
i motion is defined by
quaternion trajectory obtained by
spherical interpolation a list:
qi,1 qi,2 ... qi,nq de
nq quaternions.
For more volumes
Shoulder,Humerus,Radius,Wrist,Fingers there will be many trajectories.
Will be seen that give better results than rotations:
better convergence
more natural motions: click on
EXPL then
MOUV then
AUTO(),
change 2 quaternions for various key movments, click again on
AUTO(),
left click in white frame for change view.
How to write FITNESS function
It will be active only if the comparisons of the genetic particles
(encoding the initial random motions) with the read motions (by
LIRE)
or interactively defined (by
INTER), in which case a message is sent.
command
dist (2 strings) is used.
How to use these features
to programm an arm:
interactively imitatingla real motion capture.
interact
intelligently with a real actot he learns the postures
(being developed in
mouv_neur application).
Note:
To program this application in
C language outside
anyflo will be necessary
1) program genetic algorithmes.
2) program quaternions and spherical interpolation.
3) program real time interface.
4) optionaly program neural networks fore better recognitions.
Defining motions
Rotary movements are defined in file
.rota of form:
|
r1,1 r1,2 ... r1,nq
|
|
r2,1 r2,2 ... r2,nq
|
|
...
|
|
rnv,1 rnv,2 ... rnv,nq
|
Where
ri,j=a,x,y,z is a rotation defined by its angle
a
and its axis
x,y,z.
The movements of quaternions are defined in files
.quat of form:
|
q1,1 q1,2 ... q1,nq
|
|
q2,1 q2,2 ... q2,nq
|
|
...
|
|
qnv,1 qnv,2 ... qnv,nq
|
Where
qi,j=w,x,y,z is a quaternion.
These movement files can be built from motion capture of a real actor.
A real time interaction requires motion capture and interpretation
interfaced.
Folder env
*.h: anyflo configuration files.
*.rota: files describing movements.
Java scrypte launching anyflo in video format.
initb.h
Configuration file in folder env.
Function in anyflo language.
mouv_gen.htm
This file.
Java scrypte launching the application.
Main menu
EXPL: explanations.
CREER: creations
GEN: genetic generation.
LIRE: reading file movements.
INTER: interaction.
INI: initialisation
COL: yes/no col.
PEAU: yes/no skin display.
EXT: yes/no ext.
FONC: displays function names, click on display the text.
PASaPAS: step by step mode, click on CONTINUE (green): next image,
click on X (red) exits this mode.
Warning: dont click on RETURN, launching the programme again...
A flashing message shows the way to proceed, the menu box to click
is flashing 4 secondes.
EXIT: exit.
EXPL: explanations
HEL: help.
ROTA: click on bone name (Shoulder, Humerus,Radius, ...) then
change angle rota and axis, arm moves consequently.
Click on TOUS() all bones.
Click in green frame: change view.
COMPLEX: plane rotations and complexe numbers isomorphisme:
Change a et b unit complexe number z=a+i*b, the red point
displayed on the circle radius 1 representes the corresponding angle cosinus a
and sinus b.
QUAT: space rotations and quaternions isomorphisme:
Change angle rota and axis of unit quaternion
q=w+i*a+j*b+k*c, the red point P displayed on sphere radius 1
representes the rotation angle 2*acos(w) and axis OP.
Click in the green frame: change view.
MOUV: spherical interpolation of 2 quaternions:
Two quaternions q1=w1,x1,y1,z1 and q2=w2,x2,y2,z2 are represented by two points
P1(red) and P2 (green) of the sphere radius 1;
Change interpolation coefficient u, point Prepresenting the
interpolated quaternion between q1 and q2 is displayed on
the sphere between P1 and P2.
Change the quaternions on scales.
The spherical interpolation formula formula is:
c1=(sin((1-u)*a))/sin(a) c2=(sin(u*a))/sin(a) q=c1*q1+c2*q2
AUTO(): automatic interpolation.
Click in the green frame: change view.
MOUVS:
A POSITION is represented by a quaternion.
An elementary MOVEMENT is represented by a list of interpolated quaternions and
sinus b.
A multiple MOUVEMENT MULTIPLE (foe example the bones of an arm)
is represented by a list of such lists, this is a matrix of quaternions.
Such movement has been saved on disk in file fichier .rota
COD: encoding:
Change float x of interval [-1,1]
The integer e=ent(255*(x+1)/2) varies in interval [0,255]
Its binary expression(0 and 1) is encoded on a byte (8 bits).
It is transformed in genome constitude by 8 0 and 1,
this can be managed by a genetic algorithms.
ALGOGEN: genetic algorithm:
Choose n number of bytes encoding.
Click on ALEA(): randomly generates 2 words (n bytes).
Choose a break indice, the two words are cut at this indice, the first part
of the first geneome and the second part of the second genome are assembled
in order to make the third.
CREER: creation
HEL: help.
ROTA: ROTATIONS (an,xr,yr,zr)
The trajectories are rotations defined by an
angle an and an axis x,y,z.
QUAT: QUATERNIONS (w,x,y,z)
The trajectories are quaternions w,x,y,z.
A message is displayed indicating the selected mode (ROTA default),
the numbers of the active memories and INTER if this box has been clicked.
Choose:
1) Number nb of encoding bits (in fact 2^nb), small (better convergence
gor genomes are small, but small precision).
2) Number nb of particules
of the genetic (movements randmoly generated, angles and axis azre encoded on
binary strings by function lire_rota() and are the individuals of the
genetic.
GEN: genetic generation
HEL: help.
If INTER is not active the arm movement is regenerated from the better particle.
Command Muta[2]=generer genetique(1)ajust(Muta[0,2],k)
says genetic is regenerated (by automatically changing the mutation coefficient which is thus
variable on the scale muta) rising (probability proba) and mutating
(probability muta) for optimizinf the FITNESS() function.
pend pendulum movement.
Individuals are displayed as strings (0and 1) and red scales representing
their evaluations.
AJUST: mutation is automatically adjusted at global evaluation of the genetic.
STOP: stops cross overs, genetic does not evolve anymore.
LIRE: reading movement files
HEL: help.
LIRE click on nom.rota: loads this file killing others memories.
AJOU:click on nom.rota adds this file at others memories.
SUP: delete all memories.
The arm is animated consequently.
INTER: interaction
Click in the small frame in which is diaplayed a little arm(representing a possible webcam image)
or change rota and axe
or choose a number (under message particles)
the correspondant particle is decoded in a movement, any others particles tend to this particle.
Le bras se stabilise dans une position voisine.
The functions
The variables
The functions
Main menu:
mouv_gen(): main function.
externes(): external.
init(): initialisations.
generer_menu(): menu generation.
MEN(): first function of main menu MEN.
HEL(): help of the main menu.
INI(): reset.
COL(): yes/no col.
PEAU(): skin displaying.
EXT(): yes/no ext.
FONC(): function displaying.
fonc_FONC(): called each image if FONC is validated.
PASaPAS(): step by step mode.
EXIT(): exit.
DEUX_POINTS(): scales, des menus, des messages, texts hidden.
EXPL
EXPL(): first function of the menu EXPL.
EXPL_HEL(): help.
fonc_EXPL(): called each image if EXPL is validated.
EXPL_ROTA(): rotation explanation.
fonc_EXPL_ROTA(): called each image if EXPL_ROTA is validated.
EXPL_COMPLEX(): unit complex numbers associated to plane rotations explanation.
fonc_EXPL_COMPLEX(): called each image if EXPL_COMPLEX is validated.
EXPL_QUAT(): unit quaternions associated to space rotations explanation.
fonc_EXPL_QUAT(): called each image if EXPL_QUAT is validated.
MOUV(): quaternion spherical interpolation explanation.
fonc_EXPL_MOUV(): called each image if EXPL_MOUV is validated.
AUTO(): automatic interpolation.
EXPL_MOUVS(): several movements explanation.
fonc_EXPL_MOUVS(): called each image if EXPL_MOUVS is validated.
EXPL_COD(): movement encoding explanation.
fonc_EXPL_COD(): called each image if EXPL_COD is validated.
EXPL_ALGOGEN(): explanation of genetic algorithm.
fonc_EXPL_ALGOGEN(): called each image if EXPL_ALGOGEN is validated.
ALEA(): random generation of a genome.
croiser(): crossing 2 genomes.
aff_mot(): display of a word (float codage).
Submenu CREER
CREER(): first function of submenu CREER.
CREER_HEL(): help.
fonc_CREER():called each image if CREER is validated.
CREER_ROTA(): validation of rotation trajectories.
CREER_QUAT(): validation of quaternion trajectories.
Submenu GEN
GEN(): first function of submenu GEN.
GEN_HEL(): help.
fonc_GEN(): called each image if GEN is validated.
GEN_AJUST(): automatic adjustement of mutation.
GEN_STOP(): stops crossings.
Submenu LIRE
LIRE(): first function of submenu LIRE.
LIRE_HEL(): help.
LIRE_LIRE(): validation crush reading.
LIRE_AJOU(): validation reading by adding.
fonc_LIRE(): called each image if LIRE is validated.
Function INTER:
INTER(): validation of interaction.
fonc_INTER(): called each image if INTER is validated.
Interaction
F0(): called once at the beginning of interaction.
F5(): called each image after volumes display, allows displaying scales and texts
on the image.
Utiliy functions:
dim_ecr(): computes sizes depending on the size of the screen.
set_message(): initialize a flashing message.
SET_BIT(): computation of:
Nb_Bit=Nb_Bit0[2];Max=(2^Nb_Bit)-1;
Format=string(Nb_Bit),"B";
Nb_Bit_quat4*Nb_Bit;
coder_bras(): encoding arm movement.
lire_rota(): read a movements file name.rota in current memory.
cou_vol(): change the color of a selectedvolume
TOUS(): selects all volumes.
aff_quat(): displays a quaternion.
aff_genome(): displays a genome.
ini_mot(): initialize words.
rendre_visible(): displays volumes or skins.
rendre_invisible(): invalidates the display.
modif_param(): displays of parameters input scales.
STOP_PERIODE(): stopf flashing menus.
VOL_QUAT(): returnes the evaluation of thr position of the arm relative
to memory num.
tourner_Vol0(): rotates volumes Vol0 in memory -1 (mode INTER).
Construction functions:
cons_bras(inc): builds arm indice inc.
cons_rotule(): puilds a ball (shoulder, wrist).
cons_doigt(): builds finger.
cons_doigt_1(): builds phalinx.
cons_peau_main(): builds hand skin.
cons_peau(): builds skin.
regenerer_particules(): regenerates the particles when the model changes (by INTER)
or when a file is read (by LIRE) to destabilize the genetic that could reach an equilibrium
position without change (since the same particles crossing does not change).
Evaluation funnction:
FITNESS(): evaluation function, automatically called each image for any
particle of the genetic.
note(): returnes the note of particle p which is 1-dist(m,p) with
dist(m,p)
= distance of strings m and p = ratio of
the number of different bytes the same indice in two strings and the number of same bytes
in two strings.
Encoding decoding:
CODAGE(): transformation of a space rotation (an,xr,yr,zr) into quatrenion
(w,x,y,z) then encoding on 4*Nb_Bit bytes 0 and 1.
DECODAGE_ROTA(): decoding a genome (rotation) into a rotation.
DECODAGE_ROTA_QUAT(): decoding a genome (rotation) into a quaternion.
DECODAGE_QUAT_QUAT(): decoding a genome (quaternion) into a quaternion.
Trajectories generation:
GEN_TRAJ()
GEN_TRAJ_ROTA(): rotation trajectory generation.
GEN_TRAJ_QUAT(): quaternion trajectory generation by spherical par interpolation.
The variables
Nb_Bit: number of bits of a float encoding: default 8, if bigger inproves
convergence but at the expense of computation time. Others constants are computed from their values
in function SET_BIT().
Max=(2^Nb_Bit)-1: encoding maximal value.
Format=chaine(Nb_Bit),"B": used by command string(Format,v); for encoding integer.
Nb_Bit_quat=4*Nb_Bit: number of encoding bits of a rotation or a quaternion.
Sem_AUTO: automatic interpolation (1), manual (0).
Inc=200: increment of numbers of volumes of an arm description.
Lead,Epaule,Humerus,Radius,Poignet,Pouce,Indexe,Majeur,Annulaire,Petit,Doigts: names of bones.
Peau_Bras,Peau_Main,Peau_Pouce,Peau_Indexe,Peau_Majeur,Peau_Annulaire,Peau_Petit: names of skins.
Nb_Part: number of individuals (particles) of the genetic.
Nb_Quat: number of quaternions defining an elementary movement.
Nb_Vol: number of animated volumes.
Nb_Mem: number of memoriesencoding read movements.
Ni: variations of the image number of a trajectory.
Num: selected volume number.
Dim_Mot,Cassure,Mot1,Mot2,Mot3,Mot0: used words by EXPL_ALGOGEN.
Pend: pendulum or not.
Movement recognition
Mou=vements= generation
Hybridation
Movement recognition
Just write movements in files .rota, function
FITNESS() gives the evaluation of a particle in proportion to the proximity
of this movement with one of the basic movements.
Interactively just change the model (small white arm) clicking in the frame,
or by changing rota and axis, or by designatioin a particle number (under
the message particles). Let the genetis stabilize (the red lines under the genomes
reprsent their notes and must converge to 1 at the right), without convergence we can do:
increase the mutation coefficient muta then decrease it.
click on AJUST (automatic adjustment of mutation), then click again
on AJUST in order to let the genetic converge.
The neural networks give better results:
application mouv_neur manages the same problem in a connexionnist point of vue.
Movement generation
Crossing basic movements gives new movements dependent of the FITNESS function,
they are even more varied than the mutation
coefficient is big.
Hybridation
Read several files nom.rota with LIRE for the first then AJOU for the others.
Function FITNESS() favors individuals able to imitate
several movements (at different times) and therefore behave uniquelly
("intelligent").
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").