6. Graphiques, images, animations

a) axis([Xmin Xmax { Ymin Ymax { Zmin Zmax } } ])
b) axis('auto' | 'auto x' | 'auto y')
c) axis('manual')
d) lim_xyz = axis

Modification des valeurs limites (sans que l'un des "aspect ratio" equal ou square, qui aurait été activé, soit annulé) :
a) recadre le graphique en utilisant les valeurs spécifiées des limites inférieures/supérieures des axes X {Y {et Z}}, réalisant ainsi un zoom avant/arrière dans le graphique
b) avec auto, se remet en mode "autoscaling", c-à-d. définit automatiquement les limites inférieures/supérieurs des axes X, Y {et Z} pour afficher l'intégralité des données ;
on peut spécifier 'auto x' ou 'auto y' pour n'agir que sur un axe
c) verrouille les limites d'axes courantes de façon que les graphiques subséquents (en mode hold on) ne les modifient pas lorsque les plages de valeurs changent
d) passée sans paramètre, la fonction axis retourne le vecteur-ligne lim_xyz contenant les limites [Xmin Xmax Ymin Ymax { Zmin Zmax }]

a) xlim([Xmin Xmax]), ylim([Ymin Ymax]), zlim([Zmin Zmax])
b) xlim('auto'), ylim('auto'), zlim('auto')
d) xlim('manual'), ylim('manual'), zlim('manual')
d) lim_x = xlim, lim_y = ylim, lim_z = zlim

Même fonctionnement que la fonction axis, sauf que l'on n'agit ici que sur 1 axe à la fois

a) axis('equal') ou axis('image') ou axis('tight')
b) axis('square')
c) axis('normal')
d) axis('vis3d')

Modification des rapports d'échelle ("aspect ratio") (sans que les limites inf. et sup. des axes X, Y {et Z} soient affectées) :
a) définit le même rapport d'échelle pour les axes X et Y ; est identique à daspect([1 1 1])
b) définit les rapports d'échelle en X et Y de façon la zone graphée soit carrée
c) annule l'effet des "aspect ratio" equal ou square en redéfinissant automatiquement le rapport d'échelle des axes pour s'adapter à la dimension de la fenêtre graphique ; est identique à daspect('auto')
d) sous MATLAB, bloque le rapport d'échelle pour rotation 3D

a) ratio = daspect()
b) daspect(ratio)
c) daspect('auto')

Rapport d'échelle entre les axes X-Y{-Z} (data aspect ratio) (voir aussi la commande pbaspect relatif au "plot box")
a) récupère, sur le vecteur ratio (3 éléments), le rapport d'échelle courant entre les 3 axes du graphique
b) modifie le rapport d'échelle entre les axes selon le vecteur ratio spécifié
c) le rapport d'échelle est mis en mode automatique, s'adaptant dès lors à la dimension de la fenêtre de graphique

a) axis('off | on')
b) axis('nolabel | labelx | labely | labelz')
c) axis('ticx | ticy | ticz')

Désactivation/réactivation affichage cadre/axes/graduation, quadrillage et labels :
a) désactive/rétablit l'affichage du cadre/axes/graduation et quadrillage du graphique ; sous MATLAB (mais pas Octave) agit en outre également sur les étiquettes des axes (labels)
b) désactive l'affichage des graduations des axes (ticks), respectivement rétablit cet affichage de façon différenciée en x, y et/ou z ;
    sous MATLAB, désactivation avec set(gca,'xticklabel',[],'yticklabel',[],'zticklabel',[])
c) active l'affichage des graduations des axes (ticks) et du quadrillage (grid) de façon différenciée en x, y et/ou z

a) axis('xy')
b) axis('ij')

Inversion du sens de l'axe Y :
a) origine en bas à gauche, valeurs Y croissant de bas en haut (par défaut)
b) origine en haut à gauche, valeurs Y croissant de haut en bas.
Remarque : la dénomination ij fait référence au système de coordonnées communément utilisé en traitement d'image (origine se situant dans le coin supérieur gauche de l'image, axe horizontal nommé i et orienté normalement de gauche à droite, mais axe vertical j orienté de haut en bas !)

Ne vous attardez pas sur la syntaxe de la commande plot qui sera décrite plus loin au chapitre "Graphiques 2D"

x=0:0.1:10*pi;
y1=sin(x); y2=sqrt(x); y3=sin(x).*sqrt(x);
plot(x,y1,x,y2,x,y3);
legend('off');
grid('on');
axis([0 10 -1 3]); % changement limites (zoom)
axis('ij');        % inversion de l'axe Y

a) zoom(facteur)
b) zoom off|on|xon|yon
c) zoom reset|out

a) Zoome du facteur spécifié dans la figure courante. Si >1 => grossit, si compris entre 0 et 1 => diminue.
Si facteur est un scalaire, agit sur tous les axes. Si c'est un vecteur, le 1er élément agit sur l'axe X, le second sur l'axe Y...
b) off désactive complètement les possibilités de zoom interactif dans la figure, on les réactive. xon n'autorise le zoom interactif qu'en X, et yon qu'en Y.
c) reset mémorise le zoom courant. out retourne au facteur de zoom préalablement mémorisé avec reset.

rotate(handle, direction, angle, origine)

Applique à l'objet graphique handle une rotation de angle, autour de l'axe spécifié par sa direction et de l'origine indiquée. Si vous désirez plutôt changer l'orientation de la vue, utilisez la fonction view présentée plus bas.
  • l'angle sera spécifié en degrés
  • la direction de rotation est définie par un vecteur (0,0,0)->direction (X,Y,Z) ;
    par exemple [1 0 0] définit une rotation autour de l'axe X, [1 1 0] autour de la bissectrice entre X et Y, etc...
  • origine définit les coordonnées (X,Y,Z) du point de rotation
S'il s'agit d'un graphique 2D, une rotation dans le plan X/Y s'exprime par une rotation autour de l'axe Z, donc en utilisant la direction [0 0 1]

xcarre=[-1 1 1 -1]; ycarre=[-1 -1 1 1];

fill(xcarre/2,ycarre/2,'b')  % petit carré bleu
hold('on')
h=fill(xcarre+2,ycarre,'r'); % grand carré rouge

axis([-4 4 -4 4])
axis('equal')

for k=1:36
   pause(0.1)
  rotate(h, [0 0 1], 10, [0 0 0])
   % on ne fait tourner que le carré rouge,
   % 36 fois de 10 degrés dans le plan horiz.
   % autour de l'origine, donc 360 degrés
   % (tour complet), avec pause 0.1 seconde
   % entre chaque chaque mouvement
end

peaks(-3:0.2:3, -4:0.2:4)
colormap(jet(64))
h=get(gca,'children');  % handle de la surface

axis([-3 3 -8 8 -8 8])

for k=1:180
    pause(0.02)
   rotate(h, [1 0 0], 1, [0 0 0])
    % chaque 0.02 secondes rotation de 1 degré
    % autour de l'axe X et l'origine [0, 0, 0] ;
    % on fait 180 rotations, donc cela donne
    % un retournement complet haut-bas
end

pan off|on|xon|yon

off désactive complètement les possibilités de déplacememt (pan) interactif dans la figure, on les réactive. xon n'autorise le déplacement interactif qu'en X, et yon qu'en Y.

rotate3d off|on

off désactive la possibilité de rotation 3D interactive dans la figure, on la réactive.

a) grid('on | off')     ou     grid on | off     ou     grid
b) grid minor on | off     ou     grid minor

a) Activation/désactivation de l'affichage du quadrillage principal (grille). Par défaut le quadrillage d'un nouveau graphique n'est pas affiché. Sans paramètre, cette fonction agit comme une bascule on/off. Lorsqu'on désactive le quadrillage principal, si l'on avait activé un quadrillage mineur, celui-ci est bien entendu aussi désactivé. Noter que axis('off') désactive aussi le quadrillage.
b) Activation/désactivation de l'affichage d'un quadrillage mineur de maille plus fine que le quadrillage principal. Sans paramètre on ou off, cette fonction agit comme une bascule on/off.

Ex: voir l'exemple 1 ci-dessus

box('on|off')

Activation/désactivation de l'affichage, autour du graphique, d'un cadre (graphiques 2D) ou d'une "boîte" (graphiques 3D).
Sans paramètre, cette fonction agit comme une bascule on/off.

xlabel('label_x' {,'property',value...} )
   ylabel('label_y' {,'property',value...} )
   zlabel('label_z' {,'property',value...} )

Définit et affiche le texte de légende des axes X, Y et Z (étiquettes, labels). Par défaut les axes d'un nouveau graphique n'ont pas de labels.
Des attributs, au sens "Graphics Handles" (couples property et value), permettent de spécifier la police, taille, couleur...

Ex: voir l'exemple 3 ci-dessous

a) legend('legende_t1 ','legende_t2'... {, pos} )
b) legend('legende_t1 ','legende_t2'... {, 'Location','loc'} )
c) legend('off')

a) Définit et place une légende sur le graphique en utilisant les textes spécifiés pour les tracés t1, t2...
La position de la légende est définie par le paramètre pos: 0= Automatic (le moins de conflit avec tracés), 1= angle haut/droite, 2= haut/gauche, 3= bas/gauche, 4=bas/droite, -1= en dehors à droite de la zone graphée.
b) Autre manière plus explicite de positionner la légende : le paramètre loc peut être :
  • pour légende DANS le graphique : North= haut, South= bas, East= droite, West= gauche,
      NorthEast= haut/droite, NorthWest= haut/gauche, SouthEast= bas/droite, SouthWest= bas/gauche,
      Best= position générant le moins de conflit avec les données graphées
  • pour légende En DEHORS du graphique : NorthOutside= haut, SouthOutside= bas, EastOutside= droite, WestOutside= gauche,
      NorthEastOutside= haut/droite, NorthWestOutside= haut/gauche, SouthEastOutside= bas/droite, SouthWestOutside= bas/gauche,
      BestOutside= position générant le moins de conflit avec les données graphées
c) Désactive l'affichage de la légende

Ex: voir l'exemple 3 ci-dessous

title('titre' {,'property',value ...} )

Définit un titre de graphique qui est placé au-dessus de la zone graphée. Un nouveau graphique n'a par défaut pas de titre. Pour effacer le titre, définir une chaîne titre vide.
Si vous désirez créer un titre composé de plusieurs lignes, procédez ainsi : title( sprintf('1ere ligne\n2eme ligne') )
Des attributs, au sens "Graphics Handles" (couples property et value), permettent de spécifier la police, taille, couleur...

Ex: voir l'exemple 3 ci-dessous

a) set(gca,'Xtick | Ytick | Ztick', [valeurs] )
    xticks([valeurs])   yticks([valeurs])   zticks([valeurs])   (sous Octave depuis version 4.4)
b) xticks('auto')   yticks('auto')   zticks('auto')
c) valeurs = xticks | yticks | zticks

Quadrillage du graphique :
a) Place les traits du quadrillage du graphique, selon l'axe spécifié, aux valeurs spécifiées (suite de valeurs en ordre croissant)
b) Rétablit le quadrillage automatique, selon l'axe spécifié
c) Récupère les valeurs correspondant au traits du quadrillage courant, selon l'axe spécifié

a) set(gca,'XTickLabel | YTickLabel | ZTickLabel', labels)
    ou xticklabels(labels)   yticklabels(labels)   zticklabels(labels)   (sous Octave depuis version 4.4)
b) labels = xticklabels | yticklabels | zticklabels

Labels le long des axes, en regard du quadrillage :
a) Spécifie, par un vecteur de nombres ou un vecteur cellulaire de chaînes, les labels à afficher en regard de chaque traits de quadrillage, selon l'axe spécifié. Noter que le nombre d'éléments de labels devrait être identique au nombre de valeurs spécifiées respectivement par la commande xticks, yticks ou zticks
b) Récupère, sur un vecteur cellulaire, les labels courants correspondant à chaque traits de quadrillage, selon l'axe spécifié

