# english | # français

# Genetic movements

Some links may be not active (if this application is not in folder env/applications/mouv_gen).

#
download.
Principle
Content
The menus
The program
Use

## Principle

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 outsideanyflo 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.

## Content

### Folder env

*.h: anyflo configuration files.
*.rota: files describing movements.

### anyflo_video.js

Java scrypte launching anyflo in video format.

### initb.h

Configuration file in folder env.

### mouv_gen.fonc

Function in anyflo language.

### mouv_gen.htm

This file.

### mouv_gen.js

Java scrypte launching the application.

## The menus

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 program

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.

## Use

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").

# 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

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.

## 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").