interaction


interaction en temps réel

Principe
Options de lancement
Commandes multiples interaction ...

ascii
coe        cut
debug        displ
end        error
func
image               interpol
limit
menu        message        mouse        move
name        noswap
period        play        pull
radius        rota
screen        see        stock        STOP        swap
texture     time
win        write

Utilisation de la souris
Utilisation de menu
Caractères spéciaux
Voir aussi

Principe

Le mode interaction

Anyflo est un langage graphic évolué utilisant de préférence le mode procédural (écriture de fonctions).
       Une interface temps réel (appelant MainLoop d´OpenGL) est cependant disponible par la commande interaction. Une fois cette commande lancée l´interpréteur n´a plus la main (clic droite->interpreteur permet d´invoquer l´interpréteur pour une ligne de commandes).
Le caractère escape revient au mode interpréteur.
Remarque: la focale est initialisée à 0.8.

Call backs

L´interaction se fait au moyen de l´option interaction func, qui définit des fonctions (écrites en langage anyflo ou en C) exécutables à différents niveaux (call back).

Interaction à la souris

Des fonctionnalités permettent d´interagir à la souris:
displ: pour afficher toutes sortes d´objets.
displ exec: pour exécuter des lignes de commande ou des fonctions.
scale: pour lire des valeurs (à 1, 2 ou 3 dimensions).
menu: pour définir des menus (de style OpenGL ou anyflo).

Options de lancement

call back
format
name
period
rem
Swap
time
Modification interactive de la vue
Modification interactive des volumes
Sauver les images



Calls back
interaction func(n,"Fn"): active le callback Fn() à l´ordre n.

interaction format
Le mesage ANYFLO Michel BRET s´affiche en bas de l´écran par défaut. L´ option interaction format("ANYFLO Michel BRET"): permet que ce message ne s´affiche pas.

interaction name
interaction name("ttt"):
       affiche le message ttt au lancement pendant 400 images.
       interaction name("ttt",t): affiche le message pendant t*400 images (t >= 1).

period
interaction period(p) redéfinit la fréquence d´affichage.

Swap

interaction("noswap"):
       swap est inhibé (l´image est fixe).
interaction("swap"):
       swap est actif.

Modification interactive de la vue

interaction("rotxz_eye"):
       le bouton gauche de la souris permet de modifier le rotx et le roty de l´oeil.
interaction("rotxy_eye"):
       le bouton gauche de la souris permet de modifier le rotx et le rotz de l´oeil.
interaction("tran_eye"):
       le bouton gauche de la souris permet de déplacer l´oeil.
