interaction en temps réel
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
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 menu(0)
Inhibe les menus par défaut (utile dans une installation interactive)..
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 desoptions.
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
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.
Voir aussi validate interaction_ascii
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 displ image bitmap
interaction displ image(id)bitmappoi(x,y)
Si image id est de type 3D
ses bitmappess seront affichées.
Options:
period(1) : images 1,2, ...,nb, 1,2,...
period(-1) : images 1,2, ...,nb, nb-1,nb-2,...
poi(x,y) : au point (x,y).
poi(x,y)normal : au point (x,y) normalisé.
interaction scale
interaction scale var("A")
Fait A[2]=scale coe(A) avec les
options.
Remarque
Avec plusieurs options var("A1") var("A2") ...
permet de traiter de nombreuses échelles.
Exemple
A1=0,5,3,3;A2=0,5,3,3;A3=0,5,3,3;A4=-1,1,0,0;A5=0,2,1,1;
interaction scale("ent(1) ent int float float")var("A1 A2 A3 A4 A5")
ent(1) ent int float
poi(-300,100,300,300)rectangle(1,0,0, 0,0,0)frame(0,1) displ line(3);
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)
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).
interaction func("nnn")
appele la fonction nnn(1) une fois et nnn() à chaque image.
interaction func(-1);
inhibe cette fonctiannalité.
une telle fonction ressemble à:
nnn(sem)
{
if(sem!=NIL)
{
initialisation...
}
else
{
traitement...
}
}
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
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:
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(" ")
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 read
interaction read image(id)directory("d1;d2;...;dn;")time(t)
Fait: read image(id)name("nnn.ima")bitmap(num)
num=0,1,...,nz-1 with nz=secz image(id).
Permet de lire une grande image 3D
une bitmap à chaque frame depuis les dossiers successifs di changés
toutes les t frames.
Options:
dim=n: si toutes images n´ont pas les mêmes dimensions. (n étantune puissance de 2).
image(num,nb): nb = nombre d´images pour l´option memory=0 (5 par défaut).
memory: toutes les images sont stockées en mémoire
var=num: dossier invariable numéro num.
NP(np): np images de base sont automatiquement générées (3 par défaut)
à partir du premier directory.
rand: choix aléatoire des images d´un dossier, sinon linéaire (par défaut).
period(p): répéte p fois la lecture des images 3D.
time(t): modifie les dossiers chaque t frame (250 par défaut, 10 secondes).
var=0: rend les dossiers invariables.
var=1: rend les dossiers variables de nouveau.
(plus rapide mais demande plus de mémoire).
period(p): répète p fois la lecture des images 3D.
time(t): modifie le directory chaque t frames (250 par défaut, 10 secondes).
interaction read image directory
Retourne le nombre de dossiers, le numéro du dossier courant,
le numéro de l´ courante,
le nombre de bitmaps, le numéro de la bitmap courante,
variable.
variable = 1: dossiers variables (par défaut), 0: dossiers invariables.
Options:
name: seulement le nom du directory courant.
interaction read image directory=num
num >= 0 : modifie le numéro du dossier courant et le rend invariable.
num=-1: rend les dossiers variables de nouveau.
interaction read image directory disk
Retourne disk
interaction read image directory disk=n
Modifie disk (1 par défaut)
interaction read image directory rand
Retourne rand
interaction read image directory rand=r
Modifie rand (r=1: aléatoire, r=0: linéaire)
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
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: