Mode d’emploi des applications

 

Auteur: Michel Bret, août 2008

Matériel : PC , système Windows XP,1Go de mémoire, processeur à 3Gh minimum

carte graphique GeFORCE4 64Mo minimum

Logiciel : anyflo version 9.2

 

 

1 Contenu

 

anyflo 

            Dossier des exécutables contenant :

anyflo.exe : anyflo version 9.2 de février 2008

isdemo32.exe, itrax_mem2.exe : drivers de l’Intertrax.

WebCam.exe : driver de la caméra.

cjpeg.exe, djpeg.exe : convertisseurs jpeg.

*.js : fichiers de lancement (en java script) :

fen : Fichier contenant les dimensions de la fenêtre graphique.

*.dll : link dynamique.

env

Directory de l’environnement contenant les fichiers de lancement *.h

uti 

Directory de l’application contenant les datas :

            *.cap : Datas de capteurs physiologiques

*.dir : Directives

*.ges : Gestes

*.jou : Capteur enregistr&eacute ;

*.out : Datas du corps

*.pos : Positions

*.res : Réseaux neuronaux

*.son : Listes de fichiers wav

*.tab : Datas de capteurs physiologiques (originaux)

dll 

*.dll : Links dynamiques pour OpenGL et les drivers

lib

*.lib : Librairies pour OpenGL et les drivers

include

Includes *.h

aff

            Affichage: aff.fon, aff_fra

animer

            Animation : animer.fon, animer_fra

app

            Modèle d’pplication : app.fon

capteur

            Capteurs : capteur.fon, capteur_fra

corps

            Modèle de corps : corps.fon, corps_fra

decor

            Décors : decor.fon, decor_fra

effets

            Gestion des effets : effets.fon, effets_fra

essai

            Programme principal : essai.fon

init

            Initialisations : init.fon

reseau

            Réseaux neuronaux : reseau.fon, reseau_fra

vetements

            Vêtements : vetements.fon, vetements_fra

vue

            Gestion des vues : vue.fon, vue_fra

xxx

            Modèle de module ajouté : xxx.fon, xxx_fra

 

a_DIR : applications partageant le même environnement.

            a_ARTAUPHONE : l’Artophone (en collaboration avec Marie-Hélène Tramus).

            a_FLY : mime volant.

            a_FUN: la funambule virtuelle (en collaboration avec Marie-Hélène Tramus).

            a_MIME : programme principal des applications a_DIR.

            a_PLUME : la plume (en collaboration avec Edmond Couchot).

            a_PISSENLIT : les pissenlits  (en collaboration avec Edmond Couchot).

            a_TRAP : trapéziste.

            a_VELO : vélo.

 

a_OLD_DIR :  applications indépendantes (utilisant des versions anciennes d’anyflo).

            a_OLD_CORRIDA : corrida.

            a_OLD_DANSE: danseuse.

            a_OLD-MIROIR : fractals temps réel.

            a_OLD_ORGUE : orgue à image.

 

applications_emploi.htm : Ce fichier 

 

2 Principe

 

2-1 Format des fichiers *.js

 

1er Exemple a_MIME/mime_aud_rap_sp1.js : application appelant mime dans le dossier a_MIME :

 

f();

function f()

{

var WshShell = WScript.CreateObject("WScript.Shell");

WshShell.Run("..\\anyflo\\anyflo.exe ini=..\\env\\initb.h env=..\\env uti=..\\uti lan=\"d0() mime(\\\"*AUDRAPSP1\\\")\" win=../anyflo/fen");

}

 

..\\anyflo\\anyflo.exe : L’executable anyflo.exe d’anyflo est dans ../anyflo

ini=..\\env\\initb.h : Le fichier d’initialisation initb.h est dans ../env

env=..\\env : l’environnement est dans ../env

uti=..\\uti: les utilitaires sont dans ../uti

lan=\"d0() mime(\\\"*AUDRAPSP1\\\")\": la fonction principale mime() est dans ./

      (\\\"*AUDRAPSP1\\\") est une option de lancement, qui signifie :

            * : la chaine est à interpréter par groupe de 3 caractères

            AUD : option aud (audio)

            RAP : option rap (rapide)

            SP1 : option spe=1 (spéciale 1)

      Autres options possibles :

            FOU : option fou (fourier)

            AMP : option amp (amplitude)

            SP0 : option spe=0 (spéciale 0)

            SP2 : option spe=2 (spéciale 2)

            AGa : option age=3*a

            Ses : sexe (0 femme, 1 homme)

      La fonction vide d0() est indispensable

win=../anyflo/fen: dimensions de l’écran dans ../anyflo/fen.

 

2ème  Exemple  a_FUN/fun_itr.js: application appelant mime dans un autre dossier:

 

f();

function f()

{

var WshShell = WScript.CreateObject("WScript.Shell");

WshShell.Run("..\\anyflo\\anyflo.exe ini=..\\env\\initb.h env=..\\env uti=..\\a_MIME lan=\"d0() mime(\\\"*FUNITR\\\")\" win=../fen");

}

 

..\\anyflo\\anyflo.exe : L’executable anyflo.exe d’anyflo est dans ../anyflo

ini=..\\env\\initb.h : Le fichier d’initialisation initb.h est dans ../env

env=..\\env : l’environnement est dans ../env

uti=..\\a_MIME: place de la fonction principale mime().

lan=\"d0() mime(\\\"*FUNITR\\\")\": appel à mime() avec l’option «*FUNITR»

win=ful: plein écran.

 

3ème  Exemple a_OLD_DANSE/danse.js : application indépendante :

 

danse();

function danse()

{

var WshShell = WScript.CreateObject("WScript.Shell");

WshShell.Run("anyflo.exe env=env lan=\"d0() dan_1()\" win=ful SUP=nabukodonozor");

}

 

anyflo.exe: l’exécutable d’anyflo est dans ./

env=env: l’environnement est dans env.

lan=\"d0() dan_1()\": appel à la fonction principale dan_1() dans uti par défaut.

win=ful: plein écran.

Remarque : win=ful peut donner lieu &agrave ; un automapping erron&eacute ; on peut peut alors le remplacer par win=4000,3000 (dimensions sup&eacute ;rieures &agrave ; celles de l&eacute ;cran).

 

2-2 Structure des fichiers .fon

 

tous les fichiers xxx/xxx.fon ont la structure suivante (voir le fichier xxx/xxx.fon):

 

Déclaration des externes :

externes_xxx()

Fonctions du menu:

Menu_XXX= «XXX_AAA;» ;

Menu_XXX,= «.XXX_BBB;» ;

Menu_XXX,= «!XXX_CCC;» ;

Menu_XXX,= « >XXX_DDD ;» ;

            XXX_DDD est un sous menu

Les fonctions XXX_…() doivent être écrites.

Liste des fonctions du menu :

Fonc_XXX=set_Fonc(Menu_XXX) ;

Nombre de ces fonctions :

Nb_XXX=NP(Fonc_XXX) ;

Flags :

Flag_XXX=calloc(Nb_XXX); mémorise (off=-1, on=1).

n=0;w=“../xxx/xxx  “,Langue;

Texte du menu:

Nom_XXX=message(w,n) ;n++ ;

Text_XXX=esp_pv(Nom_XXX);

Texte affiché lorsque la souris passe sur une case du menu:

Com_XXX=rc_pv(message(w,n));n++;

Help:

Hel_XXX=message(w,n);n++;

Messages clignotants :

Cli_XXX=message(w,n);n++;

Adresses des messages :

Ad_XXX=cal_Erreur(Cli_XXX) ;

 

Fonctions obligatoires :

OPT_XXX(w) : Options

INI_XXX() : Premières initialisations

i_XXX() : Réanitialisation (touche I)

F0_XXX() : Appelée une fois en début d’interaction

F0_XXX_2() : Appelée une fois par F0_INI_2() après les menus

F4_XXX() : Appelée par F4_INI() après la dynamique

F5_XXX() : Appelée par F5_INI() après affichage

X= XXX_CON(x) : Menu de contrôle

XXX_ASCII() : Lecture clavier

 

2-3 Fichiers .fon particuliers

 

2-3-1 mime/mime.fon

 

Contient la fonction principale mime() qui inclue certains des autres fichiers :

#include ../init/init.fon

#include ../capteur/capteur.fon

#include ../corps/corps.fon

#include ../vetements/vetements.fon

#include ../reseau/reseau.fon

#include ../decor/decor.fon

#include ../aff/aff.fon

#include ../vue/vue.fon

#include ../animer/animer.fon

#include ../effets/effets.fon

 

Liste des programmes utilises (correspondant aux inclus):

prog=VUE,AFF,ANI,CAP,COR,VET,DEC,APP,RES,EFF,XXX;

 

Options :

com=OPT_APP(com);

 

Initialisations :

INI(prog,com);

 

Interaction :

interaction fonc(0,"F0")(0,"F1")(0,"F2")fonc(4,"F4")fonc(5,"F5") ;

 

Les fonctions F0, F1, F2, F4 et F5 sont dans init/init.fon.

 

Le menu est construit dans init/init.fon en fonction de prog et contient par exemple (selon la définition de prog) :

HEL : help

CAP : capteurs

RES : réseaux

ANI : animation

AFF : affichages

COR : corps

VET : vêtements

DEC : décors

VUE : vues

EFF : effets :

XXX : application ajoutée

EXIT : sortie du programme.

 

2-3-2 init/init.fon

 

Contient :

L’initialisation INI() qui appelle tous les INI_XXX_0(com), corps() et vetements() (après OPT_VET()).

 

Les options OPT_INI(prog,w).

esc la touche Echap relance le programme

ver mode verbose, touche $.

      fra version française (par défaut).

      eng version anglaise.

      cor funambule, <FUN.

      tra trapéziste, <TRA.

      fly vol mono cycle, <VEL.

      gen génétique.

      ::: souris cachée.

            Avec l’option de lancement qui, la touche Q sort du programme. Sinon cette touche est inhibée (pour éviter les sorties intempestives en démo). Pour sortir de l’application il faut alors:

            Soit faire !exit

            Soit :, ce qui revient au mode souris, cliquer dans le petit carré gris en haut et à gauche de l’écran pour faire apparaître les menus, et cliquer sur EXIT.

      ;;; menu de contrôle.

      gar touche G pour garer les images.

      qui=0 inhibe la touche Q de sortie du programme

      seq touche W pour garer les séquencs.

 

Les initialisations générales INI_INI().

 

La fonction F0() contient:

Génération des menus des prog : F0_INI();

Appel à LOC(0) pour tous les corps.

Execution des fonctions des menus : F0_INI_2();

 

La fonction F1 contient :

Appel à LOC(1) pour tous les corps.

 

La fonction F2 contient :

Appel à LOC(2) pour tous les corps.

 

La fonction F4() contient:

Appel à LOC(4) pour tous les corps.

Appel à tous les F4_XXX();

 

La fonction F5() contient:

Clavier : Appel à tous les XXX_ASCII() ;

Appel à tous les F5_XXX() ; gestion de l’interaction graphique comme les échelles.

Menu de contrôle : Appel à tous les XXX_CON() ;

Gestion des helps.

Gestion de BUG et de TIM.

 

La génération des menus F0_INI()qui appelle tous les F0_XXX().

 

Les initialisations après les menus F0_INI_2()qui appelle tous les F0_XXX_2().

 

Les réinitialisations _I() qui appelle tous les i_XXX().

 

Différents utilitaires.

 

Le comportement des corps LOC(sem)

            sem=0 : Initialisation

            sem=1 : Initialisation

                        LOC_1_ANI(): Décision

            LOC_1_DEC()

      sem=2: Avant dynamique

            LOC_2_ANI() : Collision

      sem=4

            LOC_4_VET() : Ajuster les vêtements

 

2-3-3 Fichiers dépendants

 

vetements/vetements.fon et animer/animer.fon incluent externes_corps(). Donc, dans essai/essai.fon :

si prog contient ANI ou VET il faut que prog contienne COR référencé avant, par exemple : prog=COR,ANI,VET;

 

2-4 Fichiers .pos de positions

 

Num_Positions=liste des noms des éléments ;

Nom_Positions= »Liste des noms des positions »;

Positions=NIL;

Exemple : ROU.pos

Exécuté par exec_GES(cpt)

 

2-5 Fichiers .ges de gestes

 

nom du fichier de positions

Couples (n,t)

      n,t: n=numéro du geste, t=temps (en Périodes)

-1,t: Numéros aléatoires

 

            type=debout gauche droite avance recule alea culbute danse

      durée=nombre de secondes

      coe=coefficient multiplicateur du type standard

Exemple : A.ges

Exécuté par exec_GES(cpt)

 

2-6 Fichiers .dir de directives

 

type, durée, coe

            type=debout gauche droite avance recule alea culbute danse

      durée=nombre de secondes

      coe=coefficient multiplicateur du type standard

Exemple : A.dir

 

2-7 Fichiers .cap des capteurs

 

c1,c2,…,c3

            ci=valeur du capteur i

Exemple : continu_rigide_1.tab.cap

 

2-8 Fichiers .jou d’un capteur

 

Cas particulier d’un seul capteur, correspond à CAP->JOU

Exemple : Defaut.jou

 

2-8 Fichiers .out de volume

 

Exemples:

Liste des sections en y du bassin : bassin.out

Liste des sections en y du cou : uti/cou.out 

Liste des sections en y du bassin : crane.out

 

2-9 Fichiers .son audio

 

Liste des noms de fichiers sons

Exemple:  birds.son

 

3 Configuration

 

3-1 Ecran

 

Le fichier fen contient les dimensions de l’écran (par exemple 1024 768).

Il peut être nécessaire de configurer l’écran en 1024 X 768 :

            Panneau de configuration

                        Affichage

                        Paramètres

                        Résolution de l’écran

 

3-2 Drivers

 

Selon le capteur choisi il peut être nécessaire de lancer certains drivers :

 

3-2-1 Audio

            panneau de configuration -> sons et périphériques audio -> audio -> volume

            Stéréo Mix ou Microphone

           

3-2-2 Caméra

            Brancher la caméra. Orienter la caméra de façon à ce qu’un expérimentateur (habillé en blanc et devant un fond noir) soit vu en pied.

 

            1) Image pixel :

            Lancer image_15.js

            Lancer Webcam de LabTec (taille 160 X 120) et amener l’image de la caméra en bas et à gauche de l’écran

           

2) Détecteur de mouvements :

            Lancer Webcam  de Labtec (taille 160 X 120), valider le détecteur de mouvements, commencer la surveillance, amener l’échelle de sensibilité en bas et à gauche de l’écran, régler la sensibilité au maximum (à droite).

            Lancer image_d.js et caler sur l’échelle de sensibilité, cliquer sur Labtec Webcam dont la fenêtre vient cacher celle de WebCam_d.js.

Remarque :

            Le fichier WebCam_d.js contient : « WebCam.exe a=25 » permettant de régler le sleep entre 0 (pas de sleep) et 1000 (1 seconde).

 

3-2-3 Intertrax

1) Connecter l’intertrax à un port série

2) Cliquer sur Isdemo32

        Detect -> Port 1  38400 Bauds

        Accept

        Quitter

3) Au lancement du programme l’intertrax est initialisé

 

3-2-4 Kroonde

1) Connecter le Kroonde, connecter les capteurs

2) Lancer kroonde_mem.exe

 

3-2-5 MIDI

Connecter le PCR-M1

 

4 Descriptions des modules

 

4-1 affichages aff/aff.fon

 

TES : mode pas à pas

SUI : pas suivant

VEC : affichage des vecteurs de l’équilibre (vecteur joignant le point d’ancrage au CG du corps, et vecteur de rééquilibrage).

BUG : echelles de debuging :

            L’échelle nb permet de choisir le nombre d’échelles (entre 1 et 12).

            L’échelle typ permet de choisir le type de variation (1 linéaire, 2 accéléré, 3 décéléré, 4 pendulaire).

            Chaque échelle de numéro n de 0 à 11 permet de choisir :

                        La précision p de la lecture (en dessous).

                        La lecture au dessus dans [-p,p] qui est mise dans Bug[n] et utilisable par programme.

LUM : accès aux lumières :

            échelle coe du coefficient de variation (si LDY ou LFR ont été invoqués)

            lum numéro, échelle 0 (éteinte), 1 (allumée)

            échelles poi de la position

            échelles cou de la couleur

            échelles fui de la direction

            échelles coe de l’atténuation

échelles ang de l’ouverture

LDY : lumières dynamiques

LFR : lumières associées aux fréquences (AUD et :ou FOU)

NOI : fondu au noir

BLA : fondu au blanc

ANG : echelles des angles et des positions (touche A)

            ay : rotation en y.

            dx,dz : déplacement.

            axz, axy, axx : axe de l’élément cliqué.

            Cra, Mac : crane, machoire.

            Mai : mains gauche et droite.

            Rad : radius gauche et droite.

            Hum: humerus gauche et droite.

            Bas, Rac : bassin et rachis.

            Fem : femurs gauche et droite.

            Tib : tibias gauche et droite.

            Pie : pieds gauche et droite.

            Ort : orteils gauche et droite.

            erect : erection.

            VAL : ajoute la position courante

            SUP :  choisir un numéro sur l’échelle sup, la position portant ce numéro est supprimée.

            MOD : choisir un numéro sur l’échelle mod, la position portant ce numéro est remplacée par la position courante.

            INI : supprime toutes les positions

            OFF : ni gare ni lire

            GAR : choisir un nom dans la liste des *.pos ou taper  <nom

            LIR : choisir un nom dans la liste des *.pos ou taper  <nom

SOM : choisir l’élémént sur les échelles (N), puis un sommet sur l’échelle s

EDI : choisir l’élémént sur les échelles (N), rot(axyz) et axe seront affichés

SAI : choisir la couleur d’un vêtement désigné sur les 3 échelles R, V et B

 

4-2 Animation animer/animer.fon

 

Menu principal :

IMM : immobile (fonction ANI_IMM de animer/animer.fon)

STA : stable

GES : (fonction exec_GES de animer/animer.fon), gestes à partir du fichier uti/GES contenant :

Nom d’un fichier de positions nom.pos

Des couples:

            n,t

n=numéro du mouvement (si –1 aléatoire, t= durée en Periodes .

En mode verbose ($), deux échelles s’affichent :

            Numéro du geste dans le fichier GES.

            Numéro de la position dans nom.pos, la position peut être désignée à la souris.

Si MAN a été invoqué, la position peut être tapée au clavier sous forme d’un chiffre ou de <cc suivi de ENTER pour un nombre > 9.

POS : (fonction exec_GES de animer/animer.fon), positions à partir d’un fichier nom.pos (lu dans AFF->ANG->LIR)

En mode verbose ($), l’échelle  des numéro de la position dans nom.pos s’affiche. La position courante est la plus proche de la position précédente à un aléatoire près.

Si MAN a été invoqué, la position peut être désignée à la souris  ou tapée au clavier sous forme d’un chiffre ou de <cc suivi de ENTER pour un nombre > 9.

AUT : automatique (fonction exec_AUT de animer/animer.fon)

RES : (fonction exec_RES de reseau/reseau.fon), réseaux neuronaux.

RED : (fonction exec_RED de reseau/reseau.fon), réseaux neuronaux directs (capteurs directement mappés sur la couche d’entrée).

GEN : (fonction exec_GEN de animer/animer.fon), génétique (pour plusieurs corps).

MOD : (fonction exec_MOD de animer/animer.fon), modification à la souris (clic gauche).

DIR : (fonction exec_DIR de animer/animer.fon), directives à partir du fichier uti/DIR.dir contenant des triplets:

            nn t c

            nn=nom du mouvement (debout gauche droite avance recule alea culbute pietiner)

      t=durée, c=coefficient multiplicateur des angles

En mode verbose ($), l’échelle  des numéro de la position dans nom.pos s’affiche et la position peut être désignée à la souris.

Si MAN a été invoqué la position peut être tapée au clavier sous forme d’un chiffre ou de <cc suivi de ENTER pour un nombre > 9.

MOU : (fonction exec_MOU de animer/animer.fon), mouvements :

En mode verbose ($), choisir un mouvement sur l’échelle.

Si MAN a été invoqué le numéro peut être tapée au clavier sous forme d’un chiffre ou de <cc suivi de ENTER pour un nombre > 9.

SDN :  (fonction exec_SDN de animer/animer.fon), système dynamique non linéaire.

            En mode verbose ($), les informations suivantes s’affichent :

            Echelle de la période du capteur

            Echelle de la période du bassin

            Courbe d’erreur (différence entre ces 2 périodes) et valeur de cette erreur.

            Echelle du nombre d’erreurs mémorisées.

            Echelle du seuil de l’erreur tolérée.

            Echelle du numéro de l’élément choisi.

            Phase et nom de l’élément choisi.

RAN  : (fonction exec_RAN de animer/animer.fon), aléatoire

RYT : (fonction exec_RYT de animer/animer.fon), rythmes

SIN :  (fonction exec_SIN de animer/animer.fon), sunusoidale.

MEM : (fonction exec_MEM de animer/animer.fon), génétique sur des mémoires

ROU : (fonction exec_ROU de animer/animer.fon), roulis du bassin

PUL : (fonction exec_PUL de animer/animer.fon), pulsation directe sur les membres, le bassin et le rachis

PUP : pulsation permanente (s’ajoute au type courant).

APP : (fonction exec_APP de animer/animer.fon), apprentissage non supervisé par cohérence de flux

OBS  : (fonction exec_OBS de animer/animer.fon), observation

Si ; a été invoqué (menu de contrôle), le type d’animation s’affiche en :

Vert si ANI->PAR->DYN a été invoqué (trajectoires angulaires).

Rouge si ANI->PAR->MAN a été invoqué (mode manuel).

 

PAR : Sous menu des paramètres

 

Sous menu des paramètres :

GO : impulsion

RESP : respiration

DYN : dynamique/trajectoires angulaires

COL : oui/non collision (<COL)

DUO : danse à deux, les personnages se tiennent par la main (qui peut changer)

MAN : le numéro du mouvement peut être tapé au clavier (entre 0 et 9) et sous la forme <n suivi de ENTER pour n>9. Actif pour GES, POS et DIR.

MIM : Mimétisme

 

La touche T affiche l’échelle time  (de 1 à 60 images par seconde)

TIMt : modifie le time.

TEMt : temporisation, modifie la vitesse de l’animation, de 0 (lent) à 1 (rapide).

ROTr : modifie la vitesse de rotation (entre 0 et 1).

COMr : modifie la compensation de l’équilibre(entre 1 et 12).

 

La touche ; (point virgule) provoque l’affichage du menu de contrôle en bas de l’écran. Si MAN a été invoqué le type de l’animation est en rouge.

 

<PULc : coefficient c, <PUL : coefficient .5, <PUL0 : off

 

4-3 Capteurs capteur/capteur.fon

 

SOU : souris

AUD : audio

FOU : fourier

CAM : caméra

DET : detection de collision

ITR : intertrax

KRO : kroonde angles

KRG : kroonde gyroscope

MID : MIDI

ALE : aléatoire

SIM : simulation

JOU: joue en play-back à partir des valeurs des capteurs enregistrés dans le fichier Memoire par

DAT : fichier de capteurs de format  (np captures de nc capteurs):

            C_1_0 c_1_1  …        c_1_nc-1

            C_2_0 c_2_1  …        c_2_nc-1

            …

            c_np_0            _cnp_1            …        c_np_nc-1

UDP: socket protocole UDP

ADR : choix d’un champ de capteur (entre 0 et nc-1) (ou <ADRc, ou sur l’échelle adr en mode V)

La fonction conv_mtr_cap(nom.mtr,t) écrit le fichier nom.cap_t pout la track t (0 par défaut)du fichier nom.mtr.

La fonction conv_tab_cap(nom.tab) écrit le fichier nom.tab.cap à partir du fichier nom.tab.

PAR : menu des paramètres :

VAL : variations d’ ordre 0

VIT : variations d’ordre 1 (vitesse)

ACC : variations d’ ordre 2 (accélération)

SEC : variations d’ordre 3 (secousse)

PER : choisir la période sur l’échelle per en mode verbose ($) et visualisation (V), ou en menu de contrôle ( ;) par <PERp le paramètre p s’affiche en vert.

MAJ : période majoritaire, le paramètre p s’affiche en violet.

            MOY : période moyenne, le paramètre p s’affiche en violet.

CAL : calage automatique des coefficients des capteurs (de façon à ce que le module du capteur reste voisin de 1). Sinon le coefficient multiplicateur est affiché après C, sa valeur peut être changée par CALn, exemple CAL.5 diminue la sensibilité de moitié, CAL2 la multiplie par 2 (la valeur affichée est 10 fois la valeur réelle).

SEU : choisir le seuil de filtrage sur l’échelle seu en mode verbose ($) et visualisation (V), ou en menu de contrôle ( ;) SEUs le paramètre s’affiche en rouge S s (la valeur affichée est 100 fois la valeur réelle).

ENR : enregistrement

GAR : garer

            DIF: détection difficile (si CAM), choisir le coefficient  sur l’échelle dif (si V et $) de façon à ce que l’image soit noire lorsque l’image est fixe.

            SEQ (séquence), ASS (association), ACT (action)

            ASS : association

            ACT : lance l’action

La touche V provoque l’affichage d’informations sur les capteurs :

            SILENCE si le signal plat pendant plus que 4 secondes

            ACTIF sinon

            Une échelle cap (1,2,3) permettant de choisir plus d’informations :

                        1 : Courbe de variation.

                        2 : En plus :  coefficient, valeurs, module.

                        3 :  En plus : les échelles des coefficients.

Courbe de variation.

Les 3 échelles de ces variations (en x, y et z).

Echelle du coefficient multiplicateur.

Total : Les 3 échelles de ces variations (en x, y et z) de la moyenne des capteurs

mod : Module de l’amplitude

 

Si DAT :

En mode V, choisir le nom dans la liste des *.cap, ou <nom

                        i : numéro capture (modifiable).

                        d_i : incrémenu de numéro capture (modifiable), 0 : mise à zéro.

                        capture : fenêtre de capture (modifiable), égale à la dimension d’un motif d’entrée pour RED, S : signal entier.

                        coe_aff : oefficient multiplicateur de l’affichege, -1,1 : ajusté.

                        adr : champ (numéro modifiable du capteur)

 

En mode verbose ($) des informations complémentaires sont affichées :

            sens : echelle du sens (-1, 0 ou 1).

            bras : influence des capteurs sur les bras.

            coe_ni : coefficient multiplicateur de Ni=c*Periode.

            impuls : coefficient d’impulsion

            Ni1, Ni2 : bornes de Ni

ani : coefficient multiplicateur de Coe_ANI=.15+Moy_Mod_Capt*Coe_ANI0[2]).

