Ce tutoriel est gracieusement contribué par Sylvain Lalot.

Introduction

L’idée du module est de progresser depuis la fonction de base “plot2d” jusqu’à l’obtention de figures évoluées tant au point de vue graphique que du point de vue de l’interactivité. L’idée du concepteur de ce module est de fournir des scripts scilab les plus courts possibles, mais sans expliquer ligne par ligne ce qui est demandé à scilab. C’est pour cela qu’il est souhaitable de parcourir au moins une fois l’ensemble des outils précédant celui qui doit être utilisé, en ayant assimilé et “déchiffré” les scripts associés.

Les figures sont presque toutes en niveaux de gris pour que les daltoniens ne soient pas pénalisés. Lorsque les couleurs sont utilisées, leur nom est pris dans la liste des couleurs disponible dans l’aide de scilab dans “color_list”.

La version de scilab utilisée est la 6.0.1.

Les scripts python sont exécutés dans l’environnement “spyder”. Ils ne sont présentés que pour information. Ils ne servent en rien à l’apprentissage des figures dans scilab. Ils ont servi à l’enregistrement des films. Ils peuvent être utiles aux personnes qui souhaiteraient automatiser des présentations avec scilab.

Les figures 2D

La “figure” et son “axe”

La fonction de base en 2D

La fonction de base est plot2d(x,y).

x est un vecteur (ligne ou colonne), y est un vecteur de même taille que x.

La fonction crée une fenêtre si nécessaire ou active le système d’axe actuel, puis trace y en fonction de x.

Figure_1

xdel(winsid()); //Ferme toutes les fenêtres de figures
f=scf(1); //Crée une figure de "handle" f (set current figure)
x=linspace(-%pi,%pi,50);
y=sin(x);
plot2d(x,y);

Les propriétés de base de la figure

Une figure est définie par sa position et sa taille, ses menus, sa barre d’outils, et sa barre d’information.

La visibilité de toutes ces entités est gérée par des propriétés de la figure.

La position et la taille

Il est possible d’afficher la figure sur un écran secondaire. Il faut entrer des valeurs négatives pour l’écran situé à gauche de l’écran principal.

Les valeurs sont exprimées à partir du coin haut gauche de l’écran principal et en pixels

Figure_position_taille

xdel(winsid());
x=linspace(-%pi,%pi,50);
y=sin(x);
plot2d(x,y);
f=gcf();
// la position (en pixels)
f.figure_position=[10 10]; // dans le coin gauche de l'écran ; une valeur négative de la première variable positionne la figure sur un écran situé à gauche de l'écran principal
// la taille (ici plus haute que large)
f.figure_size=[400,600];

Le nom dans la barre de titre

Les caractères affichés dans la barre de titre sont définis par le nom de la figure.

Les caractères spéciaux sont obtenus par leur code ASCII.

figure_barre_titre

xdel(winsid());
x=linspace(-%pi,%pi,50);
y=sin(x);
plot2d(x,y);
f=gcf();
f.figure_position=[10 10];
f.figure_size=[400,600];
f.resize='off'; // l'utilisateur ne peut pas modifier la taille de la figure à l'aide de la souris
f.figure_name='Caractères '+ ascii(34) + 'ASCII' + ascii(34); //latex n'est pas possible dans cette propriété

Les barres de menu, outils et information

Il existe 3 autres barres que l’on peut afficher ou cacher en modifiant une propriété de type “visible”.

La visibilité de chaque barre est gérée par une propriété de la figure :

– f.menubar_visible

– f.toolbar_visible

– f.infobar_visible

figure_barres_menu_outils_info

xdel(winsid());
x=linspace(-%pi,%pi,50);
y=sin(x);
plot2d(x,y);
f=gcf();
f.figure_position=[10 10];
f.figure_size=[400,600];
f.resize='off';
f.figure_name='Caractères '+ ascii(34) + 'ASCII' + ascii(34);
f.menubar_visible='off';// les menus peuvent être cachés (Fichier, Outils, Edition)
f.toolbar_visible='off'; // les outils (pivoter, zoom, ...) peuvent être cachés
f.infobar_visible='off'; // Les informations peuvent être cachées (partie basse de la figure)

Les propriétés de base des axes

Le systèmes d’axes est un enfant de la figure

f=gcf() ; // get current figure
ax=f.children(i) ; // i est le numéro de l'enfant. Le dernier créé porte le numéro 1.

La localisation

La position d’un axe est définie par rapport à l’autre axe

Pour l’axe horizontal, la position peut être “origin”, “bottom” (par défaut), “top”, et “middle”

Pour l’axe vertical, la position peut être “origin”, “left” (par défaut), “right”, et “middle”

axes_localisation

xdel(winsid());
x=linspace(-%pi,%pi,50);
y=sin(x);
plot2d(x,y);
f=gcf();
f.figure_position=[10 10];
f.figure_size=[400,600];
ax=f.children(1);
ax.x_location='origin'; // par défaut "bottom", peut être aussi "top" et "middle"
ax.y_location='origin'; // par défaut "left", peut être aussi "right" et "middle"

Le sens et la visibilité

Il ne faut pas oublier que par défaut le système d’axes comporte 3 axes.

axes_sens_visu

xdel(winsid());
x=linspace(-%pi,%pi,50);
y=sin(x);
plot2d(x,y);
f=gcf();
f.figure_position=[10 10];
f.figure_size=[400,600];
ax=f.children(1);
ax.x_location='origin';
ax.y_location='origin';
ax.axes_visible=['on', 'off', 'off'];
ax.axes_reverse=['on', 'off', 'off'];

La grille

L’apparence de la grille est gérée par des propriétés du système d’axes

Chaque axe de la grille possède ses propres caractéristiques.

La visibilité

La propriété de l’axe est “grid”.

Elle est gérée par une matrice : ax.grid=[x,y]

-x et y prennent la valeur 0 (trait tracé) ou -1 (pas de trait).

 

axes_grille_visu

xdel(winsid());
x=linspace(-%pi,%pi,50);
y=sin(x);
plot2d(x,y);
f=gcf();
f.figure_position=[10 10];
f.figure_size=[400,600];
ax=f.children(1);
ax.x_location='origin';
ax.y_location='origin';
ax.grid=[-1,0] //-1 ne trace pas la grille sur cet axe

Les types de traits

La propriété correspondante est grid_style

Le type de trait se retrouvera pour la représentation des courbes.

axes_grille_traits

Voir les types de trait ci-dessous.

xdel(winsid());
x=linspace(-%pi,%pi,50);
y=sin(x);
plot2d(x,y);
f=gcf();
f.figure_position=[10 10];
f.figure_size=[400,600];
ax=f.children(1);
ax.x_location='origin';
ax.y_location='origin';
ax.grid=[0,0]
ax.grid_thickness=[1,2];
ax.grid_style=[1,4]; // valeurs entières de 1 à 10

axes_grille_type_traits

Les limites des axes

Il est nécessaire de gérer 2 propriétés

Il faut définir les “data_bounds” et “tight_limits”

axes_limits

xdel(winsid());
x=linspace(-%pi,%pi,100);
y=sin(x);
plot2d(x,y);
f=gcf();
f.toolbar_visible='off';
f.menubar_visible='off';
f.infobar_visible='off';
f.figure_name='Limites du tracé';
f.figure_position=[10 10];
ax=f.children(1);
ax.font_size=2;
ax.data_bounds=[x(1) -1; x($) 1]; // [x_min y_min ; x_max y_max]
ax.tight_limits=['on' 'on' 'on'];
ax.x_location='origin';

Les graduations (gestion des axes du système d’axes)

Les “ticks” sont modifiables par des propriétés d’axes

Par exemple ;

ax.autoticks=['on' ou 'off' 'on' ou 'off' 'on' ou 'off' ] ;
ax.x_ticks=[tlist_x] ; ax.y_ticks=[tlist_y] ;

Il est possible d’utiliser des expressions Latex, mais il faut gérer la taille de police pour l’adapter à la police générale du tracé.

Latex offre le choix entre “large”, “Large”, “LARGE”, “huge”, et “Huge”.

Les sub-ticks sont gérés par une matrice.

En utilisant uniquement les fonctions de base le résultat n’est pas toujours satisfaisant.

La position des informations n’est pas finement modulable.

Ici l’abscisse -pi n’est pas visible correctement.

axes_ticks_1

xdel(winsid());
x=linspace(-%pi,%pi,100);
y=sin(x);
plot2d(x,y);
f=gcf();
f.toolbar_visible='off';
f.menubar_visible='off';
f.infobar_visible='off';
f.figure_name='Les graduations';
f.figure_position=[10 10];
ax=f.children(1);
ax.font_size=2; // taille de la police de caractères
ax.data_bounds=[x(1) -1; x($) 1];
ax.tight_limits=['on' 'on' 'on'];
ax.x_location='origin';
ax.y_location='origin';
ax.auto_ticks=['off' 'on' 'on']; // les "ticks" ne sont plus gérés automatiquement sur l'axe x
x_t_location=[-%pi 0 %pi];
x_t_label=['$\huge{-\pi}$' '$\Large{0}$' '$\huge{\pi}$']; // Notation Latex, de même taille que x_t_location
ticks_x = tlist(["ticks","locations","labels"], x_t_location, x_t_label); // ceci est une tlist
ax.x_ticks=ticks_x;
ax.sub_ticks=[1 3]; // 1 sub_tick sur x, 3 sub_ticks sur y

Il est possible de remplacer un “tick” en utilisant la fonction xstring

Il faut “effacer” le tick créé automatiquement.

On définit ensuite le texte de remplacement en utilisant éventuellement une syntaxe Latex.

axes_ticks_manu

xdel(winsid());
x=linspace(-%pi,%pi,100);
y=sin(x);
plot2d(x,y);
f=gcf();
f.toolbar_visible='off';
f.menubar_visible='off';
f.infobar_visible='off';
f.figure_name='Un tick manuel';
f.figure_position=[10 10];
ax=f.children(1);
ax.font_size=2;
ax.data_bounds=[x(1) -1; x($) 1];
ax.tight_limits=['on' 'on' 'on'];
ax.x_location='origin';
ax.y_location='origin';
ax.auto_ticks=['off' 'on' 'on'];
x_t_location=[-%pi 0 %pi];
x_t_label=['' '0' '$\huge{\pi}$']; // Notation Latex, on définit un texte vide pour le premier tick
ticks_x = tlist(["ticks","locations","labels"], x_t_location, x_t_label);
ax.x_ticks=ticks_x;
ax.sub_ticks=[1 3];
xstring(-%pi,0,'$\huge{-\pi}$');
// si la position ne convient pas, on gère la position "manuellement"
text=gce(); // get current entity
text.data=[-3.3,0]; // gére la position en (x,y)

Les graduations sur un système d’axes personnel

On utilise ici la fonction “drawaxis”

ax=drawaxis(x,y,c) ;

x et y donnent la position de l’axes

c donne le côté des graduations sur l’axes :

– dir=’u’ (“up”) ou dir=’d’ (“down”) sur un axe horizontal

– dir=’l’ (“left”) ou dir=’r’ (“right”) sur un axes vertical

Il ne faut pas oublier de ne pas tracer les axes de base.

On note également que “tics” ne s’écrit pas avec un “k” pour un axe défini avec “drawaxis”

axes__drawaxis

xdel(winsid());
x=linspace(-%pi,%pi,100);
y=sin(x);
plot2d(x,y,1,'020'); //le "1" correspond au type de ligne (voir l'aide sur la grille)
// 020 correpond à l'effacement des axes avec un tracé entre les limites de x et de y
f=gcf();
f.toolbar_visible='off';
f.menubar_visible='off';
f.infobar_visible='off';
f.figure_name='Les axes personnalisés';
f.figure_position=[10 10];
ax1=drawaxis(x=[-%pi 0 %pi] ,y=0,dir='u') ;
ax1.tics_labels=['$\huge{-\pi}$' ' ' '$\huge{\pi}$'];
ax2=drawaxis(x=0 ,y=[-1:0.2:0],dir='r'); // partie sous l'axe des x
y_c=[-1 -0.8 -0.6 -0.4 -0.2 0 ];
ax2.ytics_coord = y_c; // On n'utilise pas de tlist
y_l=[];
for i=1:5
y_l=[y_l sprintf('%1.1f',y_c(i))];
end
y_l=[y_l ' '];
ax2.tics_labels=y_l;
ax2.labels_font_size = 2;
ax3=drawaxis(x=0 ,y=[0:0.2:1],dir='l'); // partie au-dessus de l'axe x
ax3.format_n='%1.1f'; // plus rapide si le "0" est nécessaire
ax3.sub_tics=4; // pour en avoir 3 (4 intervalles)
ax3.labels_font_size = 2;

Les labels et le titre

Les propriétés des axes permettent d’ajouter rapidement de l’information, mais sans pouvoir affiner les positions

Un des avantages est de pouvoir connaître la largeur du texte que l’on souhaite utiliser.

On note que le titre se place dans une zone non accessible par la fonction xstring.

axes_labels_titre_auto

xdel(winsid());
x=linspace(-%pi,%pi,100);
y=1+sin(x);
plot2d(x,y);
f=gcf();
f.toolbar_visible='off';
f.menubar_visible='off';
f.infobar_visible='off';
f.figure_name='Le titre automatique';
f.figure_position=[10 10];
ax=f.children(1);
ax.font_size=2;
ax.data_bounds=[x(1) 0; x($) 2];
ax.tight_limits=['on' 'on' 'on'];
ax.x_location='origin';
ax.y_location='origin';
ax.auto_ticks=['off' 'on' 'on'];
x_t_location=[-%pi 0 %pi];
x_t_label=['$\huge{-\pi}$' '$\Large{0}$' '$\huge{\pi}$'];
ticks_x = tlist(["ticks","locations","labels"], x_t_location, x_t_label);
ax.x_ticks=ticks_x;
ax.sub_ticks=[1 3];
ax.title.text=['Mon titre' ; 'sur plusieurs lignes']; // une forme matricielle permet d'écrire sur plusieurs lignes
ax.title.font_size=3;
// pas de possibilité de tracé un encadrement, ni de centrer le texte
// par contre le texte est au_dessus du tracé là où il n'est pas possible d'utiliser la fonction xstring
ax.x_label.text='Label x';
ax.x_label.font_size=3;
temp=ax.x_label.position;
ax.x_label.position=[ax.data_bounds(2,1)+2*temp(1) temp(2)];
// max(x) -2*(1/2 largeur du texte)
//le texte étant centré par défaut sur 0 ici, temp(1) est négatif et correspond à la demi largeur du texte
y_l='$\large{y=\sin(t)+1}$';
ax.y_label.text=['Label ' y_l];
ax.y_label.font_size=3;
temp=ax.y_label.position;
y_l=ax.data_bounds(2,2)-2*((ax.data_bounds(2,2)+ax.data_bounds(1,2))/2-temp(2));
// max(y)-2*(moyenne(y)-position_inférieure) parce que y est positif
ax.y_label.position=[temp(1) y_l];

Il est possible d’utiliser la fonction xstring pour gérer la position et le centrage des textes

la fonction est xstring(x,y,a,b)

– x et y donnent la localisation du texte

– a donne l’orientation du texte dans le sens horaire en degrés

– b indique si une boîte est tracée autour du texte

axes_labels_titre_xstring

