SmileLab Guide de programmation

Transcription

SmileLab
Guide de programmation
Satimage-software
www.satimage-software.com
c 2004 Satimage (France)
Copyright 10 novembre 2004
Satimage - 1 avenue des prés - 94260 Fresnes - France
Tél.+33.1.46.15.92.92 – Fax +33.1.46.15.92.99
[email protected] - www.satimage-software.com
sarl satimage – société d’application du traitement d’image – rcs créteil b 383 200 573
2
Table des matières
1 Conventions
2 Un
2.1
2.2
2.3
2.4
7
environnement scriptable intégré
Le langage : AppleScript . . . . . . .
Les dictionnaires . . . . . . . . . . .
Les bibliothèques . . . . . . . . . . .
Lancer un script . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3 Calculs numériques, les bases
3.1 Les fonctions de calcul natives d’AppleScript . .
3.2 Calculer dans Smile . . . . . . . . . . . . . . . .
3.2.1 Les tableaux de réels (arrays of real)
3.2.2 Les matrices . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
4 Réalisation d’un graphique
4.1 Programmer avec QuickPlotLib . . . . . . . . . . . . . . . .
4.1.1 Création du graphique . . . . . . . . . . . . . . . . .
4.1.2 Compléter le graphique . . . . . . . . . . . . . . . . .
4.1.3 Modification des données . . . . . . . . . . . . . . . .
4.1.4 Ajouter des éléments supplémentaires à un graphique
4.1.5 Choisir les dimensions du graphique . . . . . . . . . .
4.1.6 Mettre plusieurs graphiques dans une fenêtre . . . . .
4.1.7 Personnalisation du graphique . . . . . . . . . . . . .
4.2 Programmer directement SmileLab . . . . . . . . . . . . . .
4.3 Le SmileLab Sample Center . . . . . . . . . . . . . . . . . .
.
.
.
.
9
9
9
11
11
.
.
.
.
13
13
14
14
17
.
.
.
.
.
.
.
.
.
.
19
20
20
21
23
23
23
24
25
26
27
5 Manipulations de la fenêtre graphique
29
5.1 Modification des réglages : la fenêtre d’Infos . . . . . . . . . . 29
3
4
5.2
5.3
5.4
5.5
5.6
6 La
6.1
6.2
6.3
6.4
Utilisation de la souris en lecture des données . . . . .
Zoom avant et zoom arrière . . . . . . . . . . . . . . .
Changement de l’angle de vue d’une surface . . . . . .
Changement de l’éclairage d’une surface . . . . . . . .
Déplacement et modification de la taille des graphiques
réalisation de documents avec Smile
Les “bundles” Smile . . . . . . . . . . . . . . .
Réalisation d’un document PDF . . . . . . . . .
Réalisation de fichiers JPEG, PNG, TIFF, BMP
Réalisation d’une séquence QuickTime (movie) .
7 Importation et exportation de données
7.1 Les fichiers ASCII . . . . . . . . . . . .
7.2 Les fichiers binaires . . . . . . . . . . .
7.3 Les fichiers HDF . . . . . . . . . . . .
7.4 Fichiers graphiques . . . . . . . . . . .
7.4.1 Importation de données à partir
7.4.2 Importation de données à partir
.
.
.
.
.
. . . . .
. . . . .
et PSD
. . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
d’une image bitmap
d’une séquence vidéo
.
.
.
.
.
30
30
31
31
31
.
.
.
.
35
35
36
36
37
.
.
.
.
.
.
39
39
43
45
46
46
47
8 Pilotage de codes avec Smile
49
8.1 Les chemins d’accès aux fichiers . . . . . . . . . . . . . . . . . 49
8.2 Lancement d’un executable UNIX . . . . . . . . . . . . . . . . 50
8.3 Attente de la fin de l’exécution d’un executable UNIX . . . . . 50
9 Rendre son programme scriptable
53
10 Réalisation d’une interface utilisateur
10.1 Personnalisation du menu utilisateur . . . . . . . . . . .
10.2 Réalisation de dialogues personnalisés . . . . . . . . . . .
10.3 Personnalisation de l’interface utilisateur d’un graphique
10.3.1 Comment associer un script à un objet graphique
10.3.2 Personnalisation du menu contextuel . . . . . . .
10.3.3 Gestion des touches du clavier . . . . . . . . . . .
10.3.4 Gestion des clics souris . . . . . . . . . . . . . . .
57
57
58
58
58
59
60
62
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
A Avant de commencer
65
A.1 Objet du Chapitre . . . . . . . . . . . . . . . . . . . . . . . . 65
A.2 Ce qu’il faut savoir d’AppleScript . . . . . . . . . . . . . . . . 65
5
A.3 Ce qu’il y a à savoir concernant Smile . . . . . . . . . . . . . . 71
6
Chapitre 1
Conventions
Conventions typographiques
Ce document utilise les conventions suivantes :
– pour les chemins d’accès de fichiers, on utilise la convention UNIX :
les répertoires sont séparés les uns des autres par la barre de fraction
(“slash”) /, et non pas par les deux-points : comme dans AppleScript.
Exemple :
Recopiez les bibliothèques dans le répertoire Class Scripts/Context
additions/.
– les noms de fichiers et de dossiers ainsi que les chemins d’accès sont en
italique.
Exemple :
Library/Application Support/Smile/
– les menus, les noms des fenêtres, les noms de boutons, utilisent une
police sans empattement.
Exemple :
Dans la fenêtre Contrôle Bombe H, cliquez sur Lancement.
– les exemples de scripts utilisent une police de machine à écrire.
Exemple :
tell application "Finder" to get name of window 1
– les touches de clavier sont imprimées en lettres penchées.
Exemple :
Press cmd-shift-C
– dans Acrobat Reader (ou Adobe Reader) les liens hypertexte appa7
8
raissent en mauve.
Exemple :
Voir le chapitre 1.
– dans Acrobat Reader (ou Adobe Reader) les liens URL apparaissent
en bleu foncé.
Exemple :
Visitez la page d’accueil d’AppleScript.
Vous trouverez des liens hypertexte dans ce document. Il est possible qu’ils
ne fonctionnent que depuis Acrobat ou Acrobat Reader (ou Adobe Reader).
Conventions concernant les menus
Les commandes menus sont données au moyen d’une suite hiérarchique
en utilisant >.
Exemple :
choisissez File > Open dictionary. . . > Other. . . dans le menu.
Dans Smile, un des éléments de la barre de menu est constitué d’une icône
de parchemin (entre le menu Script et le menu Fenêtre). Ce menu (fig.1.1)
s’appelle le menu des Scripts utilisateurs menu. L’utilisateur peut y installer
ses scripts personnels.
Fig. 1.1 – La barre des menus de contient un menu “Scripts utilisateur”.
Conventions concernant les touches
Pour désigner une des touches spéciales, nous utilisons la terminologie de
Apple :
– cmd désigne la touche portant un trèfle à 4 lobes
– option désigne la touche avec un signe bizarre ressemblant à une pédale.
Chapitre 2
Smile, l’environnement
scriptable intégré pour
scientifiques
2.1
Le langage : AppleScript
Smile est un environnement dans lequel vous n’utilisez qu’un seul et même
langage, AppleScript, pour effectuer toutes sortes d’opérations. AppleScript
est le langage inter-application de la plate-forme Apple. Proche de l’Anglais
mais puissant et abstrait, son utilisation est à la fois simple et naturelle.
Ainsi avec AppleScript vous pourrez utiliser les fonctions de visualisation de
données, les fonctions de la bibliothèque graphique, vous pourrez programmer
vos interfaces utilisateur personnalisées, ou encore exécuter des exécutables
UNIX.
SmileLab est une composante de Smile, la plate-forme d’automatisation 100%
AppleScript. Smile donne un cadre dans lequel il est commode de scripter et
d’automatiser n’importe quelle tâche, du post-traitement de données et de
la manipulation de fichiers jusqu’à la personnalisation des graphiques, à la
mise en ligne de fichiers ou à l’intégration de figures dans un article.
2.2
Les dictionnaires
Lors de l’écriture d’un script, vous emploierez des termes appartenant
à AppleScript lui-même, et vous utiliserez des termes spécifiques pour vous
9
10
adresser à tel ou tel composante de la machine.
Par exemple dans le script ci-dessous tell application et set font partie
de la terminologie de base d’AppleScript – tell application permet de
s’adresser à une application donnée, set permet d’assigner une valeur – alors
que le terme selection est propre au Finder.
Exemple 1
tell application "Finder" to set theList to selection
Le dictionnaire d’une application, qu’on peut consulter depuis tous les
éditeurs de script, en particulier depuis Smile, est le document qui présente
la terminologie AppleScript propre à l’application en question.
Voici les principaux dictionnaires que vous serez amené à utiliser, comment
les ouvrir, et en résumé ce qu’ils contiennent.
– le dictionnaire de Smile : sélectionnez Smile > Dictionnaire de Smile.
Le dictionnaire de Smile contient notamment la SmileLab Suite, qui
décrit les objets impliqués dans la visualisation de données, ainsi que
plusieurs autres “Suites”.
– le dictionnaire de l’osax Satimage : sélectionnez Fichier > Ouvrir un
dictionnaire > Scripting additions > Satimage.osax.
L’osax Satimage fait partie de l’installation de Smile.
Le dictionnaire de l’osax Satimage contient la bibliothèque
mathématique sur les nombres et les tableaux de nombres, ainsi que
des commandes de haut niveau pour lire et écrire les fichiers de données
numériques ASCII et binaires.
– le dictionnaire de l’osax Standard additions : sélectionnez Fichier >
Ouvrir un dictionnaire > Scripting additions > StandardAdditions.osax.
L’osax StandardAdditions fait partie de l’installation standard de
MacOS X.
Le dictionnaire de l’osax StandardAdditions contient des commandes
pour lire et écrire les fichiers ASCII ainsi que plusieurs autres fonctions
utilitaires.
Pour consulter le dictionnaire auquel appartient un terme donné, sélectionnez
le terme en question puis tapez la combinaison de touches cmd-shift-F (ou
bien sélectionnez dans le menu Script > Trouver la définition).
2.3
11
Les bibliothèques
Une bibliothèque AppleScript est simplement un script ordinaire mais qui
ne contient que des procédures (il ne contient ni lignes exécutables directement ni une procédure run), procédure que vos scripts peuvent exploiter.
Smile inclut plusieurs bibliothèques AppleScript.
Les bibliothèques de Smile que vous utiliserez principalement sont
QuickPlotLib, une famille de procédures de haut-niveau qui permettent de
visualiser des données en quelques instructions, et Graphic Kernel, la bibliothèque graphique PDF de Smile, qui vous permet de personnaliser un
graphique à volonté.
La documentation abrégée de ces bibliothèques est fournie dans le menu
Aide.
Pour afficher la définition d’une procédure qui appartient à l’une des
bibliothèques, sélectionnez son nom puis tapez le raccourci cmd-shift-F (ou
bien sélectionnez Script > Trouver la définition).
2.4
Lancer un script
Exploiter SmileLab consiste à piloter Smile au moyen du langage AppleScript. Vous devez donc connaı̂tre AppleScript et Smile. L’Annexe A présente
l’information minimale nécessaire et indique où trouver l’information de
référence sur AppleScript et sur Smile.
Suivez les instructions suivantes pour lancer un script depuis Smile.
– faites une nouvelle fenêtre de texte en sélectionnant Fichier > Nouveau
texte. Les fenêtres de texte sont blanches, si votre fenêtre a un fond
coloré c’est une fenêtre de script compilé.
– tapez (ou recopiez) votre script dans la nouvelle fenêtre. Vous pouvez
utiliser pour commencer les exemples qui sont fournis dans le SmileLab
Sample Center. Celui-ci se trouve dans le menu Aide.
– à présent vous pouvez exécuter votre script, soit ligne à ligne, soit en
bloc.
Pour exécuter une ligne donnée positionnez le point d’insertion dans
la ligne (cliquez une fois n’importe où dans la ligne) puis tapez Enter
(non pas Retour chariot). Il n’est pas nécessaire de sélectionner la ligne.
Quand vous lancez l’exécution le résultat (s’il y en a un) s’affiche dans
une fenêtre spéciale, la Console, ce qui permet de débugger pas à pas.
12
Pour exécuter un bloc d’un coup, sélectionnez-le tout entier puis tapez
Enter.
Chapitre 3
Les bases du calcul numérique
dans Smile
Dans Smile, vous pouvez utiliser les fonctions de calcul fournies de base
par AppleScript. Cependant, Smile possède ses propres fonctions de calcul,
qui constituent un cadre robuste et puissant pour effectuer des calculs intensifs.
3.1
Les fonctions de calcul natives d’AppleScript
Le langage AppleScript définit plusieurs types de données (qu’on appelle
classes). Les classes numériques sont notamment :
– string : une chaı̂ne de caractères (de taille illimitée)
– real : un réel double-précision dans la gamme ± 10308
– integer : un entier dans la gamme ± (229 − 1)
– number : un integer ou un real
– list : une liste de valeurs de n’importe lesquels de ces types (y compris
list lui-même).
Exemple 2
set myList to {myString, "string", pi/4, 2003}
Les fonctions de base vous permettent de traiter des tableaux de nombres
en utilisant des boucles de programme repeat. Par exemple ci-dessous on
calcule un pas de l’évolution cinématique d’un point dans l’espace.
13
14
Exemple 3
set x to {1.0, 1.2, 1.4}
set v to {10.0, 12.0, 0.0}
set dt to 0.01
repeat with i from 1 to 3
set item i of x to (item i of x) + dt * (item i of
v)
end repeat
x
-- {1.1, 1.32, 1.4}
La structure de liste d’AppleScript (list) est pratique, et nous recommandons de l’utiliser pour stocker de petites quantités de données (pas plus de
quelques centaines). Néanmoins elle n’a pas été conçue pour gérer des volumes
arbitrairement grands de données ni pour effectuer des calculs optimisés sur
les réels. Pour calculer sur de gros volumes de données, vous devez utiliser la
structure exploitée en interne par Smile, et qui est présentée ci-dessous : les
arrays of real (signifie “tableau de réels”).
3.2
Calculer dans Smile
Le lecteur trouvera ci-dessous un rapide résumé des fonctions de calcul de
Smile. Pour la documentation complète vous devez vous référer au document
SmileLab -- Manuel de référence.
3.2.1
Les tableaux de réels (arrays of real)
Si vous manipulez plus que quelques centaines de données, vous devez
utilisez la structure que Smile exploite en interne à la place de la list de
nombres.
Smile stocke les tableaux de réels sous la forme de arrays of real. Un
array of real est logiquement équivalent à une list de réels comme {1.0,
3.14}. La plupart des commandes acceptent indifféremment une list de
réels comme ci-dessus ou un array of real. De plus, le mot-clé as permet
de traduire les données de chacun des deux types dans l’autre.
– pour créer un array of real à partir d’une list AppleScript ordinaire
de nombres réels, utilisez l’opérateur de coercion as.
–
–
–
–
1
15
Exemple 4
set a1 to {0, pi} as array of real
-- data Lido4E6F742061207265636F7264202020200000000040490FDB pour créer un array of real avec des valeurs espacées régulièrement,
utilisez createarray.
Exemple 5
set a to createarray 41 range {-10, 10}
-- a = toutes les valeurs de -10 à 10 par pas de 0.5
array of real est une classe (class) opaque. Pour lire les nombres
il est nécessaire de passer par la list AppleScript ordinaire. Pour
transformer un array of real en une list AppleScript ordinaire de
nombres, utilisez as avec le type list of real (c’est un type virtuel :
vous ne le rencontrerez qu’à cette occasion).
Exemple 6
set x1 to a1 as list of real
-- {0.0, 3.141592741013}
Pour visualiser un array of real en un instant, utilisez les fonctions
QuickCurve ou QuickScatter1 comme ci-dessous (fig.3.1).
Exemples 7
set b1 to {0.0, 3.141592741013, 1.570796370506}
QuickCurve(0, b1, 0)
-set r to randomarray 50
QuickScatter(0, r, 0)
les coercions as array of real et as list of real fonctionnent également
sur les listes de listes et les listes d’arrays of real, respectivement.
Exemple 8
set {x1, x2} to {a1, a2} as list of real
-- {{0.0, 3.141592741013}, {3.141592741013, 0.0}}
AppleScript ne peut pas afficher de valeurs NAN (“not a number”, par
exemple 1/0). Lors de la coercion d’un array of real en list de réels
les valeurs NAN sont traduites par la constante AppleScript missing
value.
Exemple 9
QuickCurve et QuickScatter appartiennent à la bibliothèque QuickPlotLib.
QuickPlotLib est documenté dans la Section 4.1. Vous pouvez consulter la documentation rapide de QuickPlotLib au moyen du menu Aide.
16
3.0
0.8
2.0
0.6
0.4
1.0
0.2
0
0
0.5
1.0
1.5
2.0
0
10.0
20.0
30.0
40.0
Fig. 3.1 – QuickPlotLib permet de visualiser graphiquement un tableau de
nombres en une seule instruction.
(asin a1) as list of real
-- {0.0, missing value}
– l’opérateur count fonctionner sur les arrays of real de la même
façon que sur les listes AppleScript ordinaires.
Exemple 10
count a1
-- 2
– les fonctions mathématiques de base fournies dans Satimage.osax fonctionnent aussi bien sur les nombres que sur les listes de réels et que sur
les arrays of real.
Exemple 11
set c1 to cos b1
c1 as list of real
-- {1.0, -1.0, -4.37113882867379E-8}
– pour afficher les valeurs dans la Console utilisez la routine quietmsg2
(qui affiche dans la Console) et le verbe display (qui transforme une
variable en chaı̂ne de caractères).
Exemple 12
2
quietmsg est une des routines générales disponibles dans Smile. Pour consulter l’aide
rapide sur les routines de Smile, sélectionnez quietmsg puis utilisez le menu contextuel.
17
quietmsg(display a1 as list of real)
3.2.2
Les matrices
Smile définit, à partir du type array of real, un type adapté au calcul sur les tableaux bi-dimensionnel : le type matrix3 . Une matrix n’est
qu’une structure — un record AppleScript — qui, outre les données sous
forme d’array of real4 (champ array of real), contient deux entiers qui
définissent un nombre de lignes (nrows) et un nombre de colonnes (ncols).
Une structure de type matrix contient donc un ensemble paramétrique
bi-dimensionnel de scalaires. Par exemple vous décrirez une surface à deux
paramètres dans l’espace à trois dimensions au moyen de trois matrix
(x(u, v), y(u, v), z(u, v)).
Exemple 13
set x to {0, 1, 2, 2, 1, 0}
set m to {class :matrix, ncols :3, nrows :2, array of real :x}
A chaque fois que c’est nécessaire, Smile considérera m comme un tableau à
deux dimensions, par exemple ici :
0
1
2
2
1
0
Le champ array of real du type matrix range le tableau bidimensionnel en commençant par la première ligne.
Pour visualiser une matrix en quelques instants utilisez QuickBitMap ou
QuickScalarMap5 .
Exemple 14
QuickBitMap(m, 0)
3
La classe matrix appartient à Satimage.osax.
Il est préférable de passer les données d’une matrix sous forme d’un array of real.
Cependant la matrix supporte également la liste AppleScript ordinaire de réels, ce qui
peut s’avérer plus commode pour les mises au point.
5
QuickBitMap et QuickScalarMap appartiennent à la bibliothèque QuickPlotLib.
QuickPlotLib est documenté dans la Section 4.1. Vous pouvez consulter la documentation rapide de QuickPlotLib au moyen du menu Aide.
4
18
2.0
2.0
1.5
1.5
1.0
1.0
0.5
0.5
0
0
0
0.5
1.0
1.5
2.0
2.5
3.0
Fig. 3.2 – La carte en couleurs d’une petite matrice (3 x 2).
Pour convertir une matrix en texte tabulé, utilisez la commande display.
Exemple 15
set x to {0, 1, 2, 2, 1, 0}
set m to {class :matrix, ncols :3, nrows :2, array of real :x}
quietmsg(display m)
-- Résultat :
0.0
1.0
2.0
2.0
1.0
0.0
Chapitre 4
Réalisation d’un graphique
Smile est un moteur logiciel qui exploite des objets scriptables et qu’on
contrôle par l’intermédiaire de scripts. Vos scripts créent — et éventuellement
suppriment — des objets, et ils les manipulent en fonction de vos besoins.
Par conséquent pour réaliser des graphiques il faut connaı̂tre les objets de
Smile qui sont dédiés à la visualisation de données : ces objets vont vous être
présentés dans ce chapitre. Ce chapitre offre un certain nombre d’exemples
dont la plupart peuvent être exécutés tels quels. Chaque ligne est une instruction AppleScript. Pour commencer, exécutez ces instructions depuis une
fenêtre de texte (une text window). Dans les chapitres suivants vous verrez
comment affecter ces instructions à une commande de menu ou, par exemple,
à un bouton dans une fenêtre de dialogue.
Le dictionnaire de Smile (Smile > Dictionnaire de Smile) contient la liste
exhaustive des classes d’objets de Smile et leur description.
La fenêtre graphique (graphic window) Smile possède plusieurs sortes
de fenêtres, par exemple les fenêtres d’éditeur de texte ou les fenêtres de
script. Les fonctions graphiques de Smile sont implémentées dans un type
spécifique de fenêtre, la fenêtre graphique ou graphic window. Une fenêtre
graphique peut être enregistrée au format PDF, le PDF prenant comme
dimensions les dimensions du rectangle blanc (par opposition au fond gris).
Les vues graphiques (graphic views) Une fenêtre graphique sont capables d’héberger des objets destinés à afficher des graphiques, les vues graphiques, ou “vues”, ou graphic views suivant la terminologie du dictionnaire. La classe graphic view est une classe virtuelle, à savoir que vous
19
20
ne créerez que des objets appartenant à une classe descendant de graphic
view. Vous trouverez dans le dictionnaire les différentes classes descendant
de graphic view, et à quel type de graphique chacune est destinée.
– plot view : permet d’afficher des courbes, (curves)
– planar view : permet d’afficher des courbes de niveaux (contour
maps), des champs vectoriels (vector plots), des cartes bitmap
(bitmaps) et des champs scalaires en couleurs (scalar maps)
– view3D : permet d’afficher des surfaces ainsi que des objets 3D de
synthèse, les GLobjects et les GLUTobjects.
Une graphic window peut contenir un nombre arbitraire de graphic views.
Smile est livré avec une bibliothèque de fonctions de haut niveau (la bibliothèque QuickPlotLib) qui permet de réaliser un graphique moyennant
très peu d’instructions. QuickPlotLib répond à la préoccupation suivante :
vous permettre de visualiser vos données dans le temps le plus court possible.
Dans un graphique, le menu contextuel propose d’ouvrir un dialogue de
réglage qui permet de modifier pratiquement tous les paramètres du graphique (voir le Chapitre 5).
La suite de ce chapitre explique comment manipuler les objets de SmileLab
par script et comment les personnaliser.
4.1
4.1.1
Programmer avec QuickPlotLib
Création du graphique
QuickPlotLib fournit des fonctions de haut niveau pour réaliser rapidement un graphique.
Par exemple QuickCurve(x, y, anObject) permet de tracer une courbe,
où x et y sont deux arrays of real ou deux listes de réels de même taille.
L’exemple ci-dessous crée la courbe de la fig.4.3.
Exemple 16
set y to runningsum (randomarray 500 range {-1, 1})
set c to QuickCurve(0, y, 0)
Dans l’exemple ci-dessus, on a passé 0 à la place de la liste des abscisses :
QuickCurve prend alors automatiquement pour abscisses la liste des premiers entiers.
Le dernier paramètre de QuickCurve est une référence à un objet.
QuickPlotLib utilise cette référence comme indication pour déterminer où
21
0
-5.0
-10.0
-15.0
0
100.0
200.0
300.0
400.0
500.0
Fig. 4.1 – Un tirage d’une marche aléatoire de 500 pas.
dessiner les données. Si cette référence est invalide (comme par exemple ici
0), QuickCurve crée le graphique dans une nouvelle fenêtre. Si on passe une
chaı̂ne de caractères au lieu d’une référence, QuickCurve utilise cette chaı̂ne
comme titre de la nouvelle fenêtre.
QuickCurve renvoie une référence à la courbe créée, ce qui permet à votre
script de s’adresser à cet objet (et aux objets qui le contiennent), par
exemple pour les personnaliser.
Autre exemple de fonction de la bibliothèque QuickPlotLib : QuickScalarMap(x,
y, z, anObject) réalise une image en fausses couleurs du champ scalaire
stocké dans z (fig.4.2). z peut être soit une matrix soit une expression des
variables x et y (sous forme d’une chaı̂ne de caractères).
Exemple 17
set s to "exp(-((x*x)^0.3)-y*y)"
set sm to QuickScalarMap({-1, 1}, {-1, 1}, s, 0)
4.1.2
Compléter le graphique
QuickPlotLib réalise des graphiques aussi simples que possible. On peut
ensuite, en utilisant la référence à l’objet créé, le modifier à volonté par script.
Exemple 18
22
1.0
0.8
0.5
0.6
0
0.4
-0.5
0.2
-1.0
-1.0
-0.5
0
0.5
1.0
Fig. 4.2 – QuickScalarMap permet de créer la carte en couleurs de f (x, y).
set c to QuickCurve(0, y, "Random walk")
set v to container of c -- le plot view
set xlabel of v to "t (seconds)"
set ylabel of v to "x (m)"
draw window of c
12.0
10.0
x (m)
8.0
6.0
4.0
2.0
0
0
100.0
200.0
300.0
t (seconds)
400.0
500.0
Fig. 4.3 – Un tirage d’une marche aléatoire de 500 pas.
4.1.3
23
Modification des données
QuickPlotLib permet de charger de nouvelles données dans un objet graphique une fois celui-ci créé. Il suffit pour cela de rappeler la même routine en
lui passant la référence à l’objet en question en dernier paramètre. L’exemple
ci-dessous modifie les données de la courbe c créée dans l’exemple 20.
Exemple 19
set y2 to runningsum (randomarray 500 range {-1, 1})
QuickCurve(0, y2, c)
4.1.4
Ajouter des éléments supplémentaires à un graphique
En utilisant toujours la même routine de QuickPlotLib on peut créer
un nouvel objet dans le même graphique que le précédent. Il suffit pour
cela de rappeler la même routine en lui passant la référence à la graphic
view contenant l’objet en question. L’exemple ci-dessous ajoute une seconde
courbe au graphique créé dans l’exemple 20.
Exemple 20
set v to container of c -- le plot view
set y3 to runningsum (randomarray 500 range {-1, 1})
set c2 to QuickCurve(0, y3, v)
Cette technique fonctionne aussi avec les planar views. Dans l’exemple 21,
on superpose un réseau de 15 courbes de niveau à la carte en couleur de
l’exemple 17.
Exemple 21
set sm to QuickScalarMap({-1, 1}, {-1, 1}, s, 0)
set v to container of sm -- le planar view
QuickContourMap({-1, 1}, {-1, 1}, s, 15, v)
4.1.5
Choisir les dimensions du graphique
Une fois un graphique créé, on peut le redimensionner en redimensionnant
sa fenêtre avec la touche cmd enfoncée.
Pour créer automatiquement un graphique aux bonnes dimensions, il suffit
de créer explicitement la fenêtre graphique puis d’en passer la référence à
24
1.0
0.8
0.5
0.6
0
0.4
-0.5
0.2
-1.0
-1.0
-0.5
0
0.5
1.0
Fig. 4.4 – 15 courbes de niveaux superposées à l’image du champ scalaire
f (x, y).
QuickPlotLib.
Exemple 22
set w to make new graphic window with properties {pagewidth :4
as inches, pageheight :3 as inches}
set c to QuickCurve(0, "x^2", w)
4.1.6
Mettre plusieurs graphiques dans une fenêtre
On peut mettre plusieurs graphiques dans une même fenêtre. Pour cela il
faut préparer la fenêtre graphique au moyen de sa propriété grid. C’est une
liste de deux entiers {i, j} qui partage la page en i×j cases (j lignes de i
cases). L’exemple ci-dessous regroupe les exemples précédents sur une page
unique.
Exemple 23
set w to make new graphic window with properties {pagewidth :5
as inches,
pageheight :3 as inches, grid :{2, 1}}
set c to QuickCurve(0, y, w)
...
25
set sm to QuickScalarMap({-1, 1}, {-1, 1}, s, w)
...
1.0
0
0.8
x (m)
0.5
-5.0
0.6
0
-10.0
0.4
-0.5
0.2
0
100.0 200.0
300.0 400.0 500.0
t (seconds)
-1.0
-1.0 -0.5
0
0.5
1.0
Fig. 4.5 – Un plot view et un planar view dans une même page.
4.1.7
Personnalisation du graphique
Le Chapitre 5 indique comment personnaliser le graphique au moyen du
clavier et de la souris.
Le dictionnaire de la SmileLab Suite publie toutes les propriétés des objets
graphiques. Il est donc possible d’effectuer toutes les personnalisations par
script.
Exemple 24
set c to QuickCurve(0, "x^2", 0)
set c’s name to "x^2"
set c’s dash to 3
set c’s pen color to 1, 0, 0
Il est également possible de modifier le paramétrage par défaut des graphiques. Ce paramétrage (template) est défini dans des fichiers .plist (“Property list”). Par défaut Smile utilise le fichier GraphicWindow.plist situé dans
le dossier :
Smile.app/Contents/Resources/More stuff/SmileLabTemplates
Vous pouvez modifier les fichiers de template et en faire de nouveaux.
Pour changer le template par défaut, utilisez SetQPLDefaultTemplate. L’exemple
ci-dessous sélectionne le fichier des réglages destiné à l’impression en niveaux
de gris.
Exemple 25
SetQPLDefaultTemplate("GrayGraphicWindow.plist")
26
Quand on spécifie un nom de fichier à SetQPLDefaultTemplate, Smile
recherche en premier dans le domaine utilisateur :
/Users/<login>/Library/Application Support/Smile/More
stuff/SmileLabTemplates/
puis
dans
le
dossier
More
stuff/SmileLabTemplates de l’application Smile. Nous conseillons d’utiliser
le domaine utilisateur pour stocker vos fichiers template personnels. Ceci
évite de perturber les autres utilisateurs et de perdre ses fichiers lors d’une
mise à jour.
4.2
Programmer directement SmileLab
QuickPlotLib vous permet de réaliser des graphiques en quelques instructions. Comme toute bibliothèque d’appels de haut niveau, QuickPlotLib peut
entraı̂ner certains inconvénients comme des rafraı̂chissements trop fréquents
ou une gestion non optimale de la mémoire.
Pour plus d’information vous pouvez consulter QuickPlotLib qui se trouve
dans le dossier suivant :
Smile.app/Contents/Resources/Class scripts/Context additions
Vous pouvez donc préférer recourir à une programmation directe des objets SmileLab. Par exemple vous pouvez remplacer QuickPlotLib(x, y, 0)
par :
set w to make new graphic window
set v to make new plot view at w
set c to make new curve at v
set properties of c to {xdata :x, ydata :y}
Programmer les objets de SmileLab consiste simplement à appliquer
AppleScript au dictionnaire de SmileLab. Rappelons la syntaxe des principales instructions.
– pour créer un nouvel objet, utilisez make new :
Exemple 26
– pour créer un nouvel objet en tant qu’élément d’un autre objet, utilisez
make new ... at :
Exemple 27
set v to make new plot view at w
27
– pour référer à un objet, spécifiez soit son index soit son nom (name) et
son conteneur à l’aide de la préposition of. Inversement vous pouvez
utiliser la propriété container :
Exemples 28
set v to plot view 1 of w
set w to container of v
– pour assigner une nouvelle valeur à une propriété d’un objet, utilisez
le verbe set :
Exemple 29
set formula of c to "x^3"
– pour assigner de nouvelles valeurs à plusieurs propriétés en une instruction, utilisez la propriété spéciale properties :
Exemple 30
set properties of c to {xdata :x, ydata :y, pen color :2}
– pour assigner des valeurs à des propriétés d’un objet à la création,
utilisez le paramètre optionnel with properties du verbe make new :
Exemple 31
set w to make new graphic window with properties {template :
"GreyGraphicWindow.plist"}
– pour lire la valeur d’une propriété d’un objet ou pour obtenir la référence
d’un élément d’un objet, utilisez le verbe get1 :
Exemple 32
set d to (get dash of (get curve 3 of v))
– pour détruire un objet, utilisez delete2 :
Exemple 33
delete v
4.3
Le SmileLab Sample Center
SmileLab est livré avec une série d’exemples destinés à être utilisés pour
démarrer un script ou pour illustrer une fonctionnalité particulière.
1
Le verbe get est parfois optionnel.
Pour fermer une fenêtre comme en cliquant dans la case de fermeture, utilisez close.
Attention, le paramètre saving (voir le dictionnaire) n’est pas optionnel.
2
28
Pour naviguer dans les exemples fournis, sélectionnez Aide > SmileLab
Sample Center.
Pour tester un exemple, ouvrez son script, créez une nouvelle fenêtre de
texte (Fichier > Nouveau texte) puis recopiez le script dans la fenêtre de
texte. De la sorte vous pourrez exécuter le script ligne par ligne : positionnez
le curseur sur la première ligne, puis appuyez sur Enter (pas sur Retour
chariot). Le curseur saute à la ligne suivante, tandis que la Console affiche le
résultat. Pressez à nouveau la touche Enter pour exécuter la deuxième ligne
et ainsi de suite. Si vous voulez exécuter le script d’un coup sélectionnez-le en
entier puis pressez la touche Enter. Grâce à l’interprétation des commandes
AppleScript dans les fenêtres de texte, il est facile de tester immédiatement
l’effet d’une nouvelle ligne de script ou d’une modification.
Chapitre 5
Manipulations de la fenêtre
graphique à l’aide de la souris
5.1
Modification des réglages : la fenêtre
d’Infos
La fenêtre d’Infos est une fenêtre de dialogue qui vous permet de lire et
modifier l’essentiel des propriétés des graphic views (plot views, planar
views et view3D).
Fig. 5.1 – La fenêtre d’Infos pour les planar views.
29
30
La fenêtre d’Infos donne également accès aux réglages des objets contenus
dans la graphic view, par exemple les courbes (curves) du plot view. Elle
permet également de supprimer ces objets.
Pour ouvrir la fenêtre d’Infos d’une graphic view déroulez son menu
contextuel (par un ctrl-clic sur l’objet) puis sélectionnez Lire les informations.
Vous pouvez également utiliser le double-clic “en-dehors des données”, par
exemple sur un axe ou sur l’échelle des couleurs.
5.2
Utilisation de la souris en lecture des
données
Lorsque vous cliquez à l’intérieur d’une graphic view, la barre d’outils
(le bandeau sous la barre de titre)1 affiche les coordonnées de la souris en
unités utilisateur (les unités des axes) : x, y, dy/dx dans les plot view, x, y, f
dans les planar view (dans le cas où le planar view affiche un champ scalaire, et uniquement si x, y ne sont pas donnés sous forme de matrices), x, y, z
quand on clique une surface dans une view3D.
Si vous cliquez dans la fenêtre graphique mais en-dehors de toute graphic
view (par exemple, près des bords de la fenêtre) la barre d’outils affiche les
coordonnées en pixels2 et en utilisant le système de coordonnées de la fenêtre
graphique. Fonction à utiliser pour mettre au point les dimensions des objets.
5.3
Zoom avant et zoom arrière
Pour effectuer un zoom avant utilisez la touche cmd. Si vous maintenez
la touche cmd enfoncée à l’intérieur de la zone de tracé (le rectangle donnée
par plot frame) dans une vue de type plot view ou planar view tout
en faisant glisser la souris bouton enfoncé, vous obtenez un rectangle en
“pointillés progressifs”. Quand vous relâchez alors le bouton de la souris, le
graphique effectuera un zoom sur le rectangle ainsi défini.
Pour revenir à l’échelle originale du graphique, faites un double-clic avec la
touche cmd enfoncée.
1
Si la barre d’outils ne s’ouvre pas, utilisez le bouton situé à droite de la barre de titre
de la fenêtre.
2
1 pixel = 1/72 inch.
31
Il n’est pas possible dans la version actuelle de zoomer de cette façon dans
une view3D.
5.4
Changement de l’angle de vue d’une surface
Pour faire tourner une view3D, faites glisser la souris bouton enfoncée en
tenant la touche cmd appuyée. Ceci fait apparemment tourner la view3D :
en réalité la surface ne change pas, c’est la position de l’observateur eye
position qui est modifiée.
5.5
Changement de l’éclairage d’une surface
Pour déplacer la lumière dans une view3D sélectionnez Réglage de
l’éclairage dans son menu contextuel. Ce menu ouvre le dialogue de réglage
de l’éclairage dans lequel vous pouvez modifier l’orientation de la source de
lumière.
5.6
Déplacement et modification de la taille
des graphiques
La fenêtre graphique a un mode spécial, le “mode édition”, qu’on peut
activer et désactiver au moyen du menu Edition > Mode édition. Lorsque la
fenêtre graphique est en mode édition, on peut déplacer les graphic views
et modifier leurs dimensions. Cependant la plupart du temps il vaut mieux
procéder par script pour plus de précision et de reproductibilité.
Lorsque la fenêtre graphique est en mode édition, elle affiche le cadre de sa
page graphique et les bords des graphic views qu’elle contient. Une graphic
view affiche au moins deux rectangles : son cadre frame, qui délimite la
graphic view, et son cadre de traçage plot frame — en principe un rectangle plus petit que frame — qui indique le rectangle dans lequel la graphic
view représente les données (par exemple, le plot frame ne contient pas les
légendes d’axes).
Vous pouvez déplacer n’importe lequel de ces rectangles à l’aide de la souris. Vous pouvez modifier ses dimensions en déplaçant son coin inférieur droit.
32
1.0
0.8
0.6
0.4
0.2
0
0
0.2
0.4
0.6
0.8
1.0
Fig. 5.2 – La fenêtre graphique en mode édition.
Cependant pour ajuster les dimensions d’un graphique il est recommandé de
suivre les instructions ci-dessous, valables aussi bien si les modifications ont
lieu à l’aide de la souris que par script.
1. ajustez d’abord la taille de la page PDF. La page PDF est le rectangle à
fond blanc qui se dessine sur un fond gris si vous agrandissez les dimensions de la fenêtre graphique. Pour ajuster les dimensions de la page
PDF par script, modifiez les propriétés pagewidth and pageheight de
la graphic window.
2. ajustez ensuite les dimensions du cadre (frame) de la graphic view.
Quand vous déplacez ce rectangle, la graphic view se déplace en bloc.
Quand vous modifiez ses dimensions, le graphique qu’il contient se modifie en conséquence, en d’autres termes le plot frame est modifié.
3. ajustez à présente le cadre de traçage (plot frame), le cadre qui
contient la représentation des données à proprement parler. Quand vous
modifiez celui-ci, la légende (legend frame) se modifie automatiquement de façon à préserver l’aspect du graphique.
4. enfin, le cas échéant, modifiez la position et les dimensions de la légende
(legend frame).
Attention : le menu Edition > Mode édition fonctionne également sur
les fenêtres de dialogue. Si par exemple c’est une fenêtre d’Infos qui est au
premier plan et que vous sélectionnez Edition > Mode édition c’est elle qui
33
basculera en mode édition, et non la fenêtre graphique qui est au deuxième
plan. Pour désactiver le mode édition pour le dialogue sélectionnez à nouveau
Edition > Mode édition.
34
Chapitre 6
La réalisation de documents
avec Smile
Une fois que vous avez réalisé des graphiques dans une graphic window
vous pouvez en faire différents documents, papier ou électroniques.
6.1
Les “bundles” Smile
Lorsqu’on enregistre une graphic window à l’aide du menu Fichier >
Enregistrer Smile propose de l’enregistrer sous forme d’un Bundle1 , ou d’un
PDF, ou encore d’enregistrer une copie comme PDF, JPEG, PNG, TIFF,
BMP ou PSD. L’option par défaut, Bundle, crée un “bundle Smile”, c’està-dire un fichier qui retient la structure complète de la graphic window. Si
vous la ré-ouvrez plus tard, elle recréera automatiquement tous les objets
qui étaient présents dans la graphic window. Notamment, le bundle Smile
contient les scripts que vous avez éventuellement attachés aux objets, ainsi
que les données numériques qu’ils contiennent le cas échéant.
Le bundle Smile étant en réalité un dossier, vous pouvez (au moyen du
menu contextuel dans Finder) l’ouvrir et l’utiliser pour stocker des fichiers
connexes. Il est recommandé d’y stocker les fichiers de données, les codes
de calcul, les scripts spécialisés et les bibliothèques AppleScript, ainsi que
les dialogues. Quand vous ouvrez le bundle dans Finder vous observerez
qu’il contient un dossier Contents. Ne stockez aucun fichier dans ce dos1
Un “bundle” n’est autre que ce que le Finder appelle un “progiciel” c’est-à-dire en
réalité un dossier qui se présente comme un fichier.
35
36
sier Contents. En effet Smile efface le contenu de ce dossier à chaque nouvel
enregistrement du fichier. Par conséquent, stockez vos fichiers à la racine du
bundle, c’est-à-dire au même niveau que le dossier Contents.
Remarque : certaines versions du Finder n’autorisent pas le déplacement d’un
fichier à cet endroit au moyen de la souris. Si c’est le cas, procéder au moyen
d’un Copier - Coller dans Finder.
Un bundle Smile pouvant éventuellement contenir un nombre important
de fichiers, Smile ne vous autorise pas, par sécurité, à remplacer un bundle
Smile par un autre au moyen de la commande Fichier > Enregistrer sous.
Pour supprimer le bundle existant, glissez-le dans la Corbeille dans Finder.
Pour générer un PDF à partir d’une fenêtre de Smile sans perdre le lien
avec le bundle, utilisez l’option Enregistrer une copie en PDF.
6.2
Réalisation d’un document PDF
La fenêtre graphique concernée étant au premier plan, sélectionnez Fichier
> Enregistrer sous puis Format > PDF puis cliquez Enregistrer. Si nécessaire,
Smile ajoute automatiquement l’extension .pdf au nom du fichier.
La fenêtre prend le nom du fichier et dorénavant le menu Fichier > Enregistrer
met à jour le PDF.
6.3
Réalisation de fichiers JPEG, PNG,
TIFF, BMP et PSD
La fenêtre graphique concernée étant au premier plan, sélectionnez Fichier
> Enregistrer sous puis Format > Enregistrer une copie en JPEG (ou PNG
. . . ) puis cliquez Enregistrer. Si nécessaire, Smile ajoute automatiquement
l’extension ad hoc au nom du fichier.
Quand vous utilisez l’une de ces options, le document est converti en image
bitmap : ce format est bien adapté par exemple à l’affichage sur une page
web.
6.4
37
Réalisation d’une séquence QuickTime
(movie)
Les vues affichées successivement par une fenêtre graphique peuvent être
regroupées pour constituer une séquence QuickTime, un movie. On peut
choisir indépendamment la durée de chaque image dans la séquence (pas
moins de 1/60 seconde néanmoins).
Vous devez procéder en trois étapes.
1. fournissez à la graphic window une référence au nouveau fichier : stockez cette référence dans sa propriété movie file. Cette opération est
facultative : si vous préférez, vous pourrez indiquer dans un dialogue où
et sous quel nom enregistrer la nouvelle séquence au moment de l’enregistrement, c’est-à-dire à l’étape 3. L’étape 1 est donc requise pour
automatiser totalement le processus.
2. pour enregistrer l’affichage courant de la graphic window dans la séquence,
utilisez add movieframe. add movieframe admet comme paramètre
optionnel la durée de l’image (0,1 seconde par défaut).
Exemple 34
add movieframe w duration 1/30 -- 1/30 seconde
3. lorsque la réalisation de la séquence est terminée, clôturez-la en appliquant le verb save à la propriété movie file de la graphic window.
Exemple 35
save movie file of w
Au lieu d’enregistrer la totalité de la fenêtre, vous pouvez choisir de n’enregistrer dans la séquence que l’une des vues de la graphic window, c’està-dire (comme vous le découvrirez plus bas) une graphic view. Pour cela,
passez une référence à la graphic view en question — au lieu d’une référence
à sa fenêtre — à add movieframe. A noter que la propriété movie file appartient dans tous les cas à la graphic window.
Exemple 36
set v to graphic view 1 of w
add movieframe v duration 1/30
Vous pouvez ouvrir et lire une séquence vidéo dans Smile (que ce soit
Smile qui l’ait réalisée ou non). Pour cela, déposez son icône sur l’icône de
Smile, ou par script utilisez la syntaxe suivante.
Exemple 37
38
set mw to DoOpen(theMovieFile)
play mw
-- pause :
stop mw
Une fois qu’il est ouvert dans Smile, vous pouvez utilisez les boutons affichés
par la fenêtre de la séquence pour (re)lancer et arrêter la lecture ou pour la
visionner image par image.
Suivant le réglage correspondant du dialogue Préférences, Smile ouvre la
séquence, soit en noir et blanc, soit en couleurs. Quand elle est ouverte en
noir et blanc, vous pouvez importer l’image courante d’une séquence sous
forme d’un tableau de valeurs : voir Section 7.4.
Chapitre 7
Importation et exportation de
données
Vous devez traiter des données qui se présentent sous différents formats.
Souvent, les tableaux à une dimension sont stockés en ASCII par commodité.
Les données de plus haute dimensionnalité peuvent également être stockées
sous forme de fichiers ASCII — qui peuvent utiliser différents séparateurs —
ou sous forme de fichiers binaires, possiblement générés par des programmes
en C ou en FORTRAN. Le plus souvent ces fichiers contiennent des réels
codés en simple précision (sur 4 octets) ou en double précision (sur 8 octets).
Dans certains domaines il est répandu d’utiliser les fichiers HDF. Dans sa
version actuelle, Smile permet de lire et écrire les Scientific Data Sets (SDS)
des fichiers HDF4.
7.1
Les fichiers ASCII
Lecture et écriture de texte Les commandes des Compléments standard
(StandardAdditions) permettent de lire et écrire les fichiers ASCII. Pour voir
ces commandes, sélectionnez Fichier > Ouvrir un dictionnaire > Scripting additions > StandardAdditions.osax, puis dans la fenêtre dictionnaire sélectionnez
Index > File Read/Write. Vous trouverez là les commandes de base permettant de lire et écrire des données dans les fichiers : open for access, close
access, read, write.
Exemple 38
set f to alias ((path to "docs" as text) & "myTextFile.txt")
39
40
set s1 to "des mots "
set s2 to "1 2 3 4"
write s1 to f -- écriture en début de fichier
write s2 starting at (1 + (get eof f)) to f -- écriture
en fin de fichier
set s to read f
-- "des mots 1 2 3 4"
Si vous lancez le script ci-dessus alors que le fichier n’existe pas, AppleScript
affiche un message d’erreur. Pour créer un fichier par script, utilisez open
for access. Vous devez toujours contrebalancer un open for access par
un appel à close access.
Exemple 39
set f to ((path to "docs" as text) & "myTextFile.txt")
set nref to open for access file f
close access nref -- le fichier est créé
write "des mots" to file f
La commande format (dans la Satimage.osax) permet d’écrire des nombres
dans un format fixé. Dans l’exemple ci-dessous, on utilise format pour afficher
jusqu’à 5 chiffres à gauche du séparateur décimal, jusqu’à 3 chiffres à droite,
en remplaçant les zéros du début par des espaces et en affichant les zéros de
la fin.
Exemple 40
format 16/5 into "^^^^^.000"
-- "
3.200"
Extraction de données numériques La commande extractcolumn permet d’extraire des données numériques d’un fichier ASCII. En entrée, extractcolumn
attend une chaı̂ne de caractères utilisant tab comme séparateur de colonnes
et CR (ASCII 13) ou LF (ASCII 10) comme séparateur de lignes. Le paramètre in peut être, soit une telle chaı̂ne de caractères, soit un fichier qui
en contient une.
Vous pouvez indiquer quelles colonnes extraire de l’une des trois façons suivantes : extractcolumn i, extractcolumn i thru j ou extractcolumn
{i, j, ...}. Le paramètre skipping permet de sauter par exemple une
ligne d’en-tête.
Exemple 41
set {x,y} to extractcolumn {1,3} in s skipping 1
41
Par défaut, extractcolumn retourne les colonnes (ici les deux colonnes x et
y) sous forme de chaı̂nes de caractères dans lesquelles chaque ligne est séparée
de la suivante par CR. Pour obtenir directement des arrays of real vous
devez forcer la coercion au moyen du mot-clé as.
Exemple 42
set {x,y} to extractcolumn {1,3} in s as array of real
skipping 1
Ici x et y contiendront des arrays of real.
Si vous indiquez extractcolumn ...as string le résultat sera une chaı̂ne
de caractères unique contenant les colonnes sélectionnées sous forme d’un
tableau qui utilise tab et return (CR) comme séparateurs de colonnes et de
lignes, respectivement.
Exemple 43
set theTable to "An.
Rev.
%
2018
708
.3
2019
712
.6"
extractcolumn 2 thru 3 in theTable as string
-- "Rev.
%
708
.3
712
.6"
Si vous indiquez l’indice d’une colonne qui n’existe pas, extractcolumn renvoie une colonne de chaı̂nes vides si le paramètre in est une chaı̂ne de caractères ou un fichier, et il renvoie un array of real contenant une seule
valeur missing value si le paramètre in est une matrix.
Les emplacements pour lesquels extractcolumn n’a pas pu identifier un
nombre valide contiennent la valeur missing value.
Pré-traitement de fichiers ASCII Les fichiers que vous traiterez
peuvent présenter différents formats. Par exemple, votre fichier peut contenir à la fois des espaces et des tabulations. Vous pouvez donc être amené à
traiter le texte avant de lui appliquer extractcolumn.
Pour le traitement de texte, les Compléments standard proposent quelques
commandes : sélectionnez Fichier > Ouvrir un dictionnaire > Scripting Additions > StandardAdditions.osax, puis dans la fenêtre du dictionnaire sélectionnez
Index > String Commands.
En revanche la Satimage.osax offre des outils plus spécifiques et plus puissants, notamment une commande change supportant les Regular expressions.
42
Le script ci-dessous utilise les Regular expressions pour supprimer les espaces
en début de chaı̂ne de caractères, puis les espaces en fin de chaı̂ne, puis pour
remplacer par tab n’importe quelle suite d’espaces précédés ou non de tab.
Exemple 44
set
set
set
set
s
s
s
s
to
to
to
to
read f
change "^[ ]+" into "" in s with regexp
change "[ ]+$" into "" in s with regexp
change "\\t ?[ ]+" into "\\t" in s with regexp
Vous remarquez ici que dans AppleScript on délimite une chaı̂ne de caractères
au moyen des guillemets anglo-saxons (double-quotes), et qu’il faut faire
précéder la barre de fraction inversée (backslash) et les double-quotes par un
backslash : "\\" et "\"".
Fichiers tabulés (.tsv) L’extension .tsv (pour “tab-separated values”)
indique un fichier ASCII dont les colonnes sont séparées par tab (ASCII 9)
et les lignes par CR (ASCII 13) ou LF (ASCII 10).
Smile ouvre les fichiers .tsv d’une façon spéciale : au lieu d’afficher son
contenu dans une fenêtre de texte (une text window) comme il le fait pour
tout fichier ASCII, Smile affiche le contenu du fichier sous forme de courbes
et il ouvre une boı̂te de dialogue spéciale, File plotter, qui permet de personnaliser le graphique (fig.7.1). File plotter vous permet de choisir la colonne des
abscisses, la ou les colonnes à tracer en ordonnées (pour tracer plusieurs colonnes indiquez leurs numéros séparés par des virgules), ainsi que le nombre
de lignes à sauter en tête de fichier. De plus si vous indiquez 1 ligne à sauter,
File plotter essaiera d’utiliser les données contenues dans l’en-tête pour nommer l’axe des abscisses et les courbes.
Vous pouvez enregistrer les réglages courants de File plotter. Ceci vous permet d’ouvrir successivement de la même façon des fichiers de la même nature.
Le bouton Nlle fenêtre permet de laisser la fenêtre courante en l’état et d’en
créer une autre, par exemple pour comparer deux situations. De même, le
bouton Nlle courbe laisse la ou les courbes courantes en l’état et en crée une
autre ou d’autres.
43
Fig. 7.1 – Quand on ouvre un fichier .tsv, Smile le trace directement.
7.2
Les fichiers binaires
La Satimage.osax contient les commandes nécessaires pour travailler sur
des fichiers binaires, à savoir read binary et write binary.
Avant de lire des données dans un fichier binaire, il faut savoir si les réels
qu’il contient sont codés en simple précision ou en double précision1 et si le
fichier contient des blocs de remplissage (“paddings”).
Dans l’exemple ci-dessous ou lit 10.000 valeurs dans un fichier produit par
un code FORTRAN en simple précision.
Exemple 45
set a to (read binary alias "myFile" as small real skip
4 length 10000)
Le script saute les quatre premiers octets du fichier : comme c’est souvent
le cas, le format utilisé par le programme FORTRAN encapsule les blocs de
données entre deux blocs de 4 octets nuls.
Si par exemple les données avaient été écrites par des opérations d’écriture
successives, on aurait pu avoir des blocs de remplissage supplémentaires entre
données. Quand vous n’êtes pas sûr de connaı̂tre exactement comment le
fichier est structuré, utilisez la commande AppleScript standard read avec
1
A noter que read binary retourne dans tous les cas un tableau sous forme d’un array
of real, qui stocke les réels en double précision.
44
l’option as integer.
Exemple 46
set mylist to (read alias "myFile" for 256 as integer)
L’option as integer a pour résultat de lire le fichier par blocs de 4 octets,
les blocs de remplissage apparaissant comme des zéros.
La ligne ci-dessus lit 256/4 soit 64 valeurs. Ne tentez pas de l’utiliser pour
lire plus que 4000 valeurs.
Lorsque vous écrivez des données dans un fichier binaire à l’aide de write
binary, vous pouvez indiquer la position à laquelle vous voulez écrire ainsi
que le format des données (nombres codés sur 4 ou 8 octets).
Si le fichier à écrire n’existe pas encore, vous devez passer à write binary
une référence au fichier sous la forme file f2 :
Exemple 47
set f to (path to "docs" as text) & "temp.temp"
write binary file f with data a
Pour insérer un bloc de remplissage de 4 octets nuls, insérez une ligne write
0 in f entre les deux write binary concernées.
Dans les exemples ci-dessus nous avons utilisé read binary et write
binary sur des fichiers. On peut également utiliser, au lieu d’une référence à
un fichier, le numéro de référence du fichier tel que retourné par la commande
AppleScript open for access. Cette référence fournit un accès plus rapide,
de plus elle permet une lecture séquentielle du fichier, celui-ci restant ouvert
entre deux appels.
Exemple 48
set f to (path to "docs" as text) & "temp.temp"
set refNum to open for access (f as alias)
write binary refNum with data a
close access refNum
2
AppleScript gère deux classes pour indiquer un fichier, à savoir file
specification, exemple file "Startup :Applications :Calculator", et alias,
exemple alias "Startup :Applications :Calculator". alias ne peut être utilisé que
si le fichier existe, ce qui n’est pas le cas de file specification. Le Finder gère
préférentiellement les alias.
7.3
45
Les fichiers HDF
La HDF.osax (un téléchargement disponible séparément) contient les
commandes nécessaires pour écrire et lire les fichiers HDF : HDFRead, HDFExtract
et HDFWrite.
HDF.osax gère les Scientific Data Sets (SDS) du format HDF4. La structure correspondante dans Smile s’appelle le data set, dont la définition est
donnée dans HDF.osax.
Un data set est en réalité un record au sens de AppleScript, qui contient
les données sous forme d’un array of real, et les dimensions des données
sous forme d’une liste d’entiers : la longueur de la liste est la dimensionnalité
du tableau, et les entiers indiquent les tailles du tableau dans les différentes
directions.
Exemple 49
set mySDSs to (HDFRead alias f)
-- {{name :"fakeDim0", dimensions :{100}}, {name :"fakeDim1",
dimensions :{92}}, {name :"Volcano", dimensions :{100,
92}}}
Par défault HDFRead renvoie uniquement les informations sur la structure du
tableau de données et non pas les données elles-mêmes.
Pour lire les données elles-mêmes vous devez préciser data true : HDFRead
renvoie alors les données dans le champ array of real du record. A noter
que l’ordre utilisé pour le champ dimensions fonctionne comme en FORTRAN : dans le cas ci-dessus ”Volcano” est un tableau de 100 lignes de 92
colonnes.
Exemple 50
set {ySDS, xSDS, zSDS} to (HDFRead alias f data true)
set zdim to dimensions of zSDS
set z to {class :matrix, ncols :item 2 of zdim, nrows :item
1 of zdim, array of real :array of real of zSDS}
Si le tableau de données est de grande taille, par exemple s’il représente
un champ 3-dimensionnel, il peut être souhaitable d’en extraire un sousensemble, par exemple une tranche (à 2 dimensions). C’est le rôle de
HDFExtract. La syntaxe de HDFExtract suit fidèlement la syntaxe de la fonction SDreaddata de la bibliothèque HDF.
Avant d’écrire des données au moyen de HDFWrite vous devez d’abord
constituer un data set. Gardez présent à l’esprit qu’un data set n’est autre
46
qu’un simple record AppleScript :
Exemple 51
set ds to {class :data set, name :"Volcano", dimensions :
{500, 500}, array of real :a}
HDFWrite ds into file "mynewHDFfile"
7.4
Fichiers graphiques
Smile sait ouvrir tous les formats d’image que QuickTime reconnaı̂t, tels
que JPEG, PNG, BMP etc (Smile affiche ce type de fichier dans une fenêtre
de séquence vidéo). Cependant vous pouvez importer dans Smile le tableau
des niveaux de gris d’une image sans pour autant ouvrir l’image.
A l’inverse, pour importer le tableau des niveaux de gris d’une image
(ou de toutes les images) d’une séquence vidéo (”movie”), il est nécessaire
d’ouvrir le fichier dans Smile.
7.4.1
Importation de données à partir d’une image bitmap
Smile permet d’importer les données à partir d’images bitmap à l’aide
des commandes suivantes : imagefile bounds et convert imagefile. Ces
commandes permettent d’importer les données à partir de fichiers d’images
tels que .tiff ou .jpg files.
imagefile bounds renvoie sous forme d’une liste {0, 0, xmax, ymax} les
dimensions (en pixels) de l’images.
convert imagefile renvoie, sous forme d’une matrix, le tableau 2D des
niveaux de gris des pixels de l’image. Les niveaux de gris sont codés entre 0
(blanc) et 255 (noir).
Exemple 52
set m to convert imagefile (alias aPath)
QuickScalarMap(0, 0, m, 0) -- affiche les niveaux de gris
dans un scalar map
7.4.2
47
Importation de données à partir d’une séquence
vidéo
Pour travailler sur une séquence vidéo, il faut d’abord l’ouvrir dans Smile
en niveaux de gris. Par défaut Smile ouvre les séquences vidéo en couleurs :
vous pouvez modifier ce comportement dans la section Avancé du dialogue de
Préférences. Pour modifier le comportement par script, modifiez la variable
globale my gMovieGrey.
Exemple 53
set savedmode to my gMovieGrey
set my gMovieGrey to true
set mw to DoOpen(aMoviePath)
set my gMovieGrey to savedmode
Pour récupérer l’image courante sous forme d’une matrix comme plus
haut, utilisez la propriété image de la movie window.
Exemple 54
set m to image of mw
QuickScalarMap(0, 0, m, 0) -- affiche m sous forme d’une
carte en couleurs
Pour passer à l’image suivante ou à l’image précédente de la séquence,
utilisez la propriété class STEP .
Exemple 55
set class STEP of mw to 1 -- image suivante
set class STEP of mw to -1 -- image précédente
48
Chapitre 8
Pilotage de codes avec Smile
Un script AppleScript peut appeler n’importe quelle commande du shell,
exactement comme depuis Terminal. Vous pouvez par conséquent utiliser
n’importe quel outil UNIX depuis n’importe quel script dans Smile. Pour
cela, utilisez la commande AppleScript do shell script : l’instruction
AppleScript do shell script [uneCommande] est équivalente à exécuter
uneCommande depuis une fenêtre de Terminal1 .
8.1
Les chemins d’accès aux fichiers
AppleScript et UNIX utilisent des conventions différentes quand il s’agit
de désigner un fichier à l’aide d’une chaı̂ne de caractères. Là ou UNIX utilise
la barre de fraction (slash) / pour séparer les répertoires successifs, AppleScript utilise les deux-points :2 .
Pour convertir le chemin d’accès UNIX d’un fichier en référence de fichier
AppleScript utilisez la commande POSIX file. POSIX file s’utilise sur les
fichiers aussi bien que sur les répertoires.
Exemple 56
set b to "/usr/local/bin/"
set a to POSIX file b
-- file "Macintosh HD :usr :local :bin :"
1
Les deux ne sont pas rigoureusement équivalents en effet à ce jour Terminal utilise
tcsh comme shell alors que do shell script ouvre une session sh.
2
Par conséquent un / dans un nom de fichier en AppleScript se traduit en deux-points :
dans le nom UNIX du fichier.
49
50
Pour convertir une référence AppleScript à un fichier en chemin d’accès UNIX
utilisez la propriété POSIX path. Le résultat de POSIX path est une chaı̂ne
de caractères. Il se peut que vous ayez à encapsuler (“escape”) cette chaı̂ne
avant de la passer à un script de shell — ce sera le cas par exemple si le
chemin contient des espaces. Pour cela utilisez quoted form, une propriété
spéciale des chaı̂nes de caractères qui encapsule la chaı̂ne de caractères entre
guillemets simples ’ et effectue les transformations nécessaires pour rendre
la chaı̂ne compatible avec les habitudes des commandes de shell.
Exemple 57
set a to file "Macintosh HD :usr :local :bin :"
set b to POSIX path of a
-- "/usr/local/bin/"
set c to quoted form of b
-- "’/usr/local/bin/’"
8.2
Lancement d’un executable UNIX
Dans l’exemple suivant, le script lance un code de calcul nommé spl sur
des données en entrée contenues dans un fichier fin, et rend son résultat sous
forme d’une chaı̂ne de caractères dans la variable s.
Exemple 58
-- fin est le chemin d’accès d’un fichier de données
set fout to change ".ctl$" into ".out" in fin with regexp
set scpt to "/sw/bin/spl " & fin & " >& " & fout
do shell script scpt
set s to read POSIX file fout
8.3
Attente de la fin de l’exécution d’un executable UNIX
Si l’exécution du code de calcul dure davantage que quelques secondes,
vous préférerez qu’il s’exécute en tâche de fond sans vous bloquer. Il s’agit
là d’une fonctionnalité standard du shell : il vous suffit d’ajouter & (après un
espace) à la commande, et de rediriger le résultat et les erreurs vers un fichier
51
au moyen de >&. do shell script rendra alors la main immédiatement.
Exemple 59
-- fin est le chemin d’accès d’un fichier de données
set fout to change ".ctl$" into ".out" in fin with regexp
set scpt to "/sw/bin/spl " & fin & " >& " & fout & "
&"
do shell script scpt
Il est souvent souhaitable que le script attende que le code ait terminé de
s’exécuter avant de poursuivre sa propre exécution. Pour cela vous devez utilisez la commande smilepause (spécifique à Smile), qui permet de suspendre
un script sans bloquer l’application, qui demeure totalement interactive.
Exemple 60
repeat
if "/sw/bin/spl" is not in (do shell script "ps -xw")
then exit repeat
smilepause 0.1
end repeat
set s to read POSIX file fout
Pendant l’exécution d’une instruction smilepause, la touche esc déclenche
une erreur error number -128 ("Annulé par l’utilisateur") que vous
pouvez gérer spécifiquement (à l’aide d’une structure try ... end try) et
qui par défaut interromp le script.
52
Chapitre 9
Comment modifier son code
pour le rendre scriptable
Il est possible d’utiliser depuis Smile un programme UNIX tel quel, mais
il bien plus avantageux d’en effectuer réellement le portage sur OSX et de
le rendre ainsi interactif. Pour permettre d’interagir depuis Smile avec un
programme de calcul vous avez deux options.
– vous pouvez faire de votre code de calcul un Complément de pilotage
(ou “osax”). Une osax est un “plug-in” pour AppleScript, qui une fois
installée est disponible depuis n’importe quel script : le dictionnaire
d’une osax s’ajoute à la terminologie d’AppleScript. Le mécanisme des
osax est bien adapté pour de petits codes ne nécessitant pas de gros
temps de calcul ni de grosses quantités de mémoire : par exemple,
Satimage.osax implémente les fonctions transcendantes.
– dans le cas d’un code plus sophistiqué, il est préférable d’en faire une
application scriptable à part entière. En effet vous bénécifierez alors de
possibilités exclusives qui sont les suivantes :
– vous profitez d’un contexte plus confortable et plus souple pour piloter et gérer le calcul, et pour échanger des données avec lui,
– vous pouvez interagir avec votre calcul pendant qu’il s’exécute, et le
surveiller depuis Smile,
– vous pouvez débugger votre programme de calcul de façon interactive.
Le site web de Satimage-software propose des exemples de projets pour
XCode vous permettant de réaliser facilement un Complément de pilotage
ou une application scriptable.
53
54
En principe, quand une instruction adresse une commande à une application scriptable, elle attend que l’application lui ait renvoyé le résultat
avant de poursuivre l’exécution du script. Pour contourner ce problème si
par exemple votre code demande un temps de calcul important, utilisez une
des deux instructions de contrôle AppleScript with timeout (déclenchera
une erreur après un temps fixé, erreur que vous pourrez alors intercepter et
gérer) ou ignoring application responses (qui indique à l’instruction de
poursuivre immédiatement l’exécution du script sans attendre le résultat),
et utilisez smilepause pour suspendre le script sans bloquer Smile.
L’exemple ci-dessous lance un calcul qui ne bloquera pas le script appelant.
Exemple 61
ignoring application responses
tell application "MonAppliScriptable"
compute 10000
end tell
end ignoring
Pour envoyer une requête à votre programme sans risquer de rester bloqué
en cas d’anomalie, utilisez l’instruction with timeout :
Exemple 62
on EssaieLecture()
with timeout of 0.1 seconds
tell application "MonAppliScriptable"
set the result to velocity
end tell
end timeout
return the result
end EssaieLecture
Enfin, pour suspendre un script en attendant la fin d’un calcul, utilisez
smilepause :
Exemple 63
repeat
try
set v to EssaieLecture()
exit repeat -- la tentative a réussi
end try
smilepause 0.1 -- la tentative a échoué, EssaieLecture
55
rend une erreur
end repeat
Des modèles client-serveur plus sophistiqués, ne bloquant pas le script appelant, peuvent être également implémentés au moyen d’une programmation multi-tâches (“multi-threading”). Un exemple d’application à “thread”
est donné dans les exemples de projets XCode proposés sur le site web de
Satimage-software.
56
Chapitre 10
Réalisation d’une interface
graphique utilisateur
Comme on l’a vu dans les chapitres précédents, c’est au moyen de scripts
écrits en AppleScript qu’on contrôle Smile. Un script donné peut être appelé
par différents moyens : par exemple, en choisissant son nom dans un menu
déroulant, ou par l’intermédiaire d’une fenêtre de dialogue personnalisée.
Pour exploiter les fonctionnalités qui sont présentées ci-dessous, référezvous à la documentation de Smile. La documentation de Smile est incluse
dans le téléchargement de Smile. Vous pouvez également cliquer ici pour
vous rendre sur la page web de téléchargement séparé de la documentation
de Smile.
10.1
Personnalisation du menu utilisateur
Smile propose un menu appelé menu Scripts utilisateur : c’est le menu indiqué par une icône de parchemin. On peut personnaliser ce menu en ajoutant
et en supprimant des fichiers ou des dossiers dans le dossier User Scripts
de Smile ou dans le dossier /Users/<login>/Bibliothèque/Application
Support/Smile/User Scripts/.
Le menu permet de lancer des scripts ou d’ouvrir des documents.
Pour qu’un script soit disponible à tout instant, recopiez-le dans
le dossier /Users/<login>/Bibliothèque/Application Support/Smile/User
Scripts/. Il n’est pas nécessaire de quitter et relancer Smile : le menu Scripts
utilisateur se met à jour instantanément.
57
58
10.2
Réalisation de dialogues personnalisés
Avec Smile, vous pouvez réalisez des fenêtres de dialogue Aqua
entièrement scriptés, d’où vous pourrez utiliser toute la puissance d’AppleScript1 , et celle de Smile.
Un dialogue personnalisé vous permet de donner aux scripts que vous avez
rédigés l’interface graphique la mieux adaptée. Les dialogues augmenteront
votre productivité en facilitant le travail de recherche, ils vous permettent de
transmettre le résultat de votre travail à des collègues sous la forme la plus
appropriée, ils vous permettent également de présenter dans les conférences
de véritables “data shows” plutôt que des diaporamas statiques.
Un dialogue s’enregistre sur disque comme un document qui présente une
icône de Lego, qu’on peut ouvrir par double-clic ou bien par script. Pour
créer un dialogue personnalisé, on commence par installer dans une fenêtre
de dialogue vide tous les éléments nécessaires, boutons, champs de texte,
menus etc. Puis on associe des scripts au dialogue (et possiblement aussi aux
éléments qu’il contient), qui gèreront le comportement du dialogue vis-à-vis
des actions de l’utilisateur.
Pour tous les détails sur les dialogues personnalisés, ainsi que sur d’autres
moyens de personnaliser l’interface de Smile, reportez-vous à la documentation de Smile.
10.3
Personnalisation de l’interface utilisateur d’un graphique
Un graphique peut répondre aux actions de l’utilisateur de façon
entièrement personnalisée. Pour cela, vous devez associer des scripts aux
objets graphiques.
10.3.1
Comment associer un script à un objet graphique
Vous pouvez associer (on dit parfois “attacher”) un script, soit à une
graphic window, soit à une graphic view (c’est-à-dire à un objet d’une
1
Par exemple les dialogues de Préférences et de Recherche sont des dialogues personnalisés de ce type.
59
classe descendant de celle-ci). Pour associer un script à un objet graphique,
ou pour modifier son script, la graphic window doit être en mode “édition”.
Pour cela, choisissez Edition > Mode édition dans le menu (concernant le
mode édition, voir aussi la section 5.6).
En mode édition, la fenêtre graphique affiche les cadres des graphic views.
Pour ouvrir le script d’un objet, cliquez dans l’objet avec les touches cmd et
option enfoncées. Selon que vous cliquez à l’intérieur d’une graphic view ou
non, vous ouvrirez le script de la graphic view ou le script de la fenêtre.
Le script d’un objet s’ouvre dans une fenêtre de script, une script window.
Le menu File > Save met à jour le script de l’objet, et les modifications
sont effectives immédiatement. Pour enregistrer votre travail sur disque —
y compris les scripts — vous devez enregistrer la graphic window comme
“bundle”, voir Section 6.1.
10.3.2
Personnalisation du menu contextuel
Le menu contextuel2 sert à présenter des fonctionnalités personnalisées à
l’utilisateur. Vous pouvez y installer autant de commandes que nécessaire,
et l’utilisateur n’aura aucun mal à se souvenir que toutes les fonctions sont
réunies dans le menu contextuel.
Par défaut, le menu contextuel de la graphic window est vide, et le menu
contextuel des graphic views contient (au moins) la commande Lire les informations, qui permet d’ouvrir le dialogue de réglages pour l’objet en question.
Pour installer d’autres commandes dans le menu contextuel d’un objet,
vous devez ajouter deux procédures dans son script.
1. installez une procédure CustomMenuItems qui doit générer une liste de
chaı̂nes de caractères, les commandes que le menu doit afficher. Inspirezvous de l’exemple suivant.
Exemple 64
on CustomMenuItems(theView)
set theList to {"New run", "Stop run"}
return theList
end CustomMenuItems
Smile passe à CustomMenuItems une référence à l’objet. La procédure
doit retourner une liste de chaı̂nes de caractères.
2
Pour dérouler le menu contextuel d’un objet, cliquez à l’intérieur de l’objet avec la
touche ctrl enfoncée.
60
Le comportement par défaut s’obtient au moyen de continue, un motclé d’AppleScript. L’exemple ci-dessous affichera dans le menu contextuel le menu standard ainsi que des commandes personnalisées.
Exemple 65
on CustomMenuItems(theView)
set theList to {"Lancer la simulation", "Arr^
eter",
"-"}
set theBuiltIn to continue CustomMenuItems(theView)
return theList & theBuiltIn
end CustomMenuItems
2. installez une procédure do menu qui gérera les nouvelles commandes.
Pour la syntaxe de do menu, reportez-vous au dictionnaire de Smile, ou
inspirez-vous de l’exemple suivant.
Exemple 66
on do menu theCmd to theView
if theCmd is "Lancer la simulation" then
-- perform new run
else if theCmd is "Arr^
eter" then
-- stop current run
else
continue do menu theCmd to theView
end if
end do menu
Vous devez appeler le comportement par défaut au moyen du mot-clé
continue.
10.3.3
Gestion des touches du clavier
A chaque fois que l’utilisateur frappe une touche du clavier, ou une combinaison d’une touche avec une des touches spéciales (shift, option, cmd,
caps lock ou ctrl) Smile envoie un événement keyboard down au script de la
graphic window active.
Pour gérer les événements clavier, installez une procédure keyboard down
dans le script de la graphic window. Vous trouverez la syntaxe de keyboard
down dans le dictionnaire de Smile. Smile passe comme paramètres à la
procédure keyboard down la touche qui a été frappée (mot-clé character), et
61
la liste des touches spéciales éventuellement enfoncées (mot-clé modifiers)3 .
Les valeurs possibles du paramètre modifiers dont les mêmes que celles de la
propriété modifiers de l’application, qui sont présentées dans le dictionnaire
de Smile à la rubrique Class application.
L’exemple ci-dessous trace des courbes aléatoires en fonction des touches
frappées par l’utilisateur : le script gère les touches “r” (pour “remise à zéro”)
et “n” (pour “nouvelle courbe”).
Exemple 67
on keyboard down theWindow event theEvent
if modifiers of theEvent is not {} then return
if character of theEvent is not in "rn" then return
if character of theEvent is "r" then
try
set v to plot view 1 of theWindow
delete every curve of v
end try
draw theWindow
return
end if
try
set v to plot view 1 of theWindow
on error
set v to make new plot view at theWindow
end try
set c to make new curve at end of v
set f to random number from 0.0 to 2.0
set formula of c to "" & f & "*sin(x^" & f & ")"
draw theWindow
end keyboard down
Si vous souhaitez essayer cet exemple, procédez comme suit :
– sélectionnez Fichier > Nouveau texte
– dans la nouvelle fenêtre de texte, tapez la ligne suivante :
3
Attention : si les touches spéciales modifient “normalement” l’effet de la touche, le
paramètre character contient le caractère modifié. Par exemple si l’utilisateur press shifta le paramètre character contiendra A et non pas a, et le paramètre modifiers contiendra
la liste à un élément {shift down}.
62
make new graphic window
puis pressez la touche Enter (pas la touche Retour chariot)
– sélectionnez Edition > Mode édition pour passer la fenêtre graphique
en mode édition
– faites cmd-option-clic dans la fenêtre graphique. Son script s’ouvre.
– recopiez le script ci-dessus
– sélectionnez Fichier > Enregistrer puis Fichier > Fermer
– sélectionnez Edition > Mode édition pour désactiver le mode édition de
la fenêtre graphique
A présent vous pouvez frapper “n” pour faire une nouvelle courbe, et “r”
pour nettoyer la fenêtre.
10.3.4
Gestion des clics souris
A chaque fois que l’utilisateur clique dans la graphic window, Smile envoie un événement pick in au script de la graphic window ou au script de
la graphic view concernée, en fonction de l’endroit où le clic a eu lieu.
Pour gérer les clics souris, installez une procédure pick in dans le script
de la graphic window et/ou dans les scripts des graphic views. Smile passe
à pick in les paramètres suivants : pick in theObject at theRecord.
theObject est une référence à l’objet qui reçoit le clic (le propriétaire du
script). Le record theRecord contient au minimum deux quantités : point
(une liste de deux nombres réels), qui contient les coordonnées de la souris,
à savoir les coordonnées en pixels si theObject est une graphic window, ou
bien les coordonnées utilisateur si le clic a lieu à l’intérieur du plot frame
d’une graphic view.
Si le clic a lieu dans une view3D, le champ point contient une liste de 3
nombres réels (en coordonnées utilisateur) et theRecord contient également
un champ target object. Ce champ contient une référence à l’objet de la
view3D désigné par la souris, typiquement une surface.
Vous pouvez obtenir les coordonnées en pixels d’un point donnée en
coordonnées utilisateur au moyen de la commande convert coordinates.
Exemple 68
on pick in theView at theRecord
set userPt to point of theRecord
set pixelPt to convert coordinates userPt in theView
63
end pick in
Si vous installez une procédure qui gère les clics souris, vous supprimez
le comportement par défaut tel qu’il est décrit au chapitre 5. Pour restituer
le comportement par défaut, utilisez le mot-clé continue (voir Ex.69).
L’exemple ci-dessous crée un nouveau point dans la première courbe (qu’il
crée si nécessaire) du plot view à chaque clic dans son plot frame.
Exemple 69
on pick in theView at theRecord
continue pick in theView at theRecord
set theStep to step of theRecord
if theStep is not 1 then return
set {x, y} to point of theRecord
try
set c to curve 1 of theView
on error
set c to make new curve at theView
set xdata of c to {0}
set ydata of c to {0}
set line style of c to 1
set pattern style of c to 1
end try
set xdata of c to (get xdata of c) & {x}
set ydata of c to (get ydata of c) & {y}
set limits of theView to {0, 1, 0, 1}
draw theView
end pick in
Vous pouvez essayer ce script sur la graphic window de l’exemple précédent :
tapez d’abord simplement “r” pour supprimer toutes les courbes.
Si vous n’avez pas conservé la fenêtre de l’exemple précédent, procédez
comme suit :
– sélectionnez Fichier > Nouveau texte
– dans la nouvelle fenêtre de texte, tapez les deux lignes suivantes :
make new plot view at w
sélectionnez les deux lignes puis pressez la touche Enter (pas la touche
Retour chariot)
64
– sélectionnez Edition > Mode édition pour passer la fenêtre graphique
en mode édition
– faites cmd-option-clic à l’intérieur du plot view. Son script s’ouvre.
– recopiez le script ci-dessus
– sélectionnez Fichier > Enregistrer puis Fichier > Fermer
– sélectionnez Edition > Mode édition pour désactiver le mode édition de
la fenêtre graphique
Vous pouvez maintenant créer de nouveaux points en cliquant à l’intérieur
du plot view.
Annexe A
Ce qu’il faut savoir pour
exploiter Smile
A.1
Objet du Chapitre
Les sections de ce chapitre vous introduiront à AppleScript et à Smile en
vous proposant pour chacun des deux :
1. une courte présentation
2. les liens vers la documentation de référence
3. un guide pratique résumé.
A.2
Ce qu’il faut savoir d’AppleScript
AppleScript, qu’est-ce que c’est ?
AppleScript est le langage inter-application sur les machines Apple.
Depuis plus de 10 ans AppleScript est intégré aux systèmes d’exploitation
Apple.
La documentation sur AppleScript
Sur votre ordinateur, le module AppleScript de Visualisation Aide offre
une première documentation et contient des liens vers la documentation disponible sur Internet. Pour ouvrir Visualisation Aide, choisissez Aide > Aide
65
66
Mac dans le menu du Finder.
Sur Internet la page officielle des ressources concernant AppleScript est la
suivante :
www.apple.com/applescript/resources (vous pouvez cliquer ici pour visiter
cette page). Vous y trouverez en particulier, au format PDF ou consultable
en ligne, la documentation officielle : AppleScript Language Guide (ASLG),
qui contient notamment la référence du langage1 .
La version française (non officielle) de ASLG est disponible sur le site
http ://trad.applescript.free.fr/.
Il faut lire ASLG pour connaı̂tre tout ce qui est nécessaire pour écrire des
scripts AppleScript. Toutefois la syntaxe est assez simple, les erreurs engendrent des alertes à l’écran mais pas de “crash”, donc vous pouvez souhaiter démarrer en modifiant des scripts existants. Smile est livré avec une série
d’exemples qui sont parfaits pour démarrer : sélectionnez Aide > SmileLab
Sample Center.
Guide résumé d’AppleScript
Le champ d’action d’AppleScript
Voici les composants de votre système que vous pouvez contrôler à l’aide
d’AppleScript, et par quels moyens y arriver.
– AppleScript permet d’effectuer des opérations élémentaires comme les
opérations arithmétiques entre nombres et les lectures/écritures de
fichiers ASCII. AppleScript lui-même contient plusieurs opérateurs
élémentaires. De plus la terminologie peut être étendue en installant
des extensions spécifiques à AppleScript, les Compléments de pilotage
(Scripting additions). Le système d’exploitation comprend en standard
plusieurs Compléments de pilotage.
Pour ouvrir le dictionnaire d’un Complément de pilotage, sélectionnez
son nom dans Fichier > Ouvrir un dictionnaire > Scripting additions.
– AppleScript vous permet de piloter les applications qui sont “scriptables”, c’est-à-dire les applications qui possèdent un “dictionnaire”.
Quand une application scriptable est lancée, son nom s’affiche dans le
menu Fichier > Ouvrir un dictionnaire. Le dictionnaire d’une application indique quels termes il faut employer pour s’adresser à elle. Pour
piloter une application, on rédige un script qui utilise ces termes, qu’on
1
Pour consulter directement la version html de ASLG, vous pouvez cliquer ici.
67
encapsule entre un tell application "..." et un end tell2 .
Exemple 70
tell application "[nom de l’application]"
...
end tell
AppleScript permet de piloter une application distante à condition de
connaı̂tre l’adresse IP ou le nom “Rendezvous” de la machine distante.
Si vous n’indiquez pas l’identifiant et le mot de passe, un dialogue vous
proposera de les fournir.
Exemples 71
tell application "Smile" of machine
"eppc ://userid :[email protected] :3031/"
...
end tell
tell application "Smile" of machine
"eppc ://userid :[email protected]/"
...
end tell
Pour ouvrir le dictionnaire d’une application assurez-vous qu’elle soit
lancée puis sélectionnez-la dans le menu File > Open dictionary.
Pour ouvrir le dictionnaire de Smile sélectionnez Smile > Dictionnaire
de Smile.
– AppleScript vous permet de piloter une grande partie du système d’exploitation par l’intermédiaire des Scripting additions.
– Grande nouveauté du MacOS X, AppleScript vous permet de piloter la
couche UNIX par l’intermédiaire de la commande do shell script.
Exécuter la ligne do shell script theCommand dans AppleScript est
équivalent à exécuter dans Terminal la chaı̂ne de caractères contenue
dans la variable theCommand.
La syntaxe d’AppleScript
– il est fortement recommandé de se référer à ASLG (voir Section A.2)
aussi souvent que nécessaire.
Certaines informations sont également présentées dans la AppleScript
2
Quand un script est lancé dans Smile, le tell application "Smile" est implicite.
68
Suite du dictionnaire AppleScript d’AppleScript lui-même3 .
Sélectionnez Fichier > Ouvrir un dictionnaire > AppleScript. Vous
trouverez là un rappel sur les types (classes) de base d’AppleScript
ainsi que sur les opérateurs — y compris les opérateurs arithmétiques.
– comme vous le comprendrez rapidement au moyen des exemples, on
assigne une valeur à une variable au moyen du verbe set. Le verbe
“réciproque” get est souvent optionnel — mais il est parfois indispensable pour forcer AppleScript à évaluer une référence. En effet,
reference fait partie des types de base qu’AppleScript sait manipuler.
Exemple 72
set theTop to item 1 of (get bounds of window 1)
Dans le cas où une variable est d’un type complexe tel que list,
record, date, il faut utiliser copy pour créer une copie du contenu
de la variable, alors que set se contentera de faire une copie de la
référence à un même contenu.
Exemple 73
set theList to {1, 2}
set theNewRef to theList
copy theList to theNewList
set item 1 of theList to 0
-- theNewRef : {0, 2}
-- theNewList : {1, 2}
– pour adresser une instruction ou une série d’instructions à une application spécifique, encapsulez-les dans une structure tell.
Exemple 74
tell application "Finder"
set theList to selection
duplicate theList
end tell
Ceci ne s’applique qu’aux applications : pour faire appel à un
Complément de pilotage possédant l’extension .osax, aucun tell n’est
nécessaire.
3
La AppleScript Suite du dictionnaire d’AppleScript dictionary n’est pas à proprement parler une documentation officielle, il faut plutôt l’utiliser comme une aide d’appoint.
Les applications n’implémentent pas nécessairement cette suite entière.
69
Pour s’adresser à une application située sur une machine distante, utilisez le protocole eppc, soit avec l’adresse IP, soit avec le nom “Rendezvous” de la machine (celui-ci doit se terminer par .local).
Exemple 75
tell application "Smile" of machine "eppc :10.0.1.23"
tell dialog "Calculs" to DoCompute(some data)
end tell
Ici on s’adresse à un objet (le dialog "Calculs") qui appartient à
l’application distante.
– interceptez les erreurs d’exécution à l’aide de la structure try .. end
try structure.
Exemple 76
try
set f to alias somePath
-- instructions à exécuter si le fichier existe
on error -- le fichier n’existe pas
-- instructions à exécuter pour gérer l’erreur
end try
Le pilotage d’objets avec AppleScript
Par quel moyen AppleScript permet-il de piloter les applications ? Ouvrons le dictionnaire d’une application, par exemple celui du Finder. Le dictionnaire présente les définitions de quelques commandes de base (des verbes)
ainsi que la description complète de classes d’objets. Le pilotage d’une application s’effectue en manipulant les objets de cette application4 .
Dans l’exemple ci-dessous le script s’adresse à un type d’objet spécifique au
Finder, les process.
Exemple 77
tell application "Finder" to get name of every process
Un objet possède une liste de propriétés et éventuellement des éléments.
Une propriété est un champ pouvant contenir une valeur, par exemple le nom
4
Apple insiste sur le fait que, à l’inverse des “langages de macro” qui s’adressent à
l’interface de l’application — menus, boutons —, AppleScript s’adresse directement aux
objets même de l’application, ce qui permet de la piloter de façon plus puissante.
70
name de l’objet. Les éléments d’un objet sont d’autres objets qu’il est susceptible de contenir. La liste des propriétés (properties) d’un objet, ainsi que
les classes des objets qu’il peut accepter comme elements, sont renseignées
dans le dictionnaire.
La manipulation d’un objet s’effectue à l’aide de la famille des quatre
verbes élémentaires suivants.
make new : crée un nouvel objet de la classe indiquée, et retourne une
référence au nouvel objet.
Exemple 78
set theWindow to make new graphic window
La fenêtre graphique est créée au premier niveau, elle appartient directement à l’application.
Pour créer un objet comme élément d’un objet existant (son conteneur,
dont une référence est stockée dans la propriété container) il faut utiliser le paramètre optionnel at.
Exemple 79
set thePlot to make new plot view at theWindow
set theCurve to make new curve at thePlot
delete : supprime l’objet dont la référence est passée à delete. Aucune
modification ne sera enregistrée.
Exemple 80
delete theCurve
set : modifie la valeur d’une propriété d’un objet.
Exemple 81
set name of thePlot to "2 * x"
get : lit la valeur d’une propriété d’un objet.
Exemple 82
set theBounds to (get bounds of thePlot)
Obtenir la référence d’un objet
Pour faire référence à un objet, si on n’a pas conservé cette référence
dans une variable, il faut connaı̂tre son type (class) et, soit son nom soit
son index.
Exemples 83
71
set theWind to graphic window 1
set theWind to graphic window "untitled"
Pour faire référence à un objet contenu dans un autre, il faut utiliser of
pour parcourir la hiérarchie à laquelle il appartient, et dont l’application est
implicitement la racine.
Exemple 84
set theCurve to curve 3 of plot view "Températures" of
theWind
C’est ce qui permettra, par exemple de modifier une propriété de l’objet :
Exemple 85
set theCurve to curve 3 of plot view 1 of graphic window
"untitled"
set pattern style of theCurve to 8
A.3
Ce qu’il y a à savoir concernant Smile
Smile, qu’est-ce que c’est ?
Smile est un environnement de développement qui offre un accès amélioré
et à plusieurs niveaux à AppleScript. Avec AppleScript, langage moderne et
abstrait et dont la syntaxe s’inspire de l’Anglais, cette extension du langage
se fait de façon simple et naturelle.
Smile permet aussi bien d’exécuter une instruction à la volée que de
construire des solutions autonomes complètement automatisées et dotées
d’une interface utilisateur conviviale.
En effet Smile contient un environnement de développement et de debug de scripts (essentiellement basé sur l’interpréteur implémenté dans les
fenêtres de texte), il contient un éditeur de texte — Smile contient une
implémentation des Regular Expressions — il contient un éditeur (et le moteur d’exécution) d’interfaces graphiques scriptées, ainsi qu’une bibliothèque
graphique de génération de PDF. Et surtout, Smile est entièrement scriptable
— c’est ce qui le rend complètement automatisable.
La documentation sur Smile
Pour consulter rapidement les notions de base sur Smile, sélectionnez
Aide > Aide Smile. Vous trouverez là une présentation abrégée des bases à
72
connaı̂tre pour démarrer sur Smile.
La documentation complète sur Smile est incluse dans le téléchargement.
Elle est également disponible sur le site de Satimage-software (URL :
http
://www.satimage-software.com/fr/downloads documentation.html)
sous forme de plusieurs fascicules au format PDF, ce qui permet une lecture
sélective.
Notre conseil est le suivant.
1. lisez attentivement Smile-Prise en main.pdf, un document qui
présente brièvement les concepts fondamentaux avec lesquels vous devez être familier.
2. quand vous aborderez une utilisation plus experte de Smile, notamment
quand vous créerez des interfaces personnalisés, vous devez scripter
Smile : référez-vous alors à chaque fois que c’est nécessaire au document
Smile-GUI editor.pdf (non traduit à l’heure où nous écrivons).
3. sur les aspects spécifiques propres à la bibliothèque graphique de
génération de PDFs, utilisez Smile-Dessiner par script.pdf.
4. enfin, les fonctions propres à Satimage.osax, notamment les Regular
Expressions, sont documentées dans Satimage osax.pdf (non traduit à
l’heure où nous écrivons).
Guide résumé de Smile
A savoir absolument concernant l’environnement Smile pour pouvoir
démarrer rapidement sur Smile :
1. pour ouvrir le dictionnaire de Smile, sélectionnez Smile > Dictionnaire
de Smile
2. quand vous appuyez sur la touche Enter dans une fenêtre de texte5 , la
ligne courante ou bien la ou les lignes sélectionnées sont exécutées (ou
compilées, si par exemple le bloc ne contient que des procédures) à la
volée
3. les variables et les procédures créées ou compilées à la volée dans une
fenêtre de texte comme indiqué ci-dessus sont persistantes : vous pouvez
les ré-utiliser plus tard, dans la même fenêtre ou dans une autre, jusqu’à
5
Les “fenêtres de texte” (text window) sont blanches. Si votre fenêtre possède un fond
coloré, vous avez créé une “fenêtre de script” (script window).
73
ce que vous quittiez Smile.
Exemple d’une variable persistante :
Sélectionnez Fichier > Nouveau texte
Tapez dans la nouvelle fenêtre :
set x to 2
Appuyez sur la touche Enter.
Allez à la ligne puis tapez :
beep x
puis appuyez sur Enter. Comme vous le voyez, la variable x
est restée définie.
Exemple d’une procédure persistante :
Sélectionnez Fichier > Nouveau texte
Tapez dans la nouvelle fenêtre :
on AskOK()
display dialog "OK ?"
end AskOK
Sélectionnez le text entier puis appuyez sur Enter.
Allez à la ligne puis tapez :
AskOK()
puis appuyez sur Enter. Comme vous le voyez, la procédure
AskOK est restée définie, vous pourrez l’utiliser jusqu’à ce que
vous quittiez Smile.
4. la combinaison cmd-shift-F, utilisée après avoir sélectionné un terme
AppleScript (un verbe, le nom d’une classe ou le nom d’une procédure),
ouvre le dictionnaire ou la bibliothèque auquel le terme appartient et
dans lequel il est documenté. C’est la façon la plus rapide d’obtenir des
renseignements sur un terme donné.

SmileLab Guide de programmation

Transcription

Documents pareils

bilan smile 2016 - Mont

MAISONS SMILE DESCRIPTIF S052015

Dinky Toys

Transformation de Fourier `a temps discret (TFtd) 1

TP Javascript

CV - Bienvenue chez BiBiMax

Passage heure d`hiver heure d`été

INTITULE DE L`EMPLOI : INGENIEUR ENERGIE (H/F)– Projet

animation ou location de jeux d`opposition pour

KIDDY SMILE ENOUGH OF YOU EP