vit : réglage de la vitesse

seuil : ajustement des seuils en fonction de la luminosité (pour CAM).

filtre : filtrage des petites amplitudes.

dim_puls, coe_puls : Réglage des pulsations.

moy : moyenne du capteur, modifiable par <MOYn.

            vit_per : vitesse maximum de la période, modifiable par <VPEn (4 par défaut).

 

La touche V visualise les capteurs. Si le mode verbose est actif ($) on peut choisir crete sur une échelle (si crete != 0 le signal est écrêté). <CREc permet de choisir la crête.

La touche + incrémente les coefficients de 0.1

La touche - décrémente les coefficients de 0.1

Si MID est validé la liste des fichiers *.son contenant les sons associés aux notes est affiché, cliquer sur l’un d’eux le charge.

<CAPc : c=1,2,3 : degré de détail des informations affichées (1 : courbes, 2 : valeurs et fichiers, 3 : détails).

La touche A affiche les positions du fichier courant .pos

La touche ; (point virgule) provoque l’affichage du menu de contrôle en bas de l’écran, Coe_ANI0, Periode et Coe_VIT sont affichés.

<IMPn : modifie interaction coe (entre 0 et 1, .5  par défaut).

 

Options de lancement :

            ima=v : v=0,1,2, (variations), 3 (corps)

            aud: audio

            cre=c: crête

            sou: souris

            cam: cam&eacute;ra

            det: détection de mouvement

            dif : différence

            fou: Fourier

            kro: kroonde

            krg: kroond CG

            itr: itrax

            mid: MIDI

            ale: aléatoire:

            sim: simulation

            jou: jouer

            val: valeur du capteur

            vit : vitesse du capteur

            acc : accélération du capteur

            sec : secousse du capteur

            seu=s : seuil du filtre

            cal : calage automatique

            tes : teste caméra

            ima=i : 0,1,2,3 interprétation de l’image caméra

            maj : période majoritaire

            moy : période moyenne

            ser =IP du serveur (pour UDP)

            cli=IP du client (pour UDP)

            cap=k: capteurs multipliés par k

            mim : mimétisme (ANY->PAR->MIM)

 

4-4 Corps corps/ corps.fon

 

SQU : squelette

MUSC : muscles

SQ_MU : squelette + muscles

SQ_MU_PE : squelette + muscles + peau

PEAU : peau

OUT : outil

            bas : modelage du bassin

            cra : modelage du crane

            Les numéros des sections apparaissent, quand on en choisit une les numéros des sommets apparaissent, quand on en choisit un les échelles de déplacement dx, dy et dz apparaissent.

            INI : restitue les valeurs initiales

            GAR : gere le résultat dans bassin.out ou crane.out. Il faut d’abord sauvegarder ces fichiers car ils sont remplacés par cette manipulation.

 

4-5 Décors decor/ decor.fon

 

BRO: brouillard

FON: fond

OMB: ombres portées

MAP : mappes

COU : variation de la couleur du corps et des ailes

SOL : sol

CIE : cieux, choisir le nombre sur l’échelle (faire $)

CUB : cube

CAG : cage

BUL: bulles

SUR: surface

VOL : volume plat de fond

IMA : mappes animées (options de lancement «nom=fic num=im1,im2»)

STO : stop IMA

ECR : ecran

BLUn: motion blur, si n dans [0,1] la trace est n, si n<0 la trace est -n*(module capteur).

 

4-6 Effets effets/ effets.fon

 

NUM : en mode verbose ($) choisir un numéro sur l’échelle (faire $)

             Ou taper le numéro (de 0 à 9) ou <n si n>9.

LET : choisir la lettre sur l’échelle (faire $)

            Ou taper la lettre (de a à z)

SPE: spécial, choisir un numéro sur l’échelle (faire $), n=-1 (off), 0,1,…

            Pour ajouter un spécial :

                        Ajouter 1 à Max-Spe_EFF

                        Ajouter une entrée dans exec_SPE :

                                   case 3:

                        exec_SPE_3();

                        break;

            Ecrire la fonction exec_SPE_3().

SPEn : spécial n

AMP: amplitude des effets (1,13 par défaut) (<AMPn1,n2)

LEN : lent (entre 6 et 9)

RAP : rapide (entre 1 et 5)

<CYCabc: cycle entre a et b

si c >0 période=c, si c<0 période=c*(Moy_Mod_Capt-1), si c est absent période=100

<CYC inhibe le cycle

PIL : pile d’effets

LIB : libre (au sol)

FUN : funambule (sur la corde)

TRA : trapéziste (au trapèze)

FLY : envol

VEL : vélo

 

4-7 Réseaux neuronaux reseau/ reseau.fon

 

MAT : affiche la matrice des synapses

PAR : paramètres :

Choisir sur les échelles:

            num_app : numéro du réseau.

            delai : délai avant la première photo.

            tempo : entre deux photos.

            nb_photo : nombre de photos prises à chaque PHO

            nb_app : côté de la mappe de Kohonen.

            nb_motif : nombre de motifs d’entrée

            nb_cache : nombre de couches cachées

            nb_loi : nombre de lois de sortie

           

Fonctions du sous menu :

SUP : supprime l’apprentissage désigné

IMM : immobile

VUE : recentre la vue

JAM : jambes

BRA : bras

BAS : bassin

RAC : rachis

            ADA : adaptatif

            INI : supprime tout les réseaux

TYP : choix du type du réseau

            CAC : couches cchées

            KOH : kohonen

            ADA : adaptatif complétement connecté. Les entrées sont un film généré par POS ou PHO (les sorties sont automatiquement formatées).

            MEM : génétique sur les mémoires :

:Cliquer une position qui s’ajoute à l’échelle mem des mémoires.

            Pour utiliser la mémoire :

Rentrer en mode acquisition (ACQ).

Cliquer sur une mémoire, la position s’affiche.

Cliquer sur POS, la position est acquise.

ENT : choix du type d’entrée

            POS : position (par défaut). Lors de la saisie les motifs sont des positions validées par POS ou PHO

            CAP : capteur. Lors de la saisie les motifs sont les valeurs du capteur (image de la caméra, valeurs MIDI, angles du Kroonde ou de l’Itrax, fenêtre de datas, etc…) validées par POS ou PHO

            MOD : module

            DAT : fichiers datas de valeurs de capteurs.

FIC : gestion des fichiers

LIR : lire un réseau, désigner un nom dans la liste ou taper <nom

AJO : ajoute un réseau, désigner un nom dans la liste ou taper <nom

GAR : gare les réseaux, désigner un nom dans la liste ou taper <nom

INI : supression de tous les réseaux.

ACQ : Mode acquisition

 

POS : entrée position

ALE : position aléatoire

PHO : prend nb_photo photos

POSI : position

 

FIN : lance le processus d’apprentissage. L’erreur est affichée. La case noise permet de réinitialiser le matrice. Les constantes d’apprentissage varient automatiquement et la matrice est réinitialisée tant que l’erreur est supérieure à 0.5.

VOI : connecte les neurones moteurs aux muscles

STO : stoppe l’apprentissage

EXE : exécute à partir de la position courante

 

SUP : supprime la position désignée

 

4-8 Vêtements vetements/vetement.fon

 

CHE : cheveux

COI : coiffure

STR : string, <STRr,rvb

CEI : ceinture, <CEIr,v,b

JUP: jupe, Chaussettes (choisir la longueur sur l’échelle, faire $), <JUPn ,r,v,b : n=longueur, (r,v,b) = couleur (entre 0 et 1)

GIL: Gilet

GAN: gants

CHA: Chaussettes (choisir la longueur sur l’échelle, faire $), <CHAn,r,v,b

BOT : bottes (choisir la longueur sur l’échelle, faire $), <BOTn,r,v,b

PAN : pantalon (choisir la longueur sur l’échelle, faire $), <PANn,r,v,b

BIJ : bijoux, <BIJr,v,b

AIL : ailes, <AILr,v,b

RUB : rubans

VOI : voile, <VOIn,r,v,b : n=longueur, (r,v,b) = couleur (entre 0 et 1)

PLU : plumes

FIL : etoile

MIS : misstinguette, <MISr,v,b

ERE : erection, <EREe

AFF->SAI  permet de choisir la couleur sur 3 échelles

 

4-9 Vues vue/vue.fon

 

La touche O passe en mode FIX et permet de choisir les rotations en x, y et z sur des échelles, ainsi que ni et sui

FAC : face

DRO : droite

GAU : gauche

DER : derrière

COT : côté

DES : dessus

FIX : fixe

VAR : variable

FOC : focale et roulis variables

PIE : fuite sur le pied gauche

GEN : fuite sur le genoux gauche

BAS : fuite sur le bassin

RAC : fuite sur le cou

CRA : fuite sur le crane

ALT : vue alternée entre FIX et le mode choisi

 

4-10 Raccourcis clavier

 

$ (dollars) :

            Mode verbose.

$  mode verbose

f  immobile

i effet--, j effet++

G gare image

I init paramètres

P paramètres

Q quitter

T fréquence d’affichage

V visaulisation des caoteurs

W gare séquence

: (deux points) supprime les affichages des menus.

; (point virgule) menu de contrôle.

* (étoile) centrage

 

<COM enter : équivalent à la commande COM

<COM,p1,p2,p3 enter : équivalent à la commande COM(p1,p2,p3)

exemples :

            AUT : animation automatique

            CHA12 : chaussettes de longueur 12

            VOI1,1 : voile jaune

            BOT9,1 : bottes de longueur 9 et de couleur rouge

            Etc…

 

5 Fonctionnement

 

5-2 Lancement

 

5-2-1 Fichiers de lancement

 

Lancement d’anyflo seul :

anyflo/anyflo_non_gras.js : non graphique.

anyflo/anyflo_video.js : fenêtre vidéo.

anyflo/anyflo_full.js : plein écran.

 

Lancement général :

            a_MIME/mime.js lance mime.js : une danseuse, ext=0, toutes les options sont modifiables au clavier et à la souris (peut servir d’outil programmable et interactif pour VJ).

 

Lancements particuliers :

Artophone (en collaboration avec Marie-Hélène Tramus):

            a_ARTAUPHONE/ARTAUD.EXE.js

Vol :

            a_FLY/fly_aud.js : vol audio

            a_FLY/fly_cam.js : vol caméra

Funambule (en collaboration avec Marie-Hélène Tramus):

            a_FUN/fun_aud.js: funambule audio

            a_FUN/fun_cam.js: funambule caméra

            a_FUN/fun_itr.js: funambule intertrax

            a_FUN/fun_sou.js: funambule souris

Mime:

            a_MIME/mime_aud_ada: réseaux adaptatifs

            a_MIME/mime_aud_amp: amplitude variable

            a_MIME/mime_aud_duo: 2 danseuses

            a_MIME/mime_aud_rap: rapide

            a_MIME/mime_aud_rap_sp1: rapide, spéciale=1

            a_MIME/mime_aud_sp2: spéciale=2

            a_MIME/mime_aud_rap_sp0: rapide, spéciale=0

            a_MIME/mime_cam: caméra

            a_MIME/mime_cam_pol: caméra poly (danse, fun, trap, vélo)

            a_MIME/mime_def: options par défaut

            a_MIME/mime_pdi: lecture des options au clavier

            a_MIME/mime_tes_0: teste, ext=0

            a_MIME/mime_tes_1: teste, ext=1

            a_MIME/mime_tes_2: teste, ext=2

            a_MIME/mime_UDP: capteurs en UDP

Corrida :

            a_OLD_CORRIDA/corrida_aud.js : audio

            a_OLD_CORRIDA/corrida_cam.js : caméra

            a_OLD_CORRIDA/corrida_sim.js : simulation

            a_OLD_CORRIDA/corrida_sou.js : souris

Danse ancienne:

            a_OLD_DANSE/danse.js

Miroir (fractals temps réel):

            a_OLD_MIROIR/miroir1.js : 1ère version

            a_OLD_MIROIR/miroir2.js : 2ère version

Orgue  à image:

            a_OLD_ORGUE/orgue.js:

Pissenlit (en collaboration avec Edmond Couchot) :

            a_PISSENLIT/pissenlit_0.js : pissenlit simple

            a_PISSENLIT/pissenlit_demo.js : démo

            a_PISSENLIT/pissenlit_demo_vertical.js : écran vertical

            a_PISSENLIT/pissenlit_effets.js : effets automatiques

            a_PISSENLIT/pissenlit_ima.js : avec une image

            a_PISSENLIT/pissenlit_large.js : écran large

            a_PISSENLIT/pissenlit_perso.js : particulier

            a_PISSENLIT/pissenlit_rapide.js : version rapide

Plume (en collaboration avec Edmond Couchot)

            a_PLUME/plume_1.js : plume simple

            a_PLUME/plume_1_blanc.js : plume simple sur fond blanc

            a_PLUME/plume_25.js : 25 plumes

            a_PLUME/plume_25_blanc.js : 25 plumes sur fond blanc

            a_PLUME/plume_50.js : 50 plumes

            a_PLUME/plume_50_blanc.js : 50 plumes sur fond blanc

            a_PLUME/plume_fimm.js : avec films

            a_PLUME/plume_nuage.js : nuage de plumes

            a_PLUME/plume_nuage_blanc.js : nuage de plumes sur fond blanc

Trapéziste :

            a_TRAP/trap_aud.js : audio

            a_TRAP/trap_cam.js : caméra

Vélo :

            a_VELO/velo_aud.js : audio

            a_VELO/velo_cam.js : caméra

 

5-2-2 Options

 

5-2-2-1 Options générales

 

cor : Programme FUN (corde)

eng : Anglais

esc : Ignore la touche escape (pour les installations publiques)

fly : Programme FLY (vol)

fra : Français (par défaut)

gen : Génétique

pol=n : Changement de programme (LIB, FUN, TRA, FLY,VEL) avec une période de n

qui=q : si q=0 évite de quitter avec Q (sécurité en spectacle live).

tra : Programme TRA (trapèze)

vel : Programme VEL (vélo)

ver : Mode verbose

::: Pas d’affichage d’informations

;;; Menu de contrôle

 

5-2-2-2 Options de aff

 

lum=n : Nombre de lumières (1 par défaut).

 

5-2-2-3 Options de animer

 

aut: Type_Anim=ANIM_AUT automatique

app : Type_Anim=ANIM_APP

com=c: Modifie la compensation de l’équilibre(entre 1 et 12, 4 par défaut).

dir=nom.dir: Type_Anim=ANIM_DIR fichier .dir

duo: Duo (pour plusieurs corps)

dyn=-1: Trajectoires angulaires, dyn=1 : dynamiques (par défaut)

ges=nom.ges: Type_Anim=ANIM_GES fichier nom.ges

imm: Type_Anim=ANIM_IMM immobile

man: Sem_MAN=1 positions désignées à la souris

mim : Methode_Anim=MET_MIM

mod: Type_Anim=ANIM_MOD modifications manuelles

mou=n: Type_Anim=ANIM_MOU mouvement numéro n

pes=p: Pesanteur p (10 par défaut)

pos=nom.pos: Fichier de fichier .pos

ran: Type_Anim=ANIM_RAN aléatoire

red: Type_Anim=ANIM_RED réseaux neuronaux directs (capteurs directement mappés sur la couche d’entrée).

res: Type_Anim=ANIM_RES réseaux neuronaux

ryt: Type_Anim=ANIM_RYT rythmique

sau=n : Saute=n (1.5 par défaut)

sdn: Type_Anim=ANIM_SDN système dynamique non linéaire

sin=n: Type_Anim=ANIM_SIN sinusoïdale de numéro n

 

5-2-2-4 Options de capteur

 

acc: accélération capteur

ale=c: aléatoire (de coefficient c, 1 par défaut)

aud=c: audio (de coefficient c, 1 par défaut)

cal: calage automatique

cam=c: caméra (de coefficient c, 1 par défaut)

cap=c : K_Capteur0=c coefficient multiplicateur de tous les capteurs

cre=c : crête

dat=nom.dat : capteur dans nom.dat ("continu_rigide_2.tab.cap" par défaut)

det=c: detection de mouvement (de coefficient c, 1 par défaut)

dif : éclairement difficile

fou=c: fourier (de coefficient c, 1 par défaut)

ima=n : Sem_Ima0=n (0 par défaut)

itr=c: intertrax (de coefficient c, 10 par défaut)

jou=c: jouer (de coefficient c, 1 par défaut)

krg=c: kroonde (gyroscope) (de coefficient c, 1 par défaut)

kro=c: kroonde (angles) (de coefficient c, 1 par défaut)

maj : période majoritaire

mid=c: MIDI (de coefficient c, 1 par défaut)

moy=n : période moyenne (50 par défaut)

sec: secousse capteur

ser=n : serveur=n (numéro du serveur, "127.0.0.1" par défaut)

seu=f: filtre f (.01 par défaut)

sim=c: simulation (de coefficient c, 1 par défaut)

sou=c: souris (de coefficient c, 1 par défaut)

tes : calibrage de la caméra

UDP=c: protocole UDP (de coefficient c, 1 par défaut

val: val capteur

vit: vitesse capteur

 

5-2-2-5 Options de corps

 

age=a: Age (entre 0 et 100, 18 par défaut)

bet=b: Bête (0 par défaut)

ext=e: Extension (0 par défaut)

gro=g: Grosseur (1 par défaut)

lon=d: Longueur des jambes (1 par défaut)

mus: Muscles

pea: Peau

rac=n: Nombre de rachis (12 par défaut)

sei=c : K_Sein=y,x ( coey, depx, 1,1 par défaut)

sex=s: Sexe (entre 0 et 1, 0 par défaut)

squ: Squelette

tai=t: Taille (1 par défaut)

vis=v: Viscosité des ‘force rota’ (-.05 par défaut, modifiable interactivement par P)

 

5-2-2-6 Options de decor

 

bro: brouillard

bul : bulles

cie: ciel

cou: couleurs variables

fon: fond

map : mappes

nom=nn : noms des fichiers images

num=n1,n2 : numéros (premier et dernier) des images

omb: ombres portées

sol : sol

 

5-2-2-7 Options de effets

 

eff=amp : effets de numéros entre 1 et 13

eff=cyc : effet cycliques

eff=len : effets lents (entre 6 et 9)

eff=n : effet numéro n

eff=rap : effets rapides (entre 1 et 5)

pol=n : poly programme LIB, FUN, TRA, FLY, VEL de période n (0 par défaut)

spe=s : spécial numéro s

 

5-2-2-8 Options de reseaux

 

red=nom.res : nom des fichiers de réseaux directs

res=nom.res : nom des fichiers de réseaux

 

5-2-2-9 Options de vetements

 

ail : ailes

bij : bijoux

bot : bottes

cei : ceinture

cha : chaussettes

che=c : longueur des cheveux (1 par défaut dépendant de l’age et du sexe)1

coi : coiffure

ere=c : érection c (0 par défaut)

fil : files

gan : gants

gil : gilet

jup : jupe

pan : pantalon

plu : plumes

rub : rubans

str : string

voi : voile

 

5-2-2-10 Options de vue

 

alt : alternée

cot : côté

der : derrière

des : dessus

dro : droite

fac : face

gau : gauche

rou=r : roulis (0 par défaut)

var : variable

 

5-3 Menus interactifs

 

Cliquer sur le petit carré en haut et à gauche de l’écran. Le manu principal apparaît.

Cliquer sur l’une des cases invoque le sous menu correspondant.

Certaines touches du clavier sont actives.

Certaines combinaisons de touches, précédées de <, sont actives.

 

5-4 Menu de contrôle

 

5-4-1 Activation

 

La touche ; (point virgule) active le menu de contrôle en bas de l’écran (utile en démonstration publique pour cacher les manipulations). Les informations suivantes sont affichées :

Fréquence d’affichage (T), qui est masquée quand on rentre une commande <xxx.

 

Type de l’effet : numéro modifiable par :

 0 1 … 9 <10 <11 …)

<RAP

 <LEN 

<AMP.

 

Type de l’animation modifiable par :

            <AUT : automatique.

            <DIR : directives

<DIRnom : directives (fichier nom.dir, Defaut_DIR.dir par défaut).

 <IMM : immobile.

<GEN  : génétque (nécessite plusieurs corps).

<GES : gestes.

            <GESnn: fichier nn.ges (Defaut_GES.ges par défaut).

            <GES_nn : ajoute nn.ges.

<MEM : génétique sur des mémoires.

<MEMnom : fichier nom.pos (Defaut_POS.pos par défaut).

            <MEM_nom : ajoute nom.pos.

<MOD : modification à la sourtis.

<MOUn : mouvement numéro n.

<POS : positions.

<POSnom : fichier nom.pos (Defaut_POS.pos par défaut).

            <POS_nom : ajoute nom. pos et passe en mode POS.

<PUL: Pulsation directe.

<PULc: Pulsation directe de coefficient c.

<PUPc: Pulsation directe permanente de coefficient c entre 0 et 1 (s’ajoute au type courant)

<PUP0 : inhibition.

            <RESnom : réseaux neuronaux.

<RESnom : fichier nom.res (Defaut_RES.res par défaut).

                        <RES_nom : ajoute nom.res.

            <RED : réseaux neuronaux directs.

                        <REDnom : fichier nom.res (Defaut_RED.res par défaut).

                        <RED_nom : ajoute nom.res et passe en mode RES

            <ROU : Roulis du bassin.

            <SDN : système dynamique non linéaire.

           

M module(capteur)

 

P Période modifiable par :

<PERp : période constante p.

<MAJ : période majoritaire.

<MOYm : période moyenne (m=25 par défaut).

 

