Découvrir Scilab/Graphiques et sons

Un livre de Wikilivres.
Aller à : navigation, rechercher

Table des matièresIndex



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[modifier | modifier le wikicode]

Tracé 2D[modifier | modifier le wikicode]

En Coordonnées cartésiennes[modifier | modifier le wikicode]

Le tracé d’une fonction se fait en deux étapes

  1. définir l’étendue de la variable abscisse et le pas, sous la forme d’un vecteur ligne ou colonne, par exemple
    x = [début:pas:fin], ou
    x = linspace(début, fin, nombre_de_points) ;
  2. tracer la fonction avec la commande
    plot(x, f(x))
    si ƒ est la fonction.

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 plot(x, y) tracera le nuage de points (x(i ),y(i )).

Si ƒ est une fonction externe (par exemple définie avec deff ou function, voir Calcul numérique), alors on peut tracer directement la fonction avec

fplot2d(x, f).

On peut aussi définir le vecteur y par

y = feval(x, f),

puis tracer avec

plot(x,y).

Les fonctions plot2di, utilisées à la place de plot, permettent de faire varier l’apparence générale du tracé :

  • plot2d() : trait « normal » ; identique à plot, mais l’utilisation de marqueurs et des couleurs est différente (voir ci-après) ;
  • plot2d2() : trait en escalier ;
  • plot2d3() : tracé en barres ;
  • plot2d4() : tracé en « flèches » : les points adjacents sont reliés par une flèche.

Ces fonctions plot2di acceptent des arguments modifiant le tracé, sous la forme

plot2di(x, y, arguments).

Les arguments sont de la forme mot-clef = valeur. L’argument rect = [xmin, ymin, xmax, ymax] 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.

Modes de tracé 2d

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[modifier | modifier le wikicode]

La fonction scatter(x, y) 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 xrects(), xarcs() et xfarcs() pour placer respectivement des rectangles, des ellipses et des ellipses remplies. Les paramètres d'entrée sont des matrices. Pour xarcs(), 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 x et y sont des vecteurs de même dimension et a 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 x, que nous appelons ici (vecteur d'entiers correpondant à la carte des couleurs :

xrects([x - a/2 ; y + a/2 ; a*ones(x) ; a*ones(x)], z)

Les commandes xarcs() et xfarcs() sont similaires (elles tracent des ellipses inscrites dans les rectangles définis comme avec xrects()), 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) ; 34*360*ones(x)], z)

Tracé de plusieurs courbes[modifier | modifier le wikicode]

On peut superposer plusieurs courbes. Il suffit d'avoir :

  • pour les abscisses x, un vecteur colonnes ;
  • pour les ordonnées y, une matrice Y dont chaque colonne contient les ordonnées d'une courbe.

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 plot(x, [cos(x), sin(x)]).

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 legend() :

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 legends_multicolumn() 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 :

  • un signe moins « - » pour indiquer que l'on trace la ligne en continu ;
  • un signe pour tracer les ligne en discontinu : deux moins « -- » (tirets longs), deux-points « : » (pointillets), un moins et un point « -. » (trait mixte) ;
  • un signe pour indiquer que l'on met un marqueur : un plus « + », un astérisque « * », la lettre « o » (rond), un accent circonflexe « ^ » (triangle pointe en haut), inférieur « < » (triangle pointe à gauche), supérieur « > » (triangle pointe à droite), la lettre « v » (triangle pointe en bas), la lettre « d » (losange, diamond), la lettre « p » pour une étoile à cinq branches (pentagram), la lettre « s » pour un carré (square), la lettre « x » pour des croix de saint André ;
  • une lettre indiquant la couleur : « c » pour cyan, « g » pour vert (green), « k » pour noir (black), « m » pour magenta, « r » pour rouge, « w » pour blanc (white), « y » pour jaune (yellow).

Ces paramètres ne fonctionnent qu'avec la fonction plot et pas avec les fonctions plot2d.

Exemple

x=linspace(0,%pi,50);
plot(x, sin(x), "+g", x, cos(x), "-^r")
trace un sinus en croix droites vertes et un cosinus en trait plein et avec des triangles en rouge.

Avec les commandes plot2di, on change le type de tracé (couleur, marqueur) en utilisant l’argument style = n ou n est un entier positif ou négatif (par exemple plot2d(x, y, style = 1)) :

  • un nombre négatif remplace les points par des marqueurs : une étoile pour -10, des ronds pour -9, …, des petits points pour 0 ; la liste s'obtient en tapant la commande getsymbol() ;
  • un nombre positif indique un trait plein mais de couleur déterminée ; on peut voir la correspondance entre le nombre et la couleur (carte des couleurs) grâce à la commande getcolor() (voir ci-après pour la modification de la cartes de couleur).

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[modifier | modifier le wikicode]

La fonction polarplot permet en tracé en coordonnées polaires. La fonction r(theta) se trace par la commande :

polarplot(r, theta)

r et theta sont deux matrices de même dimension.

Tracé de statistiques[modifier | modifier le wikicode]

La commande bar() permet de tracer un histogramme à barres verticales, et barh() 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 stacked" (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 histplot() analyse un jeu de données et trace l'histogramme correspondant. Si x est un vecteur, la fonction histplot(n, x), 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, hist3d(x) 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[modifier | modifier le wikicode]

Considérons un champ de scalaires z défini sur un plan (x, y). On a donc :

  • un vecteur colonne x de m éléments,
  • un vecteur colonne y de n éléments et
  • z une matrice m×n.

Ainsi, au point de coordonnées (x(i), y(j)) est associée la valeur z(i, j).

Cartographie couleur[modifier | modifier le wikicode]

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 colobar() avant la commande grayplot(), 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é title (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 Sgrayplot() et Sfgrayplot() font en fait appel à la fonction fec(). 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) :

  • on a n nœuds, le nœud i étant défini par les coordonnes x(i), y(i), z(i) ; x, y et z sont donc des vecteur de dimension n ;
  • un nombre t de mailles triangulaires, une maille étant définie par son numéro j, les numéros i des trois nœuds la composant, et un entier qui n'est pas utilisé ici (utiliser la valeur 1) ; T est donc une matrice de dimension t×5 ;

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)

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.

Exemple de codage RVB de couleurs
Couleur Ligne de
la matrice
Rouge   [1, 0, 0]
Jaune   [1, 1, 0]
Vert   [0, 1, 0]
Cyan   [0, 1, 1]
Bleu   [0, 0, 1]
Magenta vidéo   [1, 0, 1]
Magenta imprimerie   [0.859, 0, 0.451]
Blanc (100 %)   [1, 1, 1]
Gris clair (75 %)   [0.75, 0.75, 0.75]
Gris moyen (50 %)   [0.5, 0.5, 0.5]
Gris foncé (25 %)   [0.25, 0.25, 0.25]
Noir (0 %)   [0, 0, 0]

Cette matrice peut être générée de manière automatique par les fonctions …colormap(n), où n est le nombre de couleurs (entier) :

get(sdf(), "color_map") : carte de couleurs par défaut ;
coolcolormap(n) : dégradé entre le cyan et le magenta ;
coppercolormap(n) : dégradé entre le noir et le cuivre clair (codage RVB [1, 0.8, 0.5]) ;
graycolormap(n) : niveaux de gris entre le noir et le blanc ;
hotcolormap(n) : dégradé entre le rouge et le jaune ;
hsvcolormap(n) : dégradé entre suivant le cercle chromatique (hue, saturation, value) : rouge, jaune, vert, cyan, bleu, magenta, et retour au rouge ;
jetcolormap(n) : dégradé entre le bleu et le rouge ;
oceancolormap(n) : dégradé de bleus ;
pinkcolormap(n) : sépia ;
rainbowcolormap(n) : dégradé selon les couleurs de l'arc-en-ciel (rouge, orange, jaune, vert, bleu, violet) ;
springcolormap(n) : dégradé entre le magenta et le jaune ;
summercolormap(n) : dégradé entre le vert et le jaune ;
whitecolormap(n) : blanc uniforme (matrice remplie de 1, équivalent à ones(n, 3)) ;
wintercolormap(n) : dégradé entre le bleu et le vert.

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[modifier | modifier le wikicode]

On peut tracer des courbes de niveau avec la fonction

contour2d(x, y, z, n)

n est le nombre de niveaux que l’on veut voir figurer. On peut aussi donner les valeurs des niveaux z1, z2, …, zn par un vecteur

contour2d(x, y, z, [z1,z2,...,zn])

Champ de vecteurs[modifier | modifier le wikicode]

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 champ1, 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 grayplot.

Tracé 3D[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

Nous voulons tracer la surface représentative d’une fonction ƒ, on a

z = ƒ(x, y).

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

z(i, j ) = ƒ(x(i ), y(j ))

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

Partons de deux vecteurs-ligne x et y, de taille possiblement différente. On peut les transformer en matrices de même dimension par la multiplication avec un vecteur de uns. Par exemple
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)
Ici, la matrice X est une matrice colonne pour laquelle chaque valeur de x est répétée n fois (n étant la taille du vecteur y), la matrice Y est une matrice colonne pour laquelle la suite des valeurs de y est répétée m fois (m étant la taille du vecteur x), et la matrice Z résulte donc de toutes les combinaisons possibles de couples (xi, yj ).

Si ƒ est une fonction « externe » (par exemple définie par deff ou function, voir Calcul numérique), on peut définir z avec la fonction feval (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

En reprenant l'exemple précédent, on peut écrire :
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[modifier | modifier le wikicode]

Les fonctions plot3d1, fplot3d1 et param3d1 permettent d’utiliser des niveaux de couleurs pour indiquer la valeur de z. L’utilisation est identique à celle de plot3d, mais les niveaux de couleur sont indiqués par la fonction

set("colormap", cmap)

(voir ci-dessus).

Tracé de surfaces pavées[modifier | modifier le wikicode]

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 Ai, 1, Ai, 2, …, Ai, m (m = 3 pour une triangulation, 4 pour un quadrillage).

Un point Ai, j a pour coordonnées (Xi, j ; Yi, j). À chaque point Ai, j est associé une cote Zi, j.

On a donc trois matrices X, Y et Z de dimensions m×n.

On trace cette surface simplement avec la fonction plot3d :

plot3d(X, Y, Z)

Par rapport au tracé de fonctions de deux variables, on peut passer d'une description

M(x(i), y(j), z(i, j)

à une description

N(X(i, j) ; Y(i, j) ; Z(i, j))

par la commande genfac3d :

[X, Y, Z] = genfac3d(x, y, z);

Angle de vue de la surface[modifier | modifier le wikicode]

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) : plot3d(x, y, z, theta, alpha), param3d(x, y, z, theta, alpha)… ;

  • plot3d(x, y, z, 0, 0) donne une vue de dessus, semblable aux cartes 2D, projection de la surface sur le plan xy selon l’axe z ; l'axe des x est vertical, l'axe des y est horizontal ;
  • plot3d(x, y, z, 90, 0) donne aussi une vue de dessus, mais tournée de 90°, l'axe des x est horizontal, l'axe des y est vertical ;
  • plot3d(x, y, z, 0, 90) donne une vue de face, projection de la surface sur le planyz selon l’axe x ;
  • plot3d(x, y, z, 90, 90) donne une vue de côté, projection de la surface sur le planzx selon l’axe y ;
  • plot3d(x, y, z, 45, 35.5) est la vue par défaut, de type perspective isométrique.

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 ebox :

  • plot3d(x, y, z, ebox=[xmin, xmax, ymin, ymax, zmin, zmax])
  • plot3d(x, y, z, theta, alpha, ebox=[xmin, xmax, ymin, ymax, zmin, zmax])

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[modifier | modifier le wikicode]

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 color_flag = 0 indique que l'on veut une couleur uniforme, et color_mode = … 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 legend() (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 legends() (au pluriel) :

legends(["titre 1", "titre 2"], [style1, style2], placement)

  • style1 et style2 sont des entiers positifs correspondant à la couleur de la surface, selon la carte de couleurs définie, ou bien des entiers négatifs correspondant au type de marqueur ;
  • placement est une chaîne de caractères de type "ul" (upper left), "ur" (upper right), "ll" (lower left), "lr" (lower left) ou "below".

Cette fonction legends() 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 leg.children est une matrice de pointeurs ; les pointeurs 1 et 3 correspondent aux textes[1], que l'on passe en police de type Times (voir ci-après Texte).

Dessin[modifier | modifier le wikicode]

Texte[modifier | modifier le wikicode]

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) :

  • 0 : police à chasse fixe (type Courier) ;
  • 1 : police de lettres grecques (type Symbol) ;
  • 2 à 5 : police à empattement (type Times),
    • 2 : romaine, maigre,
    • 3 : italique, maigre,
    • 4 : romaine, gras,
    • 5 : italique, gras ;
  • 6 à 9 : police sans empatement (type Arial),
    • 6 : romaine, maigre,
    • 7 : italique, maigre,
    • 8 : romaine, gras,
    • 9 : italique, gras.

Les tailles de police vont de 0 à 10 ; 0 correspond à un corps de 8 points, 1 à un corps de 10 points, …, 10 à 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 stringl() :

rectangle = xstringl(x, yhaut, "chaîne de caractères")

la variable rectangle est une matrice [x, ybas, largeur, hauteur] 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[2], 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 $. 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 \text{}. Pour utiliser la police par défaut de Scilab, il faut utiliser la commande jmlText{}, par exemple

xstring(0, 0, "$a = \jmlText{"+string(a)+"}$")

Formes simples[modifier | modifier le wikicode]

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é, x étant la liste des abscisses des sommets (sous la forme d'un vecteur ou d'une matrice) et y étant la liste des ordonnées des sommets (c'est une matrice de même dimension que x) ; 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  » xrects(), xarcs() et xfarcs() 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 :

  • nx et ny sont des vecteurs : Scilab trace un polygone de flèches reliant les points (nx(i), ny(i)) → (nx(i+1), ny(i+1)) ;
  • nx et ny sont des matrices de deux lignes et ayant le même nombre de colonnes :
    • la première ligne de nx indique les abscisses des points de départ des flèches, la première ligne de ny en indique les ordonnées ;
    • la deuxième ligne de nx indique les abscisses des points d'arrivée des flèches, la deuxième ligne de ny en indique les ordonnées.

Propriétés des objets[modifier | modifier le wikicode]

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 get() :

variable = get("hdl");
variable = get("current_entity");

les deux formes sont équivalentes ; le terme hdl, 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) :

  • foreground : couleur, désigné par son index dans la table des couleurs ;
  • line_mode : "on" si la ligne est tracée, "off" si elle est omise ;
  • line_style : type de trait ; c'est un entier, 0 pour un trait plein, 2 pour des pointillés longs, 3 pour des pointillés courts, 4 pour un trait d'axe (alternance trait-point)…
  • thickness : épaisseur du trait, sous la forme d'un entier positif ;
  • mark_mode : "on" si les marqueurs sont affichés, "off" sinon ;
  • mark_style : nature du marqueur, 0 pour un disque plein, 1 pour une croix, …
  • mark_size : dans le cas d'un tracé par marqueurs, taille des marqueurs ;
  • mark_foreground, mark_background : couleur respectivement de la ligne et de la surface des marqueurs, désigné par son index dans la table des couleurs.

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 plot3d et param3d ne permettent pas de définir le style d'affichage.

Nouveauté Scilab 6
La version 6 de Scilab[3] introduit la notion « d'extraction récursive » (recursive extraction). Il est désormais possible d'écrire directement
gce().line_style = 2

Placement des objets[modifier | modifier le wikicode]

Il est possible de déplacer un objet de pointeur h d'un vecteur v (de dimension 2 ou 3) avec la commande move() :

move(h, v)

Mise en forme, axes et fenêtrage[modifier | modifier le wikicode]

Utilisation de sous-fenêtres[modifier | modifier le wikicode]

L'exemple ci-dessus montre l'utilisation de la commande subplot(), 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 xsetech(), qui définit une fenêtre à l'intérieur de la fenêtre graphique :

xsetech([x, y, l, h])

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[modifier | modifier le wikicode]

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 :

  • une fenêtre graphique appelée figure ;
    • un ou plusieurs systèmes d'axes, que l'on peut voir comme des sous-fenêtres, correspondant au mot-clef axes (pluriel) ;
      • des composés, compound, qui sont une enveloppe contenant un ou plusieurs objets graphiques décrits ci-dessous :
        • des axes, au sens graphique du terme (ligne graduée), correspondant au mot-clef axis (singulier),
        • des lignes brisées, polyline, qui peuvent être tracée à partir de points mais sont aussi utilisées par Scilab pour le tracé de fonctions,
        • des cartes de couleurs, grayplot, par exemple représentant un champ scalaire avec la commande grayplot(),
        • des champs de vecteurs, champ, obtenus par exemple avec la commande champ,
        • des légendes, legend,
        • des objets tracés directement comme des arcs d'ellipse, arc, des rectangles, rectangle, du texte, text,
        • des étiquettes, label, qui correspondent aux titres des tracés et des axes.

Chaque entité a un pointeur (handle), que l'on peut obtenir avec la commande get(), 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, ...)

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 gce() met dans h le pointeur vers le dernier composé (enveloppe compound) créé, et h.children fait référence au fils de ce composé, c'est-à-dire le tracé graphique contenu dans l'enveloppe. On fixe la propriété foreground (couleur de premier plan) à 5, qui correspond au rouge dans la carte de couleurs par défaut.

Notons que si une entité enveloppe compound 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[modifier | modifier le wikicode]

Lorsque l'on demande à Scilab d'exécuter un tracé, il crée automatiquement une fenêtre graphique.

La commande scf(n) 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 gcf() (get current figure) :

f0 = gcf()

Paramètres de la fonction plot2d[modifier | modifier le wikicode]

Dans un tracé 2D, le format des axes peut se définir avec des arguments des fonctions plot2di.


Rappel
les arguments se placent après les vecteurs de valeurs
plot2di(x, y, arguments).

On peut choisir le type d’axe avec l’argument axesflag=nn est un entier positif :

  • 0 pour ne pas avoir d’axe,
  • 1 pour des axes « classiques » se recoupant en bas à droite,
  • 4 pour des axes « classiques » se coupant au centre,
  • 5 pour des axes se coupant en (0, 0)…

On peut définir le nombre de graduations et de sous-graduations des axes avec l’argument nax = [nx, Nx, ny, Ny]Nx est le nombre de graduations de l’axe x, nx le nombre de sous-graduations…

Pour une échelle logarithmique, on utilise l’argument logflag = typetype 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

  • plot2d(x, y, logflag = "nl") pour un axe des x linéaire et un axe des y logarithmique ;
  • plot2d(x, y, logflag = "ll") pour avoir deux échelles logarithmiques.
Deux tracés superposés, l'un avec des styles positifs (traits pleins en couleur), l'autre avec des styles négatifs (marqueurs)

.

Si le tracé comporte plusieurs courbes (chaque liste d'ordonnées étant une colonne d'une matrice Y), l’argument style 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 elegend() reprend les symboles :

legend("$\cos \alpha$", "$\sin \alpha$");

On peut aussi définir les légendes dans la commande plot2d() avec l’argument leg = ("texte1@texte2"), l’arobase « @ » servant à séparer les légendes, par exemple

plot2d(x, Y, style = [-2, -1], leg = "$\cos \alpha$@$\sin \alpha$")

Axes[modifier | modifier le wikicode]

Comme pour tous les objets graphiques, on peut changer les propriétés des axes en les affectant à une variable par la commande var = get("current_axes") ; on peut aussi utiliser l'abréviation var = gca(). Les principales propriétés sont (voir l'aide Scilab, entrée axes_properties) :

  • x_location : prend les valeurs "bottom", "middle", "top" ou "origin" selon que l'on veut que l'axe soit en bas, au centre, en haut ou passe par l'origine ;
  • y_location : prend les valeurs "left", "middle", "right" ou "origin" selon que l'on veut que l'axe soit à gauche, au centre, à droite bas ou passe par l'origine ;
  • isoview : vaut "on" si l'on veut que les échelles soient identiques sur les axes, "off" si l'échelle est libre ;
  • log_flags : chaîne de trois caractères, indiquant dans l'ordre qi l'axe des x, des y et le cas échéant des z est à graduations linéaires (n pour normal) ou logarithmique (l ; par exemple "lln" si les échelles en x et y sont logarithmiques et l'échelle de z est linéaire ;
  • sub_ticks : matrice [nx,ny]nx et ny est le nombre de sous-graduation (il faut 4 sous-graduations pour que la graduation principale soit divisée en 5) ;
  • axes_reverse : vecteur de trois chaînes de caractères "on" ou "off" ; si une valeur est sur "on", l'axe est inversé, par exemple ["off", "on", "off"] pour inverser l'axe y ;
  • margin : vecteur de quatre valeurs (marges gauche, droite, haut, bas) définissant la marge en proportion de la taille de l'axe (1 pour une marge de la taille de l'axe) ; cela permet par exemple de laisser de la place pour des légendes.

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 plot). 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 newaxes(), en prenant soin de rendre le fond transparent avec la propriété filled, et de ne pas afficher deux fois l'axes des x avec la propriété axes_visible.

Superposition de deux graphiques (logarithme et racine carrée entre 1 et 2) avec des échelles différentes : utilisation d'un axe à droite avec Scilab.

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 drawaxis(). La syntaxe globale est

drawaxis(x =, y =, dir =)

Pour un axe horizontal :

  • x doit être un vecteur de scalaires, donnant les positions des graduations ;
  • y est un scalaire donnant la position verticale de l'axe ;
  • dir est une chaîne de caractères valant "u" si les graduations sont vers le haut (up), ou "d" si les graduations sont vers le bas (down) ;

par exemple

x = 1:10;
plot(x, x.^2);
drawaxis(x = 1:5, y = -10, dir = "u");

Pour un axe vertical :

  • x est un scalaire donnant la position horizontale de l'axe ;
  • y est un vecteur de scalaires, donnant les positions des graduations ;
  • dir vaut "l" si les graduations sont du côté gauche (left), ou "r" si elles sont du côté droit (right).

On peut changer le comportement du paramètre x — pour un axe horizontal — ou y — pour un axe vertical — avec le paramètre tics :

  • tics = "v" (values) : comportement par défaut, le vecteur indique les valeurs des graduations ;
  • tics = "r" (range) : le vecteur a trois éléments, la valeur minimale, la valeur maximale et le nombre de graduations ; x = [xmin, xmax, n] pour un axe horizontal ;
  • tics = i : pour des graduations de la forme mantisse m et exposant a ; le vecteur a quatre éléments, la mantisse minimale, la mantisse maximale, l'exposant et le nombre de graduations ; x = [m1, m2, a, n] pour un axe horizontal, les graduations vont de m1·10a à m2·10a.

Autres fonctions[modifier | modifier le wikicode]

En tracé 2D, la fonction xgrid permet d’afficher une grille correspondant aux graduations.

La fonction set permet de définir l’apparence :

  • police des graduations et titres : set(pointeur, "font", type, taille), où
    • taille est un nombre désignant la taille des caractères, en unité arbitraire ;
    • type est un nombre désignant le type de police : 1 pour les lettres grecques (police Symbol), 2–5 pour une police avec empattements type Times (2 pour des lettre romanes, 3 en italique, 4 en gras, 5 en gras italique) ; 6–9 pour une police sans empattement type Arial (6 pour des lettres romaines, 7 en italique, 8 en gras, 9 en gras italique) ;
  • épaisseur des traits d’axe et du tracé : set("thickness", e)e est un nombre désignant l’épaisseur en unité arbitraire ;
  • taille des marqueurs (le cas échéant, voir ci-après) avec set("mark size", taille).

Le tracé peut comporter plusieurs instructions plot(), set(), xtitle().

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 (xtitle et titlepage) 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)[modifier | modifier le wikicode]

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)

  • action est un nombre entier désignant la fonction à metre en œuvre ;
  • numfig est le numéro de la figure concernée (voir scf() et gcf()).

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[modifier | modifier le wikicode]

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 driver(), puis en effectuant les tracés (plot()) dans une session d'export (entre les commandes xinit() … xend()).

Outre le fait de changer de pilote, la commande driver() indique le pilote courant ; par défaut, il s'agit du pilote d'affichage sur écran, qui selon les système s'appelle Rec ou X11. Les pilotes d'export disponibles sont :

  • export en image vectorielle : Pos ou ps (PostScript), PDF ou SVG ;
  • export en image matricielle : PNG, GIF, JPEG ou JPG, BMP, PPM.

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[modifier | modifier le wikicode]

Exemple no 1 de graphique obtenu avec Scilab.

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)
Exemple no 2 de graphique obtenu avec Scilab.

2. Un exemple de graphique avec des fonds de couleurs différentes[4]

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[modifier | modifier le wikicode]

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é data. Par exemple[5] :

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[5]

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[modifier | modifier le wikicode]

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 paramfplot2d.

Pour cela, vous devez définir :

  • l'ensemble des valeurs que prend la première variable, sous la forme d'un vecteur ;
  • l'ensemble des valeurs que prend le paramètre, sous la forme d'un vecteur.

Si f est la fonction, x le vecteur pour la variable et t le vecteur pour les paramètres, alors la syntaxe est :

paramfplot2d(f,x,t)

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 string.

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

(Voir aussi Gestion des fichiers > Enregistrer un graphique.)

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 drawlater() (qui suspend le tracé) et drawnow() (qui déclenche les tracés suspendus).

Sons[modifier | modifier le wikicode]

Scilab peut générer ou analyser des sons. Il peut même lire et écrire des fichiers .wav (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 soundsec permet de générer un vecteur correspondant au pas d'échantillonnage :

t = soundsec(n, fs)

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 analyze 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.

Annexes : fonctions de la bibliothèque graphique[modifier | modifier le wikicode]

  • plot2d : représentation de courbes dans le plan
    • plot2d2 : représentation d'une fonction constante par morceaux
    • plot2d3 : représentation de courbes dans le plan sous forme de barres verticales
    • plot2d4 : représentation de courbes dans le plan sous forme de flèches
    • fplot2d : représentation d'une courbe définie par une fonction
  • champ : champ de vecteur 2D
    • champ1 : champ de vecteur 2D, flèches colorées
    • fchamp : champ défini par une équation différentielle du premier ordre
  • contour2d : courbes de niveau d'une surface
    • fcontour2d : courbes de niveau d'une surface (définie par une fonction)
  • vgrayplot : représentation d'une surface en 2D sous forme de couleurs
    • fgrayplot : représentation d'une surface (définie par une fonction) en 2D sous forme de couleurs
  • Sgrayplot : représentation d'une surface en 2D sous forme de couleurs interpolées
    • Sfgrayplot : représentation d'une surface (définie par une fonction) en 2D sous forme de couleurs interpolées
  • xgrid : ajoute une grille sur un dessin 2D
  • errbar : ajoute des barres d'erreur sur un dessin 2D
  • histplot : dessine un histogramme
  • Matplot : dessin en 2D d'une matrice en pseudo-couleurs

Dessins 3D[modifier | modifier le wikicode]

  • plot3d : représentation en couleurs d'une surface
    • plot3d1 : représentation en couleurs d'une surface
    • fplot3d : représente une surface non paramétrique définie par une fonction
    • fplot3d1 : représente une surface non paramétrique définie par une fonction
  • param3d : représente une courbe paramétrique en 3D
    • param3d1 : représente des courbes paramétriques en 3D
  • contour : courbes de niveau sur une surface en 3D
    • fcontour : courbes de niveau sur une surface en 3D définie par une fonction
  • hist3d : représentation d'un histogramme en 3D
  • genfac3d : calcule les facettes d'une surface non paramétrique
  • eval3dp : calcule les facettes d'une surface paramétrique
  • geom3d : projection 3D vers 2D après un dessin 3D

Dessins de polygones et de lignes[modifier | modifier le wikicode]

  • xpoly : dessine une ligne brisée ou un polygone
  • xpolys : dessine un ensemble de lignes brisées ou de polygones
  • xrpoly : dessine un polygone régulier
  • xsegs : dessine des segments déconnectés
  • xfpoly : remplit un polygone
  • xfpolys : remplit un ensemble de polygones

Dessins de rectangles[modifier | modifier le wikicode]

  • xrect : dessine un rectangle
  • xfrect : remplit un rectangle
  • xrects : dessine ou remplit un ensemble de rectangles

Dessins des arcs[modifier | modifier le wikicode]

  • xarc : dessine un arc d'ellipse
  • xarcs : dessine des arcs d'ellipses
  • xfarc : remplit un secteur angulaire d'ellipse
  • xfarcs : remplit des secteurs angulaires d'ellipses

Dessins de flèches[modifier | modifier le wikicode]

  • xarrows : dessine un ensemble de flèches

Dessins de textes[modifier | modifier le wikicode]

  • xstring : dessine des chaînes de caractères
  • xstringl : calcule une boîte contenant des chaînes de caractères
  • xstringb : dessine des chaînes de caractères dans une boîte
  • xtitle : ajoute des titres et légendes sur une fenêtre graphique
  • titlepage : ajoute un titre au milieu d'une fenêtre graphique
  • xinfo : affiche une chaîne de caractères dans la sous-fenêtre des messages

Cadres et axes[modifier | modifier le wikicode]

  • xaxis : dessine un axe
  • graduate : graduations simplifiées
  • plotframe : dessine un cadre avec axes et mise à l'échelle

Transformations de coordonnées[modifier | modifier le wikicode]

  • isoview : échelle isométrique (fonction obsolète)
  • square : échelle isométrique (par changement de la taille de la fenêtre)
  • scaling : transformation affine d'un ensemble de points
  • rotate : rotation d'un ensemble de points
  • xsetech : choix d'une sous-fenêtre graphique
  • subplot : divise la fenêtre graphique en sous-fenêtres
  • xgetech : donne l'échelle graphique courante
  • xchange : transformation de coordonnées réelles vers pixels

Couleurs[modifier | modifier le wikicode]

  • colormap : utilisation des tables de couleurs
  • getcolor : boîte de dialogue pour sélectionner des couleurs dans la table des couleurs
  • addcolor : ajout de nouvelles couleurs à la tables des couleurs
  • graycolormap : table de couleurs du noir au blanc
  • hotcolormap : table de couleurs « chaude » du rouge au jaune

Contexte[modifier | modifier le wikicode]

  • xset : change des valeurs du contexte graphique ; cette fonction est obsolète et a été remplacée par set() ;
  • xget : récupère des valeurs du contexte graphique
  • xlfont : charge une police dans le contexte graphique ou donne la liste des polices
  • getsymbol : boîte de dialogue pour choisir un marqueur (ou symbole)

Sauvegarde et chargement[modifier | modifier le wikicode]

  • xsave : sauve les graphiques dans un fichier
  • xload : charge des graphiques sauvés
  • xbasimp : envoie des graphiques à une imprimante Postscript ou un fichier
  • xs2… : envoie des graphiques dans un fichier dans un format donné (voir Gestion des fichiers > Enregistrer un graphique) :
    • xs2bmp : BMP (bitmap),
    • xs2emf : EMF (enhanced metafile),
    • xs2eps : EPS (encapsulated PostScript),
    • xs2fig : XFig,
    • xs2gif : GIF (graphics interchange format),
    • xs2jpg : JPEG (joint photographic expert group),
    • xs2pdf : PDF (portable document format),
    • xs2png : PNG (portable network graphics),
    • xs2ppm : PPM (portable pixmap),
    • xs2ps : PS (PostScript).

Fonctions internes graphiques[modifier | modifier le wikicode]

  • xbasc : efface une fenêtre graphique et les graphiques enregistrés
  • xclear : efface une fenêtre graphique
  • driver : choisit un pilote graphique
  • xinit : initialisation d'un pilote graphique
  • xend : termine une session graphique
  • xbasr : redessine une fenêtre graphique
  • replot : redessine une fenêtre graphique avec de nouvelles bornes
  • xpause : suspend l'exécution de Scilab
  • xselect : met une fenêtre graphique au premier plan
  • xclea : effacement d'un rectangle
  • xclip : définit de la zone dans laquelle s'effectue l'affichage, ce qui sort de la zone étant tronqué (clipping)
  • xdel : supprime une fenêtre graphique
  • winsid : renvoie la liste des fenêtre graphiques
  • xname : change le nom d'une fenêtre graphique

Position de la souris[modifier | modifier le wikicode]

  • xclick : attend un clic de souris
  • locate : sélection d'un ensemble de points
  • xgetmouse : renvoie la position courante du pointeur de la souris

Éditeur interactif[modifier | modifier le wikicode]

  • edit_curv : éditeur graphique interactif
  • gr_menu : éditeur graphique élémentaire
  • sd2sci : conversion d'objets gr_menu en instructions Scilab
  • ged : éditeur interactif des propriétés des entités graphiques

Fonctions graphiques en automatique[modifier | modifier le wikicode]

  • bode : diagramme de Bode
  • gainplot : diagramme de magnitude
  • nyquist : diagramme de Nyquist
  • m_circle : M-circle plot
  • chart : diagramme de Nichols
  • black : diagramme de Black
  • evans : lieu des pôles d'Evans
  • sgrid : tracé de la transformée de Laplace, dans le plans des s
  • plzr : tracé de pôles zéro
  • zgrid : grille de la transformée en z

Voir aussi[modifier | modifier le wikicode]

Dans Wikipédia

Notes[modifier | modifier le wikicode]

  1. cela n'est pas documenté ; on peut identifier l'objet référencé par le pointeur i en regardant celui qui disparaît et réapparaît avec les commandes
    leg.children(i).visible = "off"
    leg.children(i).visible = "on"
    
    
  2. grâce à la bibliothèque Java JLaTeXMath
  3. la version alpha a été mise en ligne en juillet 2015, voir Sortie de Scilab 6.0.0-alpha 1 sur Scilab.org, 30/07/2015
  4. (en) Samuel Gougeon, « Plot w. part of background in a different color » sur Scilab users mailing list, 2016-03-04
  5. 5,0 et 5,1 [anglaisSerge Steer, [Scilab-users] Still running script (17avril 2013, 18h10)]

Matrices creuses < > Programmation