interaction("ini_view"): initialise la vue à ses valeurs par défaut.
illum(r,v,b:
       couleur du cadre (blmanc par défaut).
limit(x1,y1,x2,y2):
       saisies limitées au cadre (x1, y1, x2, y2) qui est affiché.
coe(c):
       multiplie les angles et les déplacements par c (1 par défaut).

Modification interactive des volumes

interaction("tran"): le bouton gauche de la souris permet de déplacer des volumes désignés.
Même chose pour interaction("rota"), interaction("rotx"), interaction("roty") et interaction("rotz").
Sauver les images
interaction write("nnn.ext"):
       les images successives seront garées sous les noms nnn0001.ext, nnn0002.ext, ...

Remarque: ces options peuvent être invoquées après être rentré dans le mode interaction.

Menus en cascade
       interaction menu("f1 f2 ...")
              Permet de définir des menus en cascade associée au bouton droit de la souris:
(bouton droit) -> menu -> f1, ...

Commandes multiples interaction...

interaction

Lance le mode interaction. Appelé dans ce mode avec des
options.


ascii
coe        cut
debug        displ
end
       error
func
limit
menu        mouse
name        noswap
play        pull
radius
screen        see        stock        STOP        swap
time
win        write

interaction displ

interaction displ vol; retourne les numéros des volumes affichables.
interaction displ vol(id); seuls les volumes id seront affichés.

interaction ascii

edit interaction ascii
ascii abs
ascii format
ascii func
ascii poi
ascii write

interaction ascii

En mode interaction retourne le code ASCII d´une touche du clavier en lecture non bloquante, sauf:
ESCAPE qui sort d´interaction et > qui initialias le buffer (utile si une touche de interaction ascii("c") func("f") est perdue).
! commençant une chaine interprétée avec ENTER.
Si le premier caractère est < (redéfinissable par interaction ascii format), la lecture attend un ENTER.
Les options d´affichage sont valables.
Remarque:
interaction ascii=0: initialise le buffer.
interaction ascii="c": met c dans le buffer.

interaction ascii abs

Retourne la caractère tapé au clabier.

interaction ascii format

Retourne le caractère c (< par défaut) de lecture au clavier par la commande:
nn=interaction ascii ...;
interaction ascii format("c")
       Redéfinit le caractère c.
Remarque:
on peut remplacer "c" par son code ascii.
Par exemple interaction ascii format("A") est équivalent à interaction ascii format(65).

interaction ascii("c") func("f")

En mode interaction associe la fonction f au caractère c. La fonction f sera exécutée chaque fois que la touche c sera enfoncée.

interaction ascii("c") func

Retourne le nom de la fonction associée à la touche c du clavier.

interaction ascii func("f")

Retourne le caractère c du clavier associé à la fonction f.
Remarque:
Cette propriété se déclare typiquement une seule fois dans une fonction interaction func(0,"f0").
interaction ascii("ccc") func("f")
       En mode interaction associe la fonction f à la chaîne ccc. La fonction f sera exécutée chaque fois que la chaîne <ccc sera rentree suivie d´un retour charriot.
Remarques:
1) <ccc x exécute f(x)
2) <ccc x y exécute f(x,y)
3) !ldc exécute la ligne de commandes ldc
Exemple: !fff(): exécute la fonction fff()
<4) interaction ascii format("k"); remplace < par k.

interaction ascii("g") write name obj

Retourne le nom des objets obj associés à la touche g.

interaction ascii write name("nnn")obj

Retourne le caractère associé aux objets obj de nom "nnn"

interaction ascii("g") write name("nnn")obj

Asocie la touche g à write obj name(nnn).
Avec les options de write image pour les images.
Remarque: les interaction ascii ... sont détruits en entrée et en sortie du mode interaction, il convient donc de les déclarer dans une fonction F0.
Options particulières:
name("nnn.eee"): les objets seront stockés sous les noms nnn1.eee, nnn2.eee ... (A1.eee A2.eee ... par défaut).
number(num,ni,inc): ni objets seront stockés sous les noms nnnnum.eee nnnnum+inc.eee ... nnnnum+(ni-1)*inc.eee (par défaut ni=25, num=1, inc=1).
number("4D",num,ni,inc): les noms seront numérotés sur 4 chiffres.
Exemples:
interaction ascii("g")write name("A.bmp")image number("4D",10,ni);; les images (plein écran) seront stockées dans les fichiers de noms successifs: A0010.bmp A0011.bmp A0012.bmp ...
interaction write name("A.jpg")image win(.5,-.5, .5,.5)normal number("4D",10,2)format("RGB"); les images (quart inférieur droit) seront stockées dans les fichiers de noms successifs: AOO10.bmp AOO12.bmp AOO14.bmp ... en inversant les composantes rouge et bleue.

interaction ascii("c")poi(x,y)

Exemple:
x=interaction asciiascii("c") poi(-200,-200)rectangle(0,0,0) frame(0,1,0)col(1,1,0);:
Affiche le texte ttt dans un rectangle noir en (-200,200) encadré de vert, x prend la valeur (en ascii) du text tapé après < qui apparait en jaune.

interaction coe

interaction coe

Redonne au coefficient multiplicateur des transformations sa valeur 1 par défaut.

interaction coe(c)

Modifie ce coefficient.
Remarque: les transformations interaction("...") sont multipliées par c.

interaction cut

Retourne le mode -1 (continu par défaut) ou 1 (pas à pas).
Options:
cut(1): passe en mode pas à pas
cut(-1): retourne au mode continu
cut(0): en mode pas à pas avance d´une image
Remarque: S´appelle typiquement dans une fonction à partir d´un menu.

interaction debug

Appelé dans une fonction F5() de type interaction func(5,"f5") , cette commande provoque l´affichage d´une échelle permettant de choisir le nombre de valeurs, avec les options de scale (l´option poi(x,y) est normalisée entre 0 et 1, l´origine est le coin bas gauche de l´écran). Pour chacune de ces valeurs 2 échelles s´affichent: La première permet de choisir une valeur comprise entre -B et B, la borne B étant choisie sur la deuxième échelle.
interaction debug(n)
       Retourne la valeur de l´échelle n (entre 0 et n-1).
interaction debug(n)=v
       Affecte la valeur v à l´échelle n (peut être utilisé dans une fonction écrite en C par: v = Val_Debug[3 * n]).
interaction debug poi=x,y
       Permet de déplacer les échelles (x et y compris entre 0 et 1).
interaction debug NP
       Retourne le nombre d´échelles validées.
interaction debug NP(n)
       Permet de choisir le nombre d´échelles validées (entre 0 et 24).
interaction debug rectangle
       Affiche les échelles en plein (valeur par défaut).
interaction debug frame
       Affiche les échelles en fil de fer.
Remarque: Les paramètres de cette fonction sont accessibles en langage C.

interaction displ

Retourne les numéros des volumes affichés.

interaction displ(num1,num2,...)

Change les numéros des volumes affichés dans cet ordre (permet de traiter les transparences).

interaction displ(0)

Tous les volumes seront affichés.

interaction screen

Retourne la période d´effacement. interaction screen(ni)
       Efface l´écran et le zbuffer toutes les ni images.
Si interaction stock ou interaction write est actif, l´image sera sauvée une image avant l´effacement (permet d´accumuler une animation d´ ordre supérieur.
Options:
func: retourne le nom de la fonction associée aux traj de traj.
interaction animate func("FIA"):
Modifie ce nom.
Remarque: cette fonction sera exécutée après chaque effacement de l´écran.

interaction win

Lance l´interaction avec une fenêtre plein ecran.

interaction end

interaction end mouse

Sort (par programme) du mode interaction mouse.

interaction error

Lorsque interaction est stoppé ajoute l´heure de début et de fin dans le fichier DATE.log.
error(-1): écrit au lieu d´ajouter.

interaction func (callbacks)

f0
f1
f2
f3
f4
f5
f6

interaction func(0,"f0")

Passe en mode interaction en exécutant la fonction f0() une seule fois. Utile pour déclarer des propriétés automatiques.

interaction func(n,"fn") (n>0)

Les fonctions fi() sont exécutées à chaque image dans l´ordre suivant:

initialise meta generate vol à zéro.

f1().

       réinitialise tous les flags:
              poi anc
              normal fac
              normal vertex
              normal fac generate
              normal vertex generate

initialise:
       force vol,
       force rota
       force vertex

Calcule les trajectoires.

f2():.

Exécute:
       collision anc
       meta
       dynamic

collisions

On peut modifier des forces.

f3(): avant l´effacement de l´écran.

Éfface l´écran.

f4().

Exécute:
       local
       limit
       displays images
       computes lights
       displays volumes
       exec interaction
       exec puls
       play audio
       exec play ascii

f5(): après l´affichage (traitement des menus, des échelles, des messages et des textes) et avant le swap.

exec message

f6(): au retour du mode interaction (par escape ou end interaction (utile pour enchainer plusieurs applications).

swappe.

Remarques:
       Ces fonctions sont exécutées à chaque image, sauf f0() qui n´est exécutée qu´une seule fois en début d´interaction. Dans de telles fonctions on peut exécuter n´importe quelle commande anyflo.

interaction write

write directory
write_image
write end
options
write vol

interaction write image

Retourne (im,ni) avec:
       im=numéro de l´image courante.
       ni=nombre d´images.
Remarques:
interaction write image=NIL quand l´animation est finie (permet de tester la fin).
Le nom de l´image est affiché, no edit pour ne pas le faire.

interaction write image number(num1,ni)

Sauve ni images dans les fichiers nnnnum1.eee, nnnnum1+1.eee, ..., nnnnum1+ni-1.eee.
Options:
edit: affiche le nom dans un rectangle noir.
number("4D"im,ni): les fichiers sont indexés avec 4 chiffres.
dim(nx,ny): taille de l´image(dim screen par défaut).
poi(x,yt: position du message (coin bas gauche par défaut), pour ne pas afficher ce message: no edit.
win(x1,y1,x2,y2): sauve la fenêtra (pleine par défaut).

interaction write end


Stops the process of writing.

Options:

abs: ne transforme pas les dimensions en puissances de 2 (pour l´option dim(nx1,ny1,nx2,ny2)).

dim(nx1,ny1): l´image est redimensionnée à (nx2,ny2) (dimensions de l´écran par défaut). (où (nx2,ny2) sont les puissances de 2 les plus proches de >nx1,ny1).
Si l´option abs est présente nx2=nx1 et ny2=ny1.

format("fff"): format de l´images.

name("Anum1.eee Bnum2.eee",n1,n1,num): pour chaque image n1 les fichiers "Anum1.eee et "Bnum2.eee sont lus et interpolés dnas les images numéros num ... (1000000000 par défaut) et utilisées par l´animation d´ordre, puis num1 et num2 sont incrémentés.
Remarque: les champs n1,n1 sont obligatoires.

normal: coordonnées normalisées (entre 0.0 et 1.0).

number(im,ni):
       im=numéro de la première image (1 par défaut).
       ni=nombre d´images.
       number("4D"im,ni): avec 4 chiffres.

win(x1,y1,x2,y2): sauve la fenêtre (x1,y1,x2,y2) (plein écran par défaut).

Notes:
interaction write end: stops the process of writing.
The images stored can be viewed with command play image.

interaction write vol

Same as write image, but for volumes.

interaction image

Permet de gérer l´interpolation continue de textures:

directory
generate
NP
read
var
image vol
image vol number

interaction image read directory("dir1,dir2,...")number(i1,num)

Lit les nbi images du dossier diri dans les images numéros i1i, i1i+1, ..., i2i, with i11, = num.
Options:
animate(ni): nombre d´images interpollées (25 par défaut).
dim(dx,dy): dimension des images lues. num1,num1+1, ...,construit le tableau 5D:
       nbi, * ,*, ii1, ii2
avec:
       nbi = nombre d´images du dossier diri.
       ii1, ii2 = première et derni&egrav;ere image numéros (i1,i1+1, ...).
Options:
animate(ni): nombre d´images interpollées (par défaut 25).
dim(dx,dy): dimension des images.

interaction image(im,im2)read number(num)

Comme précédemment avec les images [im1,im2]=im1;im1+1,...,im2 en mémoire au lieu de fichiers images, construisant les images num,num+1,..., et le tableau d´une seule séquence i1,i1+1,...,i1+num-1.

interaction image generate animate(ni)

Calcule les séqueces interpollées (with ni = nombre d´images interpollées):
d´abord le long des images de chaque dossier:
       im1i, im1i+1, im1i+1, ..., im2i, avec im11=num.
Construit le tableau 5D:
       nbi, im1i, im1i, i1i
puis entre la derniè image de chaque dossier et la première image de chaque dpssier dans le tableau:
       im1i, im1i+1, im1i+1, ..., im2i.
Ce tableau est retourné par
interaction image var.
Sa diemnsion est retournée par interaction image NP.

interaction image directory

retoure le dombre de dossiers.

interaction image var

retourne ce buffer.

interaction image var=v

change ce buffer, doit être de la forme:
       ni,im1,im2,i1,i2
       ni,im1,im2,i1,i2
       ...

interaction image vol

réalise le processus d´interpolation des textures pour tous les volumes.
Options:
image(num1,num2): séquence suivante entre num1 et num2 (par défaut).
image(num1,num2)alea: séquence aléatoire entre num1 et num2.
image(num1,num2)law(num): la séquence suivante est num entre num1 et num2.
vol(id); for the volume id.
vol(id); pour le volume id.

interaction image vol number(seq)

initialise le processus d´interpolation des textures entre la texture courante et la première texture de la séquence seq pour tous les volumes.
Options:
animate(ni): sur ni images (25 par défaut).
vol(id); pour le volume id.

interaction image NP

retourne le nombre de vecteurs de ce buffer .
Options:
dim(dx,dy): dimension des images lues.

interaction interpol

interaction interpol(ni)image(id1,id2)image(id3)

D&eacure;marre interpol(k,1-k)image(id1,id2)image(id3) depuis k=1.0 jusqu´à k=0.0 sur ni images.
Options:
interaction(id): permet de définir plusieurs tels objets avec diverses propriétés.
Remarque:
validate interaction(id)interpol image retourne 0 si le processus est terminé.

interaction limit

interaction limit

Redonne au cadre de la saisie sa valeur 1 par défaut (dimensions de l´écran).

interaction limit(x1,y1,x2,y2)

Modifie ce cadre.

interaction menu

interaction menu
simple
cascade
dynamic

interaction menu(" ")

Peut être utile après un ini graphic pour retrouver les menus.

Menu simple

interaction menu("f1 f2 ...")
       Lorsque l´on clique droit le menu d´interaction apparait. Si on clique droit sur la case menu le menu déroulant f1 f2 ... apparait. Si on clique sur fi la fonction fi() est exécutée.

Menus en cascade

Des menus en cascade peuvent être définis (comme dans OpenGL) des plus profonds jusqu´au menu principal.
Un sous menu sm est déclaré sous la forme:
       menu(">sm f1 f2 ...")
Il pourra être référencé, plus bas sous la forme:
       menu(">...sm ...")
Lorsque l´on clique sur ce menu des cases f1 f2 ...permettent de déclencher les fonctions f1() f2() ....
Exemple:
1) code:
interaction
menu(">sm3 f1 f2")
menu(">sm4 f3 f4")
menu(">sm5 f5 f6")
menu(">sm6 f7 f8")
menu(">sm1 sm3 sm4")
menu(">sm2 sm5 sm6")
menu("sm1 sm2 f6");

2) explications:
/* Niveau 2 */
menu(">sm3 f1 f2")
       Déclare le sous menu sm3 appelant les fonctions f1 et f2.
menu(">sm4 f3 f4")
       Déclare le sous menu sm4 appelant les fonctions f3 et f4.
menu(">sm5 f5 f6")
       Déclare le sous menu sm5 appelant les fonctions f5 et f6.
menu(">sm6 f7 f8")
       Déclare le sous menu sm6 appelant les fonctions f7 et f8.
/* Niveau 1 */
menu(">sm1 sm3 sm4")
       Déclare le sous menu sm1 appelant les sous menus sm3 et sm4.
menu(">sm2 sm5 sm6")
       Déclare le sous menu sm2 appelant les sous menus sm5 et sm6.
/* Niveau 0 */
menu("sm1 sm2 f0")
       Déclare le menu principal menu appelant les sous menus sm1 et sm2 et appelant la fonction f0.

Menus dynamiques

interaction menu("...")menu("...")...
Appelé hors interaction, rentre dans le module interaction en définissant les menus.
Appelé dans le module intercation, permet de redéfinir dynamiquement les menus.
Voir menu_cascade.func.

interaction name

interaction name("ttt",t)

       Affiche le message "ttt" en entrée d´interaction pendant t*50 images (t=1 par défaut).

interaction noswap

Inhibe le swap (l´image est figée).

interaction period

interaction period(np) name("A")

       Initialise la mémoire de nom "A" à np valeures nulles
interaction period name("A") poi(x)
       Empile x et retourne la période du signal x.
Remarque:
       En mode temps réel (interaction) la mémoire "A" est une pile circulaire de valeur courante x.

interaction play edit

interaction play edit(1)
       Active le mode verbose pour les commandes interaction play.
interaction play edit(0)
       Inhibe ce mode. a name="play">

interaction play

interaction play device

Retourne la valeur du capteur, et NIL si l´animation est terminée ou pas encore commencée. il faut avoir fait interaction play device name.

interaction play device name

interaction play device name("name")wait(t)
       Lit les informations du fichier name.cap généré par interaction stock device name("name") et les affecte au capteur. Lit et exécute les commandes stockées dans le fichier name.eff. Si wait(t) est présent, l´animation ne commence qu´au bout de t images (permet de caler une musique).
Remarque: name("name",dimp) permet de préciser la taille des enregistrements (ce qui peut éviter des erreurs de codage de fichier).

interaction play device write

interaction play device name("name")write("ima")
       Fait comme interaction play device name et écrit les images en nomxxxx.bmp (avec xxxx=numéro de l´image).
Pour changer le type d´extension: ext("eee") avec eee=jpg bmp ima raw
Pour changer le format: format("f") avec f=nD, n=nombre de caractères (4 par défaut).
Pouir convoler l´image dans une fenêtre de taimme (dx,dy): dim(x,y)
Cette commande peut être remplacée par:
       interaction play device name("name");
       interaction write image name("ima") ext("bmp")format("4D")dim(x,y);
Voir interaction write image.

interaction play vol

interaction play("fff")vol
       Lit les informations du fichier fff.sto généré par interaction stock name vol et les affecte aux volumes concernés.
Si edit est présent les commandes et leurs valeurs sont affichées. Garer les volumes
      
Voir: interaction write vol.

interaction radius

interaction radius

retourne le rayon de la saisie.

interaction radius(r)

modifie ce rayon.

interaction rota

interaction rota(f,v)vol(id)axis(x,y,z,v1,v2)

Si le volume id a une propriété meta move (les volumes t,t+1,... sont attachés au volume id par interaction move vol(t)vol(id)vertex(v)NP(nv)) alors, quand ils se déttachent , tendent à aligner l´axe de leurs sommets (v1,v2) avec l´axe (x,y,z) au moyen d´un couple (f,v).

interaction message

interaction message

Retourne Buf_key

interaction message("ccc")

Buf_key=ccc
Exemple: interaction message(0); vide Buf_key.

interaction mouse

interaction mouse

Un message CONTINUE (vert) et X (rouge) est affiché en haut et à gauche de l´écran, cliquer sur:
       CONTINUE: avance d´une image.
       X: sort de ce mode d´interruption.
interaction end mouse permet de sortir de ce mode par programme.
Options:
col(r,v,b): couleur du texte text (r,v,b) (blanc par défaut).
font("fff").
poi(x,y): affiche en (x,y) (en haut et à gauche de l´écran par défaut).
frame(r,v,b): affiche un cadre de couleur (r,v,b) (blanc par défaut).
rectangle(r,g,b): affiche un rectangle de coleur (r,g,b) (noir par défaut).
validate: retourne 1 si ce mode est activé, sinon retourne 0.

interaction move

interaction move vol(v2)vol(v1)vertex(v)NP(nv);

Les volumes [v2,v2+nv-1] sont affichés aux positions vertex[v,v+nv-1]vol(v1) quand le volume v1 est affiché.
Une propriété meta move est construite (ne pas la modifier).
Options!
anc: ancrage
force(x,y,z): force additionnele.

interaction move vol(v1)=ind

Inhibe cette fonctionnalité pour le volume v2 d´indice ind dans [0,nv[ en faisant voli=0.

interaction stock

stock edit
stock end
stock image
options
stock_device
stock_vol

interaction stock edit

interaction stock edit(1): active le mode verbose pour toutes les commandes interaction stock <
interaction stock edit(0): inhibe ce mode verbose.

interaction stock end

Stoppe le processus interaction stock obj.

interaction stock image

Retourne (im,ni,dni)
Ramarques:
retourne NIL quand l'animation est terminée (permet de tester la fin).
yes stock est nécessaire.

interaction stock image number(im,ni,dni)

Sauve ni image numéros im à im+ni-1 par incrément de dni (1 par défaut).

interaction stock image (im,ni,dni)name("nnn.eee")

Toutes les dni (1 par défaut) fois l´images est stockée dans l´image numéros im++.

Options:

abs: ne transforma pas les dimensions en puissances de 2 (pour l´ option dim(nx1,ny1,nx2,ny2)).

dim(nx1,ny1): l´image est redimensionnée à (nx2,ny2) (dimensions de l´écran par défaut). (où (nx2,ny2) sont les puissances de 2 les plus proches de nx1,ny1).
si l´option abs est présente nx2=nx1 et ny2=ny1.

name("Anum1.eee Bnum2.eee",n1,n1,num): chaque n1 images les fichiers "Anum1.eee et "Bnum2.eee sont lus et interpolatés dans les images numéros num ... (1000000000 par défaut) et utilisées par l´animation du premier ordre, puis num1 et num2 sont incrémentés.
Note: le champ n1,n1 est obligatoire.


number("4D"im,ni): sur 4 chiffres.

win(x1,y1,x2,y2): sauve la fenêtre (x1,y1,x2,y2) (l´écran par défaut).

Remarques:
interaction end: stoppe ce processus.
Il est recommandé de choisir (nx1,ny1) assez petits pour éviter de provoquer un débordement mémoire (par exemple
Les images stockées peuvent être visualisées avec la commande play
Ou, hors interaction,par:
for(i=1,n){displ image(i)poi(0,0)normal;wait(1/25);} Retourne (im,ni) avec:
       im=numéro de l´image stockée courante.
       ni=nombre d´images stockées.

interaction stock device

stock_device_dim        stock_device_dim        stock_device_name        stock_device_NP
interaction stock device(val)
       Après interaction stock device name permet de stocker la valeur val du capteur.
interaction stock device dim
       Retourne la dimension des enregistrements.
interaction stock device name
interaction stock(ni) device name("fff")
       Permet d´enregistrer (en ascii), à chaque image, les valeurs du capteur dans le fichier fff.cap, ainsi que les interventions interactives (<CCC ou !ccc) dans le fichier fff.eff.
       La commande interaction stock device(val), appelée à chaque image, stocke effectivement les valeurs val du capteur en mémoire. Les fichiers sont écrits à la fin de l´animation, qui est atteinte après ni appels, ou qui est interrompue par interaction stock end.
       Pour rejouer faire play device name("name").
interaction stock device name("nn")module(m)
       Lance l´animation dès que le module du capteur dépasse m (0.1 par défaut), ce qui permet de caler automatiquement n´importe quel capteur, l´animation ne démarrant que lorsque celui-là a une valeur significative.
interaction stock device name("nn")wait(t)
       Lance l´animation au bout de t images (100 par défaut). interaction stock device NP
Retourne le nombre d´images de l´animation

interaction stock vol name

interaction stock(ni) vol name("name") Stocke à chaque image:
       num: numéro du volume
       rx, ry, rz: rotations autour des axes
       cx, cy, cz: dilatations le long des axes
       a, xa, ya, za: rotation autour de l´axe (xa,ya,za)
interaction stock name("fff")vol(n1,n2,...)
Gare les informations dans le fichier fff.sto (en binaire) à la fin de l´animation, qui est atteinte après ni images.

Pour rejouer l´animation see play.
Le nom du fichier est:
       name.cap pour device(val), valeurs du capteur.
       name.sto pour device("vol"), informations sur les volumes.

interaction STOP

Sort du mode interaction (équicvallent à no interaction).

interaction swap

Active le swap (valeur par défaut).

interaction texture

interaction texture("d1 d2,...,dn")

Construit l´objet interaction texture de nom ("d1 d2,...,dn").
Options:
dim(nx,ny): redimenssionne les images
read(num): images lues dans [num,...]
rem: stoppe le process
Remarque:
si interpol texture est actif les buffers sont périodiquement lus dans les dossiers ("d1 d2,...,dn"): permet de traiter de nombreuses images qui ne peuvent toutes tenir en mémoire.

interaction time

interaction time(t)

limite la durée de l´interaction à t images (t = 0 par défaut: éternel).
Options:
interaction time(t,e): si e=0 en inhibant la touche Esc (permet d´éviter un retour intempestif au mode clavier).
interaction time(t,e,1): commence l´animation après la fin du message.
Exemple: interaction time(0,1,1); lance l´interaction, sans limitation de temps, avec la touche Esc active et le traitement ne commençant qu´après la fin du message).
interaction time("s",t): sort du mode interaction après t secondes.
interaction time("m",t): sort du mode interaction après t minutes.
interaction time("h",t): sort du mode interaction après t heures.

interaction pull

Passe en mode pull, tout sommet d´un volume désigné à la souris prendra la position de celle-ci.
Options:
limit(x1,y1,x2,y2): seuls les points intérieurs au cadre (x1,y1,x2,y2) seront pris en compte, ce cadre est affiché dans la couleur (r,v,b).
illum(r,v,b): couleur du cadre (blanc par défaut).
Remarque: le rayon de la saisie peut être modifié par interaction radius.

interaction see

Passe en mode interaction avec yes see actif, permet d´interagir au clavier, le text étant affiché sur l´image (mode recommandé en plein écran).
Remarque: Il est déconseillé de lancer une démo sous ce mode (conflits possibles entre l´interaction de la démo et l´interaction see).

UTILISATION DE LA SOURIS

Bouton de droite

Menus
Bouton du milieu
       Déplacer en x: Change la focale
Bouton de gauche
       Désignations:
Choix des paramètres d´une transformation:
       Cliquer sur un sommet pour désigner un objet, après avoir choisi une transformation (tran, rotx, roty, rotz, pull)
Bouton de droitee
       Accès au menu.

UTILISATION DU MENU

menu =>

Si l´interaction a été lancée avec l´option interaction menu("f1 f2 ...") la 1ère case est menu, cliquer dessus permet d´accéder aux menus déroulants f1 f2 ....
       Sinon cette case n´apparait pas.

quitter

Retourne au mode clavier.

interpreteur

Exécute une ligne de commandes rentrée au clavier, pour garder la main il suffit de terminer cette ligne de commande par input.

reset

Réinitialise tous les flags.

tran(eye)

Cliquer à gauche: Déplace l´oeil en (x,y)

rotxy(eye)

Cliquer à gauche: Tourne l´oeil en x et y

rotxz(eye)

Cliquer à gauche: Tourne l´oeil autour en x et z

right

Vue de droite.

front

Vue de devant.

left

Vue de gauche.

behind

Vue de derrière.

above

Vue de dessus.

below

Vue de dessous.

tran

Cliquer à gauche sur un sommet d´un volume: Le déplacement est mesuré par le déplacement en (x,y) de la souris.

rotx

Cliquer à gauche sur un sommet d´un volume: L´angle de rotation en x est mesuré par le déplacement en x de la souris.

roty

Cliquer à gauche sur un sommet d´un volume: L´angle de rotation en y est mesuré par le déplacement en x de la souris.

rotz

Cliquer à gauche sur un sommet d´un volume: L´angle de rotation en z est mesuré par le déplacement en x de la souris.

pull

Cliquer sur un sommet et déplacer est mesuré par le déplacement en (x,y) de la souris, l´intervalle de saisie est donné par radius.
Cette transformation passe en no pers, reset revient en yes pers.

memory =>

Stocke les transformations de rotation
       rotx: Rotation en x
       roty: Rotation en y
       rotz: Rotation en z
       x,y,z,an: Quaternion

Caractères spéciaux:

Esc sort du mode interaction (saut si interaction a été lancé avec l´option interaction time(0,0)).
[ endort l´interaction.
] réveille l´interaction.
!com: exécute la ligne de commandes com.
       Exemple: !cube(1);ball(2): construit un cube et une boule.
<ccc: passe ccc à interaction ascii.

Voir aussi:

edit interaction
end interaction
ini interaction
no interaction