Le protocole ASTP

LE PROTOCOLE ASTP

1. INTRODUCTION

ASTP (Audela Scripting Transfert Protocol) est un protocole de communication qui permet d'exécuter au travers du système Audela des scripts Tcl depuis un programme quelconque (celui-ci peut être écrit en C, en Basic, en Java, etc).

Cette documentation s'adresse donc aux programmeurs. Le protocole ASTP est simple à comprendre et à implémenter, aussi, même si vous n'êtes pas expert en programmation, il ne devrait pas y avoir de difficulté pour bénéficier des avantages de Audela dans vos propres réalisations. Par exemple, un couple pratiquement idéal est de concevoir l'interface utilisateur en VisualBasic, un environnement de programmation extrêmement intuitif et performant, puis utiliser Audela pour tout ce qui concerne les fonctions de calcul, le pilotage de caméras, la gestion d'un observatoire, la communication Ethernet et Internet, etc.

ASTP ajoute une puissance considérable à vos programmes de traitement ou d'acquisition d'images. En effet, non seulement vous pouvez lancer des scripts Tcl (un des langages de script les plus puissant disponible aujourd'hui), mais vous bénéficiez en plus des nombreuses librairies de fonctions écrites ou à venir pour le système Audela (LIBTT, LIBMC, LIBQM, ..). La diversité de ces librairies permet de construire par vous même une quasi infinité de macro-fonctions. Vous rêvez d'une fonction qui n'existe dans aucun logiciel : vous avez toute les briques de base pour la construire très simplement (un traitement de texte comme WordPad suffit !). Et s'il vous manque une brique de base, le système Audela est suffisamment ouvert pour que vous puissiez y ajouter cette brique en utilisant votre langage de bas niveau préféré : C, C++, Pascal, etc (pour une introduction à la construction d'une librairie Audela cliquez ici).

Enfin, il est possible de lancer depuis votre programme des scripts qui mélangent Tcl et Tk, c'est à dire que vous pouvez créer des interfaces utilisateurs dynamiques en fonction des opérations demandées par l'utilisateur de votre programme.

L'ensemble Audela, Tcl et ASTP permet d'écrire des applications qui s'échangent très bien entre utilisateurs, y compris sur des systèmes d'exploitations différents (Windows, Linux, Unix, Mac, etc). Cette facilités d'échange n'est pas le moindre des avantages du système : elle garantie un développement continu, un capacité dévolution très forte et la constitution d'un réseau d'aide si vous vous trouvez en difficulté.

Soulignons qu'il est par ailleurs possible d'exploiter la puissance de Audela sans écrire la moindre ligne de code en utilisant des programmes dédiés, par exemple Aud'Ace.

Pour être concret nous allons décrire dans ces pages comment le protocole ASTP est implanté dans le logiciel de traitement d'images IRIS.

2. LE PROTOCOLE ASTP

Le protocole entre le logiciel client (votre logiciel) et Audela est basé sur l'échange de fichiers sur le disque dur. L'efficacité de la méthode en terme de vitesse de communication n'est pas exceptionnelle, mais en contre partie la technique est facile à implémenter, elle est bien portable et fiable. Il est à noter que la relative lenteur du protocole (dans la version actuelle) n'est pas un vrai handicap si on considère que ASTP permet d'exécuter des scripts puissants qui ont une large autonomie par rapport au programme appelant. Par exemple, vous pouvez lancer un script qui pilote le télescope et la caméra de concert afin de réaliser une mosaïque d'une partie du ciel, une opération qui peut prendre plusieurs dizaines de minutes, c'est à dire une durée bien plus longue que le temps de communication entre le client et Audela.

Voici le déroulement étape par étape de l'exécution d'un script depuis le logiciel client :

2.1. Etape 1

L'utilisateur du logiciel décide de lancer un script depuis une ligne de commande, un menu, une boite de dialogue. A ce stade il est nécessaire que l'utilisateur fournisse le nom du fichier de script ainsi que les paramètres d'entrée de ce script. Supposons par exemple que l'opération souhaitée soit d'ajouter une constante à tous les pixels d'une séquence d'images. Le script qui réalise cela a pour nom offset2.tcl. Le script est programmé de telle manière qu'il attend trois paramètres. Dans l'ordre : (1) le nom générique des images, (2) la constante à ajouter aux pixels (il y a retrait si la constante est négative), (3) le nombre d'images dans la séquence. Si par exemple on souhaite traiter les images I1, I2, I3 en y ajoutant la constante 500, les 3 paramètres seront respectivement :

I 500 3

Lorsqu'on utilise IRIS un script est lancé depuis un ordre donné sur la console sous la forme d'une ligne de commande. Le mot clef de la commande est TCL. Sa syntaxe est :

TCL SCRIPT ARG1 ARG2 ARG3 ARG4 ....

SCRIPT est le nom du fichier de script Tcl (sur le disque ce fichier à toujours l'extension .tcl mais il ne faut pas préciser cette extension dans la ligne de commande)

ARG1, ARG2, ... sont les arguments (ou paramètres d'entrée) de la fonction contenue dans le fichier de script. IRIS (version 3) accepte jusqu'à 12 paramètres d'entrée.

Ainsi, en reprenant notre exemple du calcul de l'offset d'une séquence d'images, l'utilisateur entrera le commande suivante :

TCL OFFSET2 I 500 3

2.2. Etape 2

Dès que l'utilisateur a validé la commande, le logiciel client écrit sur le disque un fichier qui n'est autre qu'un petit script Tcl. Ce fichier contient des fonctions qui permettent de synchroniser le client avec le système Audela, ainsi que le nom du script que l'on souhaite exécuter (le nom de son fichier disque en fait) et la liste des paramètres. Ce script qui écrit par le client s'appelle toujours exchange.tcl dans le proptocole ASTP.

2.3. Etape 3

Le logiciel client execute sous la forme d'un shell le programme audela.exe. En d'autres termes, votre programme effectue une opération qui consiste à lancer un nouveau programme, ici audela.exe. Si audela.exe est exécuté tel quel, il lance automatiquement le script Tcl audela.tcl (ce script ce trouve toujours dans le même répertoire que audela.exe, en général le répertoire binwin si vous avez installé dans les règles Audela). Mais ici, le logiciel client fait en sorte que audela.exe lance le script exchange.tcl. Pour qu'il en soit ainsi audela.exe peut être lancé avec un flag particulier, le flag -file. Dans le cas présent audela.exe sera lancé de la manière suivante :

AUDELA -FILE EXCHANGE.TCL

2.4. Etape 4

A présent, audela.exe a pris la main. Il lance le script exchange.tcl qui s'execute alors. Des le début de exchange.tcl celui-ci utilise le service des procédures qui se trouvent dans le script astp.tcl. Ce script fait partie intégrante du protocole et doit toujours être copié dans le répertoire du disque dur qui contient votre propre bibliothèque de scripts.

Le rôle de exchange.tcl est essentiellement de récupérer les paramètres entrées par l'utilisateur puis de lancer le script qui va les utiliser.

2.5. Etape 5

Le script de l'utilisateur s'exécute alors. Il peut utiliser l'ensemble des bibliothèques écrites pour Audela. Dans notre exemple c'est le script offset2.tcl qui s'execute à cette étape.

2.6. Etape 6

Au terme de l'execution du script de l'utilisateur la main est redonnée à exchange.tcl. Celui-ci écrit alors sur le disque dur deux fichiers :

(1) un fichier result.txt qui possède deux lignes de texte. La première contient soit le texte NOERROR, soit le texte ERROR suivant que script de l'utilisateur n'a pas ou a produit une erreur. La seconde ligne contient un texte qui peut être exploité par le logiciel client. Dans le cas de IRIS cette ligne est affichée dans la console à la cloture de l'execution de la commande TCL.

(2) un fichier signal.txt qui signifie au client que l'exécution du script exchange.tcl est achevée. L'existence du fichier signal.txt (un fichier vide en fait) est surveillée en permanence par le logiciel client afin d'identifier la fin d'exécution du script et ainsi pouvoir passer à autre chose. Il y a plusieurs manière de gérer cette attente, soit par exemple en utilisant une simple boucle infinie qui s'arréte au moment de l'apparition du fichier signal.txt, soit en gérant un mécanisme de thread ou de timer qui donne à l'utilisateur le sentiment de travailler avec un système multitache (cependant il faut souligner que dans la version actuelle de ASTP il est délicat d'exploiter la dimension multitache de Audela, mais ce point est à l'étude).

2.7. Etape 7

La main est revenu au client. Celui-ci affiche éventuellement le contenu du fichier result.txt et/ou gère une erreur provoquée lors du déroulement du script.

A noter une particularité de ASTP : le fichier exchange.tcl exploite l'image située dans la mémoire vive du client (tampon image principal) sous la forme d'un fichier image disque ayant pour nom #0.fit. Ce fichier, au format FITS, est une copie de l'image courante en mémoire. Il est exploité par exchange.tcl de manière à refléter les opérations de traitement images effectuées dans le script de l'utilisateur et qui s'appliquerait normalement à l'image en mémoire s'il sagissait d'une fonction interne au client. Lorsque le client reprend la main, le fichier #0.fit peut être relu, stocké dans le tampon image principal et affichée sur l'écran (c'est ce que fait IRIS).

3. LE SCRIPT EXCHANGE.TCL

La listing ci-après montre le contenu typique du script exchange.tcl. Cet exemple traite le cas de l'utilisation du script offset2.tcl.

# --- fonctions d'intialisation ---
source c:/script/astp.tcl
astp_create {"::buf::create"}

# --- fonctions de transfert Client -> Tcl ---
astp_buf_load {"1 c:/iris/#0"}
astp_param_in {c:/iris/ c:/audela3/binwin/ i 500 3 }

# --- fonction d'execution ---
astp_source {c:/script/offset2.tcl}

# --- fonctions de transfert Tcl -> Client ---
astp_result {c:/script/result.txt}
astp_buf_save {"1 c:/iris/#0"}

# --- fonction de terminaison ---
astp_delete {c:/script/signal.txt}
exit

Voici les opérations que réalise exchange.tcl.

Tout d'abord exchange.tcl charge le fichier astp.tcl, qui contient des procédures utilitaires qui gèrent le protocole ASTP. Le chemin qui permet de localiser le fichier astp.tcl (dans cet exemple c:/script/) est définit par l'utilisateur de votre programme (dans IRIS, cela ce fait dans la rubrique Script path de la boite de dialogue Settings, voir plus loin). Il est possible de mettre les scripts où bon vous semble, mais il est important que votre répertoire de script contienne le script astp.tcl. L'installation de Audela a placé une copie de celui-ci dans le sous-répertoire astp du répertoire d'installation de Audela. Par exemple, si le chemin d'installation de Audela est c:\audela\, alors une copie de astp se situe dans le répertoire c:\audela\astp\.

Un buffer image est ensuite créé et la procédure astp_buf_load charge le fichier image #0 dans ce buffer. La localisation du fichier #0.fit est définie dans IRIS par le répertoire de travail (rubrique Working path dans le boite de dialogue Settings). Dans l'exemple, le répertoire de travail est c:\iris\.

La procédure astp_param_in décode les paramètres émis par le programme client. Nous avons ici 5 paramètres. Les deux premiers sont obligatoires. Le premier est le chemin du répertoire de travail, le second est le chemin permettant d'arriver au programme audela.exe et aux librairies Audela (ici c:\audela3\binwin\). A noter que dans ces explications nous ne faisons pas de distinction entre le caractère slash (/) et le caractère anti-slash (\), qui sont fonctionnellement équivalentes. Cependant le langage Tcl ne tolère que les slash (compatibilité avec le monde UNIX), d'où la manière d'écrire les chemins dans exchange.tcl.

La procédure astp_source exécute ensuite script offset2.tcl (notez qu'il se situe dans le répertoire c:/script/).

Une fois le déroulement du script offset2.tcl achevé, exchange.tcl écrit le fichier résultat (result.txt) sur le disque et sauvegarde le contenu du buffer image dans le fichier #0.fit.

Finalement, le fichier signal.txt est créée pour indiquer au programme client que l'ensemble de la procédure est terminée (ce fichier se situe dans le répertoire contenant les scripts. La commande Tcl exit ferme la session Tcl.

La copie d'écran ci-après montre la boite de dialogue Settings de IRIS correspondant à la paramétrisation de notre exemple.

4. ASTP ET IRIS

Nous avons vu que l'appel d'un script Tcl dans le logiciel IRIS (à partir de la version 3) ce fait depuis la ligne commande dont la syntaxe est :

TCL SCRIPT ARG1 ARG2 ARG3 ....

SCRIPT est le nom d'un fichier de script Tcl

ARG1, ARG2, ... sont les arguments (ou paramètres d'entrée) de la fonction contenue dans le fichier de script.

IRIS est écrit en C avec l'environnement de programmation Visual C++ 6.0 de Microsoft. L'implantion du protocole ASTP tient dans une seule routine qui a pour nom exe__tcl. Le code complet de cette routine est donné ci-après. Ce code sera décrit pas à pas à la suite.

/************************** EXE_TCL ***************************/
/* Exécute un script Tcl                                      */
/*   nb_arg = nombre d'arguments dans la ligne de commande    */
/*   arg[] = tableau des arguments                            */
/*   text = message en retour de l'exécution du script        */
/*   pParent = une structure qui contient la destination de   */
/*             l'affichage d'une image                        */
/**************************************************************/
int exe_tcl(int nb_arg,char *arg[],char *text,CWnd *pParent)
{
HWND hwnd;
FILE *dest,*fp;
int k,r,len;
char audela_path[_MAX_PATH];
char script_path[_MAX_PATH];
char audela_file[_MAX_PATH];
char signal_file[_MAX_PATH];
char result_file[_MAX_PATH];
char exchange_file[_MAX_PATH];
char image_path[_MAX_PATH];
char binwin_path[_MAX_PATH];
char buf[_MAX_PATH];
char cmdline[128];
char param[256];

strcpy(audela_path,ini.audela_path); // chemin du répertoire audela
strcpy(script_path,ini.script_path); // chemin du répertoire des scripts
sprintf(audela_file,"%sbinwin\\audela.exe",audela_path); // chemin complet de audela.exe
sprintf(exchange_file,"%sexchange.tcl",script_path); // chemin complet du fichier d'échange
sprintf(cmdline,"-file %s",exchange_file); // ligne de commande de audela.exe

// change les anti-slash en slash
len=(int)strlen(audela_path);
for (k=0;k<len;k++)
   {
   if (audela_path[k]=='\\') audela_path[k]='/';
   }

strcpy(image_path,ini.path);
len=(int)strlen(ini.path);
for (k=0;k<len;k++)
   {
   if (image_path[k]=='\\') image_path[k]='/';
   }

len=(int)strlen(script_path);
for (k=0;k<len;k++)
   {
   if (script_path[k]=='\\') script_path[k]='/';
   }

sprintf(binwin_path,"%sbinwin/",audela_path);    // chemin du répertoire binwin
sprintf(signal_file,"%ssignal.txt",script_path);   // chemin complet du fichier signal.txt
sprintf(result_file,"%sresult.txt",script_path);   // chemin complet du fichier result.txt

// synthèse de la ligne d'argument de la commande
strcpy(param,image_path); // le premier paramètre est toujours le chemin du répertoire de travail
strcat(param," ");
strcat(param,binwin_path); // le second paramètre est toujours le chemin du répertoire des bibliothèques
strcat(param," ");
for (k=1;k<nb_arg;k++)
   {
   strcat(param,arg[k]);
   strcat(param," ");
   }

// créée une nouvelle image en mémoire s'il n'y en à pas déjà une
if (buffer[0].pic==NULL) newimage(10,10);

// sauvegarde du buffer mémoire
if (save_picture("#0",0,0)==PB) return(PB);

// écriture du fichier exchange.tcl
if ((dest=fopen(exchange_file,"wb"))==NULL)
   {
   msg(get_msg(84));
   return(PB);
   }

write_file("# --- fonctions d'intialisation ---",dest);
sprintf(buf,"source %sastp.tcl",script_path);
write_file(buf,dest);
write_file("astp_create {\"::buf::create\"}",dest);
write_file("",dest);

write_file("# --- fonctions de transfert Client -> Tcl ---",dest);
sprintf(buf,"astp_buf_load {\"1 %s#0\"}",image_path);
write_file(buf,dest);
sprintf(buf,"astp_param_in {%s}",param);
write_file(buf,dest);
write_file("",dest);

write_file("# --- fonction d'execution ---",dest);
sprintf(buf,"astp_source {%s%s.tcl}",script_path,arg[0]);
write_file(buf,dest);
write_file("",dest);

write_file("# --- fonctions de transfert Tcl -> Client ---",dest);
sprintf(buf,"astp_result {%s}",result_file);
write_file(buf,dest);
sprintf(buf,"astp_buf_save {\"1 %s#0\"}",image_path);
write_file(buf,dest);
write_file("",dest);

write_file("# --- fonction de terminaison ---",dest);
sprintf(buf,"astp_delete {%s}",signal_file);
write_file(buf,dest);
write_file("exit",dest);

fflush(dest);
fclose(dest);

remove(signal_file);

hwnd=GetDesktopWindow();
r=(int)ShellExecute(hwnd,"open",audela_file,cmdline,NULL,SW_SHOWNORMAL);
if (r<=32)
   {
   msg(get_msg(93));
   return(PB);
   }

do { } while(access(signal_file,1)==-1);

// charge le fichier image d'échange en mémoire
if (load_picture("#0",0,0,0)==PB) return(PB);

// affiche l'image
view(pParent);

// lit le fichier résultat
if ((fp=fopen(result_file,"rt"))==NULL)
   {
   msg(get_msg(52));
   return(PB);
   }

// flag d'erreur
fgets(text,127,fp);
len=strlen(text);
if (len>0) text[len-1]='\0';
if (strcmp(text,"error")==0)
   {
   // ici, traitement éventuel d'une erreur dans le déroulement du script
   }

// lecture de la ligne de paramètres en retour du script
fgets(text,127,fp);
len=strlen(text);
if (len>0) text[len-1]='\0';

fclose(fp);
return(OK);
}

La première partie du code débute par des déclarations de variables.

Il faut noter les arguments de la fonction C exe_tcl :

nb_arg = nombre de paramètres entrées par l'utilisateur à la suite de la commande TCL. Dans le cas de l'exemple du script offset2.tcl le nombre d'argument est 4.
arg[ ] = tableau contenant les arguments. Dans le cas du script offset2.tcl on aura par exemple arg[0]=offset2, arg[1]=I, arg[2]=500 et arg[3]=3. Remarquez que arg[0] contient toujours le nom du script.
text = un pointeur qui contient la ligne en retour du script Tcl qui sera affichée sur l'écran (la console de IRIS).
pParent = un pointeur vers une structure propre à Windows qui fixe le contexte d'affichage des images.

La partie suivante du code calcule le chemin des répertoires nécessaires au fonctionnement du protocole ASTP. La variable ini.audela_path est interne à IRIS. Elle contient le chemin qui amène au programme audela.exe. Son contenu reflète exactement la zone de dialogue Audela script de la boite Settings de IRIS (appelable depuis le menu File de ce programme). La variable interne ini.script_path désigne le répertoire dans lequel est située votre bibliothèque de script (cette variable reflète le contenu de la zone de texte Script path de la boite de dialogue Settings). Enfin la variable ini.path contient le chemin du répertoire de travail (zone de texte Working path dans la boite Settings).

// change les anti-slash en slash
len=(int)strlen(audela_path);
for (k=0;k<len;k++)
   {
   if (audela_path[k]=='\\') audela_path[k]='/';
   }

strcpy(image_path,ini.path);
len=(int)strlen(ini.path);
for (k=0;k<len;k++)
   {
   if (image_path[k]=='\\') image_path[k]='/';
   }

len=(int)strlen(script_path);
for (k=0;k<len;k++)
   {
   if (script_path[k]=='\\') script_path[k]='/';
   }

On remarque que dans ce code les anti-slash des chemins sont souvent remplacé par de slash, une opération nécessaire lorsque le chemin est utilisé au sein même du script (compatibilité avec le monde UNIX).

Vient ensuite la génération de la ligne d'argument de la fonction Tcl appelée. Les deux premiers argument de cette ligne sont toujours respectivement le chemin désignant le répertoire de travail (c'est le répertoire contenant les images à traiter) et le chemin du répertoire qui contient le programme audela.exe (ainsi que les librairies d'extensions comme libtt.dll ou libqm.dll). On trouve ensuite les arguments proprement dit du script. Dans l'exemple du script offset2.tcl, cette ligne de commande contiendrait quelque chose comme "c:/image/ c:/audela/binwin/ I 200 5". Notez que les paramètres doivent être séparés par au moins un blanc.

Dans IRIS, si une image est déjà en mémoire (elle est alors aussi affichée à l'écran) elle est sauvegardée sur le disque sous le nom #0.fit (attention, vous devez obligatoire sélectionné le format FITS dans le boite de dialogue Settings). S'il n'y a pas d'images en mémoire alors que vous souhaitez exécuter un script, l'opération est possible, mais IRIS créée pour vous une minuscule image ne contenant que des zéros avec l'aide la fonction interne IRIS newimage (arbitrairement cette image a une taille de 10x10 pixels). La fonction save_picture, interne à IRIS, effectue la sauvegarde proprement dite de l'image en mémoire dans un fichier FITS.

// créée une nouvelle image en mémoire s'il n'y en à pas déjà une
if (buffer[0].pic==NULL) newimage(10,10);

// sauvegarde du buffer mémoire
if (save_picture("#0",0,0)==PB) return(PB);

Vient ensuite l'écriture ligne après ligne du fichier d'échange Tcl exchange.tcl (la fonction write_file est interne à IRIS et effectue l'écriture proprement dite d'une ligne dans un fichier texte). La fonction msg est interne à IRIS et retourne un message d'erreur adéquat si un problème se présente.

// écriture du fichier exchange.tcl
if ((dest=fopen(exchange_file,"wb"))==NULL)
   {
   msg(get_msg(84));
   return(PB);
   }

write_file("# --- fonctions d'intialisation ---",dest);
sprintf(buf,"source %sastp.tcl",script_path);
write_file(buf,dest);
write_file("astp_create {\"::buf::create\"}",dest);
write_file("",dest);
....
....

Avant de lancer le programme audela.exe on efface le fichier signal.txt :

remove(signal_file);

Le programme audela.exe est ensuite exécuté en utilisant la fonction ShellExecute de l'API Windows. La variable cmdline contient l'argument de audela.exe.

hwnd=GetDesktopWindow();
r=(int)ShellExecute(hwnd,"open",audela_file,cmdline,NULL,SW_SHOWNORMAL);
if (r<=32)
   {
   msg(get_msg(93));
   return(PB);
   }

IRIS se met alors en attente de l'écriture du fichier signal.txt par le script exchange.tcl. Cette boucle infini est très rustre car elle bloque le fonctionnement de IRIS tant que le déroulement du script n'est pas achevé. Il est bien sur possible de faire mieux dans un environnement tel que Windows, mais tel quel, le procédé fonctionne.

do { } while(access(signal_file,1)==-1);

Une fois que le script a achevé son travail, on charge en mémoire le contenu du fichier #0.fit (fonction load_picture de IRIS), puis on affiche cette image (fonction view).

// charge le fichier image d'échange en mémoire
if (load_picture("#0",0,0,0)==PB) return(PB);

// affiche l'image
view(pParent);

La routine exe_tcl se termine par la lecture des deux lignes qui se trouvent dans le fichier result.txt. Une éventuelle erreur lors du déroulement du script est traitée à ce niveau. La seconde ligne est un texte qui est affichée sur la console de IRIS (ce texte est éventuellement un message d'erreur automatiquement généré par Tcl, ce qui facilite du reste considérablement l'écriture des scripts).

5. EXEMPLES DE SCRIPTS

Voici quelques scripts élémentaires qui peuvent être appelés dans le contexte du protocole ASTP.

5.1. Calcul du jour Julien

Ce petit script retourne dans la console de IRIS le jour Julien pour une date entrée par l'utilisateur. Ce script utilise la fonction qm_jd qui est implémentée dans la librairie LIBQM.

# jd
# ------------
#
# Retourne le jour Julien d'une date
# Syntaxe : jd annee mois jour
# annee = année de la date
# mois = mois de la date
# jour = jour de la date (peut être un réel)
#

# --- conversion des parametres ASTP en langage clair
set working_path $astp(p,1)
set library_path $astp(p,2)
set annee $astp(p,3)
set mois $astp(p,4)
set jour $astp(p,5)

# --- chargement des librairies éventuelles
catch {
load ${library_path}libqm
}

# --- corps du script
set a [qm_jd $annee $mois $jour]

# --- valeur de retour
set result "Jour Julien : $a"

Le script débute en plaçant les paramètres d'entrée dans des variables aux noms explicites. Les paramètres sont stockés automatiquement dans un tableau ayant pour nom astp(). Remarquez que les deux premiers paramètres contiennent les chemins du répertoire de travail et le chemin du répertoire contenant les librairies.

La librairie LIBQM.DLL est ensuite chargée en mémoire.

La fonction qm_jd proprement dite est alors lancée. Le résultat est retourné dans la variable a. La dernière ligne synthétise un message clair qui est expédié au client au travers du fichier result.txt. C'est le contenu de cette ligne qui est affichée dans la console.

Pour utiliser ce script copiez le dans un répertoire de votre choix (c:\script\ par exemple) en pensant à y ajouter aussi le fichier astp.tcl. Puis depuis la console faites par exemple (le premier paramètre de jd.tcl est l'année, le second le mois et enfin le jour) :

TCL JD 2000 10 13.566

La figure ci-après montre la console de IRIS dans cette situation :

5.2. Ajout d'une constante à une séquence d'images

Voici le contenu du script offset2.tcl qui nous a déjà servi d'exemple. Ici encore on utilise une fonction élementaire de la librairie LIBQM : le fonction qm_offset qui ajoute une constante à une image situé dans le buffer 0 défini par le système Audela.

# offset2
# -------
# Ajoute une constante à une séquence d'images
# Syntaxe : offset2 image cst nb
# image = nom générique des images à traiter
# cst = constante à ajouter à chaque image
# nb = nombre d'images à traiter
#

# --- conversion des parametres ASTP en langage clair
set working_path $astp(p,1)
set library_path $astp(p,2)
set name $astp(p,3)
set offset $astp(p,4)
set nbimages $astp(p,5)

# --- chargement des librairies
catch {
load ${library_path}libqm
}

# --- corps du script
for {set k 1} { $k <= $nbimages } { incr k } {
   loadima $working_path$name$k
   qm_offset $offset
   saveima $working_path$name$k
   }

# --- paramètre de sortie
set result "ok"

Ce script est très semblable à jd.tcl. On note ici en plus que la gestion de la séquence d'images est effectuée par une boucle écrite en Tcl. Ceci laisse entrevoir la manière dont il est possible de concevoir des scripts complexes en utilisant un simple traitement de texte et un minimum de connaissance du langage Tcl.

5.3. Ajout d'une constante à l'image en mémoire

Le script suivant est simple car il effectue le traitement sur l'image en mémoire du logiciel client (en utilisant le fichier intermédiare #0.fit).

# offset
# ----------------
#
# Ajoute une constante à l'image courante
# syntaxe : offset cst
# cst = constante à ajouter à l'image
#

# --- conversion des parametres ASTP en langage clair
set working_path $astp(p,1)
set library_path $astp(p,2)
set cst $astp(p,3)

# --- chargement des librairies éventuelles
catch {
load ${library_path}libqm
}

# --- conversion des parametres ASTP en langage clair
qm_offset $cst

# --- valeur de retour
set result "ok"

On peut noter qu'il est possible d'utiliser une fonction de calcul différente de celle qui se trouve dans LIBQM. Par exemple, si vous voulez exploiter la fonction équivalente dans LIBTT, le script sera alors :

# offset
# ----------------
#
# Ajoute une constante à l'image courante
# syntaxe : offset cst
# cst = constante à ajouter à l'image
#

# --- conversion des parametres ASTP en langage clair
set working_path $astp(p,1)
set library_path $astp(p,2)
set cst $astp(p,3)

# --- conversion des parametres ASTP en langage clair
offset $cst

# --- valeur de retour
set result "ok"

La procédure offset est définie dans astp.tcl à partir des fonctions de base de LIBTT.

Vu depuis l'interface de IRIS, ce script s'exécute de la manière suivante :

6. TELECHARGEMENT

Pour télécharger astp.tcl et les scripts d'exemples, cliquez ici.

Cliquez ici pour aller sur la page LIBQM

Cliquez ici pour aller sur la page IRIS