(V) incrément de période modifiable par ( et ) qui augmente te diminue la vitesse.

 

C coefficient capteur modifiable par :

<CAL et - + (sauf si PER est actif).

 

S seuil de filtrage modifiable par :

<SEU puis - +

 

Type de la vue, modifiable par :

<FAC : face.

<DRO : droite.

<GAU : gauche.

<DER : derrière.

<COT : côté.

<DES : dessus.

<FIX : fixe.

<VAR : variable.

 

Type des lumières modifiable par :

            <LDY : lumières dynamiques

<LFR : lumières associées aux fréquences

 

L1 L2 modifiable par <LUM1 <LUM2

 

La couleur de l’affichage est :

                        rouge : fixes.

                        violer : automatique (pour CAL MAJ MOY)

                        vert : modifiable (SEUs PERp CALc et ( ) pour l’incrément V).

 

5-4-2 Commandes

 

<XXX suivi de ENTER exécute le menu XXX.

Commandes spéciales :

<LUMn : Active-désactive la lumière n

<CORn : Active-désactive le corps n

<NUMn : Choix du numéro du corps affecté par les modifications (-1 : tous)

Pour une bonne interprétation de ces commandes les noms de toutes les cases des menus doivent être différents.

 

5-4-3 Liste alphabétique des commande

 

<AFF : menu AFF

<AIL : ailes, AILr,v,b : couleur

<ALE : capteur aléatoire

<ALT : vue alternée (vue courante <-> ixe)

<AMP: amplitude des effets (1,13 par défaut). :

<ANG : menu ANG angles

<AUD : capteur audio

<AUT : animation automatique

<BAS : fuite au bassin

<BIJ  :  bijoux, BIJr,v,b : couleur

<BLUc: motion blur dynamique (c entre 0 et 1).

<BOT : bottes, BOTt,r,v,b : taille,couleur (entre 0 et 1)

<BRO : brouillard

<BUG : echelles debuging

<BUL : bulles

<CAG :cage

<CAL : calage des capteurs, <CALc : valeur fixe

<CAM : capteur caméra

<CAPc : c=1,2,3 : degré de détails (1 : courbes, 2 : valeurs et fichiers, 3 : détails).

<CREc permet de choisir la crête.

<CHA : chaussettes, CHAt,r,v,b : taille,couleur (entre 0 et 1)

<CHE : cheveux, CHEr,v,b : couleur

<CIE : ciel

<COI : coiffure, COIr,v,b : couleur

<COU : couleur automatique des peaux

<CPEn,r,v,b : couleur (r,v,b) de la peau du corps n, réinitialise si r,v,b est absent.

<CRA : fuite au crane

<CUB : cube

<CYC : cycle, <CYCa,b,c : bornes et période, <CYC inhibe le cycle (voir 4-6)

<DES : vue de dessus

<DET : capteur détection de mouvement

<DIRnn : animation directives, DIRnn : fichier nn.dir, <DIR_nn : ajoute nn.dir

<DRO : vue de droite

<ECR : oui-non écran

<EDI : edition de rot(axyz) et axes

<FAC : vue de face

<FIL : files

<FIX : vue fixe

<FLY : envol

<FOC : rétablit la vue courante et fait foc->1

<FON : fond

<FOU : capteur fourier

<FUN : programme funambule  (sur la corde)

<GAN gants, GANr,v,b : couleur

<GEN : animation génétique (plusieurs corps)

<GES : animation gestes

<GIL : gilet, GILr,v,b : couleur

<HAB : habit, HABr,v,b : couleur

<IMA : image de la caméra (STO)

<IMM : animation immobile

<IMPn : modifie interaction coe (entre 0 et 1, .5 par défaut).

<ITR : capteur intertrax

<JOU : capteur jouer

<JUP : jupe, <JUPn ,r,v,b : (n, r,v,b) =longueur,couleur  (entre 0 et 1)

<KNE : fuite au genoux (knee)

<KOH : réseau de Kohonen

<KRO : capteur kroonde angles

<KRG : capteur kroonde gyroscope

<LDY : lumières dynamiques

<LEN : effets automatiques lents.

<LFR : lumières associées aux fréquences

<LIB : programme danse libre (au sol)

<LUM : echelles des lumières

<MAJ : période majoritaire.

<MAP : mappes

<MID: capteur midi

<MIS : misstinguette, MISr,v,b : couleur

<MOD : animation modification

<MOU : animation mouvements, <MOUn : mouvement n

<MOYn : période moyenne, MOYm (n=25 par défaut)

<MUSC : muscles

<NUMn : choix du numéro de corps (0,1,…,Nb_Corps-1) auquel s’appliquent les paramètres

<OMB : ombres portées

<OUT : outils, cliquer sut bas (bassin) ou cra (crane)

<PAN : pantalon, PANt,r,v,b : taille,couleur

<PEAU : peaux

<PER : période, <PERn : valeur

<PIE : fuite au pied

<PIL : active/désactive la pile d’effets

<PLU : plumes

<POS : animation positions, POSnn : fichier nn.pos, <POS_nn : ajoute nn.pos

<PROn : programme (LIB, FUN, TRA, FLY, VEL) de période n, <PRO0 inhibe

<PUL : animation pulsation, PULc : redéfini le coefficient c

<PUP : pulsation permanente (s’ajoute au type courant),  PUPc : redéfini le coefficient c (entre 0 et 1), PUP0 : inhibition

<RAC : fuite au rachis

<RAP : effets automatiques rapides.

<REGr : regard=r

<RES : animation réseaux, RESnn : fichier nn.res, <RES_nn : ajoute nn.res

<RUB : rubans

<SDN : animation système non linéaire

<SIM : capteur simulation

<SOL : sol

<SOM : choisir un élément et un sommet

<SOU : capteur souris

<SPEn : spécial n (-1 : off, 0,1,… : numéro n)

<SQU : squelette

<SQ_MU : squelette + muscles

<SQU_MU_PE : squelette + muscles + peaux

<STO : stop image caméra (IMA)

<STR : string, STRr,v,b : couleur

<SUR : surface

<TRA : programme trapéziste (au trapèze)

<VAR : vue variable

<VEC : vecteur équilibre

<VEL : vélo

<VOI : voile, VOIr,v,b : couleur

<VOL : volume

<VPEv : vitesse maximum de la période (4 par défaut).

 

5-4-4 Nombres

 

0, 1, …,9 ou <n si n>9

Effets programmés (dans change_Effet() du fichier uti/reseau_int.fon)

Si MAN a été invoqué ces numéros sont affectés à des numéros de positions (POS, GES, DIR).

 

5-4-5 Lettres

 

a,b, c, f, g, h: effet programmés, _b(), _c() dans effets/effets.fon.

d : dilatation

e : extension

m : motion blurr, modifiable par BLUn

n : nette.

r : rotation.

u, v, w, x, y, z: effets programmés.

 

A : raccourci pour AFF->ANG.

C : choix de la couleur sur 3 échelles (rouge, vert et bleu) des vêtements (voir VET).

G : gare l’image courante en Nom_Image1.jpg, … (Nom_Image = « A »).

H : help

I : réinitialisation des paramètres à leurs valeurs par défaut.

K : oui non col.

N : désignation des éléments affichés sur les échelles :

                        Pet, pes : Peaux de la tête et du sexe.

                        SQUEL, MUSCL, SQMUS, PEAU : Squelette, muscles, muscles + squelette et peau.

                        mus_g : Muscles gauche, mus_d : Muscles droite

pea_g : Peau gauche, pea_d : peau droite.

                        bass : Bassin

vent : Ventre

crane : Crane

rach : Rachis

Sein_g : Sein gauche, Sein_d: Sein droite

epa_g: Epaule gauche, epa_d: Epaule droite

cla_g : Clavicuel gauche, cla_d : Clavicule droite

te3_g, te2_g, te1_g, te3_d, te2_d, te1_d: Muscles de la tête.

co3_g, co2_g, co1_g, co3_d, co2_d, co1_d: Muscles du cou..

mai_g : Main gquche, mai_d: Main droite

fem_g : Fémur gauche, fem_d : Fémur droite.

tib_g : Tibia gauche, tib_d : Tibia droite.

pie_g : Pied gauche, pie_d : Pied droite.

ort_g : Orteil gauche, ort_d : Orteil droite.

off_n: Supprime l’affichage de tous les éléments.

mac : Machoire

AFF_COU : Affiche des couleurs différentes sur les éléments.

O : fait VUE->FIX et affiche les échelles :

                        ni nombre d’images de l’ajustement automatique (ALT).

                        coe coefficient de l’ajustement automatique (ALT).

                        ouv ouverture de la correction

                        x, y, z rotation de l’œil.

P : visualisation et modification des paramètres d’animation :

                        chute, deh (déhanchement), saut (sauter), pesa (pesanteur), reac (réaction)

                        coe1, coe2, coe3, coe4 de ‘traj rota coe’

                        ajust (influence des capteurs sur les mpuvements)

                        visc (viscosité des ‘forces)

rot ( roty du corps)

resp (respiration)

Si PUL ou PUP est actif coe pup permet de choisir le coefficient, ou <PULc, ou <PUPc

En mode verbose ($) :

                        com : Compensation par équilibres et vitesses, modifiable par COMn

                        mod  (module capteur)

                        Description des corps : corps=num sexe=s age=a taille=t ext=e

Q : quitte le programme (inhibé par sécurité, validé par l’option de lancement qui).

V : visualisation des capteurs, plus d’informations en mode verbose ($).

Z : appelle toutes les fonctions i_XXX() de réinitialisations.

 

5-4-6 Touches spéciales :

 

- (moins) :

            Si CAP->PER a été invoqué diminue la période (P per sur le menu de contrôle).

            Si CAP->SEU a été invoqué diminue le seuil de filtrage (S seu sur le menu de contrôle).

            Sinon Diminue le coefficient de capteur C coe  sur le menu de contrôle.

+ (plus) :

            Si CAP->PER a été invoqué augmente la période (P per sur le menu de contrôle).

            Si CAP->SEU a été invoqué augmente le seuil de filtrage (S seu sur le menu de contrôle).

            Sinon augmente le coefficient de capteur(C)coe sur le menu de contrôle.

 ( (parenthèse ouvrante) :

Diminue l’incrément de période (augmente la vitesse)  (V)inc sur le menu de contrôle .

) (parenthèse fermante) :

Augmente l’incrément de période (diminue la vitesse)  (V)inc sur le menu de contrôle .

$ (dollars) :

            Mode verbose.

: (deux points) :

            Supprime les affichages des menus.

; (point virgule) :

            Menu de contrôle.

* (étoile) :

Centrage

                       

6 Effets programmés

 

6-1 Par numéros :

 

Cliquer sur EFF->NUM et choisir un numéro sur l’échelle ou taper son numéro n (si n>9 faire <n et ENTER).

Cliquer sur AMP : effet variable entre 1 et 13, ou taper <AMPn1,n2 (variable entre n1 et n2)

Cliquer sur LEN: effets lents variable entre 6 et 9, ou taper <LEN

Cliquer sur RAP effets rapides entre 1 et 5, ou taper <RAP

CYCa,b,c : cycle entre a et b de période c

PIL : Pile d’effets à la souris

 

6-2 Par lettres :

 

Cliquer sur EFF->LET et choisir une lettre c ou taper le caractère c

a : programmé

b : programmé

c : :programmé

d : Dilatations en fonction du capteur

e : Coefficient d’extension en fonction du capteur (choisir sur l’échelle coe_ext des coefficients)

f : Filtre maximum / minimum (fad-out et fad-in sur les capteurs)

g : programmé

h : programmé

i : programmé

j : programmé

k : programmé

l : désactive/active les lumières

m : motion blur on (flou)

n : motion blur off (net)

o : programmé

p : Fil de fer

q : Plein

r : rotation

s : programmé

t : programmé

u : programmé

v : programmé

w : programmé

x : programmé

y : programmé

z : programmé

 

6-3 Effets spéciaux

 

Taper <SPEn : effet spécial numéro n

0 : vêtements variables

1 : type d’animation variable

2 :  type d’animation et effet variables

 

6-4 Cycles

 

Taper <CYCa,b,c : effets cycliques entre a et b de période c (voir 4-6)

 