Voir aussi la fonction datetick pour graduer/formater des axes temporels

Ne vous attardez pas sur la syntaxe de la commande plot qui sera décrite plus loin au chapitre "Graphiques 2D"

date_debut = datenum('01-Apr-2005');
date_fin   = date_debut + 2;  % 2 jours plus tard

x=date_debut:0.125:date_fin;  % série toutes 3 h.
y=10*rand(1,length(x));

plot(x,y);
grid('on');
xlabel('dates'); % => premier graphique ci-contre

x_tick=date_debut:1:date_fin; % tous 1 jours (24 h)
set(gca,'Xtick',x_tick)
set(gca,'XTickLabel', ...
     datestr(x_tick,'dd-mmm-yyyy'))
                 % => second graphique ci-contre

a) text(x, y, { z,} 'chaîne' {,'property',value...} )
b) gtext('chaîne' {,'property',value...} )

a) Place l'annotation chaîne dans le graphique aux coordonnées x, y {,z} spécifiées.
Pour afficher un texte composé de plusieurs lignes, procédez ainsi : text(x, y, sprintf('1ere ligne\n2eme ligne') )
b) L'emplacement du texte dans le graphique est défini interactivement par un clic souris-gauche.

Lorsqu'on utilise plusieurs fois ces fonctions, cela ajoute à chaque fois un nouveau texte au graphique.
Des attributs, au sens "Graphics Handles" (couples property et value), permettent de spécifier la police, taille, couleur, orientation...
La propriété Rotation n'est implémentée sous Octave 4.0 qu'à l'impression ou sauvegarde de fichier graphique, mais pas à l'affichage !

Ne vous attardez pas sur la syntaxe de la commande plot qui sera décrite plus loin au chapitre "Graphiques 2D"

x=linspace(0,30,200);
y1=sin(x)./exp(x/10); y2=1.5*sin(2*x)./exp(x/10);
plot(x,y1,x,y2);
xlabel('Duree [ms]'); ylabel('Amplitude [mm]');
title('Comparaison amortisseurs');
legend('amortisseur 1','amortisseur 2',4);
text(6,1,'Experience A', ...
         'FontSize',14,'Rotation',-20, ...
         'Color','red');

a) whitebg()
b) whitebg(couleur)
c) whitebg('none')

Change la couleur de fond du graphique :
a) Inversion du schéma de couleur, agissant comme une bascule
b) Le fond est mis à la couleur spécifiée sous forme de nom (p.ex. 'yellow') ou de triplet RGB (p.ex. [0.95 0.95 0.1])
c) Rétablit le schéma de couleur par défaut

a) hold({hax,} 'on')       ou     hold on
b) hold({hax,} 'off')     ou     hold off

Par défaut, tout nouvel objet dessiné dans une figure efface le précédent.
a) Cette commande demande au moteur graphique d'accumuler dans la figure, donc superposer, les différents objets graphiques dessinés. Elle agit sur la figure courante ou celle dont on spécifie le handle hax de son système d'axes (p.ex. retourné par hax=subplot(...)). Elle peut être passée avant tout tracé ou après le premier ordre de dessin.
b) Suite à cette commande, la figure est remise dans le mode par défaut (i.e. tout nouvel objet graphique effacera le précédent). En outre, les annotations et attributs de graphique précédemment définis (labels x/y/z, titre, légende, état on/off de la grille...) sont bien évidemment effacés.

Remarque: les 2 primitives de base de tracé de lignes line et de surfaces remplies patch, de même que la fonction rectangle, dessinent par "accumulation" dans un graphique sans que hold doive être mis à on !

ishold

Retourne l'état courant du mode hold pour la figure active ou le sous-graphique actif : 0 (false) si hold est off, 1 (true) si hold est on.

Ne vous attardez pas sur la syntaxe des commandes plot, fplot et stairs qui seront décrites plus loin au chapitre "Graphiques 2D"

x1=[-2 0 3 5]; y1=[2 -1.5 1.5 0];
plot(x1,y1,'r');                 % rouge
hold('on');
fplot('exp(x/5)-1',[-3 6],'g');  % vert
x3=-pi:0.25:2*pi; y3=sin(3*x3);
stairs(x3,y3,'b');               % bleu
grid('on');

subplot(L,C,i)

Découpe la fenêtre graphique courante (créée ou sélectionnée par la commande figure(numero), dans le cas où l'on fait du "multiple windows") en L lignes et C colonnes, c'est-à-dire en L x C espaces qui disposeront chacun leur propre système d'axes (mini graphiques). Sélectionne en outre la i-ème zone (celles-ci étant numérotées ligne après ligne) comme espace de tracé courant.
• Si aucune fenêtre graphique n'existe, cette fonction en ouvre automatiquement une
• Si l'on a déjà une fenêtre graphique simple (i.e. avec 1 graphique occupant tout l'espace), le graphique sera effacé !
• Dans une fenêtre donnée, une fois le "partitionnement" effectué (par la 1ère commande subplot), on ne devrait plus changer les valeurs L et C lors des appels subséquents à subplot, faute de quoi on risque d'écraser certains sous-graphiques déjà réalisés !

Ne vous attardez pas sur la syntaxe des commandes plot, pie, bar et fplot qui seront décrites plus loin au chapitre "Graphiques 2D"

subplot(2,2,1);
plot([0 1 1 0 0],[0 0 1 1 0]);
text(0.2,0.5,'Multiple plots');
axis('off'); legend('off'); title('zone 1');
subplot(2,2,2);
pie([2 1 5 3]); legend('a','b','c','d');
title('zone 2');
subplot(2,2,3);
bar(rand(18,1)); title('zone 3');
subplot(2,2,4);
fplot('x*cos(x)',[-10*pi 10*pi]);
title('zone 4');

linkaxes(handle_axes, 'x' | 'y' | 'xy' | 'off')

Lie les limites des systèmes d'axes spécifiés par le vecteur de handles handle_axes de façon que les changements effectués dans un graphique (pan, zoom) soient reportés dans les autres. Ne s'applique qu'à des graphiques 2D.
Le second paramètre 'x' lie les axes X seulement, 'y' lie les axes Y seulement, 'xy' lie les axes X et Y, 'off' désactive cette liaison.

linkprop(handle_axes, property1, property2 ...)

De façon analogue, lie les propriétés property1 et property2 entre les différents graphiques

h1=subplot(2,1,1);
fplot('sin(x)',[0 10],'b'); grid('on')

h2=subplot(2,1,2);
fplot('cos(x)',[0 10],'r'); grid('on')

linkaxes([h1 h2],'x')   % ne lie ici que les axes X 

a) hfig = figure( {'position', [xf yf dxf dyf]} )
b) figure(numero)

a) Ouvre une nouvelle fenêtre de graphique (figure) qui devient la fenêtre de tracé active (dans laquelle on peut ensuite faire du "single plot" ou du "multiple plots"). Ces fenêtres sont numérotées automatiquement de façon incrémentale 1, 2, 3..., numéro que l'on récupère dans le handle hfig.
On peut optionnellement définir la position de la fenêtre sur l'écran par les coordonnées xf,yf en pixels de son angle inférieur gauche exprimées à partir de l'angle inférieur gauche de l'écran, ainsi que la dimension dxf,dyf de la fenêtre en pixels. Voir aussi la fonction movegui au chapitre "Programmation GUI".

b) Si la fenêtre de numero spécifié existe, celle-ci devient la fenêtre de tracé active. Si elle n'existe pas, cela ouvre une nouvelle fenêtre de graphique portant ce numero.

gcf (get current figure)

Retourne le numero de la fenêtre de graphique active (qui correspond au handle hfig de la figure)

a) close
b) close(numero)
c) close all

a) Referme la fenêtre graphique active (figure courante)
b) Referme la fenêtre graphique de numero spécifié
c) Referme toutes les fenêtre graphique !

refresh ou refresh(numero)

Raffraîchit (redessine) le(s) graphique(s) dans la fenêtre de figure courante, respectivement la fenêtre de numéro spécifié

clf ou clf(numero)           (clear figure)

Efface le(s) graphique(s) dans la fenêtre de figure courante, respectivement la fenêtre de numéro spécifié
Remet en outre hold à off s'il était à on, mais conserve la table de couleurs courante.

cla (clear axis)

Dans le cas d'une fenêtre de graphique en mode "multiple plots", cette commande n'efface que le sous-graphique courant.

shg (show graphic)

Fait passer la fenêtre de figure MATLAB courante au premier plan.
Cette commande est sans effet avec Octave sous Windows.

x=linspace(0,20,30);
y1=sin(x)./exp(x/10); y2=1.5*sin(2*x)./exp(x/10);
plot(x,y1,'r-o',x,y2,'b:.');
legend('amortisseur 1','amortisseur 2');

% même code que ci-dessus

figure
get(gca,'ColorOrder') % => affiche table ColorOrder
    % par défaut (voir partie de gauche figure ci-dessus)
get(gca,'ColorOrderIndex')  % => 1
courbes = [3 4 5; 2 2.5 3; 4 5 6] ;
plot(courbes, 'LineWidth', 3)
    % utilise couleurs d'indice 1, 2 et 3 de la table
get(gca,'ColorOrderIndex')  % indice passé à 4
hold('on')
get(gca,'ColorOrderIndex')  % indice est resté à 4
nouv_table = [  % définition manuelle nouvelle table
    1   0   0   % rouge
    0  0.5  0   % vert foncé
    0   0   1   % bleu
    0   0   0   % noir
   0.5 0.5 0.5  % gris
] ;
set(gca,'ColorOrder', nouv_table)  % affectation
    % de cette nouvelle table de couleurs ; noter que
    % cela n'affecte pas les courbes existantes !
set(gca,'ColorOrderIndex', 2)  % chang. indice
plot(2*courbes, 'LineWidth', 3)
    % => utilise couleurs d'indice 2, 3 et 4 de la table

a) plot(x1, y1 {,linespec} {, x2, y2 {,linespec} ...} )
    plot(x1, y1 {,'property',value} ... )
b) plot(vect)
c) plot(mat)
d) plot(var1,var2 ...)

Graphique 2D de lignes et/ou semis de points sur axes linéaires :
a) Dans cette forme (la plus courante), xi et yi sont des vecteurs (ligne ou colonne), et le graphique comportera autant de courbes indépendantes que de paires xi/yi. Pour une paire donnée, les vecteurs xi et yi doivent avoir le même nombre d'éléments (qui peut cependant être différent du nombre d'éléments d'une autre paire). Il s'agit d'un 'vrai graphique X/Y' (graduation de l'axe X selon les valeurs fournie par l'utilisateur).

Avec la seconde forme, définition de propriétés du graphiques plus spécifiques (voir l'exemple parlant du chapitre précédent !)

b) Lorsqu'une seule variable vect (de type vecteur) est définie pour la courbe, les valeurs vect sont graphées en Y, et c'est l'indice de chaque valeur qui est utilisé en X (1, 2, 3 ... n). Ce n'est donc plus un 'vrai graphique X/Y' mais un graphique dont les points sont uniformément répartis selon X.
c) Lorsqu'une seule variable mat (de type matrice) est passée, chaque colonne de mat fera l'objet d'une courbe, et chacune des courbes s'appuiera en X sur les valeurs 1, 2, 3 ... n (ce ne sera donc pas non plus un 'vrai graphique X/Y')
d) Lorsque l'on passe des paires de valeurs de type vecteur/matrice, matrice/vecteur ou matrice/matrice :

• si var1 est un vecteur (ligne ou colonne) et var2 une matrice :
  • si le nombre d'éléments de var1 correspond au nombre de colonnes de la matrice var2, chaque ligne de var2 fera l'objet d'une courbe, et chaque courbe utilisera le vecteur var1 en X
  • si le nombre d'éléments de var1 correspond au nombre de lignes de la matrice, chaque colonne de var2 fera l'objet d'une courbe, et chaque courbe utilisera le vecteur var1 en X
  • sinon, erreur !
• nous ne décrivons pas les autres cas (var1 est une matrice et var2 un vecteur, ou tous deux sont une matrice) qui sont très rares

Voir en outre (plus bas dans ce support de cours) :
• pour des graphiques à 2 axes Y (à gauche et à droite) : fonction plotyy
• pour des graphiques avec axes logarithmiques : les fonctions semilogx, semilogy et loglog
• pour des graphiques en semis de point avec différenciation de symboles sur chaque point : fonction scatter

plot([3 5 6 7 10], [9 7 NaN 8 6], ...
      [4 8], [7 8], 'g*')
grid('on')

plot([9 ; 7 ; 8 ; 6]);

plot([6 2 5 ; 8 3 4 ; 4 5 6]);

plot([3 5 9], [6 8 4 ; 2 3 5]);

plot([3 5], [6 8 4 ; 2 3 5]);

a1) { [x, y] } = fplot('fonction', [xmin xmax] {, tol | nb_pts } {, linespec } ) (function plot)
a2)     { [x, y] } = fplot(@fonction anonyme, [xmin xmax] ... )
a3)     { [x, y] } = fplot(function_handle, [xmin xmax] ... )
b1) { [x, ymat] } = fplot('[fonction1, fonction2, fonction3 ...]', [xmin xmax] ...)

Graphique 2D de fonctions y=fct(x) :
a) Trace la fonction fct(x) spécifiée entre les limites xmin et xmax
b) Trace simultanément les différentes fonctions spécifiées (notez bien leur énumération entre crochets [...]) sur l'intervalle xmin à xmax

La différence par rapport à plot, c'est qu'il n'y a ici pas besoin d'échantillonner les valeurs x et y de la fonction (i.e. définition d'une série de valeurs x puis du vecteur y=fct(x) ...), car fplot accepte en argument les méthodes de définition de fonction suivantes :
a1) chaîne de caractère exprimant une fonction de x : voir Ex 1
      nom d'une fonction MATLAB/Octave existante : voir Ex 2
      nom d'une fonction utilisateur définie sous forme de M-file (voir chapitre fonctions) : voir Ex 3
a2) fonction anonyme : voir Ex 1
a3) pointeur de fonction

La fonction est en fait échantillonnée automatiquement (de façon interne) par MATLAB/Octave sur un nombre de points qui dépend des paramètres facultatifs tol ou nb_pts. Voir l'aide en ligne pour davantage de détail.

Le paramètre optionnel linespec permet de spécifier un type particulier de lignes et/ou symboles.

Notez bien que l'on ne peut ici pas récupérer directement le handle de la courbe avec handle = fplot(...), car :
a) si l'on affecte fplot à [x, y], on récupère les vecteurs des valeurs x et y qui ont été automatiquement échantillonnée
b) si l'on affecte fplot à [x, ymat], on récupère le vecteur des valeurs x et une matrice ymat avec autant de colonnes que de fonctions

fplot('sin(x)*sqrt(x)', [0 20],'r');
% ou: fplot(@(x) sin(x).*sqrt(x), [0 20],'r');
hold('on');
fplot('2*log(x)-4',[1 18],'g');
% ou: fplot(@(x) 2*log(x)-4, [1 18],'g');
grid('on');  % => graphique ci-contre 

fplot('[sin(x)*sqrt(x),2*log(x)-4]',[0 20],'b');
grid('on');
ylim([-5 5])

Grapher des fonctions built-in MATLAB/Octave :

fplot('sin',[0 10],'r');
hold('on');
fplot('cos',[0 10],'g');
grid('on');

Définir une fonction utilisateur, puis la grapher :

1) Définition, dans un fichier nommé sin_sqrt.m, de la fonction suivante (voir chapitre fonctions) :

function [Y]=sin_sqrt(X)
  Y=sin(X).*sqrt(X);
return

Remarque: sous Octave, on pourrait aussi, au lieu de saisir le code de la fonction ci-dessus dans un M-file, l'entrer interactivement dans la fenêtre de commande Octave en terminant la saisie par endfunction (au lieu de return), ce qui donne lieu à une "compiled function".

2) Puis la grapher simplement avec :
fplot('sin_sqrt(x)',[0 20],'r') ou avec
fplot(@sin_sqrt, [0 20],'r')

a) semilogx(...)
b) semilogy(...)
c) loglog(...)

Graphique 2D de lignes et/ou semis de points sur axes logarithmiques :
Ces 3 fonctions, qui s'utilisent exactement comme la fonction plot (mêmes paramètres...), permettent de grapher dans des systèmes d'axes logarithmiques :
a) axe X logarithmique, axe Y linéaire
b) axe X linéaire, axe Y logarithmique
c) axes X et Y logarithmiques

Voir aussi, plus bas, la fonction plotyy pour graphiques 2D à 2 axes Y qui peuvent être logarithmiques

x1=logspace(1,6,6); y1=log(x1);
semilogx(x1,y1,'r-o', ...
         [10 100 1e4 1e5 1e6],[6 8 4 6 4],'g');
grid('on');

{ [haxes { hc1 hc2 }] } = plotyy(x1, y1, x2, y2 {,'type1' {,'type2'}} )

Deux courbes avec 2 axes Y distincts mais partageant le même axe X :
Trace la courbe définie par les vecteurs x1 et y1 relativement à l'axe Y de gauche, et la courbe définie par les vecteurs x2 et y2 relativement à l'axe Y de droite.
Les paramètres optionnels type1 et type2 permettent de définir le type de primitive de tracé 2D utiliser. Ils peuvent notamment avoir la valeur : plot, semilogx, semilogy, loglog, stem...
On récupère optionnellement sur haxes un vecteur à 2 éléments contenant le handle de chacun des 2 systèmes d'axes, sur hc1 le handle de la courbe x1/y1 et sur hc2 celui de la courbe x2/y2.

x=0:0.1:4*pi;
h=plotyy(x, sin(2*x), x, exp(x), ...
         'plot', 'semilogy');
grid('on')
xlabel('axe X')
hy1=get(h(1),'ylabel');
hy2=get(h(2),'ylabel');
set(hy1,'string','fonction 1');
set(hy2,'string','fonction 2');

a) stairs( {x,} y )
b) stairs( {x,} ymat {, linespec } )

Graphique 2D en escaliers :
a) Dessine une ligne en escaliers pour la courbe définie par les vecteurs (ligne ou colonne) x et y. Si l'on ne fournit pas de vecteur x, la fonction utilise en X les indices de y (donc les valeurs 1 à length(y) ).
b) Traçage de plusieurs courbes sur le même graphique en passant à cette fonction une matrice ymat dans laquelle chaque courbe fait l'objet d'une colonne.

Remarque : on peut aussi calculer le tracé de la courbe sans le dessiner avec l'affectation [xs,ys]=stairs(...);, puis le dessiner ultérieurement avec plot(xs,ys,linespec);

x1=0:0.6:4*pi; y1=x1.*cos(x1);
stairs(x1,y1,'r');
hold('on');
x2=0:0.2:4*pi; y2=5*cos(2*x2);
stairs(x2,y2,'g');
grid('on');

stem( {x,} y {, linespec } )

Graphique 2D en bâtonnets :
Graphe la courbe définie par les vecteurs (ligne ou colonne) x et y en affichant une ligne de rappel verticale (bâtonnet, pointe) sur tous les points de la courbe. Si l'on ne fournit pas de vecteur x, la fonction utilise en X les indices de y (donc les valeurs 1 à length(y) ).

x=0:0.2:4*pi; y=sin(x).*sqrt(x);
stem(x,y,'mo-');
grid('on');

feather( {dx,} dy)

Graphique 2D de champ de vecteurs en "plumes" :
Dessine un champ de vecteurs dont les origines sont uniformément réparties sur l'axe X (en (1,0), (2,0), (3,0), ...) et dont les dimensions/orientations sont définies par les valeurs dx et dy

dy=linspace(-1,1,10) ;
dx=0.5*ones(1,length(dy)) ;
   % vecteur ne contenant que des val. 0.5
feather(dx,dy)
grid('on')
axis([0 12 -1 1])

compass( {dx,} dy)

Graphique 2D de champ de vecteurs de type "boussole" :
Dessine un champ de vecteurs dont les origines sont toutes en (0,0) et dont les dimensions/orientations sont définies par les valeurs dx et dy

compass([1 2 -1],[2 -1 -1])
axis([-2 2 -2 2])
grid('on')

a) errorbar(x, y, error {,format} )
b) errorbar(x, y, lower, upper {,format} )

Graphique 2D avec barres d'erreur :
a) Graphe la courbe définie par les vecteurs de coordonnées x et y (de type ligne ou colonne, mais qui doivent avoir le même nombre d'éléments) et ajoute, à cheval sur cette courbe et en chaque point de celle-ci, des barres d'erreur verticales symétriques dont la longueur totale sera le double de la valeur absolue des valeurs définies par le vecteur error (qui doit avoir le même nombre d'éléments que x et y).
b) Dans ce cas, les barres d'erreur seront asymétriques, allant de :
    • y-abs(lower) à y+abs(upper)
    • y-lower à y+upper (donc Octave utilise le signe des valeurs contenus dans ces vecteurs !)

Attention : le paramètre format a une signification différente selon que l'on utilise MATLAB ou Octave :

• il correspond simplement au paramètre linespec (spécification de couleur, type de trait, symbole...) comme dans la fonction plot
• la fonction errorbar de Octave offre davantage de possibilités que celle de MATLAB : ce paramètre format doit commencer par l'un des codes ci-dessous définissant le type de barre(s) ou box d'erreur à dessiner :
    • ~ : barres d'erreur verticales (comme sous MATLAB)
    • > : barres d'erreur horizontales
    • ~> : barres d'erreur en X et en Y (il faut alors fournir 4 paramètres lowerX, upperX, lowerY, upperY !)
    • #~> : dessine des "boxes" d'erreur
  puis se poursuit par le linespec habituel, le tout entre apostrophes

Voir en outre les fonctions suivantes, spécifiques à Octave : semilogxerr, semilogyerr, loglogerr

x=0:0.1:2; y=sin(x);
y_approx = x - (x.^3/6); % approximation fct sinus
error = y_approx - y;
errorbar(x,y,error,'r--o');
grid('on');

x=[1 3 5 9 13];
y=[3 3.8 3.5 4.1 3.8];
lowerX=[0.5 1 1.5 1 2];
upperX=[2 1 2 3 2];
lowerY=[0.2 0.1 0.3 0.2 0.3];
upperY=[0.1 0.2 0.1 0.1 0];

errorbar(x,y, ...
   lowerX,upperX,lowerY,upperY,'#~>r');
hold('on');
plot(x,y,'r-o');
legend('off');
grid('on');

scatter(x, y {,size {,color } } {,symbol} {,'filled'} )

Graphique 2D de symboles :
Dessin du semis de points défini par les vecteurs de coordonnées x et y (de type ligne ou colonne, mais qui doivent avoir le même nombre d'éléments)

• size permet de spécifier la surface des symboles : ce peut être soit une valeur scalaire (=> tous les symboles auront la surface spécifiée), soit un vecteur de même dimension que x et y (=> indique alors taille de chaque symbole) ; concernant l'unité de ce paramètre, c'est la surface du "carré englobant" du symbole en [pixels^2] : ex: 100 => symbole de surface 100 pixels^2 donc de coté 10 x 10 [pixels]
  
• color permet de spécifier la couleur des symboles : ce peut être :
  • soit une couleur, appliquée uniformément à tous les symboles, exprimée sous forme de chaîne selon la syntaxe décrite plus haut (p.ex. 'r' pour rouge)
  • soit un vecteur (de la même taille que x et y) qui s'appliquera linéairement à la colormap
  • ou une matrice n x 3 de couleurs exprimées en composantes RGB
• symbol permet de spécifier le type de symbole (par défaut: cercle) selon les possibilités décrites plus haut, c'est-à-dire 'o', '*', '+', 'x', '^', '<', '>', 'v', 's', 'd', 'p', 'h'
• le paramètre-chaîne 'filled' provoquera le remplissage des symboles

Remarque : en jouant avec l'attribut color et en choisissant une table de couleur appropriée, cette fonction permet de grapher des données 3D x/y/color

facteur=50*50 ;
scatter(rand(30,1),rand(30,1), ...
        facteur*rand(30,1),rand(30,1),'p','filled');

area( {x,} ymat )

Graphique 2D de type surface :
Graphe de façon empilée (cumulée) les différentes courbes définies par les colonnes de la matrice ymat, et colorie les surfaces entre ces courbes. Le nombre d'éléments du vecteur x (ligne ou colonne) doit être identique au nombre de lignes de ymat. Si l'on ne spécifie pas x, les valeurs sont graphées en X selon les indices de ligne de ymat.

sous Octave Qt et FLTK 3.4 à 5.2, l'usage de la fonction colormap est sans effet

x=[1 2 7 11];
ymat=[1 2 4 ; 3 2 7 ; 1 5 -2 ; 2 6 4];
area(x,ymat);
colormap(autumn); % changement palette couleurs
grid('on');
set(gca,'Layer','top'); % quadrillage 1er plan
legend('Un','Deux','Trois')

a) fill(x, y, couleur)
b) fill(xA, yA, couleurA {, xB, yB, couleurB ... } )
c) patch(x, y, couleur)

Dessin 2D de surface(s) polygonale(s) remplie(s) :
a) Dessine et rempli de la couleur spécifiée le polygone défini par les vecteurs de coordonnées x et y. Le polygone bouclera automatiquement sur le premier point, donc il n'y a pas besoin de définir un dernier couple de coordonnées xn/yn identique à x1/y1.
b) Il est possible de dessiner plusieurs polygones (A, B...) d'un coup en une seule instruction en passant en paramètre à cette fonction plusieurs triplets x,y,couleur.
c) Primitive de bas niveau de tracé de surfaces remplies, cette fonction est analogue à fill sauf qu'elle accumule (tout comme la primitive de dessin de ligne line) son tracé dans la figure courante sans qu'il soit nécessaire de faire au préalable un hold('on')

On spécifie la couleur par l'un des codes de couleur définis plus haut (p.ex. pour rouge: 'r' ou [1.0 0 0] )

a=linspace(0,2*pi,20);
  x= 4.5 + 0.7*cos(a); % contour disque noir de
  y= 6.0 + 0.7*sin(a); % rayon 0.7, centre 4.5/6.0
fill([1 8 8 1],[1 7 1 7],'r', ...
     [4 5 5 4],[2 2 6 6],[0.6 0 0], ...
     x,y,'k');
axis('equal');
axis([0 9 0 8]);
grid('on');

rectangle('Position',[xmin, ymin, L, H] {, 'Curvature', c | [c_horiz, c_vert] }
          {,'LineWidth',epaisseur, 'LineStyle',type, 'EdgeColor',coul_trait, 'FaceColor',coul_remplissage } )

Dessin 2D de formes allant du rectangle à l'ellipse :
Dessine une forme de largeur L, hauteur H et dont l'angle inférieur gauche est placé aux coordonnées (xmin, ymin).
Le paramètre Curvature permet de définir la courbure des cotés de la forme, à l'aide d'une valeur c ou par 2 valeurs [c_horiz, c_vert] qui doivent être comprises entre 0 et 1. La valeur 0 signifie aucune courbure des cotés (donc coins carrés) ; 1 signifie qu'il faut courber le coté sur toute sa longueur ; entre deux, la courbure n'est appliqué qu'aux extrémités des cotés. On a ainsi, par exemple :
• avec c=0 ou c=[0,0] (ou en l'absence du paramètre Curvature) : un rectangle
• avec c=1 : les 2 petits cotés de la forme sont des demi-cercles
• avec c=[1,1] : une ellipse parfaite
Il est encore possible d'agir sur l'epaisseur du bord de la forme, le type de trait, sa couleur coul_trait, et la couleur de remplissage coul_remplissage.

Notez finalement que cette fonction, qui s'appuie sur la fonction patch, accumule son tracé dans la figure courante sans qu'il soit nécessaire de faire au préalable un hold('on')

rectangle('position',[1 0.5 4.5 1], ...
   'linewidth',6, 'linestyle','--', ...
   'edgecolor','r', 'facecolor',[1 1 0.5])
text(1.1,1,'Pas de Curvature  (ou 0, ou [0, 0])')

rectangle('position',[1 2 2 1],'curvature',1)
text(1.1,2.5,'Curvature 1')

rectangle('position',[1 3.5 2 1],'curvature',0.4)
text(1.1,4,'Curvature 0.4')

rectangle('position',[1 5 2 1],'curvature',[1 1])
text(1.1,5.5,'Curvature [1, 1]')

rectangle('position',[3.5 2 2 1], ...
   'curvature',[1 0.3])
text(3.6,2.5,'Curvature [1, 0.3]')

rectangle('position',[3.5 3.5 2 1], ...
   'curvature',[0.2 1])
text(3.6,4,'Curvature [0.2, 1]')

rectangle('position',[3.5 5 2 1], ...
   'curvature',[0.7 0.7])
text(3.6,5.5,'Curvature [0.7, 0.7]')

axis([0 6 0 6.5])
axis('equal')
grid('on')

a) pie(val {,explode} {,labels} )
b) pie3(val {,explode} {,labels} )

Graphique de type camembert :
a) Dessine un camembert 2D sur la base du vecteur val, chaque valeur se rapportant à une tranche de gâteau.
Le vecteur logique explode (de même taille que val et composé de 0 ou de 1) permet de spécifier (avec 1) quelles tranches de gâteau doivent être "détachées"
Le vecteur cellulaire labels (de même taille que val et composé de chaînes de caractères) permet de spécifier le texte à afficher à coté de chaque tranche en lieu et place des pourcentages
b) Réalise un camembert en épaisseur (3D)

val=[20 15 60 10 35 50 10];

subplot(1,2,1);
pie(val, [0 0 1 0 0 1 0]);
colormap(summer);  % changement palette couleur

subplot(1,2,2);
pie3(val);
legend('un','deux','trois','quatre', ...
       'cinq','six','sept', ...
       'location','east');

a) bar( {x,} y )
b) bar( {x,} mat {,larg} {,'style'} )
c) barh( {y,} mat {,larg} {,'style'} )

Graphique 2D en barres :
a) Dessine les barres verticales définies par les vecteurs x (position de la barre sur l'axe horizontal) et y (hauteur de la barre). Si le vecteur x n'est pas fourni, les barres sont uniformément réparties en X selon les indices du vecteur y (donc positionnées de 1 à n).
b) Sous cette forme, on peut fournir une matrice mat dans laquelle chaque ligne définira un groupe de barres qui seront dessinées :
  • côte-à-côte si le paramètre style n'est pas spécifié ou que sa valeur est 'grouped'
  • de façon empilée si la valeur de ce paramètre est 'stacked'
Avec le paramètre larg, on spécifie le rapport "largeur des barres / distance entre barres" dans le cadre du groupe ; la valeur par défaut est 0.8 ; si celle-ci dépasse 1, les barres se chevaucheront. Le nombre d'éléments du vecteur x doit être égal au nombre de lignes de la matrice mat.
c) Identique à la forme b), sauf que les barres sont dessinées horizontalement et positionnées sur l'axe vertical selon les valeurs du vecteur y

Remarque : on peut aussi calculer les tracés sans les dessiner avec l'affectation [xb,yb]=bar(...);, puis les dessiner ultérieurement avec plot(xb,yb,linespec);

x=log(1:0.5:12);
y=sin(x);
bar(x,y, 'facecolor',[0 0 0.5]);
axis([0 2.6 0 1]);
grid('on');

Premier graphique ci-contre :

x=[2 4 9 11];
mat=[10 8 7 ; 2 3 5 ; 12 13 11 ; 4 5 3];
bar(x,mat,0.9,'grouped');
hold('on');
plot([2 4 6 12],[5 9 3 10]);

barh(x,mat,0.8,'stacked');
legend('un','deux','trois',-1)
colormap(summer)

On a ensuite annoté le second graphique, en placement interactivement des chaînes de texte définies dans un tableau avec le code ci-dessous :

annot={'note1','note2','note3','note4'};
for n=1:length(annot)
  gtext(annot{n});
end

a) [nval {xout} ] = hist(y {,n} )
b) [nval {xout} ] = hist(y, x )

Histogramme 2D de distribution de valeurs, ou calcul de cette distribution :
a) Détermine la répartition des valeurs contenues dans le vecteur y (ligne ou colonne) selon n catégories (par défaut 10) de même 'largeur' (catégories appelées boîtes, bins, ou containers), puis dessine cette répartition sous forme de graphique 2D en barres où l'axe X reflète la plage des valeurs de y, et l'axe Y le nombre d'éléments de y dans chacune des catégories.
IMPORTANT: Si l'on affecte cette fonction à [nval {xout}], le graphique n'est pas effectué, mais la fonction retourne le vecteur-ligne nval contenant nombre de valeurs trouvées dans chaque boîte, et le vecteur-ligne xout contenant les valeurs médianes de chaque boîtes. On pourrait ensuite effectuer le graphique à l'aide de ces valeurs tout simplement avec la fonction bar(xout,nval).
b) Dans ce cas, le vecteur x spécifie les valeurs du 'centre' des boîtes (qui n'auront ainsi plus nécessairement la même largeur !) dans lesquelles les valeurs de y seront distribuées, et l'on aura autant de boîtes qu'il y a d'éléments dans le vecteur x.

Voir aussi la fonction [nval {vindex}]=histc(y,limits) (qui ne dessine pas) permettant de déterminer la distribution des valeurs de y dans des catégories dont les 'bordures' (et non pas le centre) sont précisément définies par le vecteur limits.

Remarque : sous MATLAB, y peut aussi être une matrice de valeurs ! Si cette matrice comporte k colonnes, la fonction hist effectue k fois le travail en examinant les valeurs de la matrice y colonne après colonne. Le graphique contiendra alors n groupes de k barres. De même, la variable nval retournée sera alors une matrice de n lignes et k colonnes, mais xout restera un vecteur de n valeurs (mais, dans ce cas, en colonne).

Voir (plus bas) la fonction rose qui réalise aussi des histogrammes de distribution mais dans un système de coordonnées polaire.

y=[4 8 5 2 6 8 0 6 13 14 10 7 4 3 12 13 6 3 5 1];

[nval xout]=hist(y)
% => nval=[2 1 4 2 4 2 0 1 1 3]
%    xout=[0.7 2.1 3.5 4.9 6.3 7.7 9.1
%          10.5 11.9 13.3]
hist(y);  % => 1er graphique ci-contre
set(gca,'XTick',xout) % annote axe X sous barres

[nval xout]=hist(y,7)
% => nval=[3 4 5 3 1 1 3]
%    xout=[1 3 5 7 9 11 13]
hist(y,7);  % => 2e graphique ci-contre
% commande d'annotation axe X pas nécessaire
%    set(gca,'XTick',xout)

centres=[3 5 11 13] ;
[nval xout]=hist(y,centres)
% => nval=[7 8 2 3]
%    xout=[3 5 11 13] % identique à centres
hist(y,centres) % => 3e graphique ci-contre
axis([2 14 0 9]);
% commande d'annotation axe X pas nécessaire
%    set(gca,'XTick',centres)

a) plotmatrix(m1, m2 {,linespec})
b) plotmatrix(m {,linespec})

Matrice de graphiques en semis de points :
a) En comparant les colonnes de la matrice m1 (de dimension P lignes x M colonnes) avec celles de m2 (de dimension P lignes x N colonnes), affiche une matrice de N (verticalement) x M (horizontalement) graphiques en semis de points
b) Cette forme est équivalente à plotmatrix(m, m {,linespec}), c'est à dire que l'on effectue toutes les comparaisons possibles, deux à deux, des colonnes de la matrice m et qu'on affiche une matrice de comportant autant de lignes et colonnes qu'ily a a de colonnes dans m. En outre dans ce cas les graphiques se trouvant sur la diagonale (qui représenteraient des semis de points pas très intéressants, car distribués selon une ligne diagonale) sont remplacés par des graphiques en histogrammes 2D (fréquence de distribution) correspondant à la fonction hist(m(:,i))

plotmatrix([1 12 25; 2 15 19; 4 16 18], ...
    [101 204; 108 210; 104 208], 'ro')

plotmatrix(randn(10,3), 'g+')

line(x, y {,z} {,'property', value ...} )

Primitive de tracé de lignes 2D/3D :
Cette fonction est une primitive de tracé de lignes 2D/3D de bas niveau proche de plot et plot3. Elle s'en distingue cependant par le fait qu'elle permet d'accumuler, dans un graphique, des tracés sans qu'il soit nécessaire de mettre hold à on !

Remarque : la primitive de tracé de surfaces remplies de bas niveau est patch

hold('off'); clf;
for k=0:32
  angle=k*2*pi/32;
  x=cos(angle); y=sin(angle);
  if mod(k,2)==0
    coul='red'; epais=2;
  else
    coul='yellow'; epais=4;
  end
  line([0 x], [0 y], ...
       'Color', coul, 'LineWidth', epais);
end
axis('off'); axis('square');

polar(angle, rayon {,linespec} )

Graphique 2D de lignes et/ou semis de points en coordonnées polaires :
Reçoit en paramètre les coordonnées polaires d'une courbe (ou d'un semis de points) sous forme de 2 vecteurs angle (en radian) et rayon (vecteurs ligne ou colonne, mais de même taille), dessine cette courbe sur une grille polaire.
On peut tracer plusieurs courbes en utilisant hold('on'), ou en passant à cette fonction des matrices angle et rayon (qui doivent être de même dimension), la i-ème courbe étant construite sur la base des valeurs de la i-ème colonne de angle et de rayon.

angle1=0:0.02:2*pi;
rayon1=sin(2*angle1).*cos(2*angle1);
polar(angle1, rayon1, 'b');

angle2=0:pi/8:2*pi;
rayon2=[repmat([0.1 0.3],1,8), 0.1];
hold('on');
polar(angle2, rayon2, 'r');

legend('courbe 1','courbe 2');

angle=0:0.02:2*pi;
polar([angle' angle'], ...
       [sin(angle') cos(angle')],'.');
legend('sinus','cosinus');

rose(val {,n} )

Histogramme polaire de distribution de valeurs (ou histogramme angulaire) :
Cette fonction est analogue à la fonction hist vue plus haut, sauf qu'elle travaille dans un système polaire angle/rayon. Les valeurs définies dans le vecteur val, qui doivent ici être comprises entre 0 et 2*pi, sont réparties dans n catégories (par défaut 20 si n n'est pas spécifié) et dessinées sous forme de tranche de gâteau dans un diagramme polaire où l'angle désigne la plage des valeurs, et le rayon indique le nombre de valeurs se trouvant dans chaque catégorie.

rose(2*pi*rand(1,1000),16);

a) rticks([valeurs]) et thetaticks([valeurs])   (sous Octave depuis version 4.4)
b) rticks('auto') et thetaticks('auto')
c) valeurs = rticks | thetaticks

"Quadrillage" (cercles concentriques et rayons) d'un graphique polaire :
a) Définit le rayon des cercles, respectivement l'angle des rayons du graphique, selon les valeurs spécifiées. S'agissant des rayons, les valeurs seront indiquées en degrés.
b) Rétablit les cercles ou rayons automatiques
c) Récupère les valeurs correspondant au rayons des cercles, respectivement aux angles des rayons du graphique

h=polar(linspace(0,4*pi,50), linspace(0,10,50));
set(h, 'linewidth',5, 'color', 'r')

thetaticks(0:45:360)  % rayon tous les 45 degrés
rticks(0:2:10)        % cercle tous les 2

{ [C, h] = } contour({X, Y,} Z {, n | v } {, linespec } )

Courbes de niveau :
Dessine les courbes de niveau (isolignes) interpolées sur la base de la matrice Z
• les vecteurs ou matrices X et Y ne servent "qu'à" graduer les axes X et Y
• le scalaire n permet de définir le nombre de courbes à tracer
• le vecteur v permet de spécifier pour quelles valeurs précises de Z il faut interpoler des courbes
• la couleur des courbes est contrôlée par les fonctions colormap et caxis (présentées plus loin)
• on peut ausssi spécifier le paramètre linespec pour définir l'apparence des courbes
• on peut affecter cette fonction aux paramètres de sortie C (matrice de contour) et h (handles) si l'on veut utiliser ensuite la fonction clabel ci-dessous

De façon interne, contour fait appel à la fonction MATLAB/Octave contourc d'interpolation de courbes (calcul de la matrice C).
Voir aussi la fonction ezcontour (easy contour) de visualisation, par courbes de niveau, d'une fonction à 2 variables définie sous forme d'une expression fct(x,y).

{handle = }clabel(C, h {,'manual'} ) (contour label)

Étiquetage des courbes de niveau :
Place des labels (valeur des cotes Z) sur les courbes de niveau. Les paramètres C (matrice de contour) et h (vecteur de handles) sont récupérés lors de l'exécution préalable des fonctions de dessin contour ou contourf (ou de la fonction d'interpolation contourc). Sans le paramètre h, les labels ne sont pas placés parallèlement aux courbes. Avec le paramètre 'manual', on peut désigner manuellement (par un clic souris-gauche) l'emplacement de ces labels.
Octave Qt et FLTK 3.4 à 4.2 n'oriente pas encore les labels selon les courbes

[C,h]=contour(X,Y,Z,[-10:5:30]); % dessin courbes
   % courbes de niveaux de -10 à 30 tous les 5
h_cl=clabel(C,h); % dessin des labels ; on
% récupère h_cl, vect. handles pointant v/chaque label
grid('on')

set(h_cl,'fontsize',7) % chang. taille tous labels

% code pour arrondir à 1 décimale le texte des labels
for k=1:length(h_cl)   % parcours de chaque label
  h_cl_s = get(h_cl(k));         % struct. k-ème label
  lab_s = h_cl_s.string;         % texte du label...
  lab_n = str2num(lab_s);        %  converti en nb
  lab_rs=sprintf('%5.1f',lab_n); %  converti chaine
  set(h_cl(k),'string',lab_rs);  %  réappliqué d/graph.
end

{ [C, h, CF] = } contourf({X, Y,} Z {, n | v } ) (contour filled)

Courbes de niveau avec remplissage :
Le principe d'utilisation de cette fonction est le même que pour contour (voir plus haut), mais l'espace entre les courbes est ici rempli de couleurs. Celles-ci sont également contrôlées par les fonctions colormap et caxis (présentées plus loin). On pourrait bien évidemment ajouter à un tel graphique des labels (avec clabel), mais l'affichage d'une légende de type "barre de couleurs" (avec la fonction colorbar décrite plus loin) est bien plus parlant.

Voir aussi la fonction ezcontourf (easy contour filled) de visualisation, par courbes de niveau avec remplissage, d'une fonction à 2 variables définie sous forme d'une expression fct(x,y).

contourf(X,Y,Z,[-10:2.5:30])
  % courbes tous les 2.5

colormap('default') % essayez winter, summer...
colorbar            % affich. barre couleurs
  % essayez p.ex. : caxis([-40 60])
  %                 caxis([-5 20])
  %                 caxis('auto')

surface({X, Y,} Z )     ou
pcolor({X, Y,} Z )     (pseudo color)

Affichage en "facettes de couleur" ou avec lissage interpolé :
La matrice de valeurs Z est affichée en 2D sous forme de facettes colorées (mode par défaut, sans interpolation, correspondant à interp('faceted')).
Les couleurs indexées sont contrôlées par les fonctions colormap et caxis (décrites plus loin).
On peut en outre réaliser une interpolation de couleurs (lissage) avec la commande shading (également décrite plus loin).

surface(X,Y,Z) % ou:  pcolor(X,Y,Z)
colorbar        % => graphique ci-contre

shading('flat') % ferait disparaître le
                % bord noir des facettes

pcolor(X,Y,Z)   % ou:  surface(X,Y,Z)
shading('interp') % interpolation de couleur
colormap(hot)     % changement table couleurs
colorbar

Illustration de la combinaison de 2 graphiques avec hold('on')

[C,h]=contour(X,Y,Z,[-10:5:30],'k');
             % courbes noires
clabel(C,h);
hold('on')
pcolor(X,Y,Z)     % ou:  surface(X,Y,Z)
colormap(pink(512))
caxis([-15 30])    % aténuer tons foncés
shading('interp')

quiver({X, Y,} dx ,dy {, scale } {, linespec {, 'filled' } } )

Affichage d'un champ de vecteurs :
Dessine le champ de vecteurs défini par les matrices dx et dy (p.ex. calculées avec la fonction gradient décrite ci-dessous) :
• les vecteurs ou matrices X et Y ne servent qu'à graduer les axes (si nécessaire)
• le paramètre scale permet de définir l'échelle des vecteurs
• avec le paramètre linespec, on peut encore définir un type de trait et couleur, ainsi que changer la flèche par un symbole, voire remplir les symboles avec 'filled'

[dx, dy] = gradient(Z {, espac_x, espac_y } )

Calcul d'un champ de vecteurs (vitesses) :
Détermine un champ de vecteurs en calculant le gradient 2D de la matrice Z.
Fonction communément utilisée pour générer les vecteurs affichés par la fonction quiver ci-dessus.
Définie ici en 2 dimension, cette fonction est aussi utilisable sous MATLAB en N-dimension.

[dx,dy]=gradient(Z,0.25,0.25);
     % calcul champ vecteurs
quiver(X,Y,dx,dy,1.5)
     % affichage champ vecteurs
axis([-2 2 -2 2])

plot3(x1,y1,z1 {,linespec} {, x2,y2,z2 {,linespec} ...} )
plot3(x1,y1,z1 {,'property',value} ... )

Graphique 3D de lignes et/ou semis de points sur axes linéaires :
Analogue à la fonction 2D plot (à laquelle on se réfèrera pour davantage de détails), celle-ci réalise un graphique 3D (et nécessite donc, en plus des vecteurs x et y, un vecteur z).
Comme pour les graphiques 2D, on peut bien évidemment aussi superposer plusieurs graphiques 3D avec hold('on').

z1=0:0.1:10*pi;
x1=z1.*cos(z1);
y1=z1.*sin(z1);

x2=60*rand(1,20)-30;  % 20 points de coord.
y2=60*rand(1,20)-30;  % -30 < X,Y < 30
z2=35*rand(1,20);     %   0 <  Z  < 35

plot3(x1,y1,z1,'r',x2,y2,z2,'o')

axis([-30 30 -30 30 0 35])
grid('on')
xlabel('x'); ylabel('y'); zlabel('z');
title('Graphique de type plot3')
legend('x=z*cos(z) y=z*sin(z)', ...
       'semis aleatoire',1)

set(gca,'xtick',[-30:10:30])
set(gca,'ytick',[-30:10:30])
set(gca,'ztick',[0:5:35])
set(gca,'Xcolor',[0.5 0.5 0.5], ...
        'Ycolor',[0.5 0.5 0.5], ...
        'Zcolor',[0.5 0.5 0.5])

ezplot3('expr_x','expr_y','expr_z', [tmin tmax] {,'animate'} ) (easy plot3)

Dessin d'une courbe paramétrique 3D :
Dessine la courbe paramétrique définie par les expressions x=fct(t), y=fct(t), z=fct(t) spécifiées, pour les valeurs de t allant de tmin à tmax. Avec le paramètre 'animate', réalise un tracé animé de type comet3.

ezplot3('t*sin(t)','t*cos(t)','t',[0,10*pi])

stem3(x,y,z {,linespec} {,'filled'} )

Graphique 3D en bâtonnets :
Analogue à la fonction 2D stem (à laquelle on se réfèrera pour davantage de détails), celle-ci réalise un graphique 3D et nécessite donc, en plus des vecteurs x et y, un vecteur z.
Cette fonction rend mieux la 3ème dimension que les fonctions plot3 et scatter3 lorsqu'il s'agit de représenter un semis de points !

x=linspace(0,6*pi,100);
y=x.*sin(x);
z=exp(x/10)-1;

stem3(x,y,z,'mp')

xlabel('x')
ylabel('x*sin(x)')
zlabel('e^x/10 -1')
grid('on')

a) mesh({X, Y,} Z {,COUL} )
b) meshc({X, Y,} Z {,COUL} ) (mesh and contours)
c) meshz({X, Y,} Z {,COUL} )

Dessin de surface 3D sous forme grille (wireframe) :
Dessine, sous forme de grille (wireframe, mesh), la surface définie par la matrice de hauteurs Z. Il s'agit d'une représentation en "fil de fer" avec traitement des lignes cachées (hidden lines). Comme vu plus haut, les vecteurs ou matrices X et Y servent à uniquement à graduer les axes ; s'ils ne sont pas spécifiés, la graduation s'effectue de 1 à size(Z).
a) Affichage de la surface uniquement
b) Affichage combiné de la surface et des courbes de niveau (sur un plan sous la surface). En fait meshc appelle mesh, puis fait un hold('on'), puis appelle contour. Pour mieux contrôler l'apparence des courbes de niveau, l'utilisateur peut donc exécuter lui-même cette séquence de commandes manuellement au lieu d'utiliser meshc.
c) Dessine, autour de la surface, des plans verticaux ("rideaux")

S'agissant du paramètre COUL :

• ce paramètre permet de spécifier la couleur de chaque maille (et visualiser ainsi des données 4D en définissant la couleur indépendemment de l'altitude)
    • si COUL est une matrice 2D de même dimension que Z, elle définit des "couleurs indexées", et une transformation linéaire est automatiquement appliquée (via les paramètres [cmin cmax] décrits plus loin) pour faire correspondre ces valeurs avec les indices de la table de couleurs courante
    • mais COUL peut aussi spécifier des "vraies couleurs" en composantes RGB ; ce sera alors une matrice 3D dont COUL(:,:,1) définira la composante rouge (de 0.0 à 1.0), COUL(:,:,2) la composante verte, et COUL(:,:,3) la composante bleue
• si COUL n'est pas spécifié, la couleur sera "proportionelle" à la hauteur Z, et le choix et l'usage de la palette sera effectué par les fonctions colormap et caxis (décrites plus loin)

hidden('on | off')

Affichage/masquage des lignes cachées :
Les fonctions mesh, meshc, meshz, waterfall effectuant un traitement des lignes cachées (hidden lines), cette commande permet de le désactiver si nécessaire.

On reprend ici, et dans les exemples suivants, la fonction utilisée dans les exemples du chapitre "Graphiques 2D de représentation de données 3D"

x=-2:0.2:2;  y=x;
[X,Y]=meshgrid(x,y);
Z=100*sin(X).*sin(Y).* ...
  exp(-X.^2 + X.*Y - Y.^2);

meshc(X,Y,Z)
colormap(jet)  % => graphique supérieur

meshz(X,Y,Z) % => graphique inférieur

waterfall({X, Y,} Z {,COUL} )

Dessin de surface 3D en "chute d'eau" :
Le graphique produit est similaire à celui de meshz, sauf que les lignes dans la direction de l'axe Y ne sont pas dessinées.
La fonction hidden peut aussi être utilisée pour faire apparaître les lignes cachées.

h=waterfall(X,Y,Z);
  % on récupère le handle du graphique pour
  % changer ci-dessous épaisseur des lignes
colormap(jet)
set(h,'linewidth',2)

{ [C, h] = } contour3({X, Y,} Z {, n | v } )

Dessin de courbes de niveau en 3D :
Cette fonction est analogue à contour (à laquelle on se réfèrera pour davantage de détails, notamment l'usage des paramètres n ou v), sauf que les courbes ne sont pas projetées dans un plan horizontal mais dessinées en 3D dans les différents plans XY correspondant à leur hauteur Z.

Voir aussi la fonction contourslice permettant de dessiner des courbes de niveau selon les plans XZ et YZ

[C,h]=contour3(x(1:10),y(1:10), ...
             Z(1:10,1:10),[0:2.5:30]);
colormap(jet)
set(h,'linewidth',2)

ribbon({x,} Y {,width} )

Dessin 3D de lignes 2D en rubans :
Dessine chaque colonne de la matrice Y comme un ruban. Un vecteur x peut être spécifié pour graduer l'axe.
Le scalaire width défini la largeur des rubans, par défaut 0.75 ; s'il vaut 1, les bandes se touchent.

ribbon(x(1:10),Z(1:10,1:10),0.7)
colormap(jet)
axis([1 10 -2 0 0 30])

a) ezmesh{c}('fonction_xy', [xmin xmax ymin ymax], n {,'circ'} ) (easy mesh/meshc)
b) ezmesh{c}('expr_x','expr_y','expr_z', [tmin tmax], n {,'circ'} )

Dessin d'une fonction z=fct(x,y) ou (x,y,z)=fct(t) sous forme grille (wireframe) :
Dessine, sous forme de grille avec n mailles, la fonction spécifiée.
a) fonction définie par l'expressions fct(x,y), pour les valeurs comprises entre xmin et xmax, et ymin et ymax
b) fonction définie par les expressions x=fct(t), y=fct(t), z=fct(t), pour les valeurs de t allant de tmin à tmax

fct='100*sin(x)*sin(y)*exp(-x^2 + x*y - y^2)';
ezmeshc(fct, [-2 2 -2 2], 40)

a) surf({X,Y,} Z {,COUL} {,'property', value...} )
b) surfc({X,Y,} Z {,COUL} {,'property', value...} ) (surface and contours)

Dessin de surface 3D colorée (shaded) :
Fonctions analogues à mesh/meshc (à laquelle on se réfèrera pour davantage de détails), sauf que les facettes sont ici colorées. On peut en outre paramétrer finement l'affichage en modifiant les diverses propriétés. De plus :
• les dégradés de couleurs sont fonction de Z ou de COUL et dépendent de la palette de couleurs (fonctions colormap et caxis décrites plus loin), à moins que COUL soit une matrice 3D définissant des "vraies couleurs" ;
• le mode de coloriage/remplissage (shading) par défaut est 'faceted' (i.e. pas d'interpolation de couleurs) :
    - avec la commande shading('flat'), on peut faire disparaître le trait noir bordant les facettes
    - avec shading('interp') on peut faire un lissage de couleur par interpolation.

Voir aussi les fonctions ezsurf et ezsurfc qui sont le pendant de ezmesh et ezmeshc.

surfc(X,Y,Z) % shading 'faceted' par défaut
colormap(jet)
axis([-2 2 -2 2 -20 30])
set(gca,'xtick',[-2:1:2])
set(gca,'ytick',[-2:1:2])
set(gca,'ztick',[-20:10:30])
% => graphique supérieur

shading('interp') % voyez aussi shading('flat')
colormap(hot)
colorbar
% => graphique inférieur

surfl({X,Y,} Z {,s {,k } } )   (surface lighted)

Dessin de surface 3D avec coloriage dépendant de l'éclairage :
Fonction analogue à surf, sauf que le coloriage des facettes dépend ici d'une source de lumière et non plus de la hauteur Z !
• Le paramètre s définit la direction de la source de lumière, dans le sens surface->lumière, sous forme d'un vecteur [azimut elevation] (en degrés), ou coordonnées [sx sy sz]. Le défaut est 45 degrés depuis la direction de vue courante.
• Le paramètre k spécifie la réflectance sous forme d'un vecteur à 4 éléments définissant les contributions relatives de [lumière ambiante, réflexion diffuse, réflexion spéculaire, specular shine coefficient]. Le défaut est [0.55, 0.6, 0.4, 10]
• On appliquera la fonction shading('interp') (décrite plus loin) pour obtenir un effet de lissage de surface (interpolation de teinte).
• On choisira la table de couleurs adéquate avec la fonction colormap (voir plus loin). Pour de bonnes transitions de couleurs, il est important d'utiliser une table qui offre une variation d'intensité linéaire, telle que gray, copper, bone, pink.

Voyez en outre, plus bas, les fonctions d'éclairage de surfaces light, lighting et camlight !

surfl(X,Y,Z);

axis([-2 2 -2 2 -20 30]);
shading('interp');
colormap(gray);

trimesh (grille, wireframe)
trisurf (surface colorée, shaded)

Dessin de surface 3D basé sur une triangulation :
Pour ce type de graphique, permettant de tracer une surface passant par un semis de points irrégulier, on se réfèrera à l'exemple du chapitre "La fonction "griddata" d'interpolation de grille dans un semis irrégulier"

scatter3(x, y, z {,size {,color } } {,symbol} {,'filled'} )

Visualisation d'un semis de points 3D par des symboles :
Cette fonction s'utilise de façon analogue à la fonction 2D scatter (à laquelle on se réfèrera pour davantage de détails).
Voir aussi plot3, et surtout stem3 qui rend mieux la 3ème dimension.

a) bar3( {x,} mat {,larg} {,'style'} )
b) bar3h( {z,} mat {,larg} {,'style'} )

Graphique de barres 3D :
Représente les valeurs de la matrice mat sous forme de barres 3D, verticalement avec la forme a), horizontalement avec la forme b).
S'il est fourni, le vecteur x ou z est utilisé pour graduer l'axe au pied des barres et espacer celles-ci.
Le scalaire larg spécifie le rapport "épaisseur des barres / espacement entre barres en profondeur" dans le cadre d'un groupe ; la valeur par défaut est 0.8 ; si celle-ci atteint 1, les barres se touchent.
Le paramètre style peut prendre les valeurs 'detached' (défaut), 'grouped', ou 'stacked'

x=[2 4 9 11];
mat=[10 8 7 ; 2 3 5 ; 12 13 11 ; 4 5 3];
bar3(x,mat,0.5,'detached')
colormap(autumn)

quiver3({X, Y,} Z, dx, dy, dz {, scale } {, linespec {, 'filled' } })

Dessin d'un champ de vecteurs 3D :
Extension à la 3e dimension de la fonction quiver vue plus haut. Dessine, sur la surface Z, le champ de vecteurs défini par les matrices dx, dy, dz. Voyez l'aide en-ligne pour davantage de détails.

Voyez aussi la fonction coneplot de tracé de vecteurs dans l'espace par des cônes.

[X,Y]=meshgrid(-2:0.25:2, -1:0.2:1);
Z = X .* exp(-X.^2 - Y.^2);
[U,V,W]=surfnorm(X,Y,Z);
       % normales à la surface Z=fct(X,Y)
surf(X,Y,Z)
hold('on')
quiver3(X,Y,Z, U,V,W, 0.5, 'b')

colormap(hot)
shading('flat')
axis([-2 2 -1 1 -.6 .6])

a) slice({X,Y,Z,} V, sx,sy,sz)
b) slice({X,Y,Z,} V, xi,yi,zi {,méthode})

Affichage 3D de données volumétriques sous forme de "tranche(s)" :
a) Les données volumétriques V (tableau tri-dimensionnel) sont représentées selon des plans orthogonaux aux axes du graphique (horizontaux ou verticaux) et placés aux cotes définies par les scalaires ou vecteurs sx, sy et sz. Si l'on ne souhaite pas de tranche selon l'une ou l'autre direction, on mettra [] en lieu et place du paramètre si correspondant à cette direction.
S'agissant des paramètres X, Y et Z, qui ne servent qu'à graduer les axes du graphique, on fournira soit les tableaux 3D auxiliaires Xm,Ym,Zm (préalablement déterminés avec meshgrid pour calculer V), soit des vecteurs (définissant les valeurs d'échantillonage en x/y/z, et de longueur correspondant aux dimensions de V). Si ces paramètres sont omis, la graduation de fera de 1 à n.

b) Sous cette forme, la "tranche" de visualisation peut être une surface quelconque (donc pas obligatoirement plane !) définie par une grille régulière xi/yi associée à des altitudes zi. La fonction slice se charge elle-même d'interpoler (avec interp3) les valeurs de V sur cette surface en utilisant l'une des méthode suivante : 'linear' (défaut), 'nearest' ou 'cubic'. Cette surface/grille d'interpolation/visualisation sera donc définie par 3 matrices 2D xi, yi et zi

min=-6; max=6; n_grid=30;
v_xyz = linspace(min,max,n_grid);
[Xm,Ym,Zm] = meshgrid(v_xyz, v_xyz, v_xyz);
   % ou simplement: [Xm,Ym,Zm]=meshgrid(v_xyz);
V = sin( sqrt(Xm.^2 + Ym.^2 + Zm.^2) ) ./ ...
    sqrt(Xm.^2 + Ym.^2 + Zm.^2);
slice(Xm,Ym,Zm, V,[],[],0)
   % ci-dessus: tranche horiz.en z=0
hold('on')
slice(v_xyz,v_xyz,v_xyz,V,0,[0,4],[])
   % tranches verticales en x=0 et en y=[0,4]
   % pour les 3 permiers paramètres, on peut
   %  utiliser Xm,Ym,Zm ou v_xyz,v_xyz,v_xyz
axis([min max min max min max])
colormap(jet)
colorbar

Poursuite avec les données V de l'exemple précédent :

clf
[xi,yi]=meshgrid([-4:0.5:4],[-4:1:4]);
   % ci-dessus définition grille X/Y
zi = 0.5 * xi; % plan incliné sur cette grille
slice (v_xyz,v_xyz,v_xyz, V, xi,yi,zi)
zi = zi + 4;  % 2e plan au dessus du précéd.
hold('on')
slice (v_xyz,v_xyz,v_xyz, V, xi,yi,zi)
zi = zi - 8;  % 3e plan au dessous du précéd.
slice (v_xyz,v_xyz,v_xyz, V, xi,yi,zi)
grid('on')
axis([min max min max min max])
set(gca,'Xtick',[min:max],'Ytick',[min:max], ...
        'Ztick',[min:max])

Poursuite avec les données V de l'exemple précédent :

clf
[xi,yi]=meshgrid([-4:0.2:4]);
zi=5*exp(-xi.^2 + xi.*yi - yi.^2);
slice (v_xyz,v_xyz,v_xyz, V, xi,yi,zi)

colorbar {('East | EastOutside | West | WestOutside | North | NorthOutside | South | SouthOutside | off')}

Affichage d'une barre graduée représentant la table de couleurs courante :
Cette barre de couleurs sera placée par défaut (si la fonction est appelée sans paramètre) verticalement à droite du graphique (ce qui correspond à 'EastOutside'). Selon que l'on spécifie la direction sans/avec Outside, la barre sera dessinée dans/en dehors de la plot box.

Ex : voir plus bas

a) colormap({hax,} named_cmap { (n) })
b) colormap({hax,} cmap)
c) cmap = named_cmap { (n) }
d) cmap = colormap

Applique une table de couleurs, ou récupère une table de couleur :
a) Applique à la figure active (ou celle spécifiée par le handle hax de son système d'axes) la table de couleur nommée named_cmap (voir liste ci-dessous). Si n n'est pas spécifié, la table aura la même taille que la table courante, par défaut 64 couleurs.
b) Applique à la figure active (ou celle spécifiée par le handle hax de son système d'axes) la table de couleur cmap (matrice nx3 de n triplets RGB).
c) Retourne sur la variable cmap la table de couleur nommée named_cmap échantillonnée sur n couleurs, ou 64 si n n'est pas spécifié.
d) Récupère, sur la matrice cmap, la table de couleur courante de la figure active.

Remarques concernant a) et b) :

• les objets qui sont basés sur des "vraies couleurs" ou des codes de couleur linespec ne seront pas affectés par un changement de table de couleurs !
• si la figure se compose de plusieurs graphiques côte à côte (usage de subplot), l'usage de hax permet de définir des tables de couleur différentes pour chacun des graphiques, mais cela semble bugué sous Octave 4.2.

• parula(n) : table par défaut sous MATLAB
• viridis(n) : table par défaut sous Octave (et Python/MatPlotLib)

• hsv(n) : valeurs teinte-saturation
• jet(n) : variante de hsv
• cubehelix(n)
• rainbow(n) : dégradé arc-en-ciel (rouge→jaune→vert→bleu→magenta)

• gray(n) : dégradé linéaire de gris (noir→gris→blanc)
• copper(n) : dégradé de bruns (noir→brun→beige)
• bone(n) : dégradé de bleus pastels (noir→bleu→blanc)
• pink(n) : dégradé de roses pastels
• ocean(n) : dégradé de bleus (noir→bleu→blanc)

• hot(n) : dégradé "chaud" noir→rouge→jaune→blanc
• cool(n) : dégradé cyan→magenta
• spring(n) : dégradé magenta→jaune
• summer(n) : dégradé vert→jaune
• autumn(n) : dégradé rouge→jaune
• winter(n) : dégradé "froid" bleu→vert

• flag(n) : alternance rouge, blanc, bleu et noir
• lines(n) : table correspondant aux couleurs de lignes par défaut (voir attribut ColorOrder de axis)
• prism(n) : effet de prisme
• colorcube(n) : color-cube étendu

• white(n) : entièrement blanc

surf(X,Y,Z)  % shading 'faceted' par défaut
axis([-2 2 -2 2 -10 30])
colormap(jet(6))
colorbar  % => premier graphique ci-contre

colormap(copper(64))
shading('flat')
colorbar  % => second graphique ci-contre

a) brighten(beta)
b) cmap = brighten(beta)

Eclaircit ou assombrit une table de couleurs :
Le paramètre beta est un scalaire qui aura pour valeur :
    0.0 à 1.0 si l'on veut augmenter la luminosité de la table de couleur (brighter)
    0.0 à -1.0 si l'on veut l'assombrir (darker).
a) Modifie la table de couleur courante de la figure active (avec répecussion immédiate au niveau de l'affichage)
b) Copie la table de couleur courante de la figure active sur cmap, et modifie cette copie sans impact sur la table de couleur courante et sur l'affichage

Remarque : les objets qui sont basés sur des "vraies couleurs" ou des codes de couleur linespec ne seront pas affectés par cette fonction !

a) caxis([cmin cmax]) (color axis)
b) caxis('auto')
c) [cmin cmax] = caxis

Changement de l'échelle des couleurs, ou récupérer les valeurs de l'échelle courante :
Agit sur la façon de mettre en correspondance les 'données de couleur' de la figure courante avec les indices de la table de couleurs (voir explications plus haut). Se répercute immédiatement au niveau de l'affichage.
a) Change l'échelle des couleurs en fonction des valeurs cmin et cmax spécifiées
b) Rétablit un scaling automatique (basé sur les valeurs min et max des données de couleur de la figure)
c) Récupère les valeurs d'échelle cmin et cmax courantes

pcolor(X,Y,Z)
colormap(jet(64))
shading('interp')
axis('off')
caxis('auto')    % défaut
colorbar('SouthOutside')   % => premier graphique

caxis([0 20])
colorbar('SouthOutside')   % => second graphique

caxis([-30 50])
colorbar('SouthOutside')   % => troisième graphique

rgbplot(cmap)

Graphe les 3 courbes R/G/B de la table de couleurs cmap spécifiée, avec l'index de couleur en abscisse (i.e. numéro de ligne de cmap) et l'intensité en ordonnée (de 0 à 1)

rgbplot(jet(256))

a) view(az, el) ou view([az el])
b) view([xo yo zo])
c) view(2 | 3)
d) view(T)
e) [az,el]=view ou T=view

Orientation de la vue 3D :
L'orientation par défaut de la vue dans une nouvelle figure 3D est : azimut=-37.5 et élévation=30 degrés sous MATLAB, et azimut=30 et élévation=30 degrés sous Octave/Gnuplot. Cette fonction changer cette orientation ou de relever les paramètres courant. Notez bien qu'elle agit sur la vue et non pas sur l'objet (ce que fait quant à elle la fonction rotate) !

a) Sous cette forme (voir figure ci-dessous), la seule actuellement utilisable sous Octave/Gnuplot, on spécifie l'orientation de la vue 3D par l'azimut az (compté dans le plan XY depuis l'axe Y négatif, dans le sens inverse des aiguilles) et l'élévation verticale el (comptée verticalement depuis l'horizon XY, positivement vers le haut et négativement vers le bas), tous deux en degrés.
b) L'orientation de la vue 3D est ici spécifiée par un vecteur de coordonnées [xo yo zo] pointant vers l'observateur
c) view(2) signifie vue 2D, c'est à dire vue de dessus (selon l'axe -Z), donc équivalent à view(0, 90)
    view(3) signifie vue 3D par défaut, donc équivalent à view(-37.5, 30)
d) Définit l'orientation à partir de la matrice 4x4 de transformation T calculée par la fonction viewmtx
e) Récupère les paramètres relatifs à l'orientation courante de la vue

Ex: view(0,0) réalise une projection selon le plan XZ, et view(90,0) réalise une projection selon le plan YZ

T = viewmtx(az, el {,phi {,[xc yc zc] } } ) (view matrix)

Matrice de transformation perspective :
Sans changer l'orientation courante de la vue, calcule la matrice 4x4 de transformation perspective T sur la base de : l'azimut az, l'élévation el, l'angle phi de l'objectif (0=projection orthographique, 10 degrés=téléobjectif, 25 degrés=objectif normal, 60 degrée=grand angulaire...), et les coordonnées [xc yc zc] normalisées (valeurs 0 à 1) de la cible. On peut ensuite appliquer cette matrice T à la vue avec view(T).

Sous MATLAB, on peut en outre faire usage de nombreuses autres fonctions de gestion de la "caméra" projetant la vue 3D dans l'espace écran/papier 2D :

• cameramenu : ajoute, à la fenêtre graphique, un menu "Camera" doté de nombreuses possibilités interactives : Mouse Mode et Mouse Constraint (effet de la souris), Scene Light (éclairer la scène), Scene Lighting (none, Flat, Gouraud, Phong), Scene Shading (Faceted, Flat, Interp), Scene Clipping, Render Options (Painter, Zbuffer, OpenGL), Remove Menu. Il est alors aussi possible de "lancer la scène en rotation" dans n'importe quelle direction.
• campos, camtarget, camva, camup, camzoom, camorbit, camroll, camlookat, camproj, campan, camdolly

shading('faceted | flat | interp')

Méthode de rendu des couleurs :
Par défaut, les fonctions d'affichage de surfaces basées sur les primitives surface et patch (les fonctions pcolor et surf notamment) réalisent un rendu de couleurs non interpolé de type 'faceted' (coloriage uniforme de chaque facette). Il existe en outre :
• le mode 'flat', qui est identique à 'faceted' sauf que le trait de bordure noir des facettes n'est pas affiché
• le mode 'interp', qui réalise un lissage de couleurs par interpolation de Gouraud

handle = light( { 'property', value, ... } )

Activation d'un éclairage :
Active un éclairage de la scène en définissant ses éventuelles propriétés : color (p.ex. 'r' ou [1 0 0]), position (vecteur [x y z]), style ('infinite' qui est le défaut, ou 'local').
On désactive cet éclairage avec lighting('none')

lightangle(az, el)

Activation d'un éclairage en spécifiant son azimut az et son élévation el (selon la même syntaxe que view)

lighting('none' | 'flat|gouraud|phong')

Méthode de rendu relative à l'éclairage :
Désactive l'éclairage (none), ou choix de l'algorithme de lissage des couleurs : pas de lissage avec flat, ou lissage avec gouraud.

camlight(handle, 'right|left|headlight' | az, el)

Définition de la position de l'éclairage :
La position par défaut, qui équivaut à right, correspond à une source de lumière placée à droite de la caméra et légèrement au-dessus de celle-ci. Mais la position de l'éclairage peut être définie précisément par son azimut az et son élévation el (selon la même syntaxe que view).
Si cette fonction est appelée avec 'right|left|headlight' mais sans handle, une source d'éclairage additionnelle est créée.

material('shiny|dull|metal|default' {,[ka kd ks n sc]})

Définit les propriétés de réflectance de la surface de l'objet par rapport à la lumière. Pour les détails, voir help material.

Dans ce exemple interactif, on fait tourner une source lumineuse rasante (10 degrés d'élévation) autour de la scène.

surf(X,Y,Z)
axis([-2 2 -2 2 -10 30])

hlight=light;              % activ. éclairage
lighting('gouraud')        % type de rendu
for az=0:5:360
  camlight(hlight,az,10) % dir. éclairage
  pause(0.05)
end

handle_objet = fonction_graphique(...)

Trace l'objet spécifié par la fonction_graphique, et retourne le handle_objet correspondant.

handle_axes = gca       (get current axis)

Retourne le handle_axes du système d'axes du graphique courant.
Si aucun graphique n'existe, dessine un système d'axes (en ouvrant une fenêtre de figure si aucune figure n'existe).

handle_figure = gcf       (get current figure)

Retourne le handle_figure de la figure courante. Ce handle porte le numéro de la figure !
Si aucune fenêtre de figure n'existe, ouvre une nouvelle figure vierge (exactement comme le ferait la fonction figure).

handle_root = groot

Retourne le handle_root de l'objet graphique racine, c'est à dire l'écran. Ce handle porte le numéro 0 !

a) set(handle)
b) get(handle)
c) handle
d) var = get(handle, 'property')
e) structure = get(handle)

a) Affiche la liste de tous les attributs (propriétés) de l'objet spécifié par handle.
b) Affiche les valeurs courantes de tous les attributs (propriétés) de l'objet spécifié par handle.
c) Depuis MATLAB R2015, cela affiche directement les principaux attributs de l'objet spécifié par handle.
d) Récupère sur var la valeur (value) courante correspondant à l'attribut property spécifié.
e) Récupère sur une structure les valeurs courantes des différents attributs (propriétés) de l'objet spécifié par son handle.

a) set(handle, 'property1', value1, {'property2', value2, ...} )
b) handle.property = value

Modifie des attributs (propriétés) spécifiées de l'objet désigné par son handle.

a) Le nom property des attributs n'est, avec cette notation, pas case-sensitive. Il est toujours spécifié en tant que chaîne de caractères (entre apostrophes).
b) Cette "notation objet" est possible depuis MATLAB R2015. Elle ne permet de changer qu'un attribut par instruction. Attention, dans le nom property est ici case-sensitive !

Les valeurs value des attributs peuvent être de différents types (nombre, chaîne, tableau...), selon le type d'attribut.

x1=[-2 0 3 5]; y1=[2 -1.5 1.5 0];
x2=[-1 2 4];   y2=[1 -0.5 0];

h1=plot(x1,y1);     % ligne, récup. handle
set(h1) % affiche la liste de tous les attributs de la courbe
get(h1) % affiche les valeurs de tous ces attributs
 h1   % affiche attributs principaux

hold('on');
h2=plot(x2,y2,'ob'); % symboles, récup. handle
get(h2) % affiche les attributs du semis points
 h2   % affiche attributs principaux

get(h1,'Parent')  % ou h1.Parent
get(h2,'Parent')  % ou h2.Parent
gca    % on voit que h1 et h2 ont le même 'parent'
        % qui est le système d'axes !
        
get(gca,'Parent')
gcf    % 'parent' du système d'axe => figure !

get(gcf,'Parent') % parent figure => écran !

set(h1,'LineWidth',3,'Color',[0.7 0 0], ...
       'LineStyle','--'); % def. "vraie couleur"
 % ou h1.LineWidth=3
 %    h1.Color=[0.7 0 0]
 %    h1.LineStyle='--'

set(h2,'Marker','*','MarkerSize',10);
 % ou h2.Marker='*'
 %    h2.MarkerSize=10

L'exemple ci-dessous illustre une possibilité d'animation basée sur les handles : on joue ici sur la taille des symboles affichés... mais on pourrait jouer sur les données X/Y

dmax=[90^2 50^2 150^2];   % dim. max étoiles
h=scatter([.2 .3 .7], [.3 .7 .5], dmax, ...
  [1 0 0; 1 1 0; 0 0 1],'p','filled'); % aff. étoiles
axis([0 1 0 1])
get(h)        % affiche les attributs

frames=500;    % nombre d'images de l'animation
duree_max=5;   % durée max. de l'animation [sec]
osc=[8 15 3];  % périodes d'oscillations 3 étoiles

for k=1:frames
  for n=1:3    % numéro de l'étoile
    dims(n)= dmax(n)* (sin(2*pi*k*osc(n)/frames)+1);
  end
  set(h,'sizedata',dims);
  pause(duree_max/frames)  % temporiser animation
end

fonction_graphique (param. habituels... , 'property', value, 'property', value, ...)

Certaines fonctions de dessin (pas toutes !) permettent de spécifier les propriétés graphiques de l'objet directement lors de l'appel à la fonction, à la suite des paramètres habituels.

x1=[-2 0 3 5]; y1=[2 -1.5 1.5 0];
x2=[-1 2 4];   y2=[1 -0.5 0];

plot(x1,y1,'linewidth',3,'color',[0.7 0 0], ...
           'linestyle','--');
hold('on');
plot(x2,y2,'marker','*','markersize',10, ...
           'linestyle','none','color','b');

a) comet( {x,} y {,p} )
b) comet3( {x, y,} z {,p} )

Trace la courbe définie par les vecteurs x, y et z à l'aide d'une comète dont la queue a une taille de p*length(y), p étant un scalaire compris entre 0.0 et 1.0 (valeur par défaut 0.1 s'il n'est pas spécifié).
a) La courbe est tracée dans un graphique 2D. Si x n'est pas spécifié, cette fonction utilise en x les indices du vecteur y (c'est-à-dire les valeurs 1 à length(y) ).
b) La courbe est tracée dans un graphique 3D

nb_points=200; % définir en fct vitesse processeur
nb_tours=10;

angle=linspace(0,nb_tours*2*pi,nb_points);
z=linspace(0,10,nb_points);
x=z.*cos(angle);
y=z.*sin(angle);

comet3(x,y,z,0.1) % affichage progressif courbe !

grid('on')

a) frame = getframe
b) frame = getframe(handle {,rect} )

Capture l'image d'une figure sous forme raster (pixmap) :
a) Récupère l'image de la figure courante
b) Permet de spécifier la figure par son handle, voire une portion de celle-ci définie par un rectangle rect de dimension [gauche bas largeur hauteur] en pixels

L'objet frame résultant est une structure comportant 2 champs :
• frame.cdata : image proprement dite, tableau de dimension HxLx3 d'entiers non signés de type uint8 représentant les composantes RGB des pixels dans la plage 0 à 255
• frame.colormap : table de couleur

a) movie(frames {,N {,fps} } )     Sous Octave, fonction disponible depuis la version 5
b) movie(frames {,[N indices] {,fps} } )

Affiche interactivement sous forme de video les différents les frames préalablement enregistrés dans le tableau frames

a) La vidéo est jouée N fois (par défaut 1 fois si ce paramètres n'est pas spécifié) à une cadence de fps frames par secondes (par défaut 12 si ce paramètres n'est pas spécifié).
Si le paramètre N est négatif, la vidéo est jouée alternativement en marche avant et marche arrière N fois.

b) Lorsqu'en 2e paramètre à la place de N on spécifie un vecteur [N indices], on restreint la vidéo aux frames dont les indices sont spécifiés.

for k=1:50
  fprintf('frame %u...\n', k);  % affichage progression génération frames
  dx=k/25;
  fplot('sin(x)/x', [dx+0 dx+(4*pi)])
  ylim([-0.3 0.5])
  f(k)=getframe;  % récupération k-ème image sur tableau f
end
close

axis('off')
movie(f,-2,50)    % affichage vidéo

Remarque: cette animation a été capturée avec le logiciel libre CamStudio,
puis convertie avi->gif-animé (pour affichage dans navigateur web)

file_id = VideoWriter(file_name,'format') [O: video]

Création d'un objet vidéo :
On ouvre ensuite celui-ci avec open(file_id), on écrit dedans avec writeVideo... (voir ci-après) et on le referme avec close(file_id).
Pour voir les formats possibles, faire VideoWriter.getProfiles
Note: cette fonction apparaît sous Octave depuis la version 2.0 du package [O: video]

file_id = avifile(file_name,'codec','format') [O: video]

Ouverture d'un fichier vidéo :
On écrit ensuite dedans avec addframe... (voir ci-après) et on le referme avec clear file_id.
Pour voir les formats possibles, faire avifile('codecs') [O: video]
ATTENTION: cette fonction disparaît sous Octave depuis la version 2.0 du package [O: video]

writeVideo(file_id, frame) [O: video]

Écriture dans fichier vidéo :
Insertion du frame dans le fichier vidéo file_id
Note: cette fonction apparaît sous Octave depuis la version 2.0 du package [O: video]

addframe(file_id, image) [O: video]

Écriture dans fichier vidéo :
Insertion de l'image dans le fichier vidéo file_id.
Si l'image provient d'un frame capturé avec getframe..., celle-ci se trouve dans le champ frame.cdata
ATTENTION: cette fonction disparaît sous Octave depuis la version 2.0 du package [O: video]

a) frame = im2frame(image {,colormap} )
b) [image {,colormap} ] = frame2im(frame)

Conversion image ↔ frame :
a) Conversion d'une image en un frame, en utilisant la table de couleur courante ou la colormap spécifiée
b) et vice-versa
Voir aussi les fonctions de manipulation de fichiers images imread, imwrite, imformats, imfinfo

file_id = VideoReader(file_name,'param') [O: video]
frame = readFrame(file_id) [O: video]

Ouverture d'un fichier vidéo et extraction de frames
Note: ces fonctions apparaissent sous Octave depuis la version 2.0 du package [O: video]

image = aviread(file_name, frame_no) [O: video]

Extraction de frames dans in fichier vidéo :
Récupère, dans le fichier vidéo file_name, l'image correspondant au frame de numéro frame_no
ATTENTION: cette fonction disparaît sous Octave depuis la version 2.0 du package [O: video]

{struct = } aviinfo(file_name) [O: video]

Attributs d'une vidéo :
Retourne les attributs du fichier vidéo file_name
ATTENTION: cette fonction disparaît sous Octave depuis la version 2.0 du package [O: video]

refreshdata({handle})

Cette fonction évalue les propriétés 'XDataSource', 'YDataSource' et 'ZDataSource' de la figure courante ou de l'objet spécifié par handle, et met à jour la figure si les données correspondantes ont changé

x_max = 10; nb_frames = 100;
x_interv = x_max/nb_frames;

x = 0:x_interv:x_max;
y = sin(x);
plot(x, y, 'YDataSource', 'y');

axis([0 x_max -1 1]);

for k = 1:nb_frames
  pause(0.1)
  y = sin(x + x_interv*k) * (nb_frames-k)/nb_frames ;
  refreshdata();
end

Remarque: cette animation a été capturée avec le logiciel libre CamStudio,
puis convertie avi->gif-animé (pour affichage dans navigateur web)