xdel(winsid());
x=linspace(-%pi,2*%pi,100);
y=1+sin(x); // varie donc de 0 à 2
plot2d(x,y);
f=gcf();
f.toolbar_visible='off';
f.menubar_visible='off';
f.infobar_visible='off';
f.figure_name='Le titre manuel';
f.figure_position=[10 10];
f.figure_size=[600 400];
ax=f.children(1);
ax.font_size=2;
min_y=-0.5;
ax.data_bounds=[x(1) min_y; x($) 3]; // le maximum de y est plus petit que la limite donnée ici
// pour laisser de la place au-dessus de l'axe pour le titre
ax.tight_limits=['on' 'on' 'on'];
ax.x_location='origin';
ax.y_location='origin';
ax.axes_visible = ['on' 'off' 'off']; // l'axe vertical par défaut n'est pas tracé
ax.auto_ticks=['off' 'on' 'on']; // les ticks sont définis par programmation
x_t_location=[-%pi 0 %pi 2*%pi];
x_t_label=['$\huge{-\pi}$' '$\Large{0}$' '$\huge{\pi}$' '$\Large{2}\huge{\pi}$'];
ticks_x = tlist(["ticks","locations","labels"], x_t_location, x_t_label);
ax.x_ticks=ticks_x;
ax_vert=drawaxis(x=0 ,y=[0:0.5:2],dir='l'); // on impose un axe vertical limité ce qui laisse de la place pour le titre
ax_vert.format_n='%1.1f';
ax_vert.sub_tics=2;
// définition du titre ---------------------------------------------------------------------
t_pos_x=(ax.data_bounds(1,1)+ax.data_bounds(2,1))/2; // le milieu de l'axe horizontal
t_pos_y=2.5; // A ajuster en fonction de la taille de la figure
xstring(t_pos_x,t_pos_y,['Mon titre'; 'sur plusieurs lignes'],0,1);
title=gce();
title.font_size=3;
title.alignment='center'; // position du texte dans la boîte
title.text_box_mode='centered'; // position de la boîte par rapport au point d'accroche
// fin de définition du titre ---------------------------------------------------------------
text_x='Angle (rd)';
xstring(1,1,text_x,0,0); // la position est gérée ensuite
x_label=gce();
font_size=3;
x_label.font_size=font_size;
x_label.data=[4.5 min_y] ; donne la position de x_label
text_y_1='Label ';
text_y_2='$\large{y=\sin(t)+1}$';
text_y=[text_y_1 text_y_2]
xstring(0,1,text_y,0,0);
y_label=gce();
y_label.font_size=font_size;
y_label.font_angle=-90; // inclinaison du texte, ici rotation anti-horaire
y_label.data=[-0.5 0] ; // position de y_label

La place du système d’axes dans la figure

Les marges sont une propriété du système d’axes

La fonction est ax.margins=[m_1, m_2, m_3,m_4]

– m_1 est la marge de gauche, m_2 la marge de droite

– m_3 est la marge supérieure, m_4 la marge inférieure

Les valeurs par défaut sont [0.125 0.125 0.125 0.125]

axes_marges

Le script (sans les indications de placement)

xdel(winsid());
x=linspace(-2,2,100);
y=x.^3;
plot2d(x,y);
f=gcf();
f.toolbar_visible='off';
f.menubar_visible='off';
f.infobar_visible='off';
f.figure_name='Les marges';
f.figure_position=[10 10];
f.figure_size=[600 400];
ax=f.children(1);
ax.font_size=2;
ax.margins=[0.1 0.2 0.4 0.15];
ax.data_bounds=[x(1) -10; x($) 10];
ax.tight_limits=['on' 'on' 'on'];
ax.x_location='origin';
ax.y_location='origin';
xstring(1,5,'Texte coupé par les limites');
text=gce();
text.font_size=3;
xstring(1,1,'Texte coupé par les limites',-90);
text=gce();
text.font_size=3;

Les labels et le titre positionnés par calcul

Les informations sont positionnées dans un second système d’axes

Il faut donc utiliser la fonction newaxes()

On rend le second système d’axes transparent en gérant sa propriété “filled”.

axes_labels_titre_calcule_newaxes

xdel(winsid());
x=linspace(-2,3,100);
y=x.^3;
plot2d(x,y);
f=gcf();
f.toolbar_visible='off';
f.menubar_visible='off';
f.infobar_visible='off';
f.figure_name='Les labels positionnés par calcul';
f.figure_position=[10 10];
figure_w=800;
figure_h=400;
f.figure_size=[figure_w figure_h];
ax=f.children(1);
margins=[0.10 0.10 0.25 0.10]
ax.margins=margins
y_min=-10; // on note que ceci est inférieur à -8
y_max=30; // on note que ceci est supérieur à 27
ax.data_bounds=[x(1) y_min; x($) y_max]; // les ticks automatiques seront corrects de -10 à 30
ax.tight_limits=['on' 'on' 'on'];
ax.x_location='origin';
ax.y_location='origin';
font_size=4;
ax.font_size=font_size;
ax1=newaxes(); // création du second système d'axes
ax1.margins=[0 0 0 0]; // celui-ci prend l'intégralité de la figure
ax1.axes_visible=['off' 'off' 'off'] ; // Les axes sont cachés, par défaut un système d'axes possède comme limites 0 et 1 sur les deux axes
ax1.filled='off' ; // le fond est transparent
label_x_text='Position (m)'
xstring(0.02,0.5,label_x_text)
label_x=gce();
font_style=label_x.font_style;
label_x.font_size=font_size;
rect_x=xstringl(0,0,label_x_text,font_style,font_size); // dimensions de la boîte entourant le texte
// rect_x(3) donne la longueur, rect_x(4) donne la hauteur
pos_max_x=1-margins(2) ; soit ici 0.9.
label_x_x=pos_max_x-rect_x(3) ; // le texte se terminera bien en pos_max_x
// position au-dessus de l'axe sachant qu'il passe par l'origine
label_x_y=margins(4)+(1-(margins(3)+margins(4)))/(1+y_max/abs(y_min));
label_x.data=[label_x_x,label_x_y]
label_y_text='$\Huge{y=x^{3}}$'
xstring(0.02,0.5,label_y_text)
label_y=gce();
rect_y=xstringl(0,0,label_y_text);
label_y.font_angle=-90;
label_y_x=margins(1)+(1-(margins(1)+margins(2)))/(1+x($)/abs(x(1)))-0.32/(figure_w/100);
// 0,32 est arbitraire mais semble convenir à beaucoup de tailles de fenêtres
label_y_y=(1-margins(3))-rect_y(3)*figure_w/figure_h;
label_y.data=[label_y_x,label_y_y];
ax1.data_bounds=[0 0; 1 1];
ax1.tight_limits=['on' 'on' 'on'];
titre_texte=['Le titre';'sur plusieurs lignes']
font_size_titre=font_size+1;
rect_titre=xstringl(0,0,titre_texte,font_style,font_size_titre);
titre_x=0.5; // l'axe x de ax1 varie bien de 0 à 1 et donc ici le texte sera centré sur l'axe x
titre_y=1-rect_titre(4)/2;
xstring(titre_x,titre_y,titre_texte)
titre=gce();
titre.alignment='center';
titre.text_box_mode='centered';
titre.font_size=font_size_titre;
titre.box='on'; // il est bien possible d'entourer le texte

Un axe logarithmique

Il est possible d’utiliser automatiquement un axe logarithmique, ou d’en définir un en utilisant la commande xarrows

La second solution offre plus de souplesse dans la représentation d’un axe.

La propriété log_flags d’un système d’axes permet de choisir le type d’axe

La fonction est ax.log_flags=’abc’ ;

– a, b, et c (respectivement axe x, axe y, axe z) peuvent prendre la valeur ‘l’ (pour logarithmique) ou ‘n’ pour linéaire

axes_log_auto

xdel(winsid());
x=logspace(-2,2,100);
y=log(x);
f1=scf(1);
f1.figure_size=[600,600];
f1.resize='off';
f1.toolbar_visible='off';
f1.menubar_visible='off';
f1.infobar_visible='off';
plot2d(x,y);
ax1=f1.children(1);
ax1.axes_visible=['on', 'on', 'off'];
ax1.axes_reverse=['off', 'off', 'off'];
ax1.x_location='origin';
ax1.y_location='origin'; // il n'y a pas de "0" sur un axe logarithmique, l'axe est ici placé en 10^0 (soit 1)
ax1.log_flags='lnn';
f1.figure_name='Axes à l' + ascii(39)+'origine et log_flags à lnn';

Un axe logarithmique personnalisé est obtenu avec la fonction xarrows.

La fonction permet de dessiner plusieurs flèches en une seule instruction :

xarrows([v1_x v2_x],[v1_y v2_y], taille_embout, couleur)

– v_x et v_y sont les coordonnées dans le système d’axe courant

– la taille de l’embout (à gérer en fonction des données à représenter et de la taille de fenêtre)

– couleur s’exprime en fonction de la carte de couleur de la figure

Il est ensuite possible de définir l’épaisseur des traits.

axes_log_xarrows

xdel(winsid());
x=logspace(-2,2,100);
y=log(x);
f1=scf(1);
f1.figure_size=[600,600];
f1.resize='off';
f1.toolbar_visible='off';
f1.menubar_visible='off';
f1.infobar_visible='off';
f1.color_map=graycolormap(10); // la carte de couleur est définie ici en niveaux de gris
ax1.log_flags='nnn';
plot2d(log(x),y); // on garde les échelles linéaires, il faut donc utiliser le logarithme de x
ax1=f1.children(1);
ax1.axes_visible=['off', 'on', 'off'];
ax1.data_bounds=[log(0.007) -5 ; log(130) 5]; // la limite inférieure est plus petite que log(0.01) pour avoir de la place pour écrire à gauche
ax1.tight_limits=['on' 'on' 'on'];
ax1.x_location='origin';
ax1.y_location='origin'; // on place bien ici l'axe en "0"
f1.figure_name='Axe logarithmique personnalisé';
tics_x=[0.01 0.05 0.1 5 10 50 100];
coord_tics_x=log(tics_x);
coord_tics_y=[2 2.2]; // pour définir la taille des ticks et leur position par rapport à l'axe (ici au-dessus)
xarrows([coord_tics_x(1); coord_tics_x($)],[coord_tics_y(1); coord_tics_y(1)] ,0,0) ; // dessine une droite représentant l'axe (taille d'embout nul), et noir (couleur "0")
seg=ax1.children(1); // il s'agit de la dernière entité de ce type à avoir été générée
seg.thickness=2; // modifie l'épaisseur du trait d'axe (ax1.thickness gère l'épaisseur du trait d'axe, des ticks, et des sub-ticks
// on trace ici les tics principaux
xarrows([coord_tics_x(1:2:$); coord_tics_x(1:2:$)],[coord_tics_y(1)*ones(coord_tics_x(1:2:$)) ; coord_tics_y(2)*ones(coord_tics_x(1:2:$))],0,0);
// ici uniquement pour les valeurs 0.01 0.1 10 et 100 par (1 :2 :$)
segs=ax1.children(1);
segs.thickness=2; // c'est l'épaisseur du trait d'axe
// on trace ici les tics secondaires pour les valeurs 0.05 5 et 50
xarrows([coord_tics_x(2:2:$); coord_tics_x(2:2:$)],[coord_tics_y(1)*ones(coord_tics_x(2:2:$)) ; coord_tics_y(2)*ones(coord_tics_x(2:2:$))],0,0);
segs=ax1.children(1);
segs.thickness=0; // les sub_ticks n'ont pas la même épaisseur que le trait d'axe
segs.segs_color = [5,7,9]; // segs correspond à 3 entités qui ont toutes une couleur différente (de plus en plus claire)
// les valeurs sont alors affichées en une localisation calculée
text1='$\Large{10^{-2}}$';
rect1=xstringl(0.01,0,text1);
xstring(coord_tics_x(1)-rect1(3)/2,coord_tics_y(1)-1.1*rect1(4),text1);
text2='$\Large{10^{-1}}$';
rect2=xstringl(coord_tics_x(3),0,text2);
xstring(coord_tics_x(3)-rect2(3)/2,coord_tics_y(1)-1.1*rect2(4),text2);
text3='$\Large{10}$';
rect3=xstringl(coord_tics_x(5),0,text3);
xstring(coord_tics_x(5)-rect3(3)/2,coord_tics_y(1)-1.1*rect3(4),text3);
text4='$\Large{100}$';
rect4=xstringl(coord_tics_x($),0,text4);
xstring(coord_tics_x($)-rect4(3)/2,coord_tics_y(1)-1.1*rect4(4),text4);

Scilab ne fait pas toujours ce que nous voudrions qu’il fasse

Même si les propriétés “data_bounds” et “tight_limits” sont respectées, les ticks ne sont pas toujours au même endroit.

La localisation dépend à la fois de la taille de la figure et des marges du système d’axes.

Le script ci-dessous trace une droite partant de (-5,-5) et arrivant à (6,6) pour 3 figures comportant chacune 2 systèmes d’axes.

Figure 1 :

– axe 1 : ticks -5 0 et 5 sur les 2 axes

– axe 2 : ticks -4 :2 :6 sur les 2 axes

Figure 2 :

– axe 1 : ticks -4 :2 :6 sur l’axe horizontal ; -5, 0 et 5 sur l’axe vertical

– axe 2 : ticks -5 :1 :6 sur l’axe horizontal ; -4 :2 :6 sur l’axe vertical

Figure 3 :

– axe 1 : ticks -4 :2 :6 sur l’axe horizontal ; -5 :1 :6 sur l’axe vertical

– axe 2 : ticks -5 :1 :6 sur l’axe horizontal ; -5 :1 :6 sur l’axe vertical

axes_limits_wrong

xdel(winsid());
margins=[0.1 0.6 0.125 0.125; 0.45 0.05 0.03 0.03 ];
size_figure=[300 300; 600 300; 600 600];
position=[10 10; 10 234; 596 10];
for i=1:3
f=scf(i);
f.figure_position=position(i,:);
plot2d([-5 6],[-5 6]);
f.figure_size=size_figure(i,:);
f.resize='off';
f.toolbar_visible='off';
f.menubar_visible='off';
f.infobar_visible='off';
f.figure_name='Figure ' + string(i);
ax1=f.children(1);
ax1.axes_visible=['on', 'on', 'off'];
ax1.axes_reverse=['off', 'off', 'off'];
ax1.x_location='origin';
ax1.y_location='origin';
ax1.log_flags='nnn';
ax1.data_bounds=[-5 -5; 6 6];
ax1.tight_limits=['on' 'on' 'on'];
ax1.margins=margins(1,:);
ax2=newaxes();
ax2.margins=margins(2,:);
plot2d([-5 6],[-5 6]);
ax2.x_location='origin';
ax2.y_location='origin';
ax2.log_flags='nnn';
ax2.data_bounds=[-5 -5; 6 6];
ax2.tight_limits=['on' 'on' 'on'];
end

Il est possible d’imposer les ticks qui sont respectés pour toutes les tailles de fenêtre

On peut par exemple utiliser la fonction drawaxis.

Ceci permet notamment de gérer facilement la position des ticks ; par exemple lorsque les valeurs ne sont pas symétriques par rapport à l’origine comme ce qui est le cas volontairement ici.

axes_limits_good

xdel(winsid());
margins=[0.1 0.6 0.125 0.125; 0.45 0.05 0.03 0.03 ];
size_figure=[300 300; 600 300; 600 600];
position=[10 10; 10 234; 596 10]
for i=1:3
f=scf(i);
f.figure_position=position(i,:);
plot2d([-5 6],[-5 6]);
f.figure_size=size_figure(i,:);
f.resize='off';
f.toolbar_visible='off';
f.menubar_visible='off';
f.infobar_visible='off';
f.figure_name='Figure ' + string(i) ;
ax1=f.children(1);
ax1.axes_visible=['off', 'off', 'off'];
ax1.axes_reverse=['off', 'off', 'off'];
// limites extérieures aux min et max de x et de y
ax1.data_bounds=[-5.5 -5.5; 6.5 6.5];
ax1.tight_limits=['on' 'on' 'on'];
ax1.margins=margins(1,:)
tics=[-5 -3 -1 0 2 4 6];
// l'axe horizontal
ax1_1=drawaxis(x=tics ,y=0,dir='d');
ax1_1.sub_tics=1;
ax1_1.tics_labels=string(tics);
// l'axe vertical
ax1_2=drawaxis(x=0 ,y=tics,dir='l');
ax1_2.sub_tics=1;
ax1_2.tics_labels=string(tics);
// le second graphe
ax2=newaxes();
ax2.margins=margins(2,:);
plot2d([-5 6],[-5 6]);
ax2.axes_visible=['off', 'off', 'off'];
ax2.log_flags='nnn';
ax2.data_bounds=ax1.data_bounds;
ax2.tight_limits=['on' 'on' 'on'];
tics=[-5 -4 -3 -2 -1 0 1 2 3 4 5 6];
ax2_1=drawaxis(x=tics ,y=0,dir='d');
ax2_1.sub_tics=1;
ax2_1.tics_labels=string(tics);
ax2_2=drawaxis(x=0 ,y=tics,dir='l');
ax2_2.sub_tics=1;
ax2_2.tics_labels=string(tics);
end

Une représentation avec les échelles identiques sur les 2 axes

La propriété “isoview” d’un axe permet de gérer automatiquement la bonne proportion entre les axes

Si ax est un système d’axes, alors ax.isoview=’on’ permet d’avoir la même échelle sur les deux axes

axes_echelles_ident

clc
clear
xdel(winsid());
f=gcf();
f.toolbar_visible='off';
f.menubar_visible='off';
f.infobar_visible='off';
f.figure_name='Les échelles identiques';
f.figure_position=[10 10];
figure_w=400;
figure_h=600;
f.figure_size=[figure_w figure_h];
f.color_map=graycolormap(10)
ax=f.children(1);
x=linspace(-2,3,100);
y=x.^3/4;
plot2d(x,y)
margins=[0.1 0.1 0.1 0.10]
ax.margins=margins
ax.x_location='origin'
ax.y_location='origin'
y_min=-10;
y_max=30;
font_size=4;
label_x_text='Position (m)'
xstring(0.02,0.5,label_x_text)
label_x=gce();
font_style=label_x.font_style;
label_x.font_size=font_size;
rect_x=xstringl(0,0,label_x_text,font_style,font_size);
label_x_x=max(x)-rect_x(3)-0.5
label_x_y=-rect_x(4)-0.4;
label_x.data=[label_x_x,label_x_y]
label_y_text='$\Huge{y=x^{3}}$'
xstring(0.02,0.5,label_y_text)
label_y=gce();
rect_y=xstringl(0,0,label_y_text);
label_y.font_angle=-90;
label_y_x=-rect_y(4)
label_y_y=max(y)-rect_y(3);
label_y.data=[label_y_x,label_y_y];
ax.isoview='on'

Les polices de caractères

Il est possible de choir une police par son numéro ou par son nom.

Il est parfois nécessaire de gérer une erreur.

fonts_xstring

clc
clear
xdel(winsid());
f1=scf(1);
f1.figure_position=[10,10];
f1.figure_size=[600,600];
f1.resize='off';
f1.toolbar_visible='off';
f1.menubar_visible='off';
f1.infobar_visible='off';
ax1=f1.children(1);
ax1.axes_visible=['off', 'off', 'off'];
ax1.axes_reverse=['off', 'off', 'off'];
ax1.data_bounds=[-5 -5 ; 5 5];
ax1.tight_limits=['on' 'on' 'on'];
f1.figure_name='Différentes polices de caractères'
font_size=2;
xstring(-4.5,4.5,'Font_size='+string(font_size))
text_font=gce();
text_font.font_size=font_size;
text_font.font_style=4;
for font_style=0:5
xstring(-4.5,4-(font_style)*4.5/9,'Font_style '+ string(font_style))
text_font=gce();
text_font.font_size=font_size;
text_font.font_style=font_style;
end
for font_style=6:10
xstring(-2,4-(font_style-6)*4.5/9,'Font_style '+ string(font_style))
text_font=gce();
text_font.font_size=font_size;
text_font.font_style=font_style;
end
font_size=4;
xstring(-4.5,-1.5,'Font_size='+string(font_size))
text_font=gce();
text_font.font_size=font_size;
text_font.font_style=4;
for font_style=0:5
xstring(-4.5,-2-(font_style)*4.5/9,'Font_style '+ string(font_style))
text_font=gce();
text_font.font_size=font_size;
text_font.font_style=font_style;
end
for font_style=6:10
xstring(-1,-2-(font_style-6)*4.5/9,'Font_style '+ string(font_style))
text_font=gce();
text_font.font_size=font_size;
text_font.font_style=font_style;
end
if size(xlfont(),2)<11 then
n_font=xlfont('Century Schoolbook')
else
n_font=11;
end
xstring(1.1,4,'Century Schoolbook')
text_font=gce();
text_font.font_size=2;
ierr = execstr('text_font.font_style=n_font;','errcatch','n')
// La fonction text_font.font_style=n_font; renvoie une erreur mais s'applique tout de même
xstring(2,-2,'Century Schoolbook')
text_font=gce();
text_font.font_size=4;
ierr = execstr('text_font.font_style=n_font;','errcatch','n')

La gestion des textes

Le positionnement, la taille, l’inclinaison, la couleur du texte, l’entourage, la couleur du fond, sont gérés par des propriétés de l’entité créée.

Il n’est pas possible d’affecter une variable lors de la création de l’entité :

texte_entite = xstring(x,y,’texte’) ; renvoie une erreur : “xstring : Nombre erroné d’argument(s) de sortie : 0 attendu(s).”

Il est donc nécessaire de passer par la commande gce(); (“get current entity”) juste après avoir utilisé la fonction xstring.

Une croix est dessinée à chaque origine du texte écrit (position x,y donnée dans la commande xstring)

xstring_localisation

clc
clear
xdel(winsid());
f1=scf(1);
f1.figure_position=[20,20];
f1.figure_size=[600,600];
f1.resize='off';
f1.toolbar_visible='off';
f1.menubar_visible='off';
f1.infobar_visible='off';
f1.figure_name='Jouer avec les textes';
f1.color_map=graycolormap(10);
ax1=f1.children(1);
ax1.axes_visible=['on' 'on' 'off'];
ax1.grid=[0,0];
ax1.grid_style=[10,10]
temp=['A';'l';'i';'g';'n';'m';'e';'n';'t']
xstring(0.1,0.1,temp)
text_temp=gce();
text_temp.font_size=2;
text_temp.alignment='center';
plot2d([0.08 0.12],[0.1 0.1])
plot2d([0.1 0.1],[0.08 0.12])
xstring(0.2,0.1,temp)
text_temp=gce();
text_temp.font_size=2;
text_temp.alignment='left';
plot2d([0.18 0.22],[0.1 0.1])
plot2d([0.2 0.2],[0.08 0.12])
xstring(0.1,0.9,'Texte_1')
text_1=gce();
text_1.font_size=2;
plot2d([0.08 0.12],[0.9 0.9])
plot2d([0.1 0.1],[0.88 0.92])
xstring(0.2,0.8,'Texte_2')
text_2=gce();
text_2.font_size=2;
text_2.text_box_mode ='centered'
plot2d([0.18 0.22],[0.8 0.8])
plot2d([0.2 0.2],[0.78 0.82])
xstring(0.4,0.6,'Texte_3')
text_3=gce();
text_3.font_size=2;
text_3.font_angle=-90;
xstring(0.4,0.6,'Texte_4')
text_4=gce();
text_4.font_size=2;
text_4.font_angle=90;
plot2d([0.38 0.42],[0.6 0.6])
plot2d([0.4 0.4],[0.58 0.62])
xstring(0.5,0.5,'Texte_5')
text_5=gce();
text_5.font_size=2;
text_5.font_angle=45;
text_5.box='on';
plot2d([0.48 0.52],[0.5 0.5])
plot2d([0.5 0.5],[0.48 0.52])
for i=1:5
xstring(0.65,(i-1)/10+0.03,'Niveau de gris :' + string(i))
text_6=gce();
text_6.font_size=2;
text_6.font_angle=0;
text_6.box='on';
text_6.fill_mode='on';
text_6.background=i; // couleur du fond de la boîte entourant le texte
text_6.font_foreground=10; // couleur du texte
end
for i=6:10
xstring(0.65,(i-1)/10+0.03,'Niveau de gris :' + string(i))
text_6=gce();
text_6.font_size=2;
text_6.font_angle=0;
text_6.box='on';
text_6.fill_mode='on';
text_6.background=i;
text_6.font_foreground=0;
end
ax1.data_bounds=[0 0 ; 1 1];
ax1.tight_limits=['on' 'on' 'on'];

Les représentations 2D de données

Introduction

Au-delà de la représentation de courbes, les camemberts, les histogrammes, les champs de vecteurs, les champs de données, les courbes de niveaux, seront abordés.

Les marqueurs

Ils sont nécessaires pour distinguer facilement les courbes les unes des autres.

Ils possèdent des propriétés variées pour gérer leur aspect, leur nombre et leur position :

– mark_mode=’on’; ou ‘off’ pour la visibilité des marqueurs

– mark_style=i; pour i variant de 0 à 14 (voir la figure ci-dessous)

– mark_size=i; pour i variant de 0 à 5 si mark_size_unit est “tabulated”

– mark_stride=i; permet de gérer l’espacement entre 2 marqueurs successifs

– mark_offset=i ; permet de gérer la position du premier marqueur.

courbes_marqueurs

clc
clear
xdel(winsid());
f=gcf();
f.toolbar_visible='off';
f.menubar_visible='off';
f.infobar_visible='off';
f.figure_name='Les marqueurs';
f.figure_position=[10 10];
figure_w=800;
figure_h=400;
f.figure_size=[figure_w figure_h];
ax=f.children(1);
ax.axes_visible=['on' 'on' 'off']
ax.font_size=2;
ax.x_location='top';
ax.y_location='origin';
for i=0:14
plot2d([0:10],(i)*ones([0:10]))
curve=ax.children(1).children(1) ; // la dernière courbe créée est bien le premier enfant du système d'axes
curve.mark_mode='on'
curve.mark_style=i;
curve.mark_size=2;
end
for i=0:7
plot2d([11:20],(i)*ones([11:20]))
curve=ax.children(1).children(1);
curve.mark_mode='on'
curve.mark_style=i;
curve.mark_size=2;
curve.mark_stride=2; // gère le nombre de marqueurs "oubliés", ici 1 sur 2
end
for i=8:14
plot2d([11:20],(i)*ones([11:20]))
curve=ax.children(1).children(1);
curve.mark_mode='on';
curve.mark_style=i;
curve.mark_size=2;
curve.mark_stride=3; // gère le nombre de marqueurs "oubliés", ici 1 sur 3
curve.mark_offset=1; // gère le décalage en début de courbe
end
ax.y_label.text='y=Mark_style';
ax.y_label.font_size=4;
ax.data_bounds=[-1 -1; 20 15];
ax.tight_limits=['on' 'on' 'on'];

Les marqueurs ont des options de couleur.

Les propriétés “mark_foreground”,” mark_background”, et “mark_size” permettent d’augmenter le nombre de marqueurs disponibles

L’exemple donné ici pour un marqueur est reproductible pour d’autres marqueurs.

courbes_marqueurs_couleur

clc
clear
xdel(winsid());
f=gcf();
f.toolbar_visible='off';
f.menubar_visible='off';
f.infobar_visible='off';
f.figure_name='La gestion des marqueurs';
f.figure_position=[10 10];
figure_w=400;
figure_h=400;
f.figure_size=[figure_w figure_h];
f.color_map=graycolormap(10)
ax=f.children(1);
x=linspace(-2,3,100);
y=x.^3/4;
plot2d(x,y)
margins=[0.1 0.1 0.1 0.10]
ax.margins=margins
ax.x_location='origin'
ax.y_location='origin'
curve=ax.children(1).children(1)
curve.mark_mode='on';
curve.mark_style=9;
curve.mark_offset=2;
curve.mark_stride=10;
curve.mark_foreground=0;
curve.mark_background=10;
plot2d(x,5-x.^2/3)
temp=gce();
curve_1=temp.children(1);
curve_1.mark_mode='on';
curve_1.mark_style=9;
curve_1.mark_offset=2;
curve_1.mark_stride=10;
curve_1.mark_foreground=7;
curve_1.mark_background=1; // 0 rend le marqueur "transparent"
curve_1.mark_size=2;

L’épaisseur, la couleur, le type de trait des courbes

Les fonctions les plus couramment utilisées sont l’épaisseur, la couleur et le type de trait.

Les propriétés sont respectivement :

– thickness=n ; n est un entier en pixels (non entier pour un export vectoriel)

– foreground=n ; n est un entier ici compris entre 0 et p pour une carte de couleur de la figure définie par f.color_map=graycolormap(p) ;

courbes_epaiseur_couleur

clc
clear
xdel(winsid());
f1=scf(1); // set current figure
f1.figure_size=[600,600];
f1.resize='off';
f1.toolbar_visible='off';
f1.menubar_visible='off';
f1.infobar_visible='off';
f1.figure_name='Aspect des courbes (épaiseur et couleur)';
f1.color_map=graycolormap(10);
t=linspace(0,2*%pi,100);
plot2d(t,1+1.4*sin(t))
ax=f1.children(1);
ax.margins=[0.1 0.1 0.1 0.1];
poly1=ax.children(1).children(1);
ax.data_bounds=[0 -0.5; 2*%pi 3]
ax.tight_limits=['on' 'on' 'on'];
poly1.thickness=6;
poly1.foreground=8
plot2d(t,1+1.4*sin(t)+0.2*(0.5-rand(t)))
poly2=ax.children(1).children(1);
poly2.thickness=1;
poly2.foreground=0;
for line_type=1:10
plot2d([4 6],((line_type-1)*0.2+1)*[1 1]);
poly3=ax.children(1).children(1);
poly3.line_style=line_type;
xstring(3.8,(line_type-1)*0.2+0.9,string(line_type))
end
for thickness=0:10
plot2d([1.1 1.6],(thickness*0.2-0.4)*[1 1]);
poly4=ax.children(1).children(1);
poly4.thickness=thickness;
xstring(0.9,(thickness*0.2-0.5),string(thickness))
end
for color_line=0:10
plot2d([1.7 2.2],(color_line*0.2-0.4)*[1 1]);
poly5=ax.children(1).children(1);
poly5.thickness=6;
poly5.foreground=color_line;
end
xstring(1.5,1.65,'Epaisseur',-90,1)
texte=gce();
texte.font_size=3;
xstring(2.2,1.65,'Couleur',-90)
texte=gce();
texte.font_size=3;
xstring(5,2.8,'Type')
texte=gce();
texte.font_size=3;

La limitation des courbes

La gestion de la limitation des courbes s’effectue par la combinaison des propriétés clip_state et clip_box

Il est nécessaire de définir les limites du système d’axes pour que la propriété clip_state=’off’ soit effective.

courbes_limitations

clc
clear
xdel(winsid());
f=gcf();
f.toolbar_visible='off';
f.menubar_visible='off';
f.infobar_visible='off';
f.figure_name='La limitation des courbes';
f.figure_position=[10 10];
figure_w=400;
figure_h=400;
f.figure_size=[figure_w figure_h];
f.color_map=graycolormap(10)
ax=f.children(1);
x=linspace(-2,3,100);
y=x.^3/4;
plot2d(x,y)
margins=[0.1 0.1 0.1 0.10]
ax.margins=margins
ax.x_location='origin'
ax.y_location='origin'
x1=linspace(-4,6,400);
plot2d(x1,2+x1.^2/10)
temp=gce();
curve_1=temp.children(1);
curve_1.clip_state='off';
plot2d(x1,5-x1.^2/3)
temp=gce();
curve_2=temp.children(1);
curve_2.clip_state='on'; // doit être associé à clip_box
curve_2.clip_box=[-1 6 3 2]
ax.data_bounds=[-2 -2 ;3 8]
ax.tight_limits=['on' 'on' 'on']

Les graphes cumulatifs

On utilise la possibilité de “remplir” une courbe pour créer des graphes cumulatifs.

Il faut bien faire attention à l’ordre des tracés. Le remplissage jusqu’à l’axe horizontal nécessite de “fermer” la courbe aux deux extrémités en y ajoutant une donnée.

Une légende créée automatiquement est présentée dans cet exemple.

courbes_cumulatif

clc
clear
xdel(winsid());
f1=scf(1);
f1.figure_size=[600,600];
f1.resize='off';
f1.toolbar_visible='off';
f1.menubar_visible='off';
f1.infobar_visible='off';
f1.figure_name='Cumul de données';
f1.color_map=graycolormap(10);
ax=f1.children(1);
ax.data_bounds=[2000 0;2016 20]
ax.tight_limits=['on' 'on' 'on']
an=[2000 2000 2002 2004 2006 2008 2010 2012 2014 2016 2016]; // 2000 est répété comme 2016
prod1=[0 5 6 4 8 6 4 7 8 5 0]; // on doit donc imposer une valeur nulle aux 2 extrémités.
prod2=[0 2 3 4 3 5 4 2 3 5 0];
prod3=[0 1 2 3 4 5 4 5 4 4 0]
plot2d(an,prod1+prod2+prod3);
poly1=ax.children(1).children(1)
poly1.fill_mode='on';
poly1.background=2
plot2d(an,prod1+prod2);// la différence avec "poly1" est bien la quantité "prod3"
poly2=ax.children(1).children(1)
poly2.fill_mode='on';
poly2.background=8
plot2d(an,prod1);
poly3=ax.children(1).children(1)
poly3.fill_mode='on';
poly3.background=5
legend(f1,'Produit 3', 'Produit 2', 'Produit 1', 2, %t ) // 2 correspond à "upper left". Les autres valeurs sont à voir dans l'aide de "legend" (propriété "pos")

Une légende peut être personnalisée

Comme pour n’importe quel texte, la légende peut être écrite avec du code Latex.

Un rectangle est créé dans la légende pour chaque courbe ; que ce soit autour du texte ou devant le texte (fonction “xrects”).

La légende est construite par concaténation de texte et de code latex.

courbes_cumul_legend_perso

xdel(winsid());
f1=scf(1);
f1.figure_size=[600,600];
f1.resize='off';
f1.toolbar_visible='off';
f1.menubar_visible='off';
f1.infobar_visible='off';
f1.figure_name='Cumul de données et légendes personnalisées';
f1.color_map=graycolormap(10);
ax=f1.children(1);
ax.data_bounds=[2000 0;2016 20]
ax.tight_limits=['on' 'on' 'on']
an=[2000 2000 2002 2004 2006 2008 2010 2012 2014 2016 2016];
prod1=[0 5 6 4 8 6 4 7 8 5 0];
prod2=[0 2 3 4 3 5 4 2 3 5 0];
prod3=[0 1 2 3 4 5 4 5 4 4 0];
// Il est posible d'inclure du texte Latex dans la légende
legend_1=['Produit ' '$x=1$']; // on note ici la façon de concaténer du texte et du code latex
legend_2=['Produit ' '$y=2$'];
legend_3=['Produit ' '$z=3$'];
couleur_1=9;
couleur_2=7;
couleur_3=5;
plot2d(an,prod1+prod2+prod3);
poly1=ax.children(1).children(1)
poly1.fill_mode='on';
poly1.background=couleur_1
plot2d(an,prod1+prod2);
poly1=ax.children(1).children(1)
poly1.fill_mode='on';
poly1.background=couleur_2
plot2d(an,prod1);
poly1=ax.children(1).children(1)
poly1.fill_mode='on';
poly1.background=couleur_3;
// les textes encadrés-----------------------------------------------------------------------
// le zéro est l'angle de la police qui permet de dessiner une boîte: le 1 en dernier
xstring(2001, 18.5,legend_1,0,1);
leg1=gce();
leg1.fill_mode='on';
leg1.background=couleur_3; // la propriété foreground gère la couleur de l'encadrement
leg1.font_foreground=10; // le texte sera blanc pour une lecture facile
xstring(2006, 18.5,legend_2,0,1);
leg2=gce();
leg2.fill_mode='on';
leg2.background=couleur_2;
xstring(2011, 18.5,legend_3,0,1);
leg3=gce();
leg3.fill_mode='on';
leg3.background=couleur_1;
// les textes ayant un symbole devant eux -------------------------------------------------
xstring(2001, 17,legend_1,0,0);
rect_4=xstringl(2001, 17,legend_1,0,0);
// recherche de la position et de la taille du texte de la légende
// rect_4(2) donne la position haute de la boîte entourant le texte
// rect_4(4) donne la hauteur de cette boîte
xrect([2000.5 rect_4(2),0.5,rect_4(4)]); // le symbole devant le texte
rect4=gce();
rect4.fill_mode='on';
rect4.background=couleur_3;
xstring(2006, 17,legend_2,0,0);
rect_5=xstringl(2006, 17,legend_2,0,0);
xrect([2005.5 rect_5(2),0.5,rect_5(4)]);
rect5=gce();
rect5.fill_mode='on';
rect5.background=couleur_2;
xstring(2011, 17,legend_3,0,0);
rect_6=xstringl(2011, 17,legend_3,0,0);
xrect([2010.5 rect_6(2),0.5,rect_6(4)]);
rect6=gce();
rect6.fill_mode='on';
rect6.background=couleur_1;

Comment mettre en avant une partie d’une courbe ?

La fonction intégrée “zoom_box” permet facilement de ne visualiser qu’une petite partie d’une courbe

S’il s’agit bien de dessiner un extrait d’une courbe, il faut créer un second système d’axes et de tracer la courbe dans ce système d’axe. Il est alors possible d’utiliser les mêmes valeurs à tracer.

La fonction xarc est utilisée pour entourer une zone d’intérêt.

courbes_details

clc
clear
xdel(winsid());
x=logspace(-2,2,200);
y=log(x)+0.2*rand(x);
f1=scf(1);
plot2d(x,y);
f1.figure_size=[600,600];
f1.resize='off';
f1.toolbar_visible='off';
f1.menubar_visible='off';
f1.infobar_visible='off';
f1.figure_name='Détails d'+ascii(39)+'une courbe'
ax1=f1.children(1);
ax1.x_location='origin';
ax1.y_location='origin';
ax1.log_flags='lnn';
ax1.data_bounds=[0.01 -5; 100 5];
ax1.tight_limits=['on' 'on' 'on'];
// encadrement de la zone d'intérêt
dim_rect_1=[5 2.5 5 1];
xrect(dim_rect_1)
// création d'un système d'axes secondaire
ax2=newaxes();
// localisé dans la partie haute (premier 0.6) à gauche (second 0.6)
ax2.margins=[0.2 0.6 0.2 0.6]
ax2.axes_visible=['on', 'on', 'off'];
plot2d(x,y) // on utilise bien les mêmes variables
ax2.zoom_box=[dim_rect_1(1) dim_rect_1(2)-dim_rect_1(4) dim_rect_1(1)+dim_rect_1(3) dim_rect_1(2)];
ax2.log_flags='lnn';
ax2.filled='off'; // transparent
ax2.sub_ticks=[4,8];
sca(ax1); // retour au système pincipal ("set current axes")
// encadrement du graphique
dim_rect_2=[0.01 4.3 0.49 3.8];
xrect(dim_rect_2);
// utilisation des dimensions précédentes pour tracer les traits de liaison graphique --> zone d'intérêt
plot2d([dim_rect_2(1)+dim_rect_2(3) dim_rect_1(1)],[dim_rect_2(2)-dim_rect_2(4) dim_rect_1(2)-dim_rect_1(4)]);
plot2d([dim_rect_2(1)+dim_rect_2(3) dim_rect_1(1)],[dim_rect_2(2) dim_rect_1(2)]);
// entourage de la zone d'intérêt par une ellipse
dim_arc=[30, 4 ,20, 0.4, 0,360*64]
xarc(dim_arc(1),dim_arc(2),dim_arc(3),dim_arc(4),dim_arc(5),dim_arc(6));
arc=gce();
arc.thickness=2;
// un nouveau système d'axes
ax3=newaxes();
// placé en bas (0.6) à droite (le 0.65)
ax3.margins=[0.6 0.2 0.65 0.2]
ax3.axes_visible=['on', 'on', 'off'];
plot2d(x,y);
ax3.zoom_box=[dim_arc(1) dim_arc(2)-dim_arc(4) dim_arc(1)+dim_arc(3) dim_arc(2)];
ax3.log_flags='lnn';
ax3.filled='off';
ax3.sub_ticks=[4,3];
sca(ax1);
dim_rect_2=[1.5 -1.7 70 3.3];
xrect(dim_rect_2);
// ici une flèche, le 4 donne la taille de la pointe en multiple de l'épaisseur du trait
xarrows((dim_arc(1)+dim_arc(3)/2)*[1 1],[dim_arc(2)-dim_arc(4) dim_rect_2(2)],4);

Une information locale est connue sous le nom de datatip

Les deux courbes ne sont pas tracées volontairement dans le même système d’axes pour voir la conséquence sur la gestion des datatips.

Une fois le script exécuté, il est possible de reproduire ce qui est montré dans le film.

Le film a été créé par programmation de scilab. Le script correspondant est donné en bas de page. Il a été enregistré avec le logiciel libre “OBS Studio”

courbes_datatips

clc
clear
xdel(winsid());
x=linspace(-2,3,100);
y=x.^3;
plot2d(x,y($:-1:1));
f=gcf();
f.toolbar_visible='off';
f.menubar_visible='off';
f.infobar_visible='off';
f.figure_name='Les datatips';
f.figure_position=[10 10];
figure_w=800;
figure_h=400;
f.figure_size=[figure_w figure_h];
f.color_map=graycolormap(10)
ax=f.children(1);
ax.axes_visible=['off' 'off' 'off']
curve_1=ax.children(1).children(1)
curve_1.thickness=3;
curve_1.foreground=7;
margins=[0.10 0.10 0.25 0.10]
ax.margins=margins
y_min=-10;
y_max=30;
font_size=4;
ax1=newaxes();
ax1.margins=[0 0 0 0];
ax1.axes_visible=['off' 'off' 'off']
ax1.filled='off'
label_x_text='Position (m)'
xstring(0.02,0.5,label_x_text)
label_x=gce();
font_style=label_x.font_style;
label_x.font_size=font_size;
rect_x=xstringl(0,0,label_x_text,font_style,font_size);
pos_max_x=1-margins(2)
label_x_x=pos_max_x-rect_x(3)
label_x_y=margins(4)+(1-(margins(3)+margins(4)))/(1+y_max/abs(y_min));
label_x.data=[label_x_x,label_x_y]
label_y_text='$\Huge{y=x^{3}}$'
xstring(0.02,0.5,label_y_text)
label_y=gce();
rect_y=xstringl(0,0,label_y_text);
label_y.font_angle=-90;
label_y_x=margins(1)+(1-(margins(1)+margins(2)))/(1+x($)/abs(x(1)))-0.32/(figure_w/100);
label_y_y=(1-margins(3))-rect_y(3)*figure_w/figure_h;
label_y.data=[label_y_x,label_y_y];
xstring(0.02,0.5,'$\Huge{y=(1-x)^{3}}$')
label_y1=gce();
rect_y=xstringl(0,0,'$\Huge{y=(1-x)^{3}}$');
label_y1.font_angle=-90;
label_y_x=0.33;
label_y_y=0.375;
label_y1.data=[label_y_x,label_y_y];
label_y1.font_foreground=7
ax1.data_bounds=[0 0; 1 1];
ax1.tight_limits=['on' 'on' 'on'];
titre_texte=['On déplace le point avec la souris. Un clic droit efface le point'; 'Un clic gauche crée un point avec une marque par défaut']
font_size_titre=font_size+1;
rect_titre=xstringl(0,0,titre_texte,font_style,font_size_titre);
titre_x=0.5;
titre_y=1-rect_titre(4)/2;
xstring(titre_x,titre_y,titre_texte)
titre=gce();
titre.alignment='center';
titre.text_box_mode='centered';
titre.font_size=font_size_titre;
titre.box='on';
ax2=newaxes();
ax2.margins=margins
ax2.data_bounds=[x(1) y_min; x($) y_max];
ax2.tight_limits=['on' 'on' 'on'];
ax2.x_location='origin';
ax2.y_location='origin';
ax2.filled='off'
ax2.font_size=font_size;
plot2d(x,y);
curve=ax2.children(1).children(1);
curve.thickness=2;
curve.foreground=0;
curve.datatip_display_mode='mouseover';
curve_1.datatip_display_mode='mouseover';
datatipToggle()
temp=size(curve.data,1)
temp_1=size(curve_1.data,1)
datatip_1=datatipCreate(curve,temp*0.75+1)
datatip_1_1=datatipCreate(curve_1,temp*0.85+1)
function str=datatip_display(h);
h.auto_orientation='off';
h.orientation=4;
pt = h.data;
str1=msprintf('X: %0.4g', pt(1));
str2=msprintf('Y: %0.4g', pt(2));
str=[str1 ; str2];
endfunction;
datatipSetDisplay(curve,datatip_display);
datatipSetDisplay(curve_1,datatip_display);
datatipSetDisplay(datatip_1,datatip_display);
datatipSetDisplay(datatip_1_1,datatip_display);
datatip_2=datatipCreate(curve,temp*0.2+1)
datatip_2_1=datatipCreate(curve_1,temp_1*0.2+1)
datatipSetDisplay(datatip_2,datatip_display);
datatipSetDisplay(datatip_2_1,datatip_display);
datatip_2.mark_style=0;
datatip_2_1.mark_style=1;
datatip_1.mark_style=10;
datatip_1_1.mark_style=2;