idl - formation et enseignement à l'observatoire de paris

- 1 - IDL est-il aussi idéal qu’il le dit!?

"IDL"

dit-il…

Petit résumé de cours IDL - Jean Aboudarham - Février 2002


Table des matièresI – LES COMMANDES DE BASE ....................................................................................................................................5

1) GÉNÉRALITÉS SUR LES NOMS DE VARIABLES................................................................................................................52) AFFECTATION DE VARIABLE ET TYPES DE VARIABLES .................................................................................................63) PRINT..............................................................................................................................................................................64) HELP...............................................................................................................................................................................75)!?......................................................................................................................................................................................76) EXIT................................................................................................................................................................................77) SAVE ET RESTORE ..........................................................................................................................................................78) LES OPÉRATIONS DE BASE .............................................................................................................................................89) LES TABLEAUX...............................................................................................................................................................910) LES FONCTIONS MATHÉMATIQUES STANDARDS........................................................................................................1011) LES OPÉRATIONS SUR LES CHAÎNES DE CARACTÈRES ...............................................................................................1112) LES TRANSFORMATIONS DE TYPES............................................................................................................................1413) LES OPÉRATEURS LOGIQUES......................................................................................................................................1514) LECTURE ET ÉCRITURE ..............................................................................................................................................16

a) A l’écran .................................................................................................................................................................16b) Dans un fichier .......................................................................................................................................................16

15) LES RENVOIS CONDITIONNELS...................................................................................................................................1816) LES BOUCLES .............................................................................................................................................................19

a) La boucle FOR … DO ….......................................................................................................................................19b) La boucle WHILE … DO … ..................................................................................................................................20

17) GESTION DES FENÊTRES.............................................................................................................................................2118) LES TRACÉS SIMPLES .................................................................................................................................................21

a) Le tracé à une dimension, plot...............................................................................................................................22b) Superposition de figures, OPLOT .........................................................................................................................24c) Tracés à deux dimensions, SURFACE et SHADE_SURF ....................................................................................25d) Images, TV et TVSCL.............................................................................................................................................26e) Les isocontours, CONTOUR, et superposition à une image, IMAGE_CONT.....................................................26

19) DES TRACÉS PLUS ÉVOLUÉS ......................................................................................................................................27a) Annotation d’un tracé, XYOUTS ...........................................................................................................................27b) Borner le tracé........................................................................................................................................................28c) Les couleurs, LOADCT et XLOADCT et autres utilités graphiques ....................................................................28

II – LES PROCÉDURES ET FONCTIONS...................................................................................................................29

1) RÈGLES GÉNÉRALES.....................................................................................................................................................29a) Procédures..............................................................................................................................................................29b) Fonctions ................................................................................................................................................................29

2) UTILISATION ................................................................................................................................................................30a) Générale .................................................................................................................................................................30b) Passage de paramètres entre programmes ...........................................................................................................30

a) Paramètres de position ......................................................................................................................................................... 30b) Mots-clés (keywords) ........................................................................................................................................................... 30g) Common ................................................................................................................................................................................ 31d) Vérification de la validité des paramètres............................................................................................................................ 31

3) LES BOUCLES ET TESTS................................................................................................................................................32a) For ... do .................................................................................................................................................................32b) If ... then..................................................................................................................................................................32c) While ... do ..............................................................................................................................................................33d) Case … of................................................................................................................................................................33e) Repeat … until ........................................................................................................................................................34f) Les sorties de boucles et labels...............................................................................................................................34

4) COMMANDES D’EXÉCUTION ........................................................................................................................................35

III – QUELQUES FONCTIONS AVANCÉES ..............................................................................................................35


1) UTILITÉS GRAPHIQUES.................................................................................................................................................35a) Sauver un graphique ou une image .......................................................................................................................35b) Faire du Postcript ..................................................................................................................................................36c) Plusieurs images sur une même fenêtre.................................................................................................................37

2) LES STRUCTURES .........................................................................................................................................................373) EXÉCUTION INDIRECTE................................................................................................................................................374) GESTION DU CURSEUR DE LA SOURIS ..........................................................................................................................38

IV – QUELQUES CONSEILS D’UTILISATION .........................................................................................................39

1) QUELQUES TRUCS DE PROGRAMMATION.....................................................................................................................392) QUELQUES ERREURS FRÉQUENTES..............................................................................................................................39

V - QUELQUES EXEMPLES ..........................................................................................................................................40

1) UNE PETITE FONCTION UTILE TRÈS SIMPLE .................................................................................................................402) UNE PROCÉDURE D'UN INTÉRÊT LIMITÉ, MAIS DÉTAILLÉE .........................................................................................41

VI – INDEX -----------------------------------------------------------------------------------------------------51


L’idéale halle aux idées d’IDLLe langage IDL, comme tous les langages de programmation consiste en une orthographe et unegrammaire. Les commandes et leur écriture correcte, ainsi que la façon de choisir les noms devariables constituent cette orthographe. La façon d’écrire les commandes et les variables les unespar rapport aux autres forme la grammaire.Sous IDL, les majuscules et les minuscules sont indifférentes!:print, PRINT, Print, PRinT sont totalement équivalents.Les différents éléments du langage IDL sont!:• Les commandes : ce sont les éléments de calcul, de tracé, d’écriture, … que le langage IDLreconnaît automatiquement.• Les variables!: elles sont définies par le programmeur, en fonction de ses besoins, et enrespectant certaines règles, suivant le rôle qu’elles auront à jouer. Elle ne peuvent porter un nomqui est déjà un mot-clé IDL.• Les procédures!: ce sont les programmes qui effectuent un élément de calcul (ou un calculcomplet), ou une série d’actions (tracé de courbe, écriture ou lecture de fichier, …) etéventuellement renvoient des résultats à une autre procédure.• Les fonctions!: ce sont des sortes de procédures qui effectuent un calcul précis et renvoient lerésultat à un programme principal. Les fonctions suivent le même principe que les commandesd’IDL. C’est pour cela qu’il faut que les fonctions soient définies avant de les utiliser, car sinon,IDL les considère comme des commandes mal orthographiés.• En plus de ces éléments, les commandes, procédures et fonctions peuvent être accompagnésd’un certain nombre d’arguments et de mots-clés. Les arguments sont des variables que l’onutilise pour les opérations effectuées (par exemple dans la ligne b=cos(a), a est l’argument).Les mots-clés sont des informations facultatives permettant de préciser ce que l’on a à faire (parexemple, le mot-clé ‘title=’ permet de définir le titre d’une figure, d’une fenêtre, …).• Pour pouvoir bien utiliser IDL, il faut également comprendre la notion de chemin d’accès (enanglais, path). Pour fonctionner correctement, IDL va chercher les commandes dans des dossiersqui sont définis dans une variable système qui s’appelle!!path. Pour voir le contenu (ou aumoins une partie) de cette variable, tapez la commande suivante!:print,!pathSi vous voulez ajouter un dossier situé ailleurs au chemin d’accès d’IDL, vous pouvez soitajouter à!!path le chemin d’accès complet de ce nouveau dossier, comme ci-dessous!:!path=!path + ‘mon_disque:dossier:sous_dossier:mon_dossiersoit, dans la plupart des versions d’IDL, il existe dans les menus une option ‘path’ qui permetd’ajouter ce dossier.Vous pouvez également définir dans les menus un ‘working folder’ (dossier de travail) qui sera lelieu où vous pourrez lire et écrire des fichiers. Sur les machines où les menus ne sont pasdisponibles, c'est le répertoire courant (d'où on a lancé IDL) qui sert de dossier de travail pardéfaut. Si on veut changer manuellement de répertoire de travail, la syntaxe change légèrementsuivant le système sous lequel on travaille!:- sous Unix!: CD,'/usr/dir/subdir'- sous VMS!: CD,'sys$sysdevice!:[dir.subdir]'


- sous Mac OS!: CD,'disque:dir:subdir'- sous Windows!: CD,'c:\usr\dir\subdir'

• Sous certaines versions d’IDL, la ligne où l’on peut entrer les commandes est limitée (et ce serasouvent le cas dans les procédures et fonctions). On peut alors utiliser le symbole $ pour indiquerque l’ordre que l’on rentre continue à la ligne suivante. Par exemple!:print, $!path• Notons pour la commodité que les flèches haute et basse permettent de rappeler les lignes decommande que l’on a précédemment rentrées, par exemple pour corriger une faute de frappe.• En ce qui concerne la grammaire, elle est relativement simple et se limite essentiellement à 6types de symboles : “,“ ; “=“ ; “( )“ ; “[ ]“ ; “/“ ; et “ “ (l'espace).Les règles générales sont :

- Les mots réservés sont séparés par des espaces (AND, …)- Les arguments et les mots-clés sont séparés par des virgules- Les indices de tableaux sont entre crochets (à partir de la version 5 d'IDL ; auparavant,

on utilisait les parenthèses, qui sont toujours reconnues pour les indices, mais celarisque de changer un jour, donc autant prendre l'habitude des crochets), séparés pardes virgules

- Les arguments de fonctions sont entre parenthèses (ce qui permet de distinguer unefonction d'un tableau)

- L'assignation d'une valeur à une variable ou à un mot-clé se fait par le signe égal- La barre de division (ou slash) met à 1 (ou Vrai, True) un mot-clé (par exemple,

/XLOG et XLOG=1 sont équivalents).

• Pour lancer IDL sur les machines Unix ou VMS, il suffit de taper IDL. Sur les micro-ordinateurs, il faut double-cliquer sur l’icône de l’application IDL. Sous Unix et VMS, quand laversion adéquate d’IDL est installée, on peut taper IDLDE, ce qui lance un environnement dedéveloppement IDL assez voisin de celui d’un PC sous Windows.• Pour quitter IDL, il suffit d’entrer la commande EXIT.• Enfin, la commande permettant d’afficher l’aide hypertexte d’IDL est le symbole pointd’interrogation (‘?’).!‘?commande’ affiche directement l’aide concernant la commande indiquée.

I – Les commandes de baseToutes les commandes se tapent à la suite du ‘prompt’ IDL>On peut enregistrer toutes les commandes que l’on entre de façon interactive avec IDL dans unfichier, par exemple ‘fichier.txt’ avec la commande suivante!:Journal,’fichier.txt’Pour arrêter l’enregistrement, il suffit de retaper!: journal.

1) Généralités sur les noms de variablesPour simplifier les choses, disons que toutes les variables (et il en est de même pour les noms deprocédures ou de fonctions) doivent être composés de lettres, de chiffres et éventuellement ducaractère «!_!» (blanc souligné). Le nom de variable commence obligatoirement par une lettre.


Exemples!:• resultat correct• tab2 correct• calc_vitesse correct• 1calc incorrect (car le premier caractère est le chiffre un)

2) Affectation de variable et types de variablesL’affectation des variables consiste à associer une valeur (ou le résultat d’un calcul) à un «!mot!»(qui est le nom de la variable).

Les principaux types de variables sont!:• Les entiers!: 0, 1, 27, 12345, -853, …

entre -32 768 et +32 767 (attention : 32 767 + 1 = -32 768 !) (16 bits)• Les réels!: 1.27, -12.3 E 7 (la lettre E est suivie de la puissance de 10 à appliquer au nombre quila précède)

entre -1x1038 et +1x1038 (32 bits)• Les chaînes de caractères!: Bonjour, Nom, … (et là, les majuscules et minuscules sontdifférenciées)

maximum = 32 767 caractères• Les nombres double précision!: il s’agit de la même chose que les réels, mais le nombre dechiffres significatifs sur lesquels sont effectués les calculs est le double. La précision est certesmeilleure, mais la vitesse de calcul s’en trouve sensiblement réduite.

Entre -1x10308 et +1x10308 (64 bits)• Les octets!: ce sont des entiers compris entre 0 et 255 (8 bits)

Exemples!:IDL> a = 2 (nombre entier)IDL> nom = ‘Moi’ (chaîne de caractères)IDL> nouvnm = “avec l’apostrophe“ (Notez que s’il y a une apostrophe, il fautencadrer la chaîne de caractère par des guillemets, ou l'inverse)IDL> nbreel = 0.314159 E 1 (nombre réel)IDL> Ry = 1.09677581 D5 (nombre réel en double précision)IDL> octet = 65B (octet correspondant au codage ASCII de lalettre ‘A’)

Quelques variables spéciales!:Notons enfin que le nombre réel p dispose d’une variable spéciale!:!pi (ou !dpi, en double précision)

3) Print‘print’ est la commande qui permet d’afficher un résultat. Elle est donc très utile!! ‘print’ suivid’une virgule, puis du nom de la ou des variables dont on veut connaître la valeur affiche lerésultat.Par exemple!:


a = 3.14print,a3.14b=2print,a,b3.14 2

IDL> print,!pi3.14159

4) Help‘help’ est la commande qui permet d’afficher la liste des variables utilisées depuis le début de lasession IDL, ainsi que leur valeur (s’il ne s’agit pas de tableaux).Si vous tapez help, après avoir entré les lignes du 3) ci-dessus, IDL affichera!:% At $MAIN$A FLOAT = 3.14000B INT = 2Compiled Procedures: $MAIN$Compiled Functions:

Si vous avez entré d’autres variables sous IDL, elles apparaîtront aussi.

Si vous ne voulez connaître le contenu que d’une seule variable, tapez ‘help’ suivi d’une virgule,puis du nom de la variable!:help,aA FLOAT = 3.14000

5)!?Le point d’interrogation lance l’aide en ligne d’IDL. Une fenêtre s’affiche, qui permet de fairedes recherches par genre, par nom, …

6) ExitPour quitter IDL, il suffit de taper exit.

7) Save et restoreLorsque l’on a effectué un certain nombre d’opérations, on peut désirer soit conserver l’ensembledes contenus de variables avant de quitter IDL pour reprendre des calculs plus tard, soit conserverune ou quelques variables seulement. C’est la commande save qui permet cela.Par exemple, pour sauvegarder toutes les variables dans un fichier nommé sauve.data!:save,filename=’sauve.data’

Pour ne sauvegarder que les variable a, b, et nom!(dans le fichier sauve.data)!:


save,a,b,nom,filename=’sauve.data’

Remarquez que comme le nom de fichier de sauvegarde est du texte, il faut l’encadrer par desapostrophes.

Pour récupérer les variables, il suffit d’utiliser la commande restore de la façon suivante!:restore,filename=’sauve.data’

Si aucun nom de fichier n’est spécifié dans la commande save, le nom du fichier de sauvegardepar défaut est IDL.sav, et si aucun nom n’est spécifié dans la commande restore, IDLessaye de trouver le fichier IDL.sav.

Donc, on peut très bien terminer une session IDL en tapant la commande save seule, puisexit!; et au lancement suivant d’IDL, commencer par la commande restore seule pour seretrouver dans la même configuration que la fois d’avant.

8) Les opérations de baseLes quatre opérations de base sont!:+ addition- soustraction* multiplication/ division^ élévation à la puissance

Les opérations (comme les fonctions) peuvent se mettre dans toute commande, ou dans touteaffectation de variable.Par exemple!:a=3b=2c=a*bd=3*2print,cprint,a*bprint,3*2

Les opérations ont un «!ordre de préséance!» qui est!: d’abord la puissance, puis multiplication etdivision, et enfin addition et soustraction. Si l’on veut que l’opération s’effectue dans un autreordre, il faut mettre des parenthèses. Les exemples suivant éclaireront ce que cela veut dire!:a=3b=4c=2print,a+b*c IDL effectue b*c puis ajoute a11print,a*b+c IDL effectue a*b puis ajoute c14print,a*b^c IDL effectue b à la puissance c et multiplie le résultat par a


48

par contre!:print,(a+b)*c IDL effectue a+b et multiplie le résultat par c14print,a*(b+c) IDL effectue b+c et multiplie le résultat par a18print,(a*b)^c IDL effectue a*b puis élève le résultat à la puissance c144

9) Les tableauxLes tableaux représentent des ensembles de valeurs communes. Par exemple, l’ensemble despoints correspondant aux valeurs d’une fonction, ou la suite des noms des élèves d’une classe.Les indices des tableaux sont indiqués entre crochets (même si IDL les reconnaît également entreparenthèses, comme indiqué dans l'introduction)Pour qu’une variable soit un tableau, il faut d’abord la définir comme telle en le spécifiant par unordre spécial fonction du type de variable. Cet ordre indique le type de variable, qu’il s’agit d’untableau, et donne le nombre d’éléments du tableau!:intarr pour un tableau d’entiers (de l’anglais integer array!: tableau entier)fltarr pour un tableau de réels (floating point array)strarr pour un tableau de caractères (string array)dblarr pour un tableau de réels double précision (double precision array)

Une image, par exemple, est un tableau à 2 dimensions d’entiers, dont chaque valeur vacorrespondre à une couleur. Si l’image fait 200 pixels de large sur 150 pixels de haut, on vadéfinir le tableau contenant l’image, ima, de la façon suivante!:ima =intarr[200,150]

Un petit film va correspondre à une succession d’images. En reprenant les images définies ci-dessus, et en supposant que ce film est composé d’une succession de 1500 images, on va définirle tableau à 3 dimensions film ainsi!:film = intarr[200,150,1500]

Pour un petit tableau (par exemple la suite des 5 premiers nombres pairs), on peut entrerdirectement les valeurs du tableau de la façon suivante (pour d’autres méthodes pour entrer lesvaleurs, on peut se reporter au paragraphe 16 sur les boucles)!:pair = intarr[5]pair = [2,4,6,8,10]

Attention!: intarr[5] indique que le tableau compte 5 éléments, mais IDL a le gros défaut denuméroter les éléments des tableau en commençant à 0. Cela signifie que l’élément 0 du tableaupair est 2, et que son dernier élément est pair[4] qui vaut 10!!!! Si l’on se trompe et quel’on demande d’afficher la valeur de pair[5], on a alors le message d’erreur (fréquent)!:% Attempt to subscript PAIR with <INT ( 5)> is out of range.% Execution halted at: $MAIN$


On peut alors imprimer à l’écran une ou des valeurs du tableau de la façon suivante!:print,pair[2]6print,pair[1:3]4 6 8

Remarque!: Dans les indices d’un tableau, le caractère ‘*’ signifie ‘tous les indices’.Ainsi, dans l’exemple vu plus haut, film[*,*,500] représente l’image numéro 501 complète.

Une fonction permet de retrouver les dimensions d'un tableau et son type : SIZE.Son utilisation est : res=SIZE(variable)Le résultat res est un tableau d'entiers longs de dimension variable. Le premier élémentcorrespond au nombre de dimensions du tableau ( = 0 s'il s'agit d'un scalaire ou si le tableau n'estpas défini). Ensuite, chaque élément suivant donne la taille de chacune des dimensions ; et enfin,les deux derniers éléments donnent respectivement le type de variable, et le nombre totald'éléments du tableau.Exemple :tab=fltarr(120,360,10)res=size(tab)print,res3 120 360 10 4 432000Cela signifie qu'il y a 3 dimensions qui contiennent respectivement 120, 360 et 10 éléments, quele tableau est de type 4 et qu'il y a en tout 432 000 éléments dans tab.Le type est ainsi défini :0 Non défini 1 Octet 2 Entier3 Entier long 4 Réel 5 Réel double précision6 Nombre complexe 7 Chaîne de caractères 8 Structure9 Complexe dble préc. 10 pointeur 11 Référence objet12 Entier non signé 13 Entier long non signé 14 Entier 64 bits15 Entier non signé 64 bits

On peut manipuler un tableau globalement si la même opération est à effectuer sur tous seséléments :tab=fltarr(120,360,10)tab=tab/3.14L'opération affecte tous les éléments du tableau.

10) Les fonctions mathématiques standardsalog logarithme népérien (ou naturel)alog10 logarithme décimalexp exponentielfactorial factoriel (n!)abs valeur absoluesqrt racine carrée (pour l’anglais square root)max maximum d’un tableau de valeursmin minimum d’un tableau de valeurs


cos cosinus (attention, tous les angles sont en radians!: p radians = 180°)sin sinustan tangente (rappelons que cotangente = 1/tangente)acos arc cosinus (fonction inverse de cosinus)asin arc sinus (fonction inverse de sinus)atan arc tangente (fonction inverse de tangente)sinh sinus hyperbolique (sinh(x) = [exp(x)-exp(-x)]/2)cosh cosinus hyperbolique cosh(x) = [exp(x)+exp(-x)]/2)tanh tangente hyperbolique (tanh(x)=sinh(x)/cosh(x))

Exemples d’utilisation!:a=exp(1)print,a2.71828print,factorial(5)120print,cos(!pi/4)0.707107

a=[2.7,5.3,1.2,7.6,4.2]print,min(a),max(a)1.2 7.6

print,alog(exp(!pi))3.14159

11) Les opérations sur les chaînes de caractèresIDL permet également de manipuler des chaînes de caractère (c’est-à-dire du texte). Ce texte semet dans une variable, entouré d'apostrophes. On peut également utiliser des guillemets, ce quipermet la présence d'apostrophes dans la chaîne, ou l'inverse.Sans que ce soit vraiment une commande, il existe une opération de base que l’on nomme laconcaténation!: il s’agit de l’addition de deux ou plusieurs chaînes de caractères, c’est-à-direl’ajout de chaînes bout à bout!:a=’Voici ‘b=’venir ‘c=’le petit lapin’d=a+b+cprint,dVoici venir le petit lapin