6-5 Pile

 

Cliquer sur EFF->PIL ou taper <PIL: effets spéciaux dans Buf_PIL déclenchés par la position en x de la souris, en mode menu de contrôle l’échelle apparaît en bas, un petit rectangle vert indique la position de la souris. Pour sortir du mode pile retaper <PIL.

 

6-6 Programmes

 

Taper <LIB : danseuse libre (au sol).

Taper <FUN : funambule (sur une corde).

Taper <TRA: trapéziste.

Taper <FLY: vol.

Taper <VEL : vélo.

 

Taper <PROn : variation cyclique du programme (LIB, FUN, TRA, FLY, VEL) de période n ., <PRO inhibe ce mode. En mode verbose ($) on peut choisir la période sur l’échelle prog.

 

7 Construction d’un réseau

 

7-1 Réseau multicouches une entrée caméra

 

1) Lancer image_15.js

puis lancer Webcam de LabTec (taille 160 X 120) et amener l’image de la caméra en bas et à gauche de l’écran

2) Lancer demo_cam.js pour une silhouette blanche sur fond noir, ou demo_cam_blanc.js pour une silhouette noire sur fond blanc, ou cam_dif.js pour une saisie des différences (environnement difficile).

3) Cliquer sur CAP

Dans ce menu cliquer sur CAM : Active la caméra

Cliquer sur RES : Passe dans le menu réseau

Cliquer sur IMA : Affiche l’image de la caméra (en bas et à gauche). Pour changer la taille de cette image cliquer sur le bord haut et déplacer la souris.

4) Cliquer sur RES

            Dans ce menu cliquer sur CAP pour associer un réseau au capteur caméra

Puis cliquer sur AFF, pour afficher les neurones et leurs connexions

puis sur VIS, pour visualiser le réseau

puis sur CAM, pour déclarer un réseau dont l’entrée est l’image caméra

puis sur INI, pour détruire tous les réseaux

on peut modifier les paramètres en cliquant sur PAR (voir 6-2-2)

et enfin sur ACQ, pour déclencher l’acquisition. Le réseau apparaît dans une fenêtre : Il y a autant de neurones d’entrées (en rouge) que de pixels sur l’image et autant de neurones de sorties (en blanc) que de contrôles musculaires. La couche cachée est représentée en rose.

On peut voir le fonctionnement de ce système artificiel de perception en déplaçant un petit objet lumineux devant la caméra et en constatant l’activation des neurones d’entrée (en rouge) qui agissent sur la couche cachée (en rose) laquelle agit sur la couche de sortie (en blanc) qui sont les neurones moteurs. En cliquant sur VOI on connecte les neurones moteurs aux muscles, ce qui a pour effet de faire bouger le personnage. Mais ces mouvements sont désordonnés, car il n’a rien appris. Le but de cette expérimentation est justement de lui faire acquérir certaines connaissances par apprentissage. Pour cela on va construire un certain nombre de « couples d’apprentissage » constitués :

D’une entrée sous la forme de l’image caméra d’un expérimentateur réel montrant une position.

Et d’une sortie sous la forme d’une position du personnage virtuel

L’apprentissage est réalisé par l’algorithme dit de la « rétropropagation de l’erreur » fonctionnant de la façon suivante :

            La matrice des poids (valeur des synapses joignant les neurones 2 par 2) est initialisée aléatoirement.

            La position d’entrée est présentée au réseau qui calcule la position de sortie via la matrice. La différence entre cette position calculée et la position souhaitée est interprétée comme une erreur servant à corriger la matrice des poids. De proche en proche cette erreur diminue et le réseau « apprend ». Ce même apprentissage fonctionne lorsqu’il y a plusieurs couples d’apprentissage.

            Nous allons prendre quelques photos de positions d’entrées, pour cela :

            Dans ce menu RES cliquer sur PHO et aller se placer de façon à apparaître droit dans l’image. Attendre que 3 photos soient prises. 3 positions d’apprentissage apparaissent  (voir la figure 1 sur laquelle on peut voir 3 petites photos en entrées et 3 positions de sorties en rouge). On peut modifier le temps d’attente dans RES->PAR->max_photo et le nombre de photos prises dans RES->PAR->nb_photo.

5) Cliquer sur SET du menu secondaire, puis sur la 2ème position (échelle du bas), le personnage s’accroupit. Puis cliquer sur PHO. Aller se positionner en position accroupie devant la caméra et attendre que 3 photos soient prises. Comme ci-dessus 3 nouvelles positions d’apprentissage apparaissent .

6) Lancer l’apprentissage en cliquant sur FIN. La courbe des erreurs doit descendre et tendre vers zéro. On peut cliquer sur VOI pour voir l’effet de l’apprentissage.

7)      Cliquer sur STOP pour arrêter l’apprentissage

 

8)      Pour tester le réseau cliquer sur VOI  et aller se placer devant la caméra et se mettre dans des positions apprises (ici debout et accroupi), le personnage doit les imiter.

9)      Définir d’autres couples d’apprentissage. Pour cela cliquer sur ACQ, choisir la troisième position, puis cliquer sur PHO et aller se positionner en extension devant la caméra et attendre que 3 photos soient prises. Continuer en 5).

 

Figure 1 : 3 positions debout et 3 positions accroupies ont déjà été faites, l’acquisition d’une position écartée est en cours

 

 

Figure 2 : Début d’apprentissage (erreur de 26% après 212 essais)

 

 

Figure 3 : Amélioration de l’erreur qui est tombée à moins de 1% (après 791 essais)

 

 

Figure 4 : Le personnage prend une position proche d’une position apprise, bien que l’exemple écarté ne soit pas exactement celui proposé en apprentissage (voir figure 1)..

 

7-2 Saisie continue

 

RES : Rentre dans le module réseau neuronal

Cliquer sur squ dans l’échelle « off anal val squ », ce qui a pour effet de diviser l’image en zones d’influence :

            Entre le bord gauche et le segment vert en haut et à gauche : Bras droite

            Entre le bord gauche et le segment vert en bas et à gauche : Jambe droite

            Entre le bord gauche et le segment jaune: Ignore cette partie de l’image

Ces zones sont modifiables en cliquant dans les rectangles jaunes et en déplaçant la souris.

Aller se placer devant la caméra de façon à ce que chaque membre se projette dans la zone correspondante. Si le réglage est adéquate, bouger les membres provoquera les mêmes mouvements sur le clone.

RES->PAR->max_photo=12 : Il sera pris 2 photos par seconde

RES->PAR->nb_photo=20 : Il y aura 20 images dans le film

RES->CON : Lance la saisie continue, on dispose de 8 secondes pour aller se positionner. Il suffit de bouger, une photo par seconde est prise jusqu’à la fin des saisies.

RES->FIN : Lance l’apprentissage

RES->STOP : Stoppe le processus

RES->VOI : Aller se placer devant la caméra et bouger. Le personnage se comporte comme lors de l’apprentissage.

 

7-3 Entrée audio

 

7-3-1 Validation de l’audio

Lancer anyflo/applications.js

Cliquer sur CAP

Cliquer sur AUD () pour valider la source audio

Enfoncer la touche V : Des échelles apparaissent, en particulier une fenêtre noire dans laquelle est affiché (en rouge) le signal audio.

Enfoncer de nouveau la touche V  pour faire disparaître ces échelles.

 

7-3-2 Construction d’un ensemble d’apprentissage

Cliquer sur AFF, pour afficher les neurones et leurs connexions

Enfoncer la touche V pour visualiser le réseau

puis cliquer sur INI, pour détruire tous les réseaux

et enfin sur ACQ, pour déclencher l’acquisition. Le réseau apparaît dans une fenêtre : Il y a autant de neurones d’entrées (Input en rouge) que d’éléments contrôlés par le réseau et autant de neurones de sorties (Output en blanc) que de contrôles musculaires. Les 3 couches cachées (Hidden) sont représentées en rose.

Pour construire un couple d’apprentissage procéder comme suit :

1)      Définir des positions successives en manipulant le personnage (touche A et SET du menu secondaire) puis les validant en cliquant sur POS.

2)      Au fur et à mesure on voit le réseau se construire : Les entrées sont visualisées en rouge et les sorties sont visualisées en vert

3)      Pour manipuler le personnage enfoncer la touche  A: Apparaissent un certain nombre d’échelles permettant de modifier des éléments:

            Cra pour le crane, Mac pour la machoire, Rachis, Bassin

            Main, Radius, Humerus, Femur, Tibia, Pied, Orteil à gauche et à droite.

Cliquer sur une échelle fait tourner cet élément autour de l’axe ,(az,ay,ax) positionné en (1,0,0) par défaut.

On peut revenir à la position neutre en cliquant sur ZER du menu secondaire.

4)      Pour manipuler plus rapidement le personnage on peut cliquer sur SET du menu secondaire, il apparaît une échelle au bas de l’écran graduée de 0 à n-1, où n est le nombre de positions par défaut définies dans le fichier pos_defaut, cliquer sur l’une des graduations positionne le personnage.

5)      On peut aussi cliquer sur ALE du menu RES, ce qui définit une position aléatoire.

 

7-3-3 Apprentissage

Cliquer sur FIN du menu RES. On voit l’algorithme de la rétropropagation de l’erreur progresser, la courbe d’erreur doit normalement tendre asymptotiquement vers zéro.

Cliquer sur STO stoppe le processus.

 

7-3-4 Compléter un ensemble d’apprentissage

Recliquer sur ACQ et poursuivre comme en 6-2-3.

 

8 Expos

 

Ce système a été montré :

A ARCO, Espagne Madrid, février 2005

Centre Saint Exépury de Reims, février 2005, février 2006

Université de Toulouse Le Mirail, colloque « Corps en mutation », 9-10-11 mars 2006.

 

9 Développements en cours

 

9-1 Mouvements

 

Acquisition, non pas de positions fixes, mais de mouvements avec la caméra, pour le moment cette fonctionnalité est réalisée par RES->CON.

 

9-2 Apprentissage compétitif

 

Utilisation des réseaux de Kohonen pour reconnaître de la musique sans professeur.

Dans c:/demos0/neurone.8.3/uti/demo_neurone.fon voir un réseau de Kohonen. Pour le moment cette fonctionnalité est réalisée par RES->KOH.

 

10 Fonctionnements particuliers

 

10-1 Funambule

 

Tous les fonctionnements sont possibles via les menus, cependant, pour des applications particulières, on peut se mettre dans un directory particulier de demos0 :

 

funambule_itr

Pour une funambule interfacée avec l’Intertrax, permettant l’étude de l’équilibre déséquilibre via des fichiers Memoire.

 

funambule_cam

            Il s’agit d’une version plus ancienne (2004), pour une funambule interfacée avec une WebCam, permettant une installation interactive pour tout public.

 

10-2 Paramètres de lancement

 

Les fichiers *.js lancent la fonction demo_reseau avec des options particulières. Voici la liste de ces options :

 

Choix de la langue :

fra: Français (par défaut)

eng: English

 

Message de la démo

            tim=0,t2,1 :  (0,0,1 par défaut)

                        t2=temps (en nombre d’images),.

 

Définition des personnages

Le nombre de personnages est déterminé par le nombre de paramètres de sex:

            sex=s1,s2,…: Sexes des personages (0: Feminin, 1: Masculin)

            age=a1,a2,…: Ages (entre 0 et 100 années) (18 par défaut)

gen=g1,g2,…: Genres (0: Humain, 1: Cheval) (0 par défaut)

            tai=t1,t2,… : Tailles (entre 0 et 1) (1 par défaut)

            gro=g1,g2,…: Grosseurs entre .8 et 1.2 (1 par défaut)

            ext=e1,e2,…: Extensions 0, 1 ou 2 (0 par défaut)

            lon=l1 ?l2,… : Longueur des jambes entre .8 et 1.2 (1 par défaut)

            vis : Visage

 

Type de l’animation

            res=nr1,nr2,…: Noms des fichiers nr.res en animation par des réseaux neuronaux.

            mul=nr1,nr2,…: Noms des fichiers nr.res en animation par des réseaux neuronaux multiples

Ces noms sont D1,B2,R1,B2,B3,B4,E1,E2,E3,E4,E5 par défaut

imm: Immobile (par défaut) (ANI->IMM)

            aut: Automatique (ANI->AUT)

            mou: Mouvements (ANI->MOU)

            for : Fourier (ANI->FOU)

            sdn: Apprentissage (ANI->SDN)

            pes=p : Pesanteur (5 par défaut) (COE)

            imp=i : Impulsion (0.1 par défaut) (COE)

            mar=marcher : Fichier marcher.res (pour Marcher=1)

            reg=r : 1 (spectateur par défaut), 2 (devant)

 

Types d’affichage;

            bro: Active les brouillards (AFF->BRO)

            tra: Active les transparences (AFF->t)

            fon: Active les variations du fond (AFF->FOND)

            map: Active les mappes (AFF->MAP)

            omb: Active les ombres portées (AFF->OMB)

            squ: Squelette (AFF->SQU)

mus: Muscles (AFF->MUS)

            pea: Peau (par défaut)  (AFF->PEA) 

            pos=np : Nom du fichier des positions (pos_defaut par défaut)

            pes=p: Pesanteur (0 par défaut)

            sol: Danseur sur un sol (par défaut)

            cie=n: Numéro du ciel actif 50 par défaut: OFF) (AFF->échelle num)

            cor:  Funambule sur une corde

 

Choix des capteurs

            sou: Souris (CAP->SOU)

            aud: Audio (CAP->AUD)

            fou: Audio (analyse de Fourier) (CAP->FOU)

            sim=s: Simulation (n=-2,-1,0) (CAP->SIM)

            itr: Intertrax (CAP->ITR)

kro: Kroonde angulaire (CAP->KRO)

            krg: Kroonde gyroscopique (CAP->KRG)

            cam=c: Caméra de luminosité c (-1: Blanc/noir, 1: noir/blanc) (CAP->CAM)

            cal: Demande de calibration au lancement

            cap=n: Variation du capteur selon la dérivée nième : linéaire(0), vitesse(1), accélération(2) , secousse(3).

 

Habillages

            che=c: Longueur des cheveux (entre 0 et 2).

            sho: Short (VET->SHO)

            jup: Juppe (VET ->JUP)

ail: Ailes (VET ->AIL)

            bot: Bottes (VET ->BOT)

            rub: Rubans (VET ->RUB)

voi: Voile (VET ->VOI)

            plu: Plumes (VET ->PLU)

            eff: Effets programmables automatiques (EFF->EFF)

            bbb: Effet b activé (EFF->b)

            rot: Rotation automatique (EFF->r)

 

Choix du type de la vue

            fac: Face (VUE->FAC)

            gau: Gauche (VUE->GAU)

            dro: Droite (VUE->DRO)

            cot: Côté (VUE->COT)

            des: Dessus (VUE->DES)

 

Choix du genre de la vue

            fix: Fixe (VUE->FIX)

            var: Variable (VUE->VAR)

 

Sons

            son=s1,s2,…: Noms des fichiers sons .wav

            seu=s: Seuil

            mem=m: Stocke l’animation dans le fichier m (Memoire par défaut)

            jou=m: Joue l’animation en lisant le fichier m (Memoire par défaut)

 

Effets programmés

            eff : Effets programmés ON, eff=n le premier effet est le numéro n

            typ=t : Type_Effet=t (0 par défaut), l’effet n (entre 0 et 9) appelle l’effet n+10*Type_Effet

 

Programmes

            pro=n : Prog2=n

 

Spéciaux

            Spe=n: Special=n

            Ser: Série de spéciaux

 

Autres

            mes=1,2,… : Messages (à changer dans la fonction MESSAGE() du fichier

 

uti/reseau_int.fon)

            ser : Enchaîne les spe[0,6]

            pro=p (0 funambule, 1 danse, 2 cage, 3 cage2)

            ver: Mode verbose ($)

            ???: Demande: sexe, age, ext, cheveux, taille, longueur, gros, visage et genre au lancement (activer la fenêtre anyflo par Alt_Tab).

 

 

11 Programmation

 

11-1 Le corps

 

Dans le dossier corps, le fichier corps.fon :

            externes_corps() : Variables globales définissant un corps.

            set_corps() génère Nb_Corps corps.

Un corps est constitué :

D’un squelette articulé de 107 os connus par leurs noms :

Orteil_g, Orteil_d, Tibia_g, …

D’un système musculaire de 30 muscles attachés aux os, se déformant selon leurs mouvements et connus par leurs noms :

Bras_1_g, Bras_2_g, …Mu1_g, Mu2_g, …, Trapeze_g, …

De 21 peaux jointives enveloppant automatiquement les éléments précédents.

 

      

Squelette, muscles, peaux et rendu

 

De réseaux neuronaux dont les entrées sont connectées aux capteurs et dont les sorties sont connectées au système musculaire et assurant interactivement les mouvements du corps. Ces réseaux peuvent soit être entraînés (apprentissage supervisé) soit s’adapter de façon autonome (apprentissage non supervisé), voir paragraphe 7.

D’autres méthodes d’animation sont également implémentées : Branchement direct des capteurs sur des procédures programmables, trajectoires, capture de mouvement, etc...

Au lancement du programme des options permettent de choisir l’age, le sexe et différentes autres propriétés (grosseur, taille, métissage avec des bêtes, etc…).

 

11-2 Les initialisations et l’interaction

 

Les fichiers *.fon se trouvent dans le dossier uti 

 

11-2-1 : Programme principal

 

demo_ext.fon : externs() variables externes

demo_reseau.fon demo_reseau() fonction main

 

11-2-2 : Générations

 

reseau_gen.fon :

init_0(w,dd): Acquisition des paramètres de lancement w, dd = date.

_INI_PAR_0() : Première initialisation des paramètres.

_INI_PAR_1() : Réinitialisation des paramètres à leurs valeurs par défaut.

Lire_messages() : Lit les messages selon la langue Langue (0 : français, 1 :anglais) dans les fichiers uti/reseau_fra ou uti/reseau_eng.

Les menus sont définis par :

            Menu_NOM= « _NOM ;f1 ;f2 ;… » : Menu NOM de fonctions de noms f1, f2,

            Fonc_NOM : Liste des Nb_NOM fonctions

            Val_NOM : Flags des fonctions.

            Flag_NOM : Flags des fonctions.

            Text_NOM : Liste des noms des fonctions

            Help_NOM : Help du menu NOM

            Err_… : Messages d’erreur

Générations diverses :

            gen_Sol() : Sol et corde pour la funambule

            gen_Ciel() : Cieux

            gen_Cube() : Cube de réflexion

            gen_Cage() : Cage

            gen_Trapeze() : Trapèze

Différents utilitaires

 

11-2-3 : Interaction

 

reseau_int.fon

F0() : Appelée une seule fois

            Génération des menus : interaction generer menu …

            Fonctions associées au clavier : interaction ascii…

            Moyennes : interaction moyenne…

            Initialisations en fonction des flags : if(Sem_…

            Collisions selon Prog (Sol ou Corde)

F1() : Exécutée avant traj

F2() : Exécutée avant dynamique

            Lit les capteurs

F3() : Exécutée avant collision

            Traite Special

F4() : Exécutée avant aff

            Gère les attaches

            Gère les vêtements (Sem_…)

F5() : Exécutée avant swap :

            Affichage sur l’image, gestion de l’interaction à la souris

            Type_Message : Messages de MESSAGE()

            Prog2 : 0 (Funambule), 1 (Danseuse), 2 (Cage), 3 (Cage2)

            Automappe Sem_Mappe

            Affichages selon Verbose

            Affichages des réseaux selon Type_Reseau

            Affichages des capteurs selon Type_Capteur

            Ecriture du fichier equilibre

Différents utilitaires

par_num() : Echelles de ANG

par_set() : Echelle de SET

par_œil : Echelle de ŒIL

par_ang : Echelle de ANG

par_coe : Echelle de COE

par_bug : Echelle de BUG

Menus :

            Menu_INT : Menu principal _INT()

            Menu_ANI : Animation _ANI() et fonctions associées :

                        _IMM() : Immobile

_GES() : Gestes

_AUT() : Automatique

_MUL() : Réseaux multiples

_GO() : Impulsion aléatoire

_RESP() : Respiration

ANI_FOU() : Fourier

VIS_ANI() : Visualisation

_MOD() : Modification à la souris

_DIR() : Directive en trajectoire

DYR() : Directive dynamique

_MOU() : Mouvements (execmou() de reseau_ani.fon)

_DUO() : corps>0 asservis au corps 0

_SDN() : Résonance Periode <-> variations du Bassin (anim_app() de reseau_ani.fon), ANI->VIS : Contrôle des paramètres :

capt : Période du capteur

corps : Période du bassin

erreur : abs(periode-bassin)

nb : Nombre d’erreurs mémorisées

err : Correction

moy : Moyenne Bassin

ini : Réinitialisation

Variations des périodes des éléments animés

Numéros des éléments animés, si l’un d’eux est cliqué :

phase : Variations dans l’espace des phases (erreur,rota) de cet élément.

            Menu_VET : Vêtements _VET() et fonctions associées :

                        _CHE() : Cheveux

_COI() : Coiffure

_STR() : String

_SHO() : Short

_CHA(): Chaussettes

_GAN(): Gants

_JUP() : Jupe

_GIL() : Gilet

-AIL() : Ailes

_BOT() : Bottes

_BIJ() : Bijoux

_PAN(): Pantalon

_RUB(): Rubans

_VOI(): Voile

_PLU() : Plumes

_FIL() : Files

            Menu_PRO : Programmation _PRO() et fonctions associées :

                        _EFF() : Effets

                        _SPE() : Special

                        _VAR() : Couleurs variables en fonction du fond (activer _FON())

                        _ROT() : Déclenche une pirouette

                        _BUL() : Bulles

                        _00(à, -0(), _1(), … , _a(), …: Effets programmés

            Menu_HEL : Help _HEL():

            UTIL : Help utilisateur

            Menu_VUE : Vues _VUE() et fonctions associées :

                        _FAC() : Face

                        _DRO() : Droite

                        _GAU() : Gauche

                        _DER() : Derrière

                        _COT() : Coté

                        _DES() : Dessus

                        _FIX() : Fixe

                        _VARO() : Variable

                        _FOC() : Focale -> 1, Roulis -> 0

                        _PIE() : Fuite -> Num_SUI=Pied_g

                        _GEN() : Fuite -> Num_SUI=Tibia_g

                        _BAS() : Fuite -> Num_SUI=Bassin

                        _RA2() : Fuite -> Num_SUI=Rach2

                        _CRA() : Fuite -> Num_SUI=Crane

            Menu_AFF : Affichages _AFF() et fonctions associées :

                        _COL() : oui-non col

                        _BRO() : oui-non brouillard

                        _SQU() : Squelette

                        _MUS() : Muscles

                        _SMP() : Squelette + Muscles + Peau

                        _PEA() : Peaux

                        _SOL() : Sol

                        _CIEL() : Cieux

                        _CUBE() : Cube de réflexion

                        _CAG() : Cage

                        _FON() : Fond

                        _OMB : Ombres portées

                        _COU() : Utilisée par l’échelle COU de _NUM()

                        _MAP() : Mappes

            Menu_PAR : Paramètres _PAR() et fonctions associées :

                        _FOR() : Visualisation des forces

                        _VIT() : Visualisation des vitesses

                        _CG() : Visualisation des centres de gravité

                        _TES() : Mode pas à pas

                        _SUITE() : Image suivante

                        _DEBUG() : Affichage couleurs des éléments en mode debug

                        _VERB() : Mode verbose

                        _SON() : Sons (fichiers de lire_son())

                        _GARE_IMA() : Gare image

            Menu_CAP : Capteurs _CAP() et fonctions associées Dans reseau_cap.fon

            Menu_FLA : Flags _FLA() et fonctions associées

                        _NUM() : Echelles des numéros

                        _DESIG() : Echelles des désignations

                        _ANG() : Echelles des angles

                        _SET() : Echelles des positions (fichier de lirepositions())

                        _COE() : Echelles des coefficients

                        _COL() : oui/non col

                        _ZER() : Init des angles, des axes et des trajectoires

                        _CEN() : Centrage

_DYNA() : trajectoires  dynamiques/angulaires

                        _BUG() : Echelles des Bugs

            Différents utilitaires

            Ini_Special() : Initialisation en fonction de Special

            Les ombres portées : _OMB(1) : Valide, _OMB(-1) : Inhibe.

            Multi() : Gère plusieurs corps

 

11-3 La fonction de comportement

 

reseau_loc.fon

A chaque corps est associé la fonction locale LOC() appelée à différents niveaux (de 0 à 4) :

0 : Initialisation des variables statiques, ajustement des vêtements

1 :  Avant traj

2 : Avant dynamique, gestion des réseaux (Type_Reseau), des animations (Type_Anim) et des bulles (Sem_Bulle)

3 : Avant collision

4 : Avant aff, gestion des vêtements (Sem_…), retour en bout de corde

det_collision() : Traitement des collisions et des réancrages.

 

11-4 L’animation

 

animer.fon

LOC_1_ANI() :

ANI->IMM : Type_Anim=ANIM_IMM, immobile

ANI->STA : Type_Anim=ANIM_STA, stable

ANI->GES: Type_Anim=ANIM_GES  exec_GES(), gestes

            Dans les fichiers *.ges

ANI->POS: Type_Anim=ANIM_POS  exec_GES(), positions

            Dans les fichiers *.pos

ANI->AUT : Type_Anim=ANIM_AUTO : exec_AUT(), automatique

            Trajectoires calculées da façon à maintenir l’équilibre.

ANI->RES: Type_Anim=ANIM_RES  exec_RES() (dans reseau.fon), réseaux neuronaux

ANI->GEN: Type_Anim=ANIM_GEN  exec_GEN(), génétiques

ANI->MOD: Type_Anim=ANIM_MOD  exec_MOD(),modifications à la souris

ANI->DIR: Type_Anim=ANIM_DIR exec_DIR(), directives trajectoires

            Fichier *.dir

ANI->MOU: Type_Anim=ANIM_MOU exec_MOU(), mouvements

            10 mouvements exec_MOU_[0,9]

ANI->SDN: Type_Anim=ANIM_SDNexec_SDN(), systèmes dynamiques non linéaires

            Les périodes sont ajustées de façon à ce que Bassin soit en phase avec Periode.

ANI->RAN: Type_Anim=ANIM_ RAN exec_ RAN (), randoms

            Trajectoires aléatoires.

ANI->RYT: Type_Anim=ANIM_ RYT exec_ RYT (), rythmes

            4 rythmes choisis aléatoirement: exec_RYT_[0,3].

ANI->MEM: Type_Anim=ANIM_ MEM exec_ MEM (), mémoires

            Dans capteur.fon :

Nb_Puls=Nb_Positions  mémoires de dimension 4*Nb_Num_Positions (a,x,y,z).

Capt_Puls_var est stocké dans la mémoire la plus différente toutes les Dim_Puls images.

Dans animer.fon :

exec_MEM() évalue la particule précédente mem, recherche le numero de la mémoire la plus proche de Capt_Puls_var et décode la particule de même numéro.

ANI->ROU : Type_Anim=ANIM_ ROU exec_ ROU (), roulis du bassin

ANI->PUL : Type_Anim=ANIM_ PUL exec_ PUL (), pulsation directe

ANI->PUP : Sem_PUP=-Sem_PUP,  pulsation directe permanente

ANI->OBS: Type_Anim=ANIM_ OBS exec_ OBS (), observations

 

orienter() : Orientations automatiques (Tête, jambes, bras) .

Zer_anim() : Initialisation avant un changement de Type_Anim

Gestion des sons : lire_son(), sons(), son(), son1(), son_abs()

 

11-5 Les capteurs

 

capteur.fon

externes_capteur() : Variables globales

INI_CAPT_0() : Premières initialisations (appelée une seule fois)

init_capteur(var_capteur) : Initialisation en fonction de Var_Capteur=ordre de la dérivée des variations des capteurs.

init_simulation(t) : Initialisation de CAP->SIM

lire_simulation(t) : Lit le fichier simulation 

F0_Capteur() : Appelée une seule fois, définie les moyennes

_SOU() : Souris

_AUD() : Audio

_FOU() : Fourier

_SIM() : Simulation

_VIS() : Visualisation

_KRO() : Kroonde

_KRG() : Kroonde CG

_ALEA(): Aléatoire

_ITR(): Intertrax

_CAM(): Caméra

_DET() : Caméra en mode détection de mouvement

_VAL() : Variation en valeurs (dérivée 0)

_VIT() : Variation en vitesses (dérivée 1)

_ACC() : Variation en accélérations (dérivée 2)

_SEC() : Variation en secousses (dérivée 3)

_IMA() : Affichage de l’image de la caméra

_ENR() : Enregistrement

_GAR() : Garer

_JOU(): Jouer

lire_capteur(): Lecture des capteurs

 

11-6 Les réseaux

 

reseau.fon

init_reseau() : Premières initialisations

lire_reseau(nn) : Lit le fichier nn.res

gen_reseau() : Génère un reseau

Menu_RES : Menu des réseaux _RESEAU() et fonctions associées :

            _AFF_RES() : Affichage

            _AFF_MAT() : Affichage de la matrice

            _VIS_RES() : Visualisation

            _INI_RES() : Initialisation

            _ACQ_RES() : Acquisition d’un nouveau réseau

            _PAR_RES() : Echelle des paramètres

            _SUP() : Suppression d’un apprentissage

            _EXE() : Exécution à partir de la position courante

            _VOI_RES() : Visualisation des actions des neurone moteurs

            _STO() : Stoppe l’apprentissage

            _ALE() : Position aléatoire

            _POS_RES(): Acquisition d’un apprentissage

            _FIN_RES() : Déclenche l’algorithme de rétropropagation de l’erreur

            _DUP() : Duplication par symétrie d’un apprentissage

            _RES_RES() : Type capteur

            _KOH() : Type Kohonen

            _PHO() : Prise de photos par la caméra

Différents utilitaires

 

11-7 Liste des mots clés (en rouge : menu de contrôle) :

 

Menu principal :

HEL

CAP

RES

ANI

AFF

COR

VET

DEC

VUE

EFF

XXX

EXIT

Menu CAP :

            SOU

            AUD

            FOU

            CAM

            DET

            <IMPn : modifie interaction coe (entre 0 et 1, .5 par défaut).

            ITR

            KRO

            KRG

            MID

            ALE

            SIM

            JOU

            <CAPc (c=1,2,3 : degré de détails)

            <CREc (c entre 0 et 1) écrêtage

            <VPEv vitesse maximum de la période du capteur (4 par défaut)

            PAR

            Sous menu PAR :

                        VAL

                        VIT

                        ACC

                        SEC

                        PER

                        MAJ

                        MOYm période moyenne (m=25 par défaut).

                        CAL

                        SEU

                        ENR

                        GAR

                        DIF

                        SEQ

                        ASS

                        ACT

Menu RES :

            MAT

            PAR

            Sous menu PAR:

                        LIR

                        AJO

                        GAR

                        SUP

                        IMM

                        VUE

                        JAM

                        BRA

                        BAS

                        RAC

                        ADA

                        POS

                        CAP

                        MOD

                        CAC

                        KOH

                        INT

                        MEM

                        INI

            DUP

            INI

            ACQ

            POS

            ALE

            PHO

            POSI

            FIN

            VOI

            STO

            EXE

            SUP

Menu ANI:

            IMM

            STA

            GESnom GES_nom

            POSnom POS_nom

            AUT

            RESnom RES_nom

            GEN

            MOD

            DIRnn

            MOUnum

            SDN

            RAN

            RYT

            MEMnom MEM_nom

            ROU

            PUL

            PUPc

            OBS

            PAR

            Sous menu PAR:

                        GO

                        RESP

                        DYN

                        COL

                        DUO

                        MAN

                        MIM

Menu AFF

            TEST

            SUI

            VEC

            BUG

            LUM

            LDY

            LFR

            NOI

            BLA

            ANG

            SOM

            EDI

            SAI

Menu COR :

            SQU

            MUSC

            SQ_MU

            SQ_MU_PE

            PEAU

            OUT

Menu VET :

            CHEr,v,b

            COIr,v,b

            STRr,v,b

            SHOn,r,v,b

            JUPr,v,b

            GILr,v,b

            GANr,v,b

            CHAn,r,v,b

            BOTn,r,v,b

            PANn,r,v,b

            BIJr,v,b

            AILr,v,b

            RUB

            VOIr,v,b

            PLU

            FIL

            MISr,v,b

            HABr,v,b

            ERE

Menu DEC:

            BRO

            FON

            OMB

            MAP

            MAC

            COU

            SOL

            CIE

            CUB

            CAG

            BUL

            SUR

            VOL

            IMA

            STO

            ECR

            BLUn: Motion blur, la trace est n*(module capteur).

Menu VUE:

            FAC

            DRO

            GAU

            DER

            COT

            DES

            FIX

            VAR

            FOC

            PIE

            KNE

            BAS

            RAC

            CRA

            ALT

Menu EFF :

            NUM

            LET

            AMPn1,n2 : Amplitude des effets (1,13 par défaut).

            LEN

            RAP

            CYCa,b,c

            PIL

            LIB

            FUN

            TRA

            FLY

            VEL

            PRO

            SPEn : Spécial n (-1 : off, 0,1,…,19 : numéro n)

Menu utilisateur XXX modifiable.

 

11-8 Le mode verbose :

 

La touche $ du clavier passe en mode verbose :

            Sem_Verbose=1 ;

            Les informations permanentes sont dans MES (affiché en bas).

            Les informations instantannés sont dans MES_2 (affiché au dessus de MES et de durée 12 images).

            Les visualisations sont activées :

Type d’animation.

Capteurs.

Echelles.

 

12 Utilisation

 

12-1 Contrôle des rythmes

 

12-1-1 Dynamique

 

<IMPn : modifie interaction coe (entre 0 et 1, .5  par défaut).

PUPc: Pulsation directe permanente de coefficient c entre 0 et 1 (s’ajoute au type courant).

 

12-1-2 Période

 

<PERp période constante p.

<MAJ : période majoritaire.

<MOYm : période moyenne m (4 par défaut).

<CALc : calage automatique des coefficients des capteurs (de façon à ce que le module du capteur reste voisin de 1). exemple CAL.5 diminue la sensibilité de moitié, CAL2 la multiplie par 2 (1 par défaut).

 

12-2 Contrôle des mouvements

 

<APPnom : apprentissage adaptatif non supervisé par cohérence de flux

fichier nom.res

adaptatif_1.res par défaut.

<APP_nom : ajoute nom.res.

Il faut des réseaux adaptatifs (de type « voisin »).

<AUT : automatique.

<DIRnom : directives (fichier nom.dir)

Defaut_DIR=A.dir

DIR_nom : ajoute nom.dir.

<IMM : immobile.

<GEN : génétique (nécessite plusieurs corps).

<GESnom : gestes (fichier nom.ges).

      Defaut_GES= »Defaut.ges».

      <GES_nn: ajoute nn.ges.

<MEMnom : génétique sur des mémoires (fichier nom.pos), <MEM_nom : ajoute nom.pos.

 

<MOD : modificationa à la souris.

<MOUn : mouvement programmé numéro n.

<POSnom : positions (fichier nom.pos).

      Defaut_POS= »Defaut.pos» ;

      <POS_nn : ajoute nn.pos.

<PULp : pulsations de coefficient c.

<PUPp : pulsation permanente de coefficient c (s’ajoute au type courant).

<RAN : randomn.

<REDnom : réseaux neuronaux directs (fichier nom.res)

Defaut_RES="A1,A2,A3,A4,B1,B2,B3,Res1,Res2,Res6" par défaut

<RED_nom : ajoute nom.res.

Il faut un capteur de type DAT

<RESnom : réseaux neuronaux (fichier nom.res)

Defaut_RES="A1,A2,A3,A4,B1,B2,B3,Res1,Res2,Res6" par défaut

<RES_nom : ajoute nom.res.

<RYT : rythmique.

<ROU : roulis du bassin.

Il faut des réseaux multicouches (de type « fac »).

<SDN : système dynamique non linéaire.

<STA : statique.