Découvrir Scilab/Graphiques et sons
5. Graphiques et sons
Ce chapitre traite de la création de graphique et de sons. Pour la création et la lecture de fichiers graphiques et sonores, voir "Gestion des fichiers".
Tracé de fonction.
Tracé 2D.
En Coordonnées cartésiennes.
Le tracé d’une fonction se fait en deux étapes
On note qu'en fait, ƒ("x") est elle-même un vecteur. On peut de manière générale définir un vecteur des valeurs de "x" et un vecteur des valeurs de "y", et la fonction codice_4 tracera le nuage de points ("x"("i" ),"y"("i" )).
Si ƒ est une fonction externe (par exemple définie avec codice_5 ou codice_6, voir "Calcul numérique"), alors on peut tracer directement la fonction avec
On peut aussi définir le vecteur "y" par 
puis tracer avec
Les fonctions codice_10, utilisées à la place de codice_11, permettent de faire varier l’apparence générale du tracé :
Ces fonctions codice_10 acceptent des arguments modifiant le tracé, sous la forme
Les arguments sont de la forme codice_19. L’argument codice_20 permet de limiter le tracé à la zone comprise dans le rectangle défini par les valeurs dans la matrice. D'autres arguments sont exposés plus loin.
Exemple
clear; clf;
x = [0:0.5:2*%pi]';
subplot(2,2,1)
plot2d1(x,sin(x),rect=[0,-1,2*%pi,1])
xtitle("plot2d1")
subplot(2,2,2)
plot2d2(x,sin(x),rect=[0,-1,2*%pi,1])
xtitle("plot2d2")
subplot(2,2,3)
plot2d3(x,sin(x),rect=[0,-1,2*%pi,1])
xtitle("plot2d3")
subplot(2,2,4)
plot2d4(x,sin(x),rect=[0,-1,2*%pi,1])
xtitle("plot2d4")
Nuage de points.
La fonction codice_21 trace un nuage de points. On peut choisir les marqueurs et leur couleur, par exemple :
scatter(x, y, "blue", "+")
place des croix bleues. On peut également utiliser codice_22, codice_23 et codice_24 pour placer respectivement des rectangles, des ellipses et des ellipses remplies. Les paramètres d'entrée sont des matrices. Pour codice_23, c'est une matrice de type :
[x1, x2, …, xn
 y1, y2, …, yn
 l1, l2, …, ln
 h1, h2, …, hn]
où le rectangle "i" est défini par son point en haut à gauche ("xi", "yi"), sa largeur "li" et sa hauteur "hi". Par exemple, si codice_26 et codice_27 sont des vecteurs de même dimension et codice_28 est le côté du carré que l'on veut tracer, on peut utiliser
xrects([x - a/2 ; y + a/2 ; a*ones(x) ; a*ones(x)])
On note que la hauteur est comptée positive vers le bas, raison pour laquelle il faut ajouter "a"/2 à "y" (pour remonter le coin du rectangle). On peut ajouter un vecteur de couleurs de même dimension que codice_26, que nous appelons ici codice_30 (vecteur d'entiers correpondant à la carte des couleurs :
xrects([x - a/2 ; y + a/2 ; a*ones(x) ; a*ones(x)], z)
Les commandes codice_23 et codice_24 sont similaires (elles tracent des ellipses inscrites dans les rectangles définis comme avec codice_22), mais il faut de plus indiquer l'angle de départ et l'angle de fin de l'arc, en 1/64 de degré (donc 0 et 34×360 pour une ellipse complète). Donc :
xarcs([x - a/2 ; y + a/2 ; a*ones(x) ; a*ones(x) ; zeros(x) ; 64*360*ones(x)], z)
Tracé de plusieurs courbes.
On peut superposer plusieurs courbes. Il suffit d'avoir :
Par exemple, si l'on a deux courbes, la matrice Y a deux colonnes, et les courbes tracées sont les courbes ("x"("i"), Y("i", 1)) et ("x"("i"), Y("i", 2)) :
x = (0:0.05:2*%pi)';
Y = [cos(x), sin(x)];
plot(x, Y)
On peut aussi simplement utiliser codice_34.
Dans ce cas-là, Scilab utilise une couleur différente pour chaque courbe ; on peut inscrire une légende sous le graphique pour chaque couleur, avec la commande codice_35 :
legend("cosinus", "sinus");
Les légendes des axes peuvent contenir des expressions mathématiques LaTeX :
legend("$\cos \alpha$", "$\sin \alpha$");
Si l'on a de nombreuses courbes, on peut afficher les légendes sur plusieurs colonnes avec la fonction codice_36 développée par Samuel Gougeon, et téléchargeable sur le Scilab FileExchange.
Si les listes d'abscisses sont différentes, alors on répète la liste des abscisses et ordonnées :
plot(x1, f1(x1), x2, f2(x2), x3, f3(x3))
On peut définir la manière dont est tracée la courbe en mettant une chaîne de caractère après la matrice des "y". Cette chaîne de caractère peut contenir :
Ces paramètres ne fonctionnent qu'avec la fonction codice_11 et pas avec les fonctions codice_60.
Exemple
x=linspace(0,%pi,50);
plot(x, sin(x), "+g", x, cos(x), "-^r")
Avec les commandes codice_10, on change le type de tracé (couleur, marqueur) en utilisant l’argument codice_62 ou "n" est un entier positif ou négatif (par exemple codice_63) :
Avec plusieurs courbes, on place les différents styles dans un vecteur ligne, par exemple
plot2d(x, [cos(x), sin(x)], style = [-1, -2])
Notons enfin que pour Scilab, les courbes sont des objets de type "polyline". On peut donc ajuster leur apparence (couleur, marqueur, type de tracé, …) en modifiant les propriétés de ces objets, voir la section "Propriétés des objets".
On peut également afficher les courbes dans des sous-fenêtres séparées, voir "Utilisation de sous-fenêtres".
En coordonnées polaires.
La fonction codice_66 permet en tracé en coordonnées polaires. La fonction "r"("theta") se trace par la commande : codice_67 où "r" et "theta" sont deux matrices de même dimension.
Par exemple :
theta = linspace(0, 2*%pi, 20)
r = 1 + 0.2*rand(1, 20, "normal")
polarplot(theta, r)
Tracé de statistiques.
La commande codice_68 permet de tracer un histogramme à barres verticales, et codice_69 un histogramme à barres horizontales. Les barres sont équidistantes et de même largeur. Dans sa forme la plus simple, il suffit de fournir un vecteur de valeurs à tracer ; les barres sont centrées sur les indices des valeurs dans le vecteur. Par exemple
y = [1 -3 5];
bar(y)
Trace un histogramme à trois barres centrées sur "x" = 1, "x" = 2 et "x" = 3, ayant pour altitude respective 1, -3 et 5. On peut préciser la largeur "l" sous la forme d'un nombre "l", et éventuellement la couleur en donnant le nom en anglais entre guillemets :
bar(y, l, "green")
La variable "y" peut aussi être une matrice de "m" lignes et "n" colonnes. Alors, la commande trace "m" histogrammes, un par ligne. Chaque histogramme est centré sur l'abscisse correspondant au numéro de la ligne. Mais si l'on ajoute l'option codice_70 (empilé), alors la commande trace un histogramme de "m" barres, une par ligne, et les barres correspondant aux valeurs de chaque ligne sont empilées. Par exemple
y = [1 3 5 ; 2 4 6];
bar(y, 0.3, "stacked")
La fonction codice_71 analyse un jeu de données et trace l'histogramme correspondant. Si "x" est un vecteur, la fonction codice_72, "n" étant un entier, va découper l’intervalle de valeurs prises par les coefficients de "x" en "n" tranches d’égale largeur, et tracer l’histogramme de répartition des valeurs selon ces tranches. Si "n" est un vecteur dont les coefficients sont strictements croissants, les valeurs des coefficients de "n" servent à déterminer les tranches.
Si "x" est une matrice, codice_73 trace un histogramme 3D tel que le parallélépipède situé en ("i", "j" ) a pour hauteur "x"("i", "j" ). Comme pour toutes les fonctions de tracé en trois dimension (voir plus loin), on peut définir l’angle de vue avec θ et α.
Carte d’un champ.
Considérons un champ de scalaires "z" défini sur un plan ("x", "y"). On a donc :
Ainsi, au point de coordonnées ("x"("i"), "y"("j")) est associée la valeur "z"("i", "j").
Cartographie couleur.
La fonction
grayplot(x, y, z)
associe une couleur à chaque valeur de "z" et trace une carte de couleurs, chaque point ("x"("i" ), "y"("j" )) ayant la couleur associée au coefficient "z"("i", "j" ). Si l'on veut afficher la légende des couleurs, il faut utiliser la commande codice_74 "avant" la commande codice_75, en lui indiquant les valeurs extrêmes :
zmin = min(z); zmax = max(z);
colorbar(zmin, zmax)
grayplot(x, y, z)
Notez que la barre de couleurs est un objet de type composé "(compound)" encapsulé dans un objet de type axes "(axes)". Le type axes possède une propriété codice_76 (objet de type étiquette, "label"), qui permet de mettre un titre à la barre :
colorbar(zmin, zmax)
e = gce();
e.parent.title.text = "Série 1"
(voir plus bas "Propriétés des objets").
La commande
Sgrayplot(x, y, z)
fait un lissage "(smoothing)" des valeurs pour avoir des dégradés de couleurs plutôt qu'un pavage. La fonction
Sfgrayplot(x, y, f)
fait une cartographie couleur lissée de ƒ("x", "y").
Les fonctions codice_77 et codice_78 font en fait appel à la fonction codice_79. Cette fonction permet de faire une interpolation des valeurs et donc de représenter un dégradé, on considérant une maillage triangulaire comme ceux utilisés dans la méthode des éléments finis (FE, "finite elements") :
l'affichage « vu de dessus » se fait par
fec(x, y, T, z);
La commande
Matplot(A)
fait une carte couleur des valeurs de la matrice A. L'abscisse "x" est le numéro de colonne, l'ordonnée "y" est le numéro de ligne, la première ligne étant en haut, respectant en cela l'organisation du tableau. Cette fonction utilise la couleur correspondante à la partie entière de la valeur.
Les niveaux de couleur sont indiqués par la fonction
set(gcf(), "color_map", cmap)
où "cmap" est une matrice de trois colonnes dont chaque ligne contient la couleur associée à un niveau, sous la forme RVB (les éléments de la matrice allant de 0 à 1). La première ligne de la matrice correspond au plus bas niveau, la dernière ligne au plus haut.
Cette matrice peut être générée de manière automatique par les fonctions codice_80, où "n" est le nombre de couleurs (entier) :
On peut par exemple utiliser
set(gcf(), "color_map", graycolormap(32))
pour avoir 32 niveaux de gris. On peut réaliser un dégradé du noir vers le rouge avec
cmap = graycolormap(32); cmap(:, 2:3) = 0;
set(gcf(), "color_map", cmap)
ou avec
r = linspace(0, 1, 32)'; cmap = [r zeros(32, 2)];
set(gcf(), "color_map", cmap)
et un dégradé du bleu vers le blanc avec
cmap = graycolormap(32); cmap(:, 2:3) = 1;
set(gcf(), "color_map", cmap)
ou avec
r = linspace(0, 1, 32)'; cmap = [r ones(32, 2)];
set(gcf(), "color_map", cmap)
Les niveaux de couleur sont également utilisés lorsque l’on trace plusieurs courbes sur le même graphique. Dans ce cas-là, des dégradés ne fournissent pas un contraste permettant de distinguer facilement des courbes voisines. La carte par défaut est bien conçue pour ce cas-là, et on peut la restaurer par
cmap = get(sdf(), "color_map");
set(gcf(), "color_map", cmap)
Courbes de niveau.
On peut tracer des courbes de niveau avec la fonction
contour2d(x, y, z, n)
où "n" est le nombre de niveaux que l’on veut voir figurer. On peut aussi donner les valeurs des niveaux "z"1, "z"2, …, "zn" par un vecteur
contour2d(x, y, z, [z1,z2...,zn])
Champ de vecteurs.
On peut également tracer un champ de vecteurs, sous la forme de flèches. Pour cela, il faut un vecteur colonne "vx" ayant les composante selon "x" du champ de vecteur, un vecteur colonne "vy" ayant les composantes selon "y" de ce champ, et utiliser la fonction
champ(x, y, vx, vy)
le vecteur de composantes ("vx"("i","j" ),"vy"("i","j" )) étant placé en ("x"("i" ), "y"("j" )).
Avec la fonction codice_97, les vecteurs tracés ont tous la même longueur, la norme du champ est indiquée par la couleur du vecteur, suivant le principe exposé pour codice_98.
Tracé 3D.
Scilab permet également le tracé de surfaces à trois dimensions. Il s'agit en général de nuages de points de la forme("x", "y", "z").
De même que les courbes sont des objets « polyline », les surfaces sont des objets « fac3d » (facettes à trois dimensions).
Tracé de fonctions de deux variables.
Nous voulons tracer la surface représentative d’une fonction ƒ, on a
Si "x" est une matrice colonne de "m" éléments, "y" une matrice colonne de "n" éléments, alors "z" est une matrice "m"×"n" définie par
alors la fonction
plot3d(x, y, z)
va tracer la surface générée par le nuage de points ("x"("i" ), "y"("j" ), "z"("i", "j" )).
Mise en œuvre
x = -2:0.1:2;
y = -3:0.1:3;
X = ones(y')*x;
Y = y'*ones(x);
Z = X.^2 + Y.^2;
plot3d(X, Y, Z)
Si ƒ est une fonction « externe » (par exemple définie par codice_5 ou codice_6, voir "Calcul numérique"), on peut définir "z" avec la fonction codice_101 (voir plus haut), ou bien utiliser 
fplot3d(x, y, f)
On peut tracer une surface paramétrique définie par trois fonctions
Pour cela, on utilise la fonction
param3d(fx(t), fy(t), fz(t))
trace la surface paramétrique ; "t" est un vecteur contenant les valeurs successives du paramètre. Si par exemple "x", "y" et "z" sont des vecteurs colonne de même dimension, alors
param3d(x, y, z)
trace la courbe passant par les points ("x"("i"), "y"("i"), "z"("i")).
Mise en œuvre
x = -2:0.1:2;
y = -3:0.1:3;
mn = size(x, "r")*size(y, "r");
X = matrix(ones(y')*x, mn, 1);
Y = matrix(y'*ones(x), mn, 1);
Z = X.^2 + Y.^2;
param3d(X, Y, Z)
Niveaux de couleur.
Les fonctions codice_102, codice_103 et codice_104 permettent d’utiliser des niveaux de couleurs pour indiquer la valeur de "z". L’utilisation est identique à celle de codice_105, mais les niveaux de couleur sont indiqués par la fonction
set("colormap", cmap)
(voir ci-dessus).
Tracé de surfaces pavées.
Considérons un pavage (par exemple une triangulation ou quadrillage) du plan ("x", "y") ; les pavés peuvent être disjoints. On a "n" pavés ; le pavé "i" est défini par un polygone de "m" points A"i", 1, A"i", 2, …, A"i", "m" ("m" = 3 pour une triangulation, 4 pour un quadrillage).
Un point A"i", "j" a pour coordonnées (X"i", "j" ; Y"i", "j"). À chaque point A"i", "j" est associé une cote Z"i", "j".
On a donc trois matrices X, Y et Z de dimensions "m"×"n".
On trace cette surface simplement avec la fonction codice_105 :
plot3d(X, Y, Z)
Par rapport au tracé de fonctions de deux variables, on peut passer d'une description
à une description
par la commande codice_107 :
[X, Y, Z] = genfac3d(x, y, z);
Angle de vue de la surface.
Le point de vue de la surface 3D est défini par deux angles en degrés, θ, rotation autour de l’axe des "z", et α, rotation autour de l’axe « horizontal » (une fois effectuée la rotation en "z") : codice_108, codice_109… ;
Plus exactement, (θ, α) désigne la direction d'observation en coordonnées sphériques.
On peut également définir les limites des axes avec le mot-clef codice_115 :
Rappelons que la propriété "isoview" permet d'avoir des axes identiques :
a = get("current_axes"); // a = gca();
a.isoview = "on";
Tracé de plusieurs surfaces.
On peut placer plusieurs surfaces sur le même graphique. Pour les distinguer, on peut modifier leur couleur et/ou leur style, mais cela nécessite de modifier les attributs des objets (voir ci après "Propriétés des objets"). Par exemple, pour changer la couleur
t = linspace(0, 2*%pi, 20)';
z1 = sin(t)*cos(t');
z2 = 10 + sin(2*t)*cos(2*t');
plot3d(t, t, z1);
s1 = gce();
s1.color_flag = 0;
s1.color_mode = 2;
plot3d(t, t, z2);
s2 = gce();
s2.color_flag = 0;
s2.color_mode = 3;
legends(["surface 1", "surface 2"], [s1.color_mode, s2.color_mode], "ur")
L'attribut codice_118 indique que l'on veut une couleur uniforme, et codice_119 indique la couleur selon la carte de couleurs.
Pour tracer des nuages de points avec des marqueurs :
t = linspace(0, 2*%pi, 20)';
z1 = sin(t)*cos(t');
z2 = 10 + sin(2*t)*cos(2*t');
plot3d(t, t, z1);
s1 = gce();
s1.surface_mode = "off";
s1.mark_mode = "on";
s1.mark_style = 1;
plot3d(t, t, z2);
s2 = gce();
s2.surface_mode = "off";
s2.mark_mode = "on";
s2.mark_style = 2;
legends(["surface 1", "surface 2"], [-s1.mark_style, -s2.mark_style], "ur")
Concernant l'adjonction de légendes : la fonction codice_35 (au singulier) ne reconnaît que des objets de type "polyline". Il faut donc « construire soi-même » la légende ; cela se fait avec la commande codice_121 (au pluriel) :
legends(["titre 1", "titre 2"], [style1, style2], placement)
où
Cette fonction codice_121 crée des objets de type "texte" (les textes des légendes) et "polyline" (les traits ou symboles faisant référence aux surfaces) ; les pointeurs faisant références à ces objets (voir ci après "Propriétés des objets") sont placés dans une matrice. Si l'on veut modifier les propriétés de la légende (police du texte, couleur des symboles), il faut identifier les pointeurs et modifier les attributs. Par exemple :
legends(["surface 1", "surface 2"], [s1.color_mode, s2.color_mode], "ur")
leg = gce();
leg.children(1).font_style = 2;
leg.children(3).font_style = 2;
la variable codice_128 est une matrice de pointeurs ; les pointeurs 1 et 3 correspondent aux textes, que l'on passe en police de type Times (voir ci-après "Texte").
Dessin.
Texte.
La fonction
xstring(x, y, "chaîne de caractères");
écrit « chaîne de caractère » sur le graphique, le point en bas à gauche de la boîte contenant le texte étant au point ("x","y"). Cela permet par exemple de placer une étiquette "(label)" sur le graphique.
On peut choisir la fonte — police (famille) et corps (taille) — de la manière suivante :
xstring(x, y, "chaîne de caractères");
t = gce(); // t pointe vers le texte qui vient d'être dessiné
t.font_style = 2 // référence de la police
t.font_size = 2 // corps (taille de caractères)
Les références de la police sont (voir l'aide "graphics_fonts") :
Les tailles de police vont de codice_129 à codice_144 ; codice_129 correspond à un corps de 8 points, codice_130 à un corps de 10 points, …, codice_144 à un corps de 54 points.
Si l'on connaît le point en "haut" à gauche de la boîte devant contenir la chaîne, on peut déterminer le point en "bas" à gauche par la commande codice_148 :
rectangle = xstringl(x, yhaut, "chaîne de caractères")
la variable codice_149 est une matrice codice_150 décrivant la boîte contenant le texte. On peut préciser la fonte : référence de la police et corps (taille), par exemple
rectangle = xstringl(x, yhaut, "chaîne de caractères", 2, 10)
La chaîne de caractères peut contenir des expressions mathématiques LaTeX, par exemple
xstring(0, 0, "$x_{1, 2} = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}$")
Notons que pour que le code soit interprété correctement, il faut que la chaîne commence et finisse par le signe codice_151. Par exemple, si l'on veut intercaler la valeur d'une variable, il faut utiliser
xstring(0, 0, "$a = "+string(a)+"$")
Signalons que l'on peut introduire du texte « normal » au sein d'une formule LaTeX avec la commande codice_152. Pour utiliser la police par défaut de Scilab, il faut utiliser la commande codice_153, par exemple
xstring(0, 0, "$a = \jmlText{"+string(a)+"}$")
Formes simples.
Il est possible de dessiner directement des figures géométriques sur le graphique.
La fonction
xpoly(x, y, "lines", 1)
permet de tracer un polygone fermé, codice_26 étant la liste des abscisses des sommets (sous la forme d'un vecteur ou d'une matrice) et codice_27 étant la liste des ordonnées des sommets (c'est une matrice de même dimension que codice_26) ; la ligne relie les points ("x"("i" ), "y"("i" )). La fonction
xfpoly(x, y, "lines", 1)
permet de tracer un polygone rempli.
La fonction
xrect(x, y, l, h)
trace un rectangle dont le point en haut à gauche est ("x", "y"), de largeur "l" et de hauteur "h". La fonction
xfrect(x, y, l, h)
trace un rectangle rempli.
La fonction
xarc(x, y, l, h, a1, a2)
trace un arc d'ellipse compris dans le rectangle dont le point en haut à gauche est ("x", "y"), de largeur "l" et de hauteur "h". Chaque degré d'angle est divisé en 64 secteurs, l'arc part de l'angle trigonométrique "a1"×64 ° et va jusqu'à l'angle ("a1"+"a2")×64 °. Pour tracer une ellipse entière, il faut donc entrer :
xarc(x, y, l, h, 0, 360*64)
La fonction
xfarc(x, y, l, h, a1, a2)
trace un arc d'ellipse rempli.
Notons que les commandes « au pluriel » codice_22, codice_23 et codice_24 permettent de tracer plusieurs objets (voir "Nuage de points").
La fonction
xarrows(nx, ny)
permet de tracer des flèches. Deux cas se présentent :
Propriétés des objets.
Pour changer les propriétés des traits des dessins, il faut utiliser la commande :
set(gce(), "propriété", valeur);
sur l'objet courant, où "propriété" est un mot-clef (voir ci-après). On peut aussi associer une variable à l'élément dessiné ; cela se fait juste après la création de l'objet, avec la fonction codice_168 :
variable = get("hdl");
variable = get("current_entity");
les deux formes sont équivalentes ; le terme codice_169, signifiant "handle" (littéralement « poignée », intermédiaire d'action), désigne le pointeur vers l'objet. On peut aussi utiliser l'abréviation
variable = gce();
(pour "get current entity").
L'avantage est qu'ainsi, on peut modifier les propriétés de l'objet plus tard, alors qu'il n'est plus l'objet courant.
Pour définir la propriété de cet élément, on fait alors
variable.propriété = valeur;
Ces deux méthodes sont valables quel que soit l'objet (tracé de fonction, courbe, polygone, arc d'ellipse, texte, …).
Les principales propriétés d'un objet sont (voir "Polyline_properties" dans l'aide Scilab) :
Par exemple
xarc(0, 1, 0.5, 0.5, 0, 360*64) // ellipse
set(gce(), "line_style", 2) // pointillés
ou bien
xarc(0, 1, 0.5, 0.5, 0, 360*64) // ellipse
a = gce(); // ou bien get("hdl")
a.line_style = 2 // pointillés
L'utilisation des propriétés permet d'ajuster finement le rendu du graphique, en particulier pour les tracés en perspective : les fonctions codice_105 et codice_186 ne permettent pas de définir le style d'affichage.
gce().line_style = 2
Placement des objets.
Il est possible de déplacer un objet de pointeur "h" d'un vecteur "v" (de dimension 2 ou 3) avec la commande codice_187 :
move(h, v)
Mise en forme, axes et fenêtrage.
Utilisation de sous-fenêtres.
L'exemple ci-dessus montre l'utilisation de la commande codice_188, qui permet de diviser la fenêtre graphique. On peut ainsi mettre plusieurs graphiques côte à côte :
subplot(m, n, i)
place le tracé qui suit l’instruction dans la "i" e case (dans l’ordre de lecture européen) d’un tableau "m"×"n". Notez que l'on peut utiliser différentes valeurs de "m" et de "n" au sein d'une fenêtre ; si par exemple on veut un graphique occupant la partie gauche dans toute sa hauteur, et deux graphiques l'un au dessus de l'autre à droite :
x = linspace(0, 2*%pi, 20);
y1 = x^2 ; y2 = cos(x) ; y3 = sin(x) ;
subplot(1, 2, 1) // 1re colonne, ligne unique
plot(x, y1)
subplot(2, 2, 2) // 2e colonne, 1re ligne
plot(x, y2)
subplot(2, 2, 4) // 2e colonne, 2e ligne
plot(x, y3)
On peut aussi utiliser la commande codice_189, qui définit une fenêtre à l'intérieur de la fenêtre graphique :
xsetech([x, y, l, h])
où "x" et "y" sont les coordonnées du point en haut à gauche de la sous-fenêtre, et "l" et "h" sont la largeur et la hauteur ; ces valeurs sont des "fractions" de la fenêtre globale (donc allant de 0 à 1). On peut également définir les valeurs extrêmes des axes de cette sous-fenêtre avec un second vecteur, avec deux syntaxes possibles :
xsetech([x, y, l, h], [xmin, ymin, xmax, ymax])
xsetech(wrect = [x, y, l, h], frect = [xmin, ymin, xmax, ymax])
Organisation des entités graphiques.
Pour Scilab, les entités graphiques sont organisées de manière arborescente, hiérarchique. Chaque entité a des propriétés, et les enfants de cette entité héritent de certaines propriétés par défaut, voir l'entrée "graphic_entities" dans l'aide de Scilab. Les principales entités sont, de la racine vers les feuilles :
Chaque entité a un pointeur "(handle)", que l'on peut obtenir avec la commande codice_168, et qui permet de faire référence à l'entité, par exemple :
f = get("current_figure"); // ou gcf() ; permet d'agir sur la figure
a = get("current_axes"); // ou gca() ; permet d'agir sur le système d'axes
h = get("current_entity"); // ou gce() ; permet d'agir sur l'entité (polyline, arc, ...)
où "f", "a" et "h" sont des variables.
On peut fixer le contenu et un certain nombre de propriétés de ces entités par des fonctions spécifiques, comme nous l'avons vu précédemment. Mais l'on peut modifier directement une propriété. Par exemple, les commandes suivantes sont équivalentes :
plot(X, Y, "r");
plot(X, Y)
h = gce();
h.children.foreground = 5;
dans le deuxième exemple, la commande codice_205 met dans "h" le pointeur vers le dernier composé (enveloppe codice_192) créé, et codice_207 fait référence au fils de ce composé, c'est-à-dire le tracé graphique contenu dans l'enveloppe. On fixe la propriété codice_170 (couleur de premier plan) à 5, qui correspond au rouge dans la carte de couleurs par défaut.
Notons que si une entité enveloppe codice_192 contient plusieurs tracés, c'est alors un vecteurs d'entités. On peut changer les propriétés des différents objets par
h.children(1).foreground = 3;
h.children(2).foreground = 4;
Création d'une fenêtre.
Lorsque l'on demande à Scilab d'exécuter un tracé, il crée automatiquement une fenêtre graphique.
La commande codice_210 crée une fenêtre graphique dont l'étiquette (identification de figure, "figure id") est le nombre "n". Cela permet d'avoir plusieurs fenêtres, et donc de faire des tracés dans plusieurs fenêtres.
Le fenêtre dans laquelle se fait le tracé est la dernière fenêtre créée. On peut aussi « mettre la fenêtre dans une variable » — pointeur ("handle", litt. poignée) — et ainsi passer d'une fenêtre à l'autre, par exemple
f1 = scf(1) // créée la fenêtre 1 et crée la poignée f1
f2 = scf(2) // créée la fenêtre 2 et crée la poignée f2
// La fenêtre active est la fenêtre 2 (dernière créée)
scf(f1)
// la fenêtre active est la fenêtre 1
Si la fenêtre existe déjà, on peut récupérer son pointeur par la commande codice_211 "(get current figure)" :
f0 = gcf()
Paramètres de la fonction plot2d.
Dans un tracé 2D, le format des axes peut se définir avec des arguments des fonctions codice_10.
On peut choisir le type d’axe avec l’argument codice_214 où "n" est un entier positif :
On peut définir le nombre de graduations et de sous-graduations des axes avec l’argument codice_215 où "Nx" est le nombre de graduations de l’axe "x", "nx" le nombre de sous-graduations…
Pour une échelle logarithmique, on utilise l’argument codice_216 où "type" est une chaîne de deux caractères, « n » (pour normal) ou « l » (pour logarithmique), le premier caractère correspondant à l’axe des "x" et le second à l’axe des "y". Par exemple
Si le tracé comporte plusieurs courbes (chaque liste d'ordonnées étant une colonne d'une matrice Y), l’argument codice_219 est une matrice, la valeur de chaque élément indiquant le style de chaque courbe, par exemple
x = (0:0.05:2*%pi)';
Y = [cos(x), sin(x)];
plot2d(x, Y, style = [-2, -1])
Dans ce cas-là, la command ecodice_35 reprend les symboles :
legend("$\cos \alpha$", "$\sin \alpha$");
On peut aussi définir les légendes dans la commande codice_12 avec l’argument codice_222, l’arobase « @ » servant à séparer les légendes, par exemple
plot2d(x, Y, style = [-2, -1], leg = "$\cos \alpha$@$\sin \alpha$")
Axes.
Comme pour tous les objets graphiques, on peut changer les propriétés des axes en les affectant à une variable par la commande codice_223 ; on peut aussi utiliser l'abréviation codice_224. Les principales propriétés sont (voir l'aide Scilab, entrée "axes_properties") :
Exemple
a = gca();
a.x_location = "middle";
a.y_location = "middle";
a.axes_reverse(2) = "on";
a.isoview = "on";
a.sub_ticks = [4,4];
Comme indiqué plus haut, les objets graphiques sont organisés de manière hiérarchisée, avec des relations « parent-enfant ». Les axes sont les enfants d'une figure, et sont les parents de « composés » (en particulier des lignes polygonales obtenues par les commandes de type codice_11). On peut ainsi définir plusieurs axes sur une même figure, les composés rattachés à chaque système d'axe ayant la même échelle. Cela permet de supperposer des graphiques d'échelles différentes, avec la commande codice_252, en prenant soin de rendre le fond transparent avec la propriété codice_253, et de ne pas afficher deux fois l'axes des "x" avec la propriété codice_254.
Exemple
// Ensemble de départ
x = [1:0.05:2];
// Création de l'axe de gauche et tracé de la 1re fonction
a1 = newaxes();
a1.tight_limits = "on";
plot(x, log(x));
legend("ln", 2);
// Création de l'axe de droite et tracé de la 2nde fonction
a2 = newaxes();
a2.filled = "off"; // pas de couleur de fond pour ce tracé
a2.axes_visible(1) = "off"; // 2nd axe x caché
a2.y_location = "right";
a2.tight_limits = "on";
plot(x, sqrt(x), "r");
legend("sqrt", 1);
Enfin, il est possible de dessiner soi-même un axe avec la commande codice_255. La syntaxe globale est
drawaxis(x = …, y = …, dir = …)
Pour un axe horizontal :
par exemple
x = 1:10;
plot(x, x.^2);
drawaxis(x = 1:5, y = -10, dir = "u");
Pour un axe vertical :
On peut changer le comportement du paramètre codice_26 — pour un axe horizontal — ou codice_27 — pour un axe vertical — avec le paramètre codice_268 :
Autres fonctions.
En tracé 2D, la fonction codice_274 permet d’afficher une grille correspondant aux graduations.
La fonction codice_275 permet de définir l’apparence :
Le tracé peut comporter plusieurs instructions codice_279, codice_280, codice_281.
La fonction
xtitle("nom du graphique", "axe des x", "axe des y")
met un titre au graphique et aux axe. La fonction
titlepage("titre")
met un titre au milieu du graphique. Les chaînes des deux fonctions (codice_282 et codice_283) peuvent contenir des expressions mathématiques LaTeX ou Mathml (voir la section "Texte").
La fonction
clf
efface la fenêtre graphique "(clear figure)", et la fonction
xdel
supprime toutes les fenêtres graphiques.
Scilab Graphic Editor (ged).
Le Scilab Graphic Editor est un ensemble de fonctions permettant de modifier ue fenêtre graphique de manière interactive. On appelle ces fonctions avec la commande
ged(action, numfig)
où
Par exemple, l'action 8 permet d'éditer les propriétés de la fenêtre et l'action 9 permet d'éditer les propriétés des axes. Par exemple
scf(0);
plot2d();
ged(8, 0);
Export direct vers un fichier.
Nous avons vu précédemment comment enregistrer un graphique (voir "Gestion des fichiers > Enregistrer un graphique".)
Il est également possible de rediriger la sortie graphique directement vers un fichier ; il n'y a donc pas d'affichage sur écran. Cela se fait en changeant le pilote "(driver)", avec la commande codice_284, puis en effectuant les tracés (codice_279) dans une session d'export (entre les commandes codice_286).
Outre le fait de changer de pilote, la commande codice_284 indique le pilote courant ; par défaut, il s'agit du pilote d'affichage sur écran, qui selon les système s'appelle codice_288 ou codice_289. Les pilotes d'export disponibles sont :
Le code typique d'une session d'export au format SVG est le suivant :
pilote_original = driver("SVG");
xinit("nom_de_fichier.svg")
plot(…)
xend()
driver(pilote_original)
Exemple.
1. Voici le graphique que l’on obtient avec les instructions ci-dessous.
clear; clf;
deff("[z] = f(x, y)", "z = sin(x) * cos(y)")
set(gcf(), "color_map", jetcolormap(32))
x = %pi * [-1:0.05:1]';
y = x;
z = feval(x, y, f);
subplot(2, 2, 1)
grayplot(x, y, z)
subplot(2, 2, 2)
contour2d(x, y, z, 5)
subplot(2, 2, 3)
plot3d1(x, y, z, 0, 90)
subplot(2, 2, 4)
plot3d1(x, y, z, 70, 70)
2. Un exemple de graphique avec des fonds de couleurs différentes
x = linspace(0, 10, 100);
clf
drawlater
plot(x, sin(x))
xgrid(color("grey70"))
xfpolys([2 5 5 2 ; 7 8.5 8.5 7]',[-1 -1 1 1 ; -1 -1 1 1]'..
 [color("scilabpink") color("bisque")]) // tracé des rectangles
axes = gca();
axes.grid_position = "foreground"; // amène la grille au premier plan
cpoly = axes.children(1).children; // matrice de composants de type polyline (les rectangles)
cpoly.line_mode="off"; // efface les lignes des rectangles
cpoly(1).data(:, 3) = -1; // ajoute aux coordonnées des points une composante z = -1
cpoly(2).data(:, 3) = -1; // pour placer les rectangles derrière les autres objets
drawnow
Tracé évolutif.
Lors de calculs longs, il peut être intéressant de tracer le résultat au fur et à mesure. Pour cela, on crée un polygone "(polyline)" vide (ne contenant aucun point), on récupère son pointeur, et l'on ajoute les points un par un dans la propriété codice_300. Par exemple :
clf;
a = gca();
a.data_bounds = [0 -1;10 1];
a.axes_visible = "on";
xpoly([],[]); p = gce(); // polygone vide
for x = 0:0.1:10
 p.data=[p.data ; x, sin(x)]; // ajout d'un point
end
Si c'est la courbe complète qui évolue, on peut changer la totalité de la propriété data, par exemple
clf; a = gca();
a.data_bounds = [0 -1;10 1];
a.axes_visible = "on";
t = (0:0.01:10)';
w = 1:0.1:10;
xpoly([],[]); p = gce(); // polygone vide
realtimeinit(0.01) // unité de temps = 1/100 sec.
for k = 1:length(w)
 realtime(k) // attend l'instant donné (k centièmes de sec) pour afficher
 // permet de ralentir l'affichage
 p.data = [t, sin(w(k)*t)]; // affichage de la courbe pour le paramètre w(k)
end
Animations.
Si vous utilisez une fonction paramétrique (en fait, une fonction de deux variables), il est alors possible de considérer la deuxième variable comme le temps et d'afficher l'évolution de la courbe en fonction du temps. Ceci se fait avec la fonction codice_301.
Pour cela, vous devez définir :
Si codice_302 est la fonction, codice_26 le vecteur pour la variable et codice_304 le vecteur pour les paramètres, alors la syntaxe est :
Vous pouvez aussi faire générer plusieurs fichier images, puis ensuite générer un GIF animé avec ces images — par exemple avec JASC Animation Shop ou encore le programme Convert de la suite ImageMagick, mais nous préférerons la solution libre avec The Gimp, voir "Création d'animation .gif" de l'Atelier graphique de Wikipédia. Vous pouvez générer des noms de fichier numérotés en utilisant la fonction codice_306.
Exemple
for i = 0:9
 for j = 1:9
 clf;
 y = feval(x, t(i*10 + j), f); // f est une fonction de x ayant un paramètre t allant de 1 à 99
 plot2d(x,y)
 nom = "test"+string(i)+string(j)+".png";
 xs2png(0,nom,1);
 end
end
Si l'on veut afficher une animation en temps réel, on a intérêt à retarder le tracé pour tout tracer d'un coup. Cela se fait avec les commandes codice_307 (qui suspend le tracé) et codice_308 (qui déclenche les tracés suspendus).
Sons.
Scilab peut générer ou analyser des sons. Il peut même lire et écrire des fichiers codice_309 (voir "Gestion des fichiers").
Un son est en fait un vecteur dont les valeurs sont comprises entre -1 et 1 ; les valeurs hors de cet interval sont ignorées (phénomène d'écrêtage).
Si ƒ"s" est la fréquence d'échantillonage en hertz, alors le pas d'échantillonage est 1/ƒ"s". L'instruction codice_310 permet de générer un vecteur correspondant au pas d'échantillonnage :
t = soundsec(n, fs)
où "n" est le nombre de secondes et ƒ"s" est la fréquence. Si l'on omet ƒ"s", Scilab prend la valeur 22 050.
Si l'on a défini la fonction de son "s" (pression relative de l'air/tension d'alimentation normée du haut-parleur en fonction du temps), alors on peut générer un vecteur de valeurs "u" :
u = s(t)
et jouer le son
sound(u, fs)
L'instruction codice_311 détermine le spectre sonore du son et trace le graphique.
analyze(s)
"Voir aussi Découvrir Scilab/Gestion des fichiers#Enregistrer et lire des fichiers de sons."
Notes.
"Matrices creuses" < ↑ > "Programmation"