La première commande que nous allons voir permet de déterminer la longueur d’une chaîne decaractères!:a=“Ceci est un texte d’une certaine longueur“b=strlen(a)print,b41 Il s’agit du nombre de caractères (espaces compris) comprenant la variable a


On peut également comprimer tous les espaces multiples (c’est relativement rare) en un seul parla commande strcompress!:c=strcompress(a)print,cCeci est un texte d’une certaine longueur

Par contre, en ajoutant à la commande strcompress le mot-clé (keyword) /remove_all,on peut alors supprimer tous les espaces!:c=strcompress(a,/remove_all) (Attention de bien mettre le mot-clé dans laparenthèse)print,cCeciestuntexted'unecertainelongueurprint,strlen(c)35

Une autre commande permet de manipuler les espaces en tête et en fin de chaîne de caractères!:nouvelle_chaine=strtrim(chaine[,flag])Ce qui est entre crochets ([ ]) est facultatif. Le mot-clé ‘flag’ permet de préciser si l’on veutsupprimer les espaces de tête (flag vaut 1), ceux de fin (flag vaut 0!; c’est par défaut ce quefait IDL si ‘flag’ n’est pas précisé), ou les espaces de début et de fin (flag vaut 2)!:b=’ 1 ‘c=’2’print,b+c 1 2print,c+b2 1d=strtrim(b)print,d+c 12print,c+d2 1d=strtrim(b,1)print,c+d1 2print,d+c21fl=2d=strtrim(b,fl)print,c+d21print,d+c12

Les commandes strlowcase et strupcase permettent de transformer toute une chaîne decaractères en minuscules ou en majuscules respectivement!:b=strlowcase(a)c==strupcase(a)


print,b,cceci est un texte d'une certaine longueurCECI EST UN TEXTE D'UNE CERTAINE LONGUEUR

Ces deux commandes peuvent être particulièrement utiles quand vous demandez dans uneprocédure de répondre à une question par 'oui' ou par 'non'. Vous transformez ainsi la réponse enminuscules ou en majuscules, et comparez à oui ou non sans avoir à penser à toutes lespossibilités de combinaisons de minuscules et de majuscules.

La commande strpos permet de trouver la position d’une chaîne de caractères dans un texte(Attention!: IDL compte toujours à partir de 0. Donc s’il répond que la sous-chaîne se trouve enposition n, vous compterez de 1 à n+1 pour trouver la position)!:b=strpos(a,’une’)print,b20 ‘une’ commence donc à la 21ème lettre de la variable a

Si la sous-chaîne n’existe pas dans la variable, IDL retourne la valeur –1!:b=strpos(a,’deux’)print,b-1

Pour extraire une sous-chaîne d’une chaîne de caractères, on utilise la commande strmid, dontla forme générale est!:sous_chaine = strmid(variable,premier_caractere[,longueur])Ce qui est entre crochets ([ ]) est facultatif. Si la longueur de la chaîne à extraire n’est pasprécisée, IDL extrait tous les caractères depuis la position du 1er caractère indiquée (encommençant de compter à 0) jusqu’à la fin de la variable!:b=strmid(a,20,3)print,bunec=strmid(a,20)print,cune certaine longueur

On peut également remplacer une partie de texte par une autre (de même longueur!!) avec lacommande strput!:strput,destination,source[,position]Ainsi, IDL remplace dans la variable ‘destination’ à partir de la position ‘position’ (encomptant à partir de 0) le texte initial par le contenu de la variable ‘source’. Si ‘source’dépasse la fin initiale de ‘destination’, le contenu de ‘source’ est tronqué, afin que lavariable ‘destination’ fasse toujours la même longueur. Si la position n’est pas précisée,IDL commence le remplacement en position 0.Exemples!:On veut remplacer dans la variable a ‘un’ par ‘LE’ pour obtenir!:Ceci est LE texte d’une certaine longueur. On doit donc faire!:strput,a,’LE’,9print,a


Ceci est LE texte d’une certaine longueur

Par contre, si on veux maintenant remplacer ‘LE’ par ‘un exemple de’, les choses secompliquent!: Il faut tout d’abord extraire la partie qui précède ‘LE’, et celle qui le suit. Ensuite,concaténer (additionner dans le sens des chaînes de caractères) la première partie avec ‘unexemple de’ puis avec la dernière partie!:d=strpos(a,'LE') On cherche la position de ‘LE’print,d 9b=strmid(a,0,9) On extraie la 1ère partie du texteprint,bCeci est (il y a un espace à la fin)c=strmid(a,11) On extraie la 2ème partie du texteprint,c texte d'une certaine longueure=b+'un exemple de'+c On effectue la concaténationprint,eCeci est un exemple de texte d'une certaine longueur

12) Les transformations de typesOn peut être amené, dans une procédure, ou en cours de calcul, à vouloir changer un type devariable en un autre, par exemple transformer un entier en réel, ou l’inverse, ou une chaîne decaractère en nombre. Certaines commandes permettent ces transformations!:a=2 Nombre entierb=3.5 Nombre réelc=’4’ Chaîne de caractèresprint,a 2print,b 3.5000print,c4d=float(a) Transforme a en réele=fix(b) Transforme b en entierf=string(b) Transforme b en chaîne de caractèresg=fix(c) Transforme c en entierprint,d 2.00000 Réelprint,e 3 Entier (il a perdu la partie après la virgule)print,f 3.50000 Chaîne de caractèresprint,g 4 Entiera=-3.5 Réel négatifprint,fix(a)


-3 Entier

Attention donc à toujours bien définir le type de variables utilisées pour éviter l’erreur del’exemple suivant!:a=2b=3c=a/bprint,c0

En effet, a et b étant entiers, IDL fait le calcul en entiers et c, étant inférieur à 1 est arrondi à 0!!De même!:d=b/aprint,d1

Ce type d’erreur est très fréquent, et souvent difficile à retrouver dès que l’on effectue des calculsun peu compliqués.

13) Les opérateurs logiquesOn peut effectuer des opérations de logique sur des nombres ou des chaînes avec les 4 opérateursclassiques!:ET ANDOU OROU exclusif XORNON NOTVoici ci-dessous les tables de vérité correspondantes!:

and 0 1 or 0 1 xor 0 1 not 0 10 1 0 0 1 1 0 0 1 1 01 0 1 1 1 1 1 1 0

Ces opérations donnent 0 si le résultat est faux!:a=2print,a and 22print,a and 10

Ces opérateurs peuvent être utilisés de paire avec d’autres opérateurs de comparaison (et c’est cequi se passe le plus souvent, voir le paragraphe 15 sur les renvois conditionnels).


14) Lecture et écriture

a) A l’écranOn a vu que pour afficher un résultat à l’écran, on utilise la commande ‘print’. On peut égalemententrer des valeurs au clavier avec la commande ‘read’!:a=0read,a

Vous entrez 1 au clavier quand IDL affiche ‘:’print,a1

Encore une fois, attention au type de variable. Dans l’exemple ci-dessus, si vous entrez la valeur1.5 au clavier, a contiendra toujours 1 car il est considéré comme entier. Donc, si l’on prévoitd’entrer un entier, un réel ou une chaîne de caractères, on va commencer respectivement par!:a=0 oua=0. oua=’’

Au lieu des ‘:’ qu’affiche IDL, vous pouvez souhaitez quelque chose de plus parlant, un ‘prompt’indiquant ce qu’il faut entrer au clavier. Cela se fait avec le mot-clé ‘prompt’!:a=0read,prompt=’Entrez un entier ’,a

Vous entrez 1 au clavier quand IDL affiche ‘Entrez un entier ‘print,’Vous avez entré!: ‘,aVous avez entré!: 1

Remarquez que dans cet exemple la commande ‘print’ est également plus parlante.

b) Dans un fichierC’est maintenant plus compliqué, mais on ne va voir pour l’instant qu’une façon la plus simplepossible. Supposons que vous souhaitiez sauvegarder dans un fichier un tableau de valeurs. Ilvous faut tout d’abord ouvrir ce fichier en précisant que c’est pour y écrire, tout en spécifiant unnuméro associé à ce fichier (ce qui permet d’avoir plusieurs fichiers ouverts en même temps sanspour autant qu’IDL se mélange entre eux), et bien sûr son nom. Ensuite, vous écrirez les valeursdans le fichier, et enfin vous fermerez ce fichier. Attention!: si vous ouvrez en écriture un fichierqui existe déjà, vous écrirez à la place de ce qui s’y trouvait avant, qui sera alorsirrémédiablement perdu!!Le numéro associé au fichier s’appelle numéro d’unité logique (en anglais Logical Unit Number,que l’on trouve souvent sous la forme LUN).Un petit exemple!:a=[2,4,6,8,10] On crée un tableau de 5 élémentsprint,a Et on l’affiche pour vérifier 2 4 6 8 10


openw,1,’tableau.dat’ On ouvre (et on crée) le fichier tableau.dat associé aunuméro d’unité logique 1 (s'il existait déjà, la versionprécédente est effacée)

printf,1,a On écrit le contenu de la variable a dans le fichier associé àl’unité logique 1

close,1 On ferme le fichier associé à l’unité logique 1

Pour relire ces valeurs, on ouvre en lecture le fichier, on le lit, et on le referme. Mais d’abord,pour savoir quoi lire, il faut définir la (ou les) variable à lire!:a=intarr(5) On définit un tableau d’entiers de 5 élémentsprint,a On l’écrit à l’écran pour vérifier 0 0 0 0 0openr,1,’tableau.dat’ On ouvre le fichier tableau.dat associé au numéro d’unité

logique 1readf,1,a On lit dans la variable a le contenu du fichier associé à

l’unité logique 1close,1 On ferme le fichier associé à l’unité logique 1print,a On affiche la variable a pour vérification 2 4 6 8 10

openw sert donc à ouvrir un fichier en écriture (write) et openr en lecture (read).Remarquez que c’est très proche de la lecture au clavier ou de l’écriture à l’écran, sauf que l’on aremplacé print et read par printf et readf (pour print file et read file). En réalité, lescommandes read et print sont respectivement équivalentes à readf,0 et printf,-1!: lesnuméros d’unités logiques pour le clavier et l’écran sont respectivement 0 et -1. Il ne faut doncpas les utiliser pour un fichier. Le numéro d’unité logique peut prendre des valeurs entre 1 et 99.On peut également utiliser un mot-clé pour ne pas avoir à choisir un numéro, et surtout être sûr dene pas utiliser un numéro d’unité logique déjà utilisé par ailleurs, ce qui ferait «!planter!» leprogramme. Ce mot clé est /get_lun (pour get logical unit number). On ferme alors le fichiernon pas par close, mais par la commande free_lun (pour free logical unit number). Les numérosd’unités logiques ainsi utilisés s’étendent entre 100 et 128, ce qui veut dire que l’on peut aumaximum ouvrir 29 fichiers simultanément de cette façon. Reprenons l’exemple ci-dessus aveccette formulation!:a=[2,4,6,8,10]print,a 2 4 6 8 10openw,unit,’tableau.dat’,/get_lun On ouvre en écriture le fichier

t a b l e a u . d a t , et IDL metautomatiquement un numéro d’unité logiquedans la variable unit

printf,unit,a IDL écrit le contenu de la variable a dans lefichier associé à unit

free_lun, unit On libère l’unité logique unit

a=intarr(5)print,a 0 0 0 0 0


openr,unit,’tableau.dat’,/get_lun On ouvre en lecture le fichiertableau.dat et IDL met automatiquementun numéro d’unité logique dans la variableunit

readf,unit,a IDL lit le contenu du fichier associé à l’unitélogique unit dans la variable a

free_lun,unit On libère l’unité logique unitprint,a 2 4 6 8 10

Notons enfin qu’il existe une autre forme d’écriture dans un fichier déjà existant, qui consiste àajouter des données en fin de fichier. C’est la commande openu (où le ‘u’ est pour update!:mettre à jour) qui permet cela. L’ouverture du fichier se fait en ajoutant à la commande openu lemot-clé /append (pour «!coller à la fin!») de la façon suivante!:Openu,unit,nom_du_fichier,/get_lun,/append

Une fonction utile!: Pour choisir un nom de fichier en lecture, on peut utiliser la fonctiondialog_pickfile qui affiche une fenêtre permettant de choisir en cliquant le nom de fichierà mettre dans une variable!:fichier=dialog_pickfile()print,fichier

s’affiche alors le chemin complet d’accès et le nom de fichier. On peut donc remplacerdans les exemples ci-dessus le nom en clair ‘tableau.dat’ par la variable fichier.[notez que dans les versions d’IDL antérieures à la version 4, cette fonction n’existe pas, mais ilexiste une autre fonction semblable!: pickfile, qui s’utilise de la même façon!:fichier=pickfile()]. On peut ajouter le mot-clé FILTER= à cette fonction afin den’afficher que les fichiers ayant un certain type de nom. Par exemple, si on désire ne voir que lesfichiers ayant une extension ‘.dat’, on met!:fichier=dialog_pickfile(filter=’*.dat’)Le symbole * remplace n’importe quel nombre de caractères.

15) Les renvois conditionnelsLes conditions d’exécution d’une commande se traduisent par la commande!:if expression then commande1 else commande2que l’on peut traduire en français ainsi!: «!Si l’expression est réalisée, alors on exécutecommande1, et sinon, on exécute commande2.!»Cette commande est surtout utile au sein des procédures et des fonctions, comme on le verra plusloin.La partie else commande2 n’est pas obligatoire. Si on l’omet, cela signifie que si la conditionn’est pas réalisée, rien ne se passe.L’expression est une condition. Elle s’exprime en termes de comparaison, avec des opérateursrelationnels!:

Nom anglais Nom français Nom anglais Nom françaislt lower than plus petit que le lower or equal inférieur ou égalgt greater than plus grand que ge greater or equal supérieur ou égal


eq equal égal ne non equal différentCes opérateurs sont encadrés d’espaces pour être reconnus, et les comparaisons complètes,entourées de parenthèses. On peut également associer à ces opérateurs relationnels des opérateursbooléens (logiques) pour effectuer plusieurs sortes de comparaisons.Ainsi, on peut écrire!:a=3b=2if (a le b) then c=1 else c=0 on pourrait écrire, de façon tordue!:

if not(a gt b) then c=1 else c=0print,c0if ((a gt b) and (c eq 0) then print,’Pas de doute, a > b’ else

print,’Dans ce cas, a < b’(toute cette ligne doit être tapée sur une seule ligne, ou alors, il faut utiliser le signe decontinuation $)

Attention à une erreur fréquente qui consiste à faire la comparaison avec le signe ‘=’ au lieu del’opérateur ‘eq’.

16) Les bouclesLes boucles sont des moyens d’effectuer de façon simple des actions répétitive. Leur utilitéapparaîtra plus amplement quand nous aborderons la partie écriture d’une procédure.

a) La boucle FOR … DO …Sa forme générale est!:for variable = expression1, expression2, incrément do commandevariable est le nom de variable qui va servir à compter le nombre de fois que l’on effectue lamême opération!; expression1 est la valeur de départ de la boucle, expression2 sa valeurfinale, incrément indique la valeur que l’on ajoute à la valeur précédente à chaque fois quel’on effectue le calcul ou la commande. Quant à la commande, ce peut être n’importe quelleexpression!: un calcul, un affichage, …La commande ci-dessus peut se traduire en français de la façon suivante!; «!Effectuer lacommande en faisant commencer la variable à expression1 et en l’incrémentant deincrément à chaque fois jusqu’à ce que l’on dépasse expression2!».Par exemple!:a=intarr[10]for i=0,9,1 do a[i]=2*(i+1)

ces deux lignes vont permettre de remplir le tableau a avec les nombres pairs entre 2 et 20(rappel!: IDL commence à compter à 0).

Quand l’incrément est de 1, on peut l’omettre!: l’exemple ci-dessus est équivalent à!:a=intarr[10]for i=0,9 do a[i]=2*(i+1)

Autre exemple!:


for i=0,10 do print,factorial(i) 1.0000000 1.0000000 2.0000000 6.0000000 24.000000 120.00000 720.00000 5040.0000 40320.000 362880.00 3628800.0

On peut ainsi également remplir des tableaux à plusieurs dimension en imbriquant les boucles lesunes dans les autres comme dans les exemples suivants!:a=intarr[4,4]for j=0,3 do for i=0,3 do a[i,j]=(i+1) + 4*jprint,a

1 2 3 45 6 7 89 10 11 1213 14 15 16

for j=0,3 do for i=0,3 do a[i,j]=(i+1)*(j+1)print,a

1 2 3 42 4 6 83 6 9 124 8 12 16

b) La boucle WHILE … DO …Cette boucle est équivalente à une boucle FOR … DO … accompagnée d’une condition. Saforme générale est!:while expression do commandece qui peut se traduire en français!: «!tant que l’expression est réalisée, continuer à effectuer lacommande indiquée!».Par exemple, supposons que l’on ait un tableau de nombres pairs, et que l’on souhaite savoir pourquelle valeur de l’indice (commençant à 0) le contenu de ce tableau devient supérieur à 10!:a=intarr[10] On définit le tableaufor i=0,9 do a[i]=2*(i+1) On le remplit de nombres pairsj=0 On initialise l’indicewhile (a[j] le 10) do j=j+1 On boucle tant que a(j) est inférieur ou égal à 10,

c’est-à-dire jusqu’à ce que a(j) soit supérieur à 10!!print,j5 On constate que la boucle while a continué jusqu’à

ce que a(j) ait dépassé 10, et j vaut donc 1 de plusque l’indice!: pour j=4, la condition était encore


vérifiée et donc l’opération j=j+1 s’est effectuée. Ilfaut donc être très prudent quand on effectue cegenre d’opérations.

Cela pourrait s’écrire autrement de la façon suivante!:a=intarr[10]for i=0,9 do a[i]=2*(i+1)j=0for i=0,9 do if (a[i] le 10) then j=iprint,j4

Cette fois-ci, on a bien directement la bonne valeur!! Pour while, son utilisation dans desprocédures de commandes permettra de mieux voir son intérêt.

17) Gestion des fenêtresQuelques commandes IDL permettent de manipuler les fenêtres graphiques. Pour ouvrir unefenêtre, il faut entrer WINDOW,n où n est le numéro de fenêtre à ouvrir (entre 0 et 31). Pourfermer une fenêtre déjà ouverte : WDELETE,n où n est le numéro de la fenêtre à fermer.Quand plusieurs fenêtres sont ouvertes, pour rendre active la fenêtre n, il faut entrer : WSET,n.Pour effacer le contenu de la fenêtre actuellement active, on utilise la commande ERASE.

18) Les tracés simplesL’une des grandes forces d’IDL réside en ses possibilités de tracés. Il est donc largement tempsde les voir. Pour ce faire, nous allons commencer par définir des tableaux qui nous servironsensuite pour les tracés!:

x1=fltarr(361)On définit ici un tableau x1 comprenant 361 éléments, allant de 0 à 360 qui va correspondreaux abscisses des tracés.

for i=0,360 do x1[i]=float(i)On affecte à x1 les nombres REELS de 0 à 360. Cela va correspondre à des angles endegrés.

ang=fltarr(361)On définit un autre tableau de mesure d’angles

for i=0,360 do ang[i]=2.*!pi/360.*float(i)Ce tableau ang correspond à la transformation de l’angle x1 qui est en degrés en radians.Remarquez que dans l’opération, on a bien pris soin de tout exprimer en nombres réels afind’éviter les mauvaises surprises.

y1sin=fltarr(361)Le tableau y1sin va correspondre aux ordonnées des tracés

for i=0,360 do y1sin[i]=sin(ang[i])On calcule ici le sinus de l’angle exprimé en radians

y1cos=fltarr(361)On définit un autre tableau…


for i=0,360 do y1cos[i]=cos(ang[i])… qui est défini en calculant le cosinus des angles en radians

x2=fltarr(21)On défini une autre abscisse comportant 21 éléments classés de 0 à 20.

for i=0,20 do x2[i]=float(i)La valeur de x2 est le nombre réel correspondant à l’indice.

y2fact=fltarr(21)On définit une ordonnée associée à x2

for i=0,20 do y2fact[i]=factorial(i)y2fact n’est que le calcul du factoriel de l’indice (i!). La fonction factorial transformeautomatiquement le résultat en nombre réel. Il n’est donc pas nécessaire d’utiliser float

y2exp=fltarr(21)Un deuxième tableau associé à x2

for i=0,20 do y2exp[i]=exp(i)qui correspond à l’exponentielle de l’indice. Ici aussi, la fonction exp transforme le résultaten nombre réel automatiquement

y1y2=fltarr(361,21)Enfin, un dernier tableau, à deux dimensions, cette fois, qui va servir pour d’autres sortesde tracés

for i=0,360 do for j=0,20 do y1y2[i,j]=y1sin[i]*y2exp[j]Le tableau y1y2 est donc égal au produit du sinus par l’exponentielle.

a) Le tracé à une dimension, plotLa commande plot trace une courbe, c’est-à-dire un graphique à 2 dimensions, quelque chosede la forme y=f(x). L’axe des abscisses est donc x et celui des ordonnées y. Cela signifie que lacommande plot ne s’applique qu’à un tableau à 1 seule dimension.La façon la plus simple d’utiliser la commande plot est la suivante!:plot,y1sinet le dessin suivant s’affiche dans une nouvelle fenêtre!:

Notez que l’on n’a pas besoin de préciser les indices. Si on voulait n’en tracer qu’une partie, de 0à 180 par exemple, il faudrait préciser les indices!:plot,y1sin[0:180]En entrant la commande plot,y1cos, on trace donc un cosinus. Mais on peut améliorer leschoses. Tout d’abord, on a ici les angles exprimés en degrés (en réalité, c’est l’indice qui est


affiché), mais on pourrait souhaiter les avoir en radians. Pour cela, il suffit, avant de mettre lenom de la variable à tracer, de mettre le nom de la variable contenant les valeurs des abscisses!:plot,ang,y1sin

On peut maintenant désirer mettre un titre à l’axe des abscisses (angle x en degrés), un autre àl’axe des ordonnées (sinus(x)), et un titre général au graphique (fonction sinus). Ce sont les mots-clés xtitle=valeur, ytitle=valeur et title=valeur qui vont le permettre!:xt=’angle x en degres’plot,y1sin,xtitle=xt,ytitle=’sinus(x)’,title=’fonction sinus’

Attention!: par défaut, en général, les accents ne passent pas dans les graphiques!!

On obtient donc la figure ci-dessous!:

Si maintenant, on souhaite tracer une fonction dont l’étendue (en abscisse et/ou en ordonnée) esttrès importante, on peut avoir des problèmes avec cette méthode. Par exemple, le tableau defactorielles y2fact calculé plus haut donnerait!:

Ce qui n’est pas des plus explicite…Heureusement, il existe une variante de PLOT qui permet d’utiliser des échelles logarithmiques!:PLOT_IO, PLOT_OI, PLOT_OOLes deux lettres suivant le caractère blanc souligné représentent respectivement l’abscisse etl’ordonnée. La lettre I indique un tracé linéaire, et la lettre O un tracé logarithmique.Ainsi, pour le tracé de factorielle ci-dessus, la commande suivante permettra d’effectuer un tracélinéaire suivant les abscisses et logarithmique suivant les ordonnées!:PLOT_IO,y2fact


On obtient alors le tracé ci-dessous, nettement plus «!lisible!»!:

b) Superposition de figures, OPLOTOn pourrait désirer superposer au tracé de sinus le tracé du cosinus. Pour ce faire, on utilise lacommande OPLOT (pour ‘overplot’). Le principe de cette commande est d’effectuer le nouveautracé dans le cadre défini par la commande PLOT précédente. PLOT efface la fenêtre avantd’effectuer le tracé, contrairement à OPLOT.On ne peut donc pas redéfinir les valeurs des axes, ni les labels. Par contre, on peut définir le typede ligne utilisé pour le tracé grâce au keyword LINESTYLE, qui peut aussi s’appliquer à lacommande PLOT. De plus, OPLOT utilise le système (linéaire ou log) adopté par PLOT.Donc, les commandes permettant de tracer la fonction sinus avec un trait continu, la fonctioncosinus avec des pointillés, d’avoir l’angle en radians en abscisse sont!:xr=’Angle en radians’PLOT,ang,y1sin,xtitle=xr,ytitle=’sinus/cosinus(x)’, $

title=’fonctions sinus et cosinus’OPLOT,ang,y1cos,linestyle=1

Les différents styles de lignes que l’on peut choisir avec LINESTYLE sont!:0!= Trait continu1 = Pointillé2 = Tirets3 = Point-tiret4 = Point-point-point-tiret5 = Grands tirets


c) Tracés à deux dimensions, SURFACE et SHADE_SURFBeaucoup de données nécessitent des tracés à deux dimensions!: une intensité en fonction de X etY.La première solution consiste à utiliser SURFACE, qui efface la fenêtre en cours (ou en ouvreune) et trace une vue inclinée du tableau suivant 3 axes X, Y et Z.Voici la façon dont est représentée la surface correspondant au tableau y1y2 grâce à lacommande!:SURFACE,y1y2

Le quadrillage qui y est visible correspond à celui des axes X et Y (Z est l’axe vertical).SHADE_SURF,y1y2 donnerait, quant à lui!:

Ce sont les ombres qui font ressortir ici le relief de cette surface. Ces deux types de tracésfonctionnent exactement de la même façon.On peut redéfinir les valeurs des axes X et Y du tracé en les introduisant dans la commande (maisaprès le tableau à tracer, contrairement à ce que l’on fait avec PLOT)!:SURFACE,y1y2,X,YOn peut également donner un titre et des labels à chacun des axes du tracé avec les keywords!:TITLE=…, XTITLE = …, YTITLE = …, ZTITLE = …Enfin, on peut demander une échelle logarithmique pour l’un ou plusieurs des axes grâce auxkeywords!:XLOG=1, YLOG=1, ZLOG=1(ou /XLOG, /YLOG, /ZLOG)SURFACE et SHADE_SURF, comme PLOT, effacent la fenêtre (si elle existe déjà) avantd’effectuer le tracé.


d) Images, TV et TVSCLQuand il s’agit réellement d’une image (exemple typique, une image de détecteur), la commandeTV permet d’afficher cette image, comme dans l’exemple ci-dessous pour les données dat!:TV,dat

Dans les cas où l’étendue de valeurs du tableau image serait beaucoup plus petite, ou plus grandeque l’étendue de couleurs ou niveaux de gris disponibles sur le tracé, l’image peut prendre unaspect étrange. Pour éviter ce genre de problème, la commande TVSCL (pour TV scale, mettre àl’échelle) permet d’optimiser automatiquement l’étendue des données par rapport à l’étendue del’affichage. Son fonctionnement est rigoureusement le même que pour TV!:TVSCL, datAucune de ces deux commandes n’efface la fenêtre avant d’effectuer le tracé, d’où l’utilité de lacommande permettant d’effacer la fenêtre!:ERASE

e) Les isocontours, CONTOUR, et superposition à une image, IMAGE_CONTLa commande CONTOUR permet de tracer les isocontours d’une image. On peut définir lesniveaux d’isophotes grâce au mot-clé LEVELS auquel on adjoint un vecteur contenant les valeursque l’on désire (soit en utilisant un tableau, soit directement). La figure ci-dessous à gauchereprésente le tracé avec la commande!:CONTOUR,datet la figure de droite, avec la commande!:CONTOUR,dat,levels=[250,350,450,550,650,750,850]

Il peut souvent être utile de pouvoir superposer les isophotes à l’image originale. Le moyen leplus simple (et de loin) consiste à utiliser la commande IMAGE_CONT.


IMAGE_CONT,dat donne l’image suivante!:

19) Des tracés plus évolués

a) Annotation d’un tracé, XYOUTSRevenons au tracé du 18) b) qui montre le sinus et le cosinus. On pourrait souhaiter rendre lafigure plus claire en précisant quelle courbe correspond à quelle fonction. Une commande permetd’écrire du texte sur une figure!: XYOUTS. Elle fonctionne sur tous les types de tracés. Sa formegénérale d’utilisation est!:XYOUTS,X,Y,texteOù X et Y sont les position de début d’écriture, et ‘texte’ est le texte à écrire.Ainsi, pour tracer la figure ci-dessous, il faut entrer les lignes qui suivent!:

xr=’Angle en radians’PLOT,ang,y1sin,xtitle=xr,ytitle=’sinus/cosinus(x)’, $

title=’fonctions sinus et cosinus’OPLOT,ang,y1cos,linestyle=1

; Jusqu’ici, rien n’a changéoplot,[6,6.5],[0.5,0.5],linestyle=0 ; On trace un trait plein

de X=6 à X=6.5, en Y=0.5xyouts,6.6,0.5,'sinus' ; On écrit ‘sinus’ en X=6.6, Y=0.5oplot,[6,6.5],[0.25,0.25],linestyle=1 ; On trace un trait

pointillé de X=6 à X=6.5 en Y=0.25


xyouts,6.6,0.25,'cosinus' ; On écrit ‘cosinus’ en X=6.6,Y=0.25

b) Borner le tracéOn peut très bien ne tracer qu’une partie de l’étendue du tableau à tracer. L’une des façons peutconsister à ne dire de tracer qu’entre telle et telle valeur de l’indice, par exemple!:PLOT,dat[50:120]Mais on ne sait pas toujours à quel indice couper. Il est souvent plus commode de dire!: «!Je veuxtracer l’abscisse entre x1 et x2 et l’ordonnée entre y1 et y2!». Pour ce faire, on peut, dans PLOT,SURFACE et SHADE_SURF définir une étendue (en anglais «!range!») pour chaque axe, X, Y, ouZ grâce aux mots-clés XRANGE, YRANGE, ZRANGE, et lui imposer de s’y conformer (sinon, IDLpeut avoir tendance à arrondir les bornes) en mettant à 1 le mot-clé correspondant XSTYLE,YSTYLE ou ZSTYLE, comme dans l’exemple ci-dessous!:PLOT,X,dat,YRANGE=[10,50],/YSTYLE

c) Les couleurs, LOADCT et XLOADCT et autres utilités graphiques• Pour les surfaces ombrées (SHADE_SURF) et pour les tracés d’images (TV et TVSCL), on peutchoisir des tables de couleurs (ou des niveaux de gris) afin de mieux faire ressortir certainsmotifs. Taper la commande LOADCT affiche la liste de tables de couleurs disponibles (40) etdemande le numéro de la table choisie. On peut également entrer directement après LOADCT lenuméro de table (0 est la table de niveaux de gris)!:LOADCT,n où n est le numéro de la table à charger.Une autre solution consiste à lancer la commande XLOADCT qui affiche une fenêtre où l’on peutvisualiser les différentes tables, et y effectuer certaines corrections.• Sur les tracés divers présentés ci-dessus, on a pu remarquer que les courbes étaient en blanc surfond noir. Pourtant, pour des articles, par exemple, il est préférable d’avoir l’inverse. Pour cefaire, il suffit d’utiliser le mot-clé permettant de définir la couleur de fond (background) et lemot-clé définissant la couleur de tracé (color). La valeur 0 est le noir, et 255, le blanc. Donc!:PLOT,ang,y1sin,background=255,color=0 donne la figure suivante!:

• Enfin, on peut préférer tracer les points d’une fonction plutôt qu’une ligne continue enprécisant, avec la commande PLOT, le mot-clé PSYM (pour Plot SYMbol) que l’on met à lavaleur du symbole de tracé que l’on désire utiliser. Par exemple!:PLOT,ang,y1sin,PSYM=1 va tracer des signes + à chaque valeur.


(2=*, 3=., 4=diamant, 5=triangle, 6=carré, 7=X, 10=tracé d’histogramme)

II – Les procédures et fonctionsLes procédures et les fonctions sont des ensembles de commandes IDL regroupées dans unprogramme permettant d’automatiser certaines tâches. La plupart des commandes IDL sont soitdes procédures, soit des fonctions. XYOUTS , par exemple, est une procédure, etDIALOG_PICKFILE est une fonction. Nous allons voir les différences entre ces deux sortes deprogrammes dans la suite. Mais à première vue, la principale différence est qu’une procédures’appelle directement (comme XYOUTS), alors qu’une fonction s’appelle sous la forme!:variable = nom_de_fonction(paramètres)comme par exemple!: nom_de_fichier=dialog_pickfile(filter=’*.dat’)Par exemple, les quelques lignes qui ont servi à tracer les fonctions sinus et cosinus pourraientêtre introduites dans une procédure, si l’on avait besoin d’effectuer souvent le même tracé.La ponctuation ‘;’ (point-virgule) indique un commentaire!: rien de ce qui le suit, jusqu’au retourchariot suivant, n’est pris en compte par IDL.Il est fortement recommandé (sinon obligatoire) de nommer toutes les procédures et fonctionsavec leur nom suivi de l'extension .PRO.Il est également recommandé d'utiliser le 'template' fourni par IDL (template.pro) quiindique un certain nombre d'informations à mettre en début de programme pour en faciliterl'utilisation.

1) Règles générales

a) ProcéduresUne procédure commence toujours par PRO suivi du nom de la procédure, et éventuellement d’uncertain nombre de paramètres, et se termine toujours par END!:PRO nom_de_procédure,param1,param2,…Liste de commandes IDL ...END

b) FonctionsUne fonction commence toujours par FUNCTION suivi du nom de la fonction, et éventuellementd’un certain nombre de paramètres. Son avant-dernière lignes est RETURN suivi d’un nom devariable, et elle finit par END!:FUNCTION nom_de_fonction,param1,param2, …Liste de commandes IDL ...RETURN,variableENDC’est la variable qui suit la commande RETURN qui est renvoyée lors de l’appel de la fonction.


2) Utilisation

a) GénéraleUne procédure s’appelle simplement par son nom, suivi des éventuels paramètres et mots-clés quil’accompagnent. Une virgule sépare le nom de la procédure des autres termes, ainsi lesparamètres et mots-clés entre eux.Une fonction s’appelle de la façon suivante!:variable = nom_fonction(paramètres, mots_clés)Les paramètres et mots-clés, tous regroupés entre parenthèses, sont séparés les uns des autres pardes virgules.Pour pouvoir être exécutée, une procédure, ou une fonction, doit être compilée, y compris aprèschaque modification.C’est la commande .run qui permet de le faire.Pour qu’IDL sache qu’il s’agit d’une procédure ou d’une fonction, il faut que le répertoire oùcelle-ci est enregistrée fasse partie du «!path!» ou du «!working path!» (cf l’introduction).Normalement, dans ce cas, les procédures sont automatiquement compilées. Par contre, il estfortement recommandé de compiler toutes les fonctions que l’on a créées avant de tenter de lesexécuter (car dans certains cas, IDL n’a pas le moyen de savoir s’il s’agit d’une fonction ou biend’un tableau qui a été mal défini).Les procédures et fonctions peuvent bien sûr s’appeler les unes les autres.

b) Passage de paramètres entre programmes

a) Paramètres de positionL’utilisation de ces paramètres, comme leur nom l’indique, dépend de leur position. C’est-à-direque la transmission se fait dans un ordre précis depuis le programme appelant (ou directementdepuis IDL), et la procédure ou fonction les utilise dans ce même ordre. Par exemple!:XYOUTS,X,Y,texteLa procédure d’écriture de texte dans les figures sait que le premier paramètres est la position enX, le second la position en Y et le troisième le texte à écrire.Dans le cas suivant!:PLOT,ang,y1sinla procédure compte le nombre de paramètres (nous verrons au d) ci-dessous comment faire)!: s’iln’y en a qu’un, c’est le tracé à effectuer, s’il y en a deux, le premier indique les valeurs desabscisses et le second correspond au tracé.Le nombre de paramètres dans l’appel et dans la procédure ou fonction doit être le même, SAUFsi l’on teste leur présence dans la procédure ou fonction.En résumé, ces paramètres doivent être en bon nombre et dans l’ordre qu’il faut.

b) Mots-clés (keywords)Les mots-clés, quant à eux, sont optionnels. Leur position importe peu. En effet, ils secaractérisent par la présence d’un nom, du genre!:nom_keyword=variable


Par exemple, pour la fonction dialog_pickfile, on a vu que l’on pouvait utiliser un filtre defichier sous la forme suivante par exemple!:flt=’*.dat’fn=dialog_pickfile(filter=flt)Dans le cas de la procédure PLOT, on avait utilisé!:PLOT,ang,y1sin,background=255,color=0On pourrait aussi bien l’écrire!:PLOT,ang,y1sin,color=0,background=255On ne peut pas changer les position des deux premiers paramètres, mais les deux mots-clés,color et background se mettent où on veut (la présence de leur nom de mot-clé permet à laprocédure ou fonction de les reconnaître).Rappelons que la forme /keyword équivaut à écrire keyword=1.

g) CommonUne autre façon de passer des arguments entre procédures et fonctions consiste à utiliser le‘common’. Le common porte un nom séparé des paramètres à transmettre par une virgule. Iciencore, c’est la position des paramètres qui est déterminante. Le common est très rigided’utilisation!: il doit impérativement comporter toujours le même nombre de variables et on nepeut PAS le modifier au cours d’une même session IDL. Si on veut le corriger, il faut quitter IDLet le relancer. L’avantage du common est de permettre de transmettre de longues séries devariables (constantes ou tableaux ou structures) sans être obligé de les retaper lors de l’appel de laprocédure ou de la fonction. Voici sa forme générale!:common nom,var1,var2,var3,...

d) Vérification de la validité des paramètresDans un procédure ou fonction, on a vu qu’il pouvait être utile de vérifier le nombre deparamètres (comme dans PLOT), ou si des mots-clés étaient utilisés. Pour ce faire, on dispose detrois commandes IDL!:• La fonction N_PARAMS renvoie le nombre de paramètres qui ont été inclus dans l’appel de laprocédure ou de la fonction!:nbre=N_PARAMS()On peut ainsi vérifier si tous les paramètres sont présents ou sélectionner ce que l’on va fairesuivant le nombre de paramètres (comme dans le cas de PLOT, vu ci-dessus).• N_ELEMENTS est une fonction qui renvoie le nombre d’éléments de la variable ou del’expression donnée en argument!:nb=n_elements(expression)Exemple!:aa=[1,2,3,4] ; aa est donc un tableau entier de 4 élémentsprint,n_elements(aa)

4print,n_elements(bb)

0


car la variable bb n’est pas définie. Cette fonction offre donc la possibilité de vérifier qu’unevariable (et donc un paramètres dans une procédure ou fonction) est bien définie, et sinon,éventuellement de lui donner une valeur par défaut.• KEYWORD_SET est une fonction qui renvoie une valeur non nulle si son argument est défini etnon nul. On l’utilise, comme son nom l’indique pour tester la présence de mots-clés dans uneprocédure ou fonction et pouvoir éventuellement donner des valeurs par défaut aux variables dontles mots-clés ne sont pas spécifiés. Par exemple, on peut imaginer que PLOT contient quelquechose du genre!:if not(KEYWORD_SET(color)) then color = 255if not(KEYWORD_SET(backgroung)) then background = 0En clair!: si ces deux keywords ne sont PAS précisés (d’où le ‘not’), on leur donne des valeurspar défaut.

3) Les boucles et testsL’un des intérêts des procédures et fonctions est de pouvoir effectuer des opérations qui prennentplusieurs lignes de calcul. D’où l’importance des boucles et des tests. Toutes les boucles et testspeuvent s’imbriquer les uns dans les autres. La seule contrainte est qu’il ne doit pas y avoir decroisement entre boucles ou tests différents.

a) For ... doLa boucle FOR est l’une des plus utilisées. On l’a vue sur une ligne de commande!:FOR var1=val1,val2,val3 DO expressionRappelons que val3 est optionnelle. Son absence signifie un incrément de 1.Il est fréquent que l’on ait besoin d’effectuer plusieurs calculs dans une même boucle. Pour cela,on utilise une formulation de ce type!:FOR k=0,n-1 DO BEGIN

calcul1calcul2

ENDFORL’indentation des lignes dans une boucle est une règle utile afin d’être sûr de bien refermer lesboucles ouvertes!: chaque begin (qu’il s’agisse de FOR ou d’autre chose) engendre dans leslignes suivantes une indentation supplémentaire qui s’achève avec le END correspondant!:FOR k=0,n-1 DO BEGIN

calcul1FOR l=0,k DO BEGIN

calcul2calcul3

ENDFORcalcul4

ENDFOR

b) If ... thenDe même, le test IF, que l’on a vu sur une seule ligne de commande sous la forme!:IF condition THEN expression1 ELSE expression2


peut s’écrire sur plusieurs lignes afin de pouvoir exécuter une ou plusieurs expressions si lacondition est vérifiée, et une ou plusieurs expressions si elle ne l’est pas. Voici les différentesformulations possibles!:• Forme simple!:IF condition THEN BEGIN

calcul1calcul2

ENDIF ELSE calcul3• Variante!:IF condition THEN BEGIN

calcul1calcul2

ENDIF ELSE BEGINcalcul3calcul4

ENDELSE• Plusieurs tests à effectuer!:IF condition1 THEN BEGIN

calcul1calcul2

ENDIF ELSE IF condition2 THEN BEGINcalcul3calcul4

ENDIF ELSE BEGINcalcul5calcul6

ENDELSE

c) While ... doL’expression WHILE sert à répéter une opération tant qu’une condition n’est pas remplie. Celarevient à une combinaison d’une boucle FOR et d’un test IF. Sur une seule ligne, on l’écrit!:WHILE condition DO expressionPar exemple, pour ajouter 1 à un nombre tant qu’il n’a pas dépassé 10!:WHILE (i LE 10) DO i=i+1On peut également effectuer plusieurs opération dans cette boucle!:WHILE condition DO BEGIN

calcul1calcul2

ENDWHILE

d) Case … ofL’expression CASE revient à effectuer une multitude de tests IF successif de façon «!propre!».Son sens est!: «!Dans le cas où l’expression aurait!: telle valeur, faire telle chose!; telle autrevaleur, faire telle autre chose!; etc...!». Sa forme générale est!:CASE expression OF


expression1: expressionexpression2: BEGIN

calcul1calcul2

ENDexpression3: expression

ELSE: BEGINcalcul3calcul4END

ENDCASEUn petit exemple sera plus parlant!:Rep=’’READ,PROMPT=’Entrez votre réponse (entre 1 et 3)’,repCASE rep OF

1: PRINT,’Vous avez entré 1’2 OR 3: BEGIN

PRINT,’Vous avez entré 2’PRINT,’ou bien 3’

ENDELSE: PRINT,’Vous avez entré autre chose’ENDCASE

e) Repeat … untilCette expression permet de répéter une opération jusqu’à ce qu’une condition soit réalisée. Saforme sur une ligne de commande est!:REPEAT calcul UNTIL conditionOn peut également mettre cette expression sur plusieurs lignes, suivant les besoins!:REPEAT BEGIN

calcul1calcul2mise à jour éventuelle de la condition

ENDREP UNTIL condition

f) Les sorties de boucles et labelsLa sortie de boucle est toujours un problème. Par exemple, quand on teste les éléments d’untableau jusqu’à trouver l’élément recherché, il faut interrompre la boucle. La méthode classiqueconsiste – même si ce n’est pas très sain, car les conditions de test des boucles ne sont jamaisvérifiées – à utiliser la commande GOTO. Elle s’utilise sous la forme!:GOTO,labeloù label est un nom qui apparaît ailleurs dans le programme suivi de ‘:’ (deux points), indiquantl’endroit où le programme doit continuer. Exemple!:FOR i=0,ind DO BEGIN

IF tab(i) eq (-1) THEN GOTO,suiteENDFOR


suite:…Depuis la version 5.4 d’IDL, il existe une commande permettant de sortir proprement d’uneboucle!: BREAK. Ainsi, l’exemple ci-dessus devient!:FOR i=0,ind DO BEGIN

IF tab(i) eq (-1) THEN BREAKENDFOR…

4) Commandes d’exécutionUn certain nombre de commandes permettent de compiler une procédure ou une fonction, del’interrompre, de la relancer, de sortir d’un programme après un plantage...• Tout d'abord, on peut souhaiter interrompre l'exécution d'une procédure qu'on a lancée parmégarde. Pour cela, il faut taper, sous UNIX ou VMS : Control-C ; Control-Break sousWindows ; ou Command-. (point) sous Macintosh• On peut également vouloir interrompre une procédure ou une fonction à certains endroits précis,afin de pouvoir vérifier la validité des résultats intermédiaires, avant de continuer. Pour ce faire,il suffit de rajouter aux endroits stratégiques une ligne contenant simplement la commande STOP.Le programme s'interrompt alors pour donner la main à l'utilisateur, en laissant les variables duprogramme en l'état, ce qui permet de les vérifier, de tracer des courbes, ... Pour continuerl'exécution, il faut taper, dans la ligne de commande IDL : .CONT (point-cont). Si on désirearrêter le programme (et donc perdre les calculs non enregistrés), il faut entrer dans la ligne decommande : RETALL. Cette commande RETALL sert d'une façon générale à reprendre la mainau niveau des variables d'environnement IDL quand une procédure ou une fonction a "planté"pour une raison quelconque. Si on veut reprendre le programme n lignes plus loin, au lieu de.CONT , il faut entrer .SKIP n (point SKIP espace n). Cela peut permettre de faire unbranchement manuel à une autre partie de programme.• .COMPILE (point-compile) permet de compiler des procédures ou fonctions (indispensableavant de pouvoir les exécuter).• .RUN (point-run) compile également procédures et fonctions mais, dans le cas d'un programmeprincipal, lance l'exécution à la suite de la compilation.• .RNEW (point-rnew) est identique à .RUN, mais, en plus, il remet toutes les variables duprogramme à zéro (sauf celles qui sont dans un COMMON, car, comme son nom l'indique, il estcommun à toutes les actions d'IDL, et donc aussi à l'environnement interactif).

III – Quelques fonctions avancées

1) Utilités graphiques

a) Sauver un graphique ou une imageOn peut récupérer l'image de la fenêtre en cours dans un tableau de données (il s'agit vraimentd'une représentation point à point de la fenêtre : pour un PLOT, par exemple, les textes divers,titres et autres, sont aussi sauvegardés) grâce à la fonction TVRD :tab=TVRD()


Le tableau tab ainsi créé a donc les dimensions en pixels de la fenêtre.Des commandes permettent de sauvegarder soit les fenêtres, soit les tableaux de données (issusdes fenêtres ou non, ce peut être directement les données non arrangées pour le tracé) sous desformats d'images variés. Citons les principaux :• WRITE_JPEG,nom_de_fichier,tableau,quality=nle mot-clé quality indique la qualité de l'image JPEG à créer (c'est-à-dire l'inverse du taux decompression). Par défaut, quality=75. Une très mauvaise qualité d'image, mais excellentecompression est : quality=0. Une excellente qualité mais mauvaise compression est donnéepar quality=100 (c'est le maximum).• WRITE_GIF,nom_de_fichier,tableau• WRITE_PNG,nom_de_fichier,tableau (PNG est un format lisible par les navigateursweb)• WRITE_PICT,nom_de_fichier,tableauDans le cas de ce format (pour Macintosh), lavariable tableau n'est pas indispensable. Si on l'omet, la fenêtre en cours est sauvée au formatPICT.

b) Faire du PostcriptPar défaut, les commandes graphiques sont dirigées vers le système de fenêtrage de la machineutilisée (X Windows pour UNIX et VMS, Windows pour PC, Mac pour Macintosh). Mais onpeut demander explicitement que ces commandes soient dirigées vers un autre type de sortie,particulièrement vers un fichier postcript, ce qui peut être indispensable pour les articles, parexemple.Le nom du système de fenêtrage utilisé pour les tracés se trouve dans une variable système qui estune structure (voir le 2) ci-dessous pour les structures), et on peut donc le récupérer dans unevariable :a=!d.nameLa commande print,a donnera, suivant les cas, X, ou MAC, ou WIN, ...Pour rediriger les sorties graphiques vers un fichier postcript (dont le nom par défaut, si lacommande DEVICE n'est pas utilisée, est IDL.PS), il faut entrer la commande :SET_PLOT,'PS' (bien mettre PS en majuscules, il s'agit d'une chaîne de caractères).Pour fermer le fichier postcript ainsi créé, entrer : DEVICE,/CLOSE. Il faut alors rediriger lessorties graphiques vers le terminal utilisé (par exemple, pour un terminal X, il faudrait entrer :SET_PLOT,'X'). Le plus simple, pour avoir un programme portable sur tout type de terminal,est d'utiliser le contenu de !d.name comme vu plus haut. Exemple :a=!d.nameSET_PLOT,'PS'DEVICE,FILENAME='nom_du_fichier.ps' (on peut ajouter

/ENCAPSULATED pour avoir du postcript encapsulé)PLOT,ang,y1sin,title='sinus'DEVICE,/CLOSESET_PLOT,a


c) Plusieurs images sur une même fenêtreUne variable système définit le nombre de figures à tracer sur une même fenêtre (ou page, si le'device' utilisé est du postcript) : !p.multi.Avant d'effectuer le premier tracé, il faut entrer :!p.multi=[0,col,lign] où col est le nombre de colonnes que l'on désire et

lign le nombre de lignes (par exemple : !p.multi=[0,2,3] mettrasur la fenêtre 2 tracés par ligne sur 3 lignes)

Pour revenir à un seul tracé par fenêtre (ou page), il suffit d'entrer !p.multi=0

2) Les structuresUne structure est un type de variable spécial, multiple, qui peut comprendre plusieurs types sousun seul nom. On peut ainsi mélanger dans une même variable des entiers, des réels, des chaînesde caractères, etc...La définition d'une structure se fait de la façon suivante :a={champ_1: définition_1, champ_2,définition_2, ...}où le champ revient à un nom de variable, et la définition, à une valeur par défaut (par exemple 0pour un entier, 0. pour un réel, '' (chaîne vide) pour une chaîne de caractères) ou un tableau.Pour utiliser la structure, on met le nom suivi d'un point, suivi du nom du champ (sans espaces).Petit exemple standard tiré de la doc IDL :a={name:' ',ra=0.,dec=0.,inten=fltarr(12)}On peut directement entrer les valeurs des champs, bien sûr.Pour obtenir un tableau de structure, on utilise la fonction REPLICATE :b=REPLICATE(a,100) pour créer un tableau à 100 élémentsOn aurait pu le faire directement de la façon suivante :a=REPLICATE({name:' ',ra=0.,dec=0.,inten=fltarr(12)},100)Pour remplir le ième élément de cette structure a, on fait :a[i] = {'Betelgeuse',12.4,54.2,fltarr(12)}Si l'on veut définir seulement le champ ra du 6ème élément de la structure, on entre :a[5].ra='30.3'Pour imprimer le 5ème élément du champ inten de la 6ème structure :print,a[5].inten[4]Pour créer une structure b identique à la structure a, il suffit de faire b=a.Enfin, pour voir la définition des différents champs définissant la structure a, il faut faire :help,a,/structureOn notera que, dans le b) du 1) ci-dessus, la variable système !p est une structure, dont l'un deschamps s'appelle multi.

3) Exécution indirecteIl peut parfois être utile de pouvoir disposer du nom d'une procédure ou d'une fonction dans unevariable. Ainsi, on peut, sans faire appel à IF décider dans un programme de la procédure oufonction à lancer, voire entrer directement ce nom au clavier quand le programme le demande.Une autre solution peut consister à construire dynamiquement une ligne de programme IDL.• CALL_PROCEDURE,'nom_de_procédure',argument1,argument2,...permet de lancer une procédure. Le nom de la procédure peut être dans une variable. Exemple :


var='PLOT'CALL_PROCEDURE,var,ang,y1sin,COLOR=127• res=CALL_FUNCTION('nom_de_fonction',argument1,argument2,…)fonctionne de la même façon que CALL_PROCEDURE. Exemple :res=CALL_FUNCTION('SQRT',4)• EXECUTE est une fonction plus universelle. Elle permet de mettre une commande dans unevariable de type chaîne de caractères, et de l'exécuter. Ainsi, on peut construire dynamiquementune commande sans être obligé d'aligner les lignes de programme pour prendre en compte toutesses combinaisons possibles. Elle s'utilise sous la forme :res=EXECUTE(cmd)res contient 1 si la commande s'est bien exécutée, et 0 s'il y a eu un problème.Petit exemple : on désire construire une commande de tracé de courbe (PLOT) générale, quitienne compte du tableau de valeurs des abscisses si le keyword absc, qui prend la valeur ang, aété entré dans la procédure et qui, sinon, fasse un tracé simple :cmd='PLOT,'if keyword_set(absc) then cmd=cmd+'ang,'cmd=cmd+'y1sin,color=127'res=EXECUTE(cmd)if (res eq 0) then print,'Problème de tracé'Si l'utilisation de la fonction EXECUTE est générale, elle est cependant plus lente queCALL_PROCEDURE et que CALL_FUNCTION, donc il vaut mieux utiliser ces deux dernièresquand c'est possible.

4) Gestion du curseur de la sourisIl est possible d'utiliser le curseur de la souris pour déterminer des positions sur une fenêtregraphique. Cela peut être utile par exemple pour déterminer l'endroit d'une coupe sur une image.La forme générale la plus utile est :CURSOR,X,Y,wait,/deviceX et Y vont contenir la position du curseur dans la fenêtre graphique (en coordonnées directesgrâce au keyword device). 'wait' est un paramètre qui détermine à quel type d'opérationIDL doit réagir. Les valeurs possibles de 'wait' sont :0 Renvoie immédiatement le résultat1 Renvoie le résultat si un bouton de souris est en position appuyée2 Renvoie le résultat si un bouton de souris est pressé, relâché, ou si on bouge la souris3 Renvoie le résultat si on appuie sur un bouton de souris4 Renvoie le résultat si on relâche un bouton de sourisExemple d'utilisation : data est un tableau image, et on utilise la souris pour déterminer où faireune coupe horizontale de cette image :TVSCL,dataCURSOR,x,y,4,/devicePLOT,data(*,y)


IV – Quelques conseils d’utilisation

1) Quelques trucs de programmationD'une façon générale, pensez à avoir une doc IDL sous la main et/ou à utiliser l'aide en ligne (quis'appelle par '? '). D'autre part, toutes les routines IDL proposées sont optimisées, donc necherchez pas à refaire ce qui existe déjà. Par exemple, la commande TOTAL, qui effectue lasomme des éléments d'un tableau est 10 fois plus rapide que d'effectuer une boucle FORéquivalente.• Pour aller plus vite dans les calculs quand on effectue des boucles sur les indices, il estimportant de les manipuler dans l'ordre correct, sous peine de multiplier le temps de calcul defaçon considérable. IDL se déplace sur une même ligne en premier (1er élément de la premièreligne jusqu'au dernier élément de la première ligne avant de passer au 1er élément de la 2ème ligne),comme en Fortran. Sous IDL, le 1er indice représente donc la colonne et le second la ligne. Parexemple, soit un tableau tab[3,2] : il a 3 colonnes et 2 lignes, qui sont :

tab[0,0] tab[1,0] tab[2,0]tab[0,1] tab[1,1] tab[2,1]

Pour aller le plus vite dans le calcul, il faut donc faire varier d'abord le 1er indice du début à la fin.Par exemple, soit tab un tableau 512x512. Si on doit faire un calcul sur tous les éléments dutableau, il faut entrer :FOR y=0,511 DO FOR x=0,511 DO tab[x,y]=...(Si le calcul sur le tableau est un tant soit peu compliqué, on peut gagner jusqu'à un facteur 50 entemps par rapport à la formulation inverse).• Quand on manipule des tableaux, il faut faire attention à optimiser leur apparition dans desformules. Par exemple, si tab est un tableau de n éléments, l'opération :B = tab * 16. / MAX(tab) effectue 2xn opérations alors queB = 16. / MAX(tab) * tab effectue n+1 opérations.• Il faut éviter les tests IF dans les boucles car ils ralentissent considérablement l'exécution. Onpeut souvent les remplacer par des opérateurs logiques (valant 0 ou 1). Par exemple :for i=0,(n-1) do if (b[i] gt 0) then a[i]=a[i]+b[i]peut être remplacé par :a = a + (b gt 0) * b• Il faut également sortir des boucles tout ce que l'on peut en sortir (ce n'est pas la peined'effectuer n fois le même calcul qui pourrait l'être hors de la boucle).• Quand on effectue une opération sur une même variable (ou tableau), une variable (ou tableau)temporaire est créé(e) le temps de l'opération. Si on travaille sur de gros tableaux de données quisont à la limite de la mémoire disponible, l'opération simple tab = tab + 1 va occuper 2 foisplus de mémoire, et risque de faire planter IDL. Une solution à cela est d'utiliser la fonctionTEMPORARY qui ne nécessite pas de mémoire supplémentaire :tab = TEMPORARY(tab) + 1

2) Quelques erreurs fréquentesUn certain nombre d'erreurs sont standard dans tous les langages de programmation :• Oubli d'une parenthèse dans une formule• Oubli d'un END après un BEGIN (pour les FOR, IF, CASE, …)• Erreur de frappe dans un nom de variable


• Erreur dans le nom d'une commande• Dans une chaîne de caractères, mettre une apostrophe dans la chaîne• Mettre le signe '=' dans un opérateur logique au lieu de 'eq'

D'autres erreurs sont plus typiques d'IDL :• La plus classique : se tromper dans les indices d'un tableau (rappelons que les indices d'untableau de 512 éléments s'étendent de 0 à 511)• Utiliser un mauvais type de variable dans une procédure ou fonction (par exemple, mettre unevariable entière pour le titre d'un tracé, alors qu'il faut une chaîne de caractères)• Dépasser la capacité maximum d'un entier lors d'une opération• Mélanger les entiers et réels dans une opération, provoquant ainsi des arrondis• Ne pas mettre le bon nombre d'arguments dans une procédure ou fonction• Mettre un '/' devant un argument de procédure ou fonction, alors qu'il s'agit d'un paramètre, etnon d'un mot-clé.• Mettre une mauvaise échelle dans un tracé, et rien n'apparaît car les données sont confonduesavec l'un des axes.

V - Quelques exemples

1) Une petite fonction utile très simplefunction nbdim,data

;+; NAME:; NBDIM;; PURPOSE:; Determine the number of dimensions of an array;; USE:; Res=NBDIM(Data);; INPUT:; Data: Data for which you want the number of; dimensions;; OUTPUT:; Res: Number of dimensions;;-

a=size(data) & b=a[0] ; le symbole & permet plusieurs; commandes sur une même ligne

return,bend


2) Une procédure d'un intérêt limité, mais détailléepro tracer,data,tr_typ,xtit=xtit,ytit=ytit,ztit=ztit,tit=tit

;+; NAME:; TRACER;; PURPOSE:; Permettre d'effectuer un tracé au choix;; CATEGORY:; Utilité;; CALLING SEQUENCE:; TRACER,Data,Tr_typ;; INPUTS:; Data: Données à tracer;; OPTIONAL INPUTS:; Tr_typ: Type de tracé à effectuer. Si ce paramètre n'est pas; précisé, le choix est demandé à l'utilisateur. Les valeurs; possibles sont :; 1 = PLOT; 2 = SURFACE; 3 = SHADE_SURF;; KEYWORD PARAMETERS:; XTIT: Label de l'axe des X; YTIT: Label de l'axe des Y; ZTIT: Label de l'axe des Z; TIT: Titre de la figure;; OUTPUTS:; Aucun;; OPTIONAL OUTPUTS:; Aucun;; COMMON BLOCKS:; Aucun;; SIDE EFFECTS:; Aucun de connu;; RESTRICTIONS:; Aucune;; CALL:; NBDIM


; (On indique ici les autres procédures non standard appelées; par la routine);; EXAMPLE:;;; MODIFICATION HISTORY:; Written by: J.A. Mai 2001;;-

; Initialisations

tp=['Plot','Surface','Shade_surf']if not(keyword_set(xtit)) then xtit='' ; définit la valeur

; par défaut de xtitif not(keyword_set(ytit)) then ytit='' ; définit la valeur

; par défaut de ytitif not(keyword_set(ztit)) then ztit='' ; définit la valeur

; par défaut de ztitif not(keyword_set(tit)) then tit='' ; définit la valeur

; par défaut de tit

if N_elements(data) ne 0 then begin ; vérifie qu'il y a bien; des données à tracer

dm=nbdim(data) ; appel à la routine NBDIM qui détermine; le nombre de dimensions de data

if N_params() eq 1 then begin ; cas où Tr_typ n'est pas entré; à l'appel de la procédure

print,'Choisissez le type de tracé à effectuer'print,' 1. Plot'print,' 2. Surface'print,' 3. Shade_surf'print,'' ; Pour sauter une lignerep='' ; On définit ici le type de variable

; de la réponse (chaîne de caractères)read,prompt='Entrez votre choix : ',reptr_typ=fix(rep) ; On transforme la réponse en entier.

; Cette méthode évite un plantage; du programme si l'entrée n'est; pas correcte

endifif tr_typ lt 1 or tr_typ gt 3 then begin

print,'Mauvais choix'endif else begin ; vérifie la compatibilité des dimensions

; avec le type de tracéif ((tr_typ eq 1) and (dm ne 1)) or (((tr_typ eq 2) or $

(tr_typ eq 3)) and (dm ne 2)) then beginprint,'La dimension des données (',dm,$

') ne correspond pas au type de tracé (', $tp[tr_typ],')'

endif else begincase tr_typ of


1: Plot,data,xtitle=xtit,ytitle=ytit, $title=tit

2: Surface,data,xtitle=xtit,ytitle=ytit, $ztitle=ztit,title=tit

3: Shade_surf,data,xtitle=xtit,ytitle=ytit, $ztitle=ztit,title=tit

endcaseendelse

endelseendifend


Index!d.name,43!dpi,7!p.multi,43!path,4!pi,7&,48.COMPILE,42.CONT,42.RNEW,42.run,35,42.SKIP,42/append,21/ENCAPSULATED,43/get_lun,20/remove_all,14/XLOG,30/YLOG,30/ZLOG,30?,6abs,12acos,12alog,12alog10,12AND,18asin,12atan,12background,33BREAK,41CALL_FUNCTION,45CALL_PROCEDURE,45CASE,40chaînes de caractère,13chaînes de caractères,6close,19color,33Command-.,41common,37CONTOUR,31Control-Break,41Control-C,41cos,12cosh,12CURSOR,45dblarr,10DEVICE,43dialog_pickfile,21dossier de travail,5double précision,7entiers,6eq,22ERASE,25,31EXECUTE,45exit,8

exp,12factorial,12filter,21fix,17float,17fltarr,10fonction,35for,23,38free_lun,20ge,22GIF,42GOTO,41gt,22help,8IDLDE,5if,21,39IMAGE_CONT,31indices des tableaux,10intarr,10journal,6JPEG,42KEYWORD_SET,38keywords,36label,41le,22LEVELS,31LINESTYLE,29LOADCT,33Logical Unit Number,19lt,22majuscules,4max,12min,12minuscules,4mots-clés,36N_ELEMENTS,37N_PARAMS,37ne,22NOT,18octets,7openr,20openu,21openw,19opérateurs booléens,22opérateurs logiques,17OPLOT,28OR,18paramètres,36PICT,43plot,26PLOT_IO,28PLOT_OI,28PLOT_OO,28

PNG,43postcript,43print,7printf,19procédure,35prompt,19PSYM,34quality,42read,18réels,6REPEAT,41REPLICATE,44restore,9RETALL,42RETURN,35save,8SET_PLOT,43SHADE_SURF,30sin,12sinh,12SIZE,11sous-chaîne,15sqrt,12STOP,42strarr,10strcompress,13string,17strlen,13strlowcase,14strpos,15strput,15strtrim,14structure,44strupcase,14SURFACE,29tableaux,10tan,12tanh,12TEMPORARY,47title,27TV,30TVRD,42TVSCL,31unité logique,19variables,6WDELETE,25while,24,39WINDOW,25working folder,5WRITE_GIF,42WRITE_JPEG,42WRITE_PICT,43WRITE_PNG,43

idl - formation et enseignement à l'observatoire de paris

Documents