6. Graphiques, images, animations

6.1 Concepts de base

Les fonctionnalités graphiques sous Octave ont fortement évolué ces dernières années (implémentation des Handle Graphics...) pour rejoindre le niveau de MATLAB. Nous nous basons ici sur les versions suivantes :

L'aide en ligne relative aux fonctions de réalisation de graphiques s'obtient, de façon classique, en frappant help fonction_graphique (Ex: help plot). En outre :

Pour une comparaison des possibilités graphiques entre Octave/FLTK, Octave/Gnuplot et MATLAB, voyez cette intéressante page : http://octave.sourceforge.net/compare_plots/

6.1.1 La notion de "backends graphiques" sous Octave

MATLAB, de par sa nature commerciale monolithique, intègre son propre moteur d'affichage de graphiques.

GNU Octave est conçu, dans la philosophie Unix, de façon plus modulaire en s'appuyant sur des outils externes. En matière de visualisation, on parle de "backends graphiques" :

Ces différentes solutions n'empêchent pas l'utilisateur de recourir à d'autres "backends graphiques" s'il le souhaite. Parmi les autres projets de couplage ("bindings") avec des grapheurs existants, ou de développement de backends graphiques propres à Octave, on peut citer notamment : Quant aux anciens projets suivants, ils sont (ou semblent) arrêtés : JHandles (package Octave-Forge, développement interrompu depuis 2010, voir cette ancienne page), Yapso (Yet Another Plotting System for Octave, 2D et 3D, basé OpenGL), PLplot (2D et 3D), Oplot++ (2D et 3D, seulement sous Linux et macOS), KMatplot (2D et 3D, ancien, nécessitant Qt/KDE), KNewPlot (2D et 3D, ancien, nécessitant Qt et OpenGL), Grace (2D).

6.1.2 Choix du backend graphique sous Octave

Depuis Octave 4.0, que ce soit en mode graphique (GUI) ou commande (CLI), le backend sélectionné par défaut est Qt/OpenGL. C'est aussi celui-ci que nous vous recommandons désormais d'utiliser.
available_graphics_toolkits
Indique quels sont les backends disponibles dans votre distribution d'Octave
backend_courant=graphics_toolkit
Retourne le nom du backend qui est couramment actif
graphics_toolkit('qt' | 'fltk' | 'gnuplot')
Commute sur le backend spécifié
Attention : avant de passer cette commande commencez par fermer, avec close('all'), les fenêtres de graphiques qui auraient été ouvertes avec un autre backend

6.1.3 Fenêtres de graphiques

Les graphiques MATLAB/Octave sont affichés dans des fenêtres de graphiques spécifiques appelées "figures". Celles-ci apparaissent lorsqu'on fait usage des commandes figure ou subplot, ou automatiquement lors de toute commande produisant un tracé (graphique 2D ou 3D).

Dans les chapitres qui suivent on présente l'aspect et les fonctionnalités des fenêtres graphiques correspondant aux différentes backends graphiques. Le code qui a été utilisé pour produire les illustrations est le suivant :

    x=0:0.1:10*pi;
    y1=sin(x); y2=sqrt(x); y3=sin(x).*sqrt(x);
    plot(x,y1,x,y2,x,y3); 
    grid('on');
    axis([0 30 -6 6]);
    set(gca,'Xtick',0:5:30);  set(gca,'Ytick',-5:1:5);  
    title('Fenêtre de graphique MATLAB / FLTK / Gnuplot');
    xlabel('X'); ylabel('Y=fonction(X)');
    legend('sinus(x)','racine(x)','sin(x)*racine(x)');  

Fenêtre graphique MATLAB v7 à R2014

Les caractéristiques principales des fenêtres de graphiques MATLAB sont :
  • Une barre de menus comportant notamment :
    • Edit > Copy Figure : copie de la figure dans le presse-papier (pour la "coller" ensuite dans un autre document) ; voyez Edit > Copy Options qui permet notamment d'indiquer si vous prenez l'image au format vecteur (défaut => bonne qualité, redimensionnable...) ou raster, background coloré ou transparent...
    • Tools > Edit Plot, ou commande plotedit, ou bouton Edit Plot (icône de pointeur) de la barre d'outils : permet de sélectionner les différents objets du graphique (courbes, axes, textes...) et, en double-cliquant dessus ou via les articles du menu Tools, d'éditer leurs propriétés (couleur, épaisseur/type de trait, symbole, graduation/sens des axes...)
    • File > Save as : exportation du graphique sous forme de fichier en différents formats raster (JPEG, TIFF, PNG, BMP...) ou vecteur (EPS...)
    • File > Export Setup, File > Print Preview, File > Print : mise en page, prévisualisation et impression d'un graphique (lorsque vous ne le "collez" pas dans un autre document)
    • Affichage de palettes d'outils supplémentaires avec View > Plot Edit Toolbar et View > Camera Toolbar
    • View > Property Editor, ou dans le menu Edit les articles Figure Properties, Axes Properties, Current Object Properties et Colormap, puis le bouton Inspector (ou la commande propedit) : pour modifier de façon très fine les propriétés d'un graphique (via ses handles...)
    • Ajout/dessin d'objets depuis le menu Insert
    • Un menu Camera apparaît lorsque l'on passe la commande cameramenu

Fenêtre graphique Qt/OpenGL depuis Octave ≥ 4.0

Les caractéristiques principales des fenêtres de graphiques Qt sous Octave sont :
  • Une barre d'outils comportant les boutons suivants (que l'on peut, pour certains, aussi activer via le menu Edit) :
    • Rotate : souris-gauche-glisser-horiz. effectue une rotation 2D, souris-gauche-glisser-vertic. effectue une rotation 3D, souris-milieu fait un autoscale en annulant la rotation 3D dans le cas d'une figure 2D
    • Z+ (Zoom In) : un clic souris-gauche fait un zoom avant 2x, souris-gauche-glisser effectue un rectangle-zoom
    • Z- (Zoom Out) : un clic souris-gauche fait un zoom arrière 2x
    • Z+ ou Z- : souris-roulette effectue un zoom avant/arrière (sans affecter la dimension Z dans les graphiques 3D)
    • Pan : souris-gauche-glisser pour déplacement horiz./vertical, souris-milieu fait un autoscale
    • Insert Text : ouvre une fenêtre de dialogue permettant de placer dans la figure une annotation en définissant police, taille, style et couleur ; comme pour la fonction annotation, la position est définie en unités normalisées par rapport à la fenêtre de figure, c'est-à-dire système de coordonnées dont l'angle inférieur gauche est (0,0) et l'angle supérieur droite (1,1) (et non dans le système d'axes du graphique comme le texte placé avec text) ; l'annotation sera donc fixe par rapport à la fenêtre de figure et ne change pas si l'on fait un pan ou zoom du graphique
    • Select : n'est pas encore opérationnel
    • Axes : affichage/masquage des axes et de la grille (bascule)
    • Grid : affichage/masquage de la grille (bascule, comme grid('on|off'))
    • Autoscale : autoscaling des axes (comme axis('auto'))

  • Une barre de menus comportant :
    • File > Save et Save as : sauvegarder la figure sur un fichier graphique de type (selon l'extension que vous spécifiez):
      • vectorisé: PDF (défaut), SVG
      • raster: PNG, JPG
    • File > Close Figure ou ctrl-W ou case de fermeture X : referme la fenêtre de figure (comme close)
    • Edit > Copy ou ctrl-C : copie la figure dans le "presse-papier" en format raster haute définition (plus élevée que ne le ferait une copie d'écran), pour pouvoir la "coller" ensuite dans un autre document
    • Help : informations sur les versions de QtHandles et Qt

Fenêtre graphique FLTK/OpenGL depuis Octave ≥ 3.4

Les caractéristiques principales des fenêtres de graphiques FLTK sous Octave sont :
  • Une barre d'outils, en bas à gauche, utilisée conjointement avec la souris :
    • bouton P ou touche p (pan) puis :
      souris-gauche-glisser : déplacement X/Y dans graphiques 2D ou 3D
      souris-droite-glisser : effectue un rectangle-zoom
    • bouton R ou touche r (rotate) puis souris-gauche-glisser : effectuer une rotation 3D dans graphiques 2D ou 3D
    • bouton A ou touche a ou souris-gauche-double clic : autoscaling des axes (comme axis('auto'))
    • souris-roulette : effectue un zoom avant/arrière
    • bouton G ou touche g : affichage/masquage de la grille (bascule, comme grid('on|off'))
    • bouton ? : affichage aide sur les raccourcis clavier et l'usage de la souris

  • Une barre de menus comportant :
    • File > Save et Save as : sauvegarder la figure sur un fichier graphique de type (selon l'extension que vous spécifiez):
      • vectorisé: PDF, SVG, PS (PostScript)
      • raster: PNG, JPG
    • File > Close ou case de fermeture X : referme la fenêtre de figure (comme close)
    • Edit : reprend les fonctionnalités P R A G vues plus haut

Fenêtre graphique Gnuplot ≥ 4.6 depuis Octave ≥ 4.0

Les caractéristiques principales des fenêtres de graphiques Gnuplot ≥ 4.6 sous Octave sont :
  • Une barre d'outils comportant :
    • bouton Copy graph to clipboard ou ctrl-C : copie la figure dans le "presse-papier" aux formats raster + vecteur GDI (pour pouvoir la "coller" ensuite dans un autre document)
    • bouton Print graph : imprime la figure (via dialogue d'impression standard)
    • bouton Save graph as EMF ou ctrl-S : sauvegarde la figure sur un fichier graphique raster de type EMF
    • bouton ✄ Grid : affichage/masquage de la grille (bascule, comme grid('on|off'))
    • un(des) bouton(s) ✄ 1 ✄ 2 ✄ 3 ... : affichage/masquage des différentes courbes composant le graphique (bascules)
    • un bouton/menu Options permettant de modifier certaines préférences de Gnuplot et les sauvegarder dans le fichier "wgnuplot.ini"

  • Concernant l'utilisation de la souris (mode que l'on peut désactiver/réactiver en frappant m) :
    • fenêtre 2D ou 3D :
      souris-roulette : déplacement du graphique selon l'axe Y
      souris-maj-roulette : déplacement du graphique selon l'axe X
      souris-ctrl-roulette : faire un zoom avant/arrière en X/Y (axe Z non affecté dans les graphiques 3D)
    • fenêtre 2D seulement :
      souris-droite-glisser souris-droite : effectue un rectangle-zoom
    • fenêtre 3D seulement :
      souris-gauche-glisser : rotation 3D
      souris-milieu-mvmt horizontal : zoom avant/arrière (utiliser ctrl pour graphiques complexes)
      souris-milieu-mvmt vertical : changement échelle en Z (utiliser ctrl pour graphiques complexes)
      souris-maj-milieu-mvmt vertical : changement origine Z (utiliser ctrl pour graphiques complexes)
    • dans l'angle inférieur gauche s'affichent, en temps réel :
      • fenêtre 2D: les coordonnées X/Y précises du curseur, que vous pouvez inscrire dans le graphique en cliquant avec souris-milieu
      • fenêtre 3D: l'orientation de la vue (angle d'élévation par rapport au nadir, et azimut) et les facteurs d'échelle en X/Y et en Z

  • Finalement, s'agissant des raccourcis clavier Gnuplot :
    • g : affichage/masquage de la grille (bascule)
    • b : affichage/masquage de la box du graphique 2D ou 3D (bascule)
    • a : autoscaling des axes (comme axis('auto'))
    • p et n : facteur de zoom précédent, respectivement suivant (next)
    • u : dé-zoomer (unzoom)
    • q : fermeture de la fenêtre graphique (quit)
Pour mémoire, suivre ce lien pour accéder aux informations relatives aux anciennes versions de : • Gnuplot 3.x à 4.0 embarqué dans Octave-Forge 2.x Windows, • Gnuplot 4.2.2/4.3 embarqué dans Octave 3.0.1/3.0.3 MSVC

6.1.4 Axes, échelle, zoom/pan/rotation, quadrillage, légende, titre, annotations

Les fonctions décrites dans ce chapitre doivent être utilisées après qu'une fonction de dessin de graphique ait été passée (et non avant). Elles agissent immédiatement sur le graphique courant.

Fonction et description
Exemple Illustration
Lorsque l'on trace un graphique, MATLAB/Octave détermine automatiquement les limites inférieures et supérieurs des axes X, Y {et Z} sur la base des valeurs qui sont graphées, de façon que le tracé occupe toute la fenêtre graphique (en hauteur et largeur). Les rapports d'échelle des axes sont donc différents les uns des autres. Les commandes axis et xlim/ylim/zlim permettent de modifier ces réglages.
a) axis([Xmin Xmax Ymin Ymax { Zmin Zmax }])
b) axis('auto')
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 ; sous MATLAB il est possible de définir les valeurs -inf et inf pour faire déterminer les valeurs min et max (équivalent de auto)
b) se remet en mode "autoscaling", c-à-d. définit dynamiquement les limites inférieures/supérieurs des axes X, Y {et Z} pour faire apparaître l'intégralité des données ; sous MATLAB 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
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 !)
Ex 1

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]
Ex 2a

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
Cliquer sur ce graphique pour voir l'animation !

Remarque: cette animation a été capturée avec le logiciel libre recordMyDesktop, puis convertie en gif-animé (pour affichage dans navigateur web) avec l'outil libre ffmpeg
Ex 2b

peaks(-3:0.2:3, -4:0.2:4)
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
Cliquer sur ce graphique pour voir l'animation !

Remarque: cette animation a été capturée avec le logiciel libre recordMyDesktop, puis convertie en gif-animé (pour affichage dans navigateur web) avec l'outil libre ffmpeg
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) set(gca,'Xtick | Ytick | Ztick', [valeurs] )
b) set(gca,'XTickLabel | YTickLabel | ZTickLabel', labels)
Graduation des axes et lignes de grille :
Commandes basées sur la technique des "Handle Graphics". On utilise ici la fonction gca (get current axes) qui retourne le "handle" du graphique courant
a) Spécifie les valeurs (suite de valeurs en ordre coissant), sur l'axe indiqué, auxquelles il faut : dessiner un 'tick' sur l'axe, afficher la valeur, et faire partir une ligne de grille
b) Spécifie le texte à afficher (label) en regard de chaque tick. Le paramètre labels peut être un vecteur de nombres, une matrice de chaînes , un tableau cellulaire de chaînes. Commande particulièrement utile si l'on veut graduer l'axe avec des chaînes (p.ex. des dates formatées...). Important : le nombre de valeurs et de labels doit être identique !

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

Ex 3

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');   % => premier graphique ci-contre

xlabel('dates');

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) grid('on | off')     ou     grid on | off
b) grid
a) Activation/désactivation de l'affichage du quadrillage (grid). Par défaut le quadrillage d'un nouveau graphique n'est pas affiché.
b) Sans paramètre, 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' {,'propriété','valeur'...} )
   ylabel('label_y' {,'propriété','valeur'...} )
   zlabel('label_z' {,'propriété','valeur'...} )
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 "Handle Graphics" (couples propriété et valeur), 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' {,'propriété','valeur'...} )
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 "Handle Graphics" (couples propriété et valeur), permettent de spécifier la police, taille, couleur...

Ex: voir l'exemple 3 ci-dessous

a) text(x, y, { z,} 'chaîne' {,'propriété','valeur'...} )
b) gtext('chaîne' {,'propriété','valeur'...} )
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 "Handle Graphics" (couples propriété et valeur), 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 !

Ex 4

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) annotation('line', x, y)
b) annotation('arrow', x, y)
c) annotation('doublearrow', x, y)
d) annotation('textarrow', x, y)
e) annotation('textbox', pos)
f) annotation('rectangle', pos)
g) annotation('ellipse', pos)
Place dans la figure une annotation. ATTENTION: notez que la position (x, y, pos) est définie en unités normalisées par rapport à la fenêtre de figure, c'est-à-dire dans un système de coordonnées dont l'angle inférieur gauche est (0,0) et l'angle supérieur droite (1,1). (Donc pas dans le système d'axes du graphique comme le texte placé avec text). L'annotation sera donc fixe par rapport à la fenêtre de figure et ne bouge pas si l'on fait un pan/zoom/rotation du graphique.
a) Place un texte
b) Place une flèche
c) Place une double flèche
d) Place un texte associé à une flèche
e) Place un texte dans une boîte
f) Place un rectangle
g) Place une ellipse
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

Afficher du texte mis en forme (indices, exposants, caractères spéciaux...)

texlabel('expression')
Sous MATLAB, convertit au format TeX l'expression spécifiée. Cette fonction est généralement utilisée comme argument dans les commandes title, xlabel, ylabel, zlabel, et text pour afficher du texte incorporant des indices, exposants, caractères grecs...

Ex: text(15,0.8,texlabel('alpha*sin(sqrt(x^2 + y^2))/sqrt(x^2 + y^2)')); affiche:

Sous Octave, un interpréteur TeX est implémenté dans les backends graphiques Qt et FLTK. Toute fonction affichant du texte peut faire usage des codes de formatage suivants :
{ } : permet de grouper des caractères pour leur appliquer un code de formatage
\bf : ce qui suit sera en gras
\it : ce qui suit sera en italique
\rm : retour à fonte normale (annulation du gras ou de l'italique)
^ : le caractère suivant (ou groupe) est mis en exposant
_ : le caractère suivant (ou groupe) est mis en indice
\car : permet d'afficher un caractère grec défini par son nom car
\fontname{fonte} : utilise la fonte spécifiée pour le texte qui suit
\fontsize{taille} : affiche le texte qui suit dans la taille spécifiée
\color[rgb]{red green blue} : affiche le texte qui suit dans la couleur spécifiée par le triplet {red green blue}

Notez cependant que ces fonctionnalités ne sont pour l'instant supportées qu'à l'affichage et non à l'impression ou sauvegarde d'un fichier graphique !

Ex: title('normal \bfGRAS\rm {\ititalique} \fontsize{18} \color[rgb]{1 0 0}H_2O \color[rgb]{0 0.5 0}y=x^2 \color[rgb]{0 0 1}e^{i*\pi}') affiche :


6.1.5 Graphiques superposés, côte-à-côte, ou fenêtres graphiques multiples

Par défaut, MATLAB/Octave envoie tous les ordres graphiques à la même fenêtre graphique (appelée "figure"), et chaque fois que l'on dessine un nouveau graphique celui-ci écrase le graphique précédent. Si l'on désire tracer plusieurs graphiques, MATLAB/Octave offrent les possibilités suivantes :

  1. Superposition de plusieurs tracés de type analogue dans le même graphique en utilisant le même système d'axes (overlay plots)
  2. Tracer les différents graphiques côte-à-côte, dans la même fenêtre mais dans des axes distincts (multiple plots)
  3. Utiliser des fenêtres distinctes pour chacun des graphiques (multiple windows)

A) Superposition de graphiques dans le même système d'axes ("overlay plots")

Fonction et description
Exemple Illustration
a) hold('on')     ou     hold on
b) hold('off')     ou     hold off
a) Cette commande indique à MATLAB/Octave d'accumuler (superposer) les ordres de dessin qui suivent dans la même figure (pour empêcher qu'un nouveau tracé efface le précédent). Elle peut être passée avant tout tracé ou après le premier ordre de dessin. Dans les modes "multiple plots" ou "multiple windows" (voir plus bas), l'état on/off de hold est mémorisé indépendemment pour chaque sous-graphique, resp. chaque fenêtre de figure
b) Après cette commande, MATLAB/Octave est remis dans le mode par défaut, c'est-à-dire que tout nouveau 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, permettent de dessiner 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.
Ex

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');
Vous constaterez que :
• on superpose des graphiques de types différents (plot, fplot, stairs...)
• ces graphiques ont, en X, des plages et des nombres de valeurs différentes


B) Graphiques côte-à-côte dans la même fenêtre ("multiple plots")

Fonction et description
Exemple Illustration
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 !
Ex

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, propriété1, propriété2 ...)
De façon analogue, lie les propriétés spécifiées entre les différents graphiques
Ex
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 
puis jouez avec le pan et zoom de l'un des 2 graphiques...


C) Graphiques multiples dans des fenêtres distinctes ("multiple windows")

Fonction et description
a) figure
b) figure(numero)
a) Ouvre une nouvelle fenêtre de graphique (figure), et en fait la fenêtre de tracé active (dans laquelle on peut ensuite faire du "single plot" ou du "multiple plots"). Ces fenêtres sont automatiquement numérotées 1, 2, 3...
b) Si la fenêtre de numero spécifié existe, en fait la fenêtre de tracé active. Si elle n'existe pas, 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, dans ce cas là, au handle de la figure)


6.1.6 Autres commandes de manipulation de fenêtres graphiques ("figures")

Fonction et description
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.
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 !
Met hold à off s'il n'y a plus de fenêtre graphique
shg (show graphic)
Fait passer la fenêtre de figure MATLAB courante au premier plan.
Cette commande est sans effet avec Octave sous Windows.


6.1.7 Traits, symboles et couleurs de base par 'linespec'

Plusieurs types de graphiques présentés plus bas utilisent une syntaxe, initialement définie par MATLAB et maintenant aussi reprise par Octave 3, pour spécifier le type, la couleur et l'épaisseur ou dimension de trait et de symbole. Il s'agit du paramètre linespec qui est une combinaison des caractères définis dans le tableau ci-dessous (voir help linespec).

Le symbole indique que la spécification n'est valable que pour MATLAB, le symbole indique qu'elle n'est valable que pour Octave/Qt, le symbole indique qu'elle n'est valable que pour Octave/FLTK, le symbole indique qu'elle n'est valable que pour Octave/Gnuplot . Sinon c'est valable pour tous les grapheurs/backends !

Il est possible d'utiliser la fonction [L,C,M,err]=colstyle('linespec') pour tester un linespec et le décoder sur 3 variables séparées L (type de ligne), C (couleur) et M (marker). Si linespec est erroné, une erreur err est retournée.

Pour un rappel sur l'ancienne façon de spécifier les propriétés de lignes sous Octave 2.x, suivre ce lien.

Couleur ligne et/ou symbole
Caractère Effet
y jaune (yellow)
m magenta
c cyan
r rouge (red)
g vert clair (green)
b bleu (blue)
w blanc (white)
k noir (black)
Type de ligne
Caractère Effet
(rien) affichage d'une ligne continue,
sauf si un symbole est spécifié (auquel cas le symbole est affiché et pas la ligne)
- ligne continue
-- ligne traitillée
: ligne pointillée
-. ligne trait-point
Symbole (marker)
Caractère Effet
(rien) pas de symbole
o cercle
* étoile de type astérisque
+ signe plus
x croix oblique (signe fois)
. (point) petit disque rempli
symbole point
^ < > v
< v
> ^
triangle (orienté selon symbole)
triangle pointé vers le bas vide/rempli
triangle pointé vers le haut vide/rempli
s carré vide (square) ( rempli)
d losange vide (diamond) ( rempli)
p étoile à 5 branches (pentagram)
carré vide
h étoile à 6 branches (hexagram)
losange vide

Ci-dessous, exemples d'utilisation de ces spécifications linespec.

Exemple Illustration
Ex 1 sous MATLAB, Octave/Qt et Octave/FLTK
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');
Ex 2 sous Octave/Gnuplot
% même code que ci-dessus


On verra plus loin (chapitre 3D "Vraies couleurs, tables de couleurs et couleurs indexées") qu'il est possible d'utiliser beaucoup plus de couleurs en spécifiant des "vraies couleurs" sous forme de triplets RGB (valeurs d'intensités [red green blue] de 0.0 à 1.0), ou en travaillant en mode "couleurs indexées" via une "table de couleurs" (colormap). Les couleurs ainsi spécifiées peuvent être utilisées avec la propriété 'color' de la commande set (voir chapitre qui suit), commande qui permet de définir également plus librement l'épaisseur et le type de trait, ainsi que le type de symbole et sa dimension.

Pour définir de façon plus fine les types de traits, symboles et couleurs, on utilisera la techique des "handles" décrite ci-après dans le chapitre "Handle Graphics".

6.1.8 Interaction souris avec une fenêtre graphique

Il est possible d'interagir entre MATLAB/Octave et un graphique à l'aide de la souris.

On a déjà vu plus haut la fonction gtext('chaîne') qui permet de placer interactivement (à l'aide de la souris) une chaîne de caractère dans un graphique.

[x, y {,bouton}] = ginput(n)
Attend que l'on clique n fois dans le graphique à l'aide de souris-gauche, et retourne les vecteurs-colonne des coordonnées x et y des endroits où l'on a cliqué, et facultativement le numéro de bouton de la souris qui a été actionné (1 pour souris-gauche, 2 pour souris-milieu, 3 pour souris-droite).
Si l'on omet le paramètre n, cette fonction attend jusqu'à ce que l'on frappe enter dans la figure.

6.2 Graphiques 2D

Sous MATLAB, la liste des fonctions relatives aux graphiques 2D est accessible via help graph2d et help specgraph. Concernant Octave/Gnuplot, on se réfèrera au chapitre "Plotting" du Manuel Octave (HTML ou PDF).

6.2.1 Dessin de graphiques 2D

Fonction et description
Exemple Illustration
a) plot(x1, y1 {,linespec} {, x2, y2 {,linespec} ...} )
    plot(x1, y1 {,'PropertyName',PropertyValue} ... )
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 : 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
• pour tracer des courbes 2D/3D dans un fichier au format AutoCAD DXF : fonction dxfwrite du package "plot" (qui ne semble cependant plus maintenu)

Ex 1 selon forme a) ci-dessus
plot([3 5 6 10], [9 7 NaN 6], ...
      [4 8], [7 8], 'g*')
Remarque importante : lorsque l'on a des valeurs manquantes, on utilise NaN
Ex 2 selon forme b) ci-dessus
plot([9 ; 7 ; 8 ; 6]);
Ex 3 selon forme c) ci-dessus
plot([6 2 5 ; 8 3 4 ; 4 5 6]);
Ex 4.1 selon forme d)1 ci-dessus
plot([3 5 9], [6 8 4 ; 2 3 5]);
Ex 4.2 selon forme d)2 ci-dessus
plot([3 5], [6 8 4 ; 2 3 5]);
a) { [x, y] } = fplot('fonction', [xmin xmax] {, tol | nb_pts } {, linespec } ) (function plot)
b) { [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 2 méthodes de définition de fonction suivantes :

  • 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

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

Voir encore la fonction ezplot (easy plot) qui permet de dessiner une fonction 2D définie sous sa forme paramétrique. A titre d'exemple, voyez la fonction ezplot3 plus bas.

Ex 1
fplot('sin(x)*sqrt(x)', [0 20],'r');
hold('on');
fplot('2*log(x)-4',[1 18],'g');
grid('on');
ou
fplot('[sin(x)*sqrt(x),2*log(x)-4]', ...
     [0 20],'b');
grid('on');
ylim([-5 5])
Important : Notez qu'il est ici suffisant de faire le produit sin(x)*sqrt(x), donc avec l'opérateur * sans devoir utiliser le produit élément par élément .*. En effet, l'expression que l'on passe ainsi à fplot sera évaluée de façon interne point après point pour différentes valeurs de x, et non pas appliquée à un vecteur x.
Remarque : constatez, dans la 1ère solution, que l'on a superposé les graphiques des 2 fonctions dans des plages de valeurs en X qui sont différentes !
Ex 2

Grapher des fonctions built-in MATLAB/Octave :

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

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

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

Ex
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');
plotyy(x1, y1, x2, y2 {,'type1' {,'type2'}} )
Graphique avec 2 axes Y distincts :
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 être : plot, semilogx, semilogy, loglog, stem...
Ex
x=0:0.1:4*pi;
h=plotyy(x, sin(2*x), x, exp(x), ...
         'plot', 'semilogy');
xlabel('axe X');

hy1=get(h(1),'ylabel');
hy2=get(h(2),'ylabel');
set(hy1,'string','fonction 1');
set(hy2,'string','fonction 2');
Remarque : nous devons ici utiliser la technique des 'handles' (ici variables h, hy1 et hy2) pour étiqueter les 2 axes Y
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);

Ex
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) ).
Ex
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
Ex
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
Ex
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

Ex 1
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');
Remarque : on illustre ci-dessus la différence entre la fonction sinus et son approximation par un polynôme
Ex 2 (graphique ci-contre réalisé avec Octave)
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 :
    surface du "carré englobant" du symbole en [pixels^2] : ex: 100 => symbole de surface 100 pixels^2 donc de coté 10 x 10 [pixels]
    largeur et hauteur du "carré englobant" du symbole en [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

Ex: (graphique ci-contre réalisé avec MATLAB ou Octave/FLTK)
if ~ exist('OCTAVE_VERSION')
  facteur=50*50 ; % MATLAB
else
  facteur=50 ;    % Octave
end

scatter(rand(30,1),rand(30,1), ...
        facteur*rand(30,1),rand(30,1),'p','filled');
Remarque : nous graphons donc ici 30 paires de nombres x/y aléatoires compris entre 0 et 1 ; de même, nous définissons la couleur et la taille des symboles de façon aléatoire
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.
Remarque : si on ne veut pas "empiler" les surfaces, on utilisera plutôt la fonction fill

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

Ex
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] )

Ex
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')

Ex
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)
Ex
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);

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

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]);
Second graphique ci-contre :
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).
Remarque : il existe sous Octave une variante de cette fonction nommée hist2d (dans le package "plot", qui ne semble cependant plus maintenu)

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

Ex
y=[4 8 5 2 6 8 0 6 13 14 10 7 4 3 12 13 6 3 5 1];
1) Si l'on ne spécifie pas n => n=10 catégories, et comme les valeur y vont de 0 à 14, les catégories auront une largeur de (14-0)/10 = 1.4, et leurs 'centres' xout seront respectivement : 0.7, 2.1, 3.5, 4.9, etc... jusqu'à 13.3
[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
2) Spécifions n=7 catégories => elles auront une largeur de (14-0)/7 = 2, et leurs 'centres' xout seront respectivement : 1, 3, 5, 7, 9, 11 et 13
[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
set(gca,'XTick',xout) % annote axe X sous barres
3) Spécifions un vecteur centres=[3 5 11 13] définissant les centres de 4 boîtes
[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]);
set(gca,'XTick',centres) % annote axe X sous barres



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

1) La fonction ci-dessous produit le premier graphique ci-contre

plotmatrix([1 12 25; 2 15 19; 4 16 18], ...
           [101 204; 108 210; 104 208], 'ro')
2) La fonction ci-dessous produit le second graphique ci-contre
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

Ex
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.
Voir aussi la fonction ezpolar qui permet de tracer, dans un système polaire, une fonction définie par une expression.
Voir en outre les fonctions cart2pol et pol2cart de conversion de coordonnées carthésiennes en coordonnées polaires et vice-versa.

Ex 1
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');
Ex 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.
Ex
rose(2*pi*rand(1,1000),16);
Explications : on établit ici un vecteur de 1000 nombres aléatoires compris entre 0 et 2*pi, puis on calcule et dessine leur répartition en 16 catégories (1ère catégorie pour les valeurs allant de 0 à 2*pi/16, etc...).

6.3 Graphiques 2D½ et 3D

MATLAB/Octave offre un grand nombre de fonctions de visualisation permettant de représenter des données 3D sous forme de graphiques 2D½ (vue plane avec représentation de la 3e dimension sous forme de courbes de niveau, champ de vecteurs, dégradés de couleurs...) ou de graphiques 3D (vue perspective). Ces données 3D peuvent être des points/symboles, des vecteurs, des lignes, des surfaces (par exemple fonction z = fct(x,y) ) et des tranches de volumes (dans le cas de jeux de données 4D).

S'agissant des représentations perspectives 3D, et comme dans tout logiciel de CAO/modélisation 3D, différents types de "rendu" des surfaces sont possibles : "fil de fer" (mesh, wireframe), coloriées, ombrées (shaded surface). L'écran d'affichage ou la feuille de papier étant 2D, la vue finale d'un graphique 3D est obtenue par projection 3D->2D au travers d'une "caméra" dont l'utilisateur définit l'orientation et la focale, ce qui donne un effet de perspective.

La liste des fonctions relatives aux graphiques 3D est accessible sous MATLAB via help graph3d ainsi que help specgraph. Concernant GNU Octave, on se réfèrera au chapitre "Plotting" du Manuel Octave (HTML ou PDF), et à l'aide en-ligne pour les fonctions additionnelles apportées par Octave-Forge.

6.3.1 Fonctions auxiliaires de préparation/manipulation de données 3D

La fonction "meshgrid" de préparation de grilles de valeurs Xm et Ym

La fonction meshgrid est très souvent utilisée lorsqu'il s'agit de calculer le maillage d'une surface 3D. Pour démontrer son utilité et fonctionnement, prenons un exemple concret.

Donnée du problème :

Détermination et visualisation, par un graphique 3D, de la surface   z = fct(x,y) = sin(x/3)*cos(y/3)   en "échantillonnant" cette fonction selon une grille X/Y de dimension de maille 1.0 en X et 0.5 en Y, dans les plages de valeurs 0 ≤ x ≤ 10 (=> 11 valeurs) et 2 ≤ y ≤ 5 (=> 7 valeurs). Pour représenter graphiquement cette surface, il s'agit au préalable de calculer une matrice z dont les éléments sont les "altitudes" z correspondant aux points de la grille définie par les vecteurs x et y. Cette matrice aura donc (dans le cas du présent exemple) la dimension 7 x 11 (respectivement length(y) lignes, et length(x) colonnes).


    x  0 1 2 3 4 5 6 7 8 9 10
y     ------------------------
2    |                        |
2.5  |                        |
3    |       matrice  z       |
3.5  |        (7 x 11)        |
4    |                        |
4.5  |                        |
5    |                        |
      ------------------------


Solution 1 : méthode classique ne faisant pas intervenir les capacités vectorisées de MATLAB/Octave :

Cette solution s'appuie sur 2 boucles for imbriquées utilisées pour parcourir tous les points de la grille et de calculer individuellement chacun des éléments de la matrice z. C'est la technique classique utilisée dans les langages de programmation "non vectorisés", et son implémentation MATLAB/Octave correspond au code suivant :

x=0:1:10;  y=2:0.5:5;  % domaine des valeurs de la grille en X et Y

for k=1:length(x)      % parcours de la grille, colonne après colonne
  for l=1:length(y)    % parcours de la grille, ligne après ligne
    z1(l,k)= sin(x(k)/3)*cos(y(l)/3); % calcul de la matrice z, élément après élément
  end
end

surf(x,y,z1);          % visualisation de la surface

Solution 2 : solution MATLAB/Octave vectorisée faisant intervenir la fonction meshgrid :

x=0:1:10;  y=2:0.5:5;     % domaine des valeurs de la grille en X et Y

[Xm,Ym]=meshgrid(x,y);
z2=sin(Xm/3).*cos(Ym/3); % calcul de la matrice z en une seule instruction vectorisée
     % notez bien que l'on fait produit .* (élém. par élém.) et non pas * (vectoriel)
surf(x,y,z2);             % visualisation de la surface
Remarque: dans le cas tout à fait particulier de cette fonction, on aurait aussi pu faire tout simplement z=cos(y'/3)*sin(x/3) (en transposant y et en utilisant le produit vectoriel). Nous vous laissons réfléchir pourquoi cela fonctionne ;-)

Explications relatives au code de la solution 2 :

 x=[ 0  1  2  3  4  5  6  7  8  9  10] (11 él.)
    -------------(7x11)---------------
   | 0  1  2  3  4  5  6  7  8  9  10 |
   | 0  1  2  3  4  5  6  7  8  9  10 |
   | 0  1  2  3  4  5  6  7  8  9  10 |
Xm=| 0  1  2  3  4  5  6  7  8  9  10 |
   | 0  1  2  3  4  5  6  7  8  9  10 |
   | 0  1  2  3  4  5  6  7  8  9  10 |
   | 0  1  2  3  4  5  6  7  8  9  10 |
    ----------------------------------

                                                              (7 él.) 
    ------------------------(7x11)-------------------------
   | 2    2    2    2    2    2    2    2    2    2    2   |    |  2|
   | 2.5  2.5  2.5  2.5  2.5  2.5  2.5  2.5  2.5  2.5  2.5 |    |2.5|
   | 3    3    3    3    3    3    3    3    3    3    3   |    |  3|
Ym=| 3.5  3.5  3.5  3.5  3.5  3.5  3.5  3.5  3.5  3.5  3.5 |  y=|3.5|
   | 4    4    4    4    4    4    4    4    4    4    4   |    |  4|
   | 4.5  4.5  4.5  4.5  4.5  4.5  4.5  4.5  4.5  4.5  4.5 |    |4.5|
   | 5    5    5    5    5    5    5    5    5    5    5   |    |  5|
    -------------------------------------------------------

Description générale de la fonction meshgrid :

a) [Xm,Ym] = meshgrid(x {,y} )
b) [Xm,Ym,Zm] = meshgrid(x, y, z)
a) A partir des vecteurs x et y (de type ligne ou colonne) définissant le domaine de valeurs d'une grille en X et Y, génération des matrices Xm et Ym (de dimension length(y) lignes * length(x) colonnes) qui permettront d'évaluer une fonction z=fct(x,y) (matrice) par une simple instruction vectorisée (i.e. sans devoir implémenter des boucles for) comme illustré dans la solution 2 de l'exemple ci-dessus. Il est important de noter que la grille peut avoir un nombre de points différent en X et Y et que les valeurs définies par les vecteurs x et y ne doivent pas nécessairement être espacées linéairement, ce qui permet donc de définir un maillage absolument quelconque.
Si le paramètre y est omis, cela est équivalent meshgrid(x,x) qui défini un maillage avec la même plage de valeurs en X et Y
La fonction meshgrid remplace la fonction meshdom qui est obsolète.
b) Sous cette forme, la fonction génère les tableaux tri-dimensionnels Xm,Ym et Zm qui sont nécessaires pour évaluer une fonction v=fct(x,y,z) et générer des graphiques 3D volumétriques (par exemple avec slice : voir exemple au chapitre "Graphiques 3D volumétriques").
ndgrid(...)
C'est l'extension à n-dimension de la fonction meshgrid

La fonction "griddata" d'interpolation de grille à partir d'un semis irrégulier

Sous MATLAB/Octave, les fonctions classiques de visualisation de données 3D nécessitent qu'on leur fournisse une matrice de valeurs Z (à l'exception, en particulier, de fill3, tricontour, trimesh, trisurf). Or il arrive souvent, dans la pratique, que l'on dispose d'un semis de points (x,y,z) irrégulier (c-à-d. dont les coordonnées X et Y ne correspondent pas à une grille, ou que celle-ci n'est pas parallèle au système d'axes X/Y) provenant par exemple de mesures, et que l'on souhaite interpoler une surface passant par ces points et la grapher. Il est alors nécessaire de déterminer au préalable une grille X/Y régulière, puis d'interpoler les valeurs Z sur les points de cette grille à l'aide de la fonction d'interpolation 2D griddata.
[XI,YI,ZI] = griddata(x,y,z, xi,yi {,methode} )
Sur la base d'un semis de points irrégulier défini par les vecteurs x, y, z, interpole la surface XI,YI,ZI aux points de la grille spécifiée par le domaine de valeurs xi et yi (vecteurs). On a le choix entre 3 methodes d'interpolation différentes :
'linear' : interpolation linéaire basée triangle (méthode par défaut), disontinuités de 0ème et 1ère dérivée
'nearest' : interpolation basée sur le voisin le plus proche, disontinuités de 0ème et 1ère dérivée
'cubic' : interpolation cubique basée triangle, surface lissée
Illustration par un exemple :

Plutôt que d'entrer manuellement les coordonnées x/y/z d'une série de points irrégulièrement distribués, nous allons générer un semis de point x/y irrégulier, puis calculer la valeur z en chacun de ces points en utilisant une fonction z=fct(x,y) donnée, en l'occurence z= x * exp(-x^2 -y^2). Nous visualiserons alors ce semis de points, puis effecuerons une triangulation de Delaunay pour afficher cette surface sous forme brute par des triangles. Puis nous utiliserons griddata pour interpoler une grille régulière dans ce semis de points, et nous visualiserons la surface correspondante.

Solution :

1) Génération aléatoire d'un semis de points X/Y irrégulier :

x= 4*rand(1,50) -2;  % vecteur de 50 val. entre -2 et +2
y= 4*rand(1,50) -2;  % vecteur de 50 val. entre -2 et +2

plot(x,y,'o');
grid('on');
axis([-2 2 -2 2]);

2) Calcul de la valeur Z (selon la fonction donnée) en chacun des points de ce semis :

z= x.*exp(-x.^2 - y.^2);  % calcul de Z en ces points

stem3(x,y,z,'-*');
grid('on');

3) Triangulation de Delaunay pour afficher la surface brute :

tri_indices= delaunay(x, y);    % formation triangles
                                % => matrice d'indices
trisurf(tri_indices, x, y, z);  % affichage triangles
set(gca,'xtick',[-2 -1 0 1 2]);
set(gca,'ytick',[-2 -1 0 1 2]);
set(gca,'ztick',[-0.5 -0.25 0 0.25 0.5]);
Sous Octave seulement, on aurait aussi pu dessiner dans un graphique 2D les courbes de niveau avec cette fonction du package "plot" (qui n'est cependant plus maintenu) :
 tricontour(tri_indices, x, y, z, [-0.5:0.1:0.5], 'r-o')

4) Définition d'une grille régulière X/Y, et interpolation de la surface en ces points :

xi= -2:0.2:2;
yi= xi';   % ce doit être un vecteur colonne !!!
[XI,YI,ZI]= griddata(x,y,z,xi,yi,'linear');
                 % interpolation sur grille
surfc(XI,YI,ZI); % affich. surf. interpolée et contours

% pour superposer sur ce graphique le semis de point :
hold('on');
plot3(x,y,z,'.');

La fonction "interp2" d'interpolation de points à partir d'une grille régulière

La fonction interp2 travaille de façon inverse par rapport à griddata, en ce sens qu'elle interpole un semis de points irrégulier à partir d'une grille régulière.
zi = interp2(X,Y,Z, xi,yi {,methode} )
En s'appuyant sur la grille régulière définies par les matrices X, Y et Z (X et Y devant être passées au format produit par meshgrid), cette fonction interpole les valeurs zi correspondant au semis irrégulier de points de coordonnées xi, yi.
Voir aussi la fonction d'interpolation 3D interp3 et la fonction d'interpolation multidimensionnelle interpn
Illustration par un exemple :

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

subplot(3,1,1)    % ****** 1er graphique ******
surf(X,Y,Z)
xlabel('X'); ylabel('Y'); zlabel('fct(X,Y)')
view(-10,20)

subplot(3,1,2)    % ****** 2ème graphique ******
contour(X,Y,Z,[-10:1:30]);
grid('on')
xlabel('X'); ylabel('Y')

xo =-2; yo =-2;   % (x,y) origine du  profil
xd = 2; yd = 2;   % (x,y) destination profil
nbpoints = 40;    % nombre points du profil
xprofil = linspace(xo, xd, nbpoints)
yprofil = linspace(yo, yd, nbpoints)

hold('on')
plot(xprofil, yprofil, 'b.-')  % trace du profil

zprofil = interp2(X,Y,Z, xprofil, yprofil, 'linear')

subplot(3,1,3)    % ****** 3ème graphique ******
sprofil = sqrt( (xprofil-xo).^2 + (yprofil-yo).^2 )
            % abscisse curviligne le long du profil
plot(sprofil, zprofil, 'b.-')  % profil vertical
grid('on')
xlabel('Abscisse curviligne'); ylabel('fct(X,Y)')

6.3.2 Graphiques 2D½

On appelle les types de graphiques présentés ici des graphiques 2D½ ("2D et demi") car, représentant des données 3D sur un graphique à 2 axes (2D), ils sont à mi-chemin entre le 2D et le 3D.

Dans la "galerie" de présentation des fonctions graphiques de ce chapitre, nous visualiserons toujours la même fonction 2D z=fct(x,y) dont les matrices X, Y et Z sont produites par le code MATLAB/Octave ci-dessous :
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);
Figure ci-contre ensuite produite avec : surf(X,Y,Z)

MATLAB et Octave 3

Fonction et description
Exemple Illustration
{ [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.0 n'oriente pas encore les labels selon les courbes
Ex
[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')
On pourrait formater les labels des courbes de niveau avec :
(faire disp(get(h_cl(1))) pour comprendre structure/champs)
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).

Ex
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).
Ex 1
surface(X,Y,Z) % ou:  pcolor(X,Y,Z)
colorbar

shading('flat') % ferait disparaître le
                % bord noir des facettes
Ex 2
pcolor(X,Y,Z)   % ou:  surface(X,Y,Z)
shading('interp') % interpolation de couleur
colormap(hot)     % changement table couleurs
colorbar
Ex 3

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.
Ex
[dx,dy]=gradient(Z,0.25,0.25);
     % calcul champ vecteurs
quiver(X,Y,dx,dy,1.5)
     % affichage champ vecteurs

6.3.3 Graphiques 3D

Nous décrivons ci-dessous les fonctions MATLAB/Octave les plus importantes permettant de représenter en 3D des points, lignes, barres et surfaces.

Fonction et description
Exemple Illustration
plot3(x1,y1,z1 {,linespec} {, x2,y2,z2 {,linespec} ...} )
plot3(x1,y1,z1 {,'PropertyName',PropertyValue} ... )
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').

Voir en outre (plus bas dans ce support de cours) :
• pour tracer des courbes 2D/3D dans un fichier au format AutoCAD DXF : fonction dxfwrite du package "plot" (qui ne semble cependant plus maintenu)

Ex
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.
Ex Le code ci-dessous réalise la même courbe rouge que celle de l'exemple plot3 précédent :
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 !
Ex
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.
Ex

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) % => 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.
Ex
h=waterfall(X,Y,Z);
  % on récupère le handle du graphique pour
  % changer ci-dessous épaisseur des lignes
    
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

Ex
[C,h]=contour3(x(1:10),y(1:10), ...
             Z(1:10,1:10),[0:2.5:30]);
colormap('default')
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.

Sous Octave 3.4 à 4.0 :
- x doit être une matrice de même dimension que Y (donc ne peut pas être un vecteur)
- width ne peut pas être spécifier si l'on omet x

Ex

Graphique ci-contre réalisé avec MATLAB :

ribbon(x(1:10),Z(1:10,1:10),0.7)
axis([1 10 -2 0 0 30])
Sous Octave, vous pouvez essayer :
ribbon(Z(1:10,1:10))
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
Ex Le code ci-dessous réalise la même surface que celle de l'exemple mesh précédent :
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} {,'PropertyName', PropertyValue...} )
b) surfc({X,Y,} Z {,COUL} {,'PropertyName', PropertyValue...} ) (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.

Ex
surfc(X,Y,Z) % shading 'faceted' par défaut

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.
Ex
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'

Ces 2 fonctions, qui existaient sous Octave 3.0.1/JHandles, ont disparu sous Octave 3.2 à 4.0 !?

Ex (graphique ci-contre réalisé avec MATLAB)
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.

Ex
[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])

Et citons encore quelques autres fonctions graphiques 3D qui pourront vous être utiles, non décrites dans ce support de cours :


6.3.4 Graphiques 3D volumétriques (représentation de données 4D)

Des "données 4D" peuvent être vues comme des données 3D auxquelles sont associées un 4e paramètre qui est fonction de la position (x,y,z), défini par exemple par une fonction v = fct(x,y,z).

Pour visualiser des données 4D, MATLAB/Octave propose différents types de graphiques 3D dits "volumétriques", le plus couramment utilisé étant slice (décrit ci-dessous) où le 4ème paramètre est représenté par une couleur !

De façon analogue aux graphiques 3D (pour lesquels il s'agissait d'élaborer préalablement une matrice 2D définissant la surface Z à grapher), ce qu'il faut ici fournir aux fonctions de graphiques volumétriques c'est une matrice tri-dimensionnelle définissant un cube de valeurs V. Si ces données 4D résultent d'une fonction v = fct(x,y,z), on déterminera cette matrice 3D V par échantillonnement de la fonction en s'aidant de tableaux auxiliaires Xm,Ym et Zm (ici également tri-dimensionnels) préalablement déterminées avec la fonction meshgrid.

Fonction et description
Exemple Illustration
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

Ex 1
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])
colorbar
Ex 2

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])
Ex 3

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)

On peut encore mentionner les fonctions de représentation de données 4D suivantes, en renvoyant l'utilisateur à l'aide en-ligne et aux manuels pour davantage de détails et des exemples :


6.3.5 Paramétres de visualisation de graphiques 3D

Nous présentons brièvement, dans ce chapitre, les fonctions permettant de modifier l'aspect des graphiques 3D (et de certains graphiques 2D) : orientation de la vue, couleurs, lissage, éclairage, propriétés de réflexion... La technique des "Handle Graphics" permet d'aller encore beaucoup plus loin en modifiant toutes les propriétés des objets graphiques.

Vraies couleurs, tables de couleurs (colormaps), et couleurs indexées

On a vu plus haut que certaines couleurs de base peuvent être choisies via la spécification linespec utilisée par plusieurs fonctions graphiques (p.ex. 'r' pour rouge, 'b' pour bleu...), mais le choix de couleurs est ainsi très limité (seulement 8 couleurs possibles).

1) Couleurs vraies

En informatique, chaque couleur est habituellement définie de façon additive par ses composantes RGB (red, green, blue). MATLAB et Octave ont pris le parti de spécifier les intensités de chacune de ces 3 couleurs de base par un nombre réel compris entre 0.0 et 1.0. Il est ainsi possible de définir des couleurs absolues, appelées "couleurs vraies" (true colors), par un triplet RGB [red green blue] sous la forme d'un vecteur de 3 nombres compris entre 0.0 et 1.0.

Ex: [1 0 0] définit le rouge-pur, [1 1 0] le jaune, [0 0 0] le noir, [1 1 1] le blanc, [0.5 0.5 0.5] un gris intermédiaire entre le blanc et le noir, etc...

2) Table de couleurs

À chaque figure MATLAB/Octave est associée une "table de couleurs" (palette de couleurs, colormap). Il s'agit d'une matrice, que nous désignerons par cmap, dont chaque ligne définit une couleur par un triplet RGB. Le nombre de lignes de cette matrice est donc égal au nombre de couleurs définies, et le nombre de colonnes est toujours 3 (valeurs, comprises entre 0.0 et 1.0, des 3 composantes RGB de la couleur définie).

3) Couleurs indexées

Bon nombre de fonctions graphiques 2D, 2D½, 3D (contour, surface/pcolor, mesh et surf pour ne citer que les plus utilisées...) travaillent en mode "couleurs indexées" (pseudo-couleurs) : chaque facette d'une surface, par exemple, ne se voit pas attribuer une "vraie couleur" (triplet RGB) mais pointe, par un index, vers une couleur de la table de couleurs. Cette technique présente l'avantage de pouvoir changer l'ensemble des couleurs d'un graphique sans modifier le graphique lui-même mais en modifiant simplement de table de couleurs (palette). En fonction de la taille de la table choisie, on peut aussi augmenter ou diminuer le nombre de nuances de couleurs du graphique.

Lorsque MATLAB/Octave crée une nouvelle figure, il met en place une table de couleur par défaut en utilisant la fonction jet(64). La fonction jet(n) crée une table de n couleurs en dégradés allant du bleu foncé au brun en passant par le cyan, vert, jaune, orange et rouge. La table de couleur par défaut d'une nouvelle figure a par conséquent 64 couleurs.

Ex: jet_cmap=jet(64); calcule et stocke la table de couleurs par défaut sur la matrice jet_cmap ; jet_cmap(57,:) retourne par exemple la 57ème couleur de cette table qui, comme vous pouvez le vérifier, est égale (MATLAB) ou très proche (Octave) de [1 0 0], donc le rouge pur.

L'utilisateur peut créer lui-même ses propres tables de couleur et les appliquer à un graphique avec la fonction colormap présentée plus bas. Il existe cependant des tables de couleur prédéfinies ainsi que des fonctions de création de tables de couleurs.

Ex: ma_cmap=[0 0 0;2 2 2;4 4 4;6 6 6;8 8 8;10 10 10]/10; génère une table de couleurs composées de 6 niveaux de gris allant du noir-pur au blanc-pur ; on peut ensuite l'appliquer à un graphique existant avec colormap(ma_cmap)

4) Scaled mapping et direct mapping

La mise en correspondance (mapping) des 'données de couleur' d'un graphique (p.ex. les valeurs de la matrice Z d'un graphique surf(..., Z), ou les valeurs de la matrice 2D COUL d'un graphique surf(..., Z, COUL)) avec les indices de sa table de couleurs peut s'effectuer de façon directe (direct mapping) ou par une mise à l'échelle (scaled mapping).

Nous présentons ci-dessous les principales fonctions en relation avec la manipulation de tables de couleurs.

Fonction et description
Exemple Illustration
a) colormap(cmap)
b) colormap(named_cmap)
c) cmap = colormap
Appliquer une table de couleurs, ou récupérer la table courante d'une figure :
a) Applique la table de couleur cmap (matrice nx3 de n triplets RGB) à la figure active.
b) Applique une table de couleur nommée à la figure active. On dispose, sous MATLAB/Octave, des 18 tables nommées suivantes (voir leur description plus bas) : autumn, bone, colorcube, cool, copper, flag, gray, hot, hsv, jet, lines, pink, prism, spring, summer, vga, white, winter
c) Récupère, sur la matrice cmap, la table de couleur courante de la figure active

Remarque IMPORTANTE : 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 !

colormap('list')
Affiche la liste des fonctions named_cmap de tables de couleurs prédéfinies (autumn, bone, cool...)
a) brighten(beta)
b) cmap = brighten(beta)
Eclaircir ou assombrir 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 luminosoté 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 IMPORTANTE : 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) cmap = named_cmap { (n) }
b) colormap(named_cmap { (n) } )
Calcule d'une table de couleur, ou application d'une table calculée :
MATLAB/Octave offre 17 fonctions named_cmap de calcul de tables de couleurs décrites ci-dessous avec une illustration des dégradés de couleur correspondant (réalisés avec la fonction colorbar).
a) Retourne une table de couleur avec n entrées/couleurs sur la variable cmap (table que l'on peut ensuite appliquer à la figure active avec colormap(cmap). Si n n'est pas spécifié, la table aura la même taille que la table courante, par défaut 64 couleurs.
b) Calcule et applique directement à la figure active une table de couleur.
Fonctions de création de tables de couleurs :
  • gray(n) : linear gray-scale
  • copper(n) : linear copper-tone
  • bone(n) : gray-scale with tinge of blue
  • pink(n) : pastel shades of pink

  • spring(n) : shades of magenta and yellow
  • summer(n) : shades of green and yellow
  • autumn(n) : shades of red and yellow
  • winter(n) : shades of blue and green

  • white(n) : all white

  • hot(n) : black-red-yellow-white
  • cool(n) : shades of cyan and magenta
  • jet(n) : variant of HSV
  • hsv(n) : hue-saturation-value

  • flag(n) : alternating red, white, blue, and black
  • lines(n) : color map with the line colors
  • prism(n) : prism
  • colorcube(n) : enhanced color-cube

  • vga : Windows colormap for 16 colors (fonction retournant palette de 16 couleurs, donc pas de paramètre n)
Illustration des palettes générées par ces fonctions :
Ex
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
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)
Ex
rgbplot(jet(256))
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
Ex
pcolor(X,Y,Z)
colormap(jet(64))  % colormap par défaut
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
Examinez bien l'échelle des barres de couleur

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.

Autres paramètres de visualisation

Fonction et description
Exemple Illustration
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, camproj, camorbit, campan, camdolly, camroll, camlookat
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
Ex: voir plus haut les exemples pcolor, surfc, surfl et caxis  
handle = light( { 'PropertyName', PropertyValue, ... } )
Activation d'un éclairage :
Active un éclairage de la scène en définissant ses éventuelles propriétés (Position, Color, Style...). On désactive cet éclairage avec lighting('none')
Voir aussi la fonction camlight.
lightangle(handle, az, el)
Direction de l'éclairement :
Définition de l'azimut az et de l'élévation el de cet éclairage (selon même syntaxe que view).
Attention : si on ne passe pas l'argument handle, chaque fois que l'on passe cette commande une nouvelle source de lumière est créée !
lighting('none | flat | gouraud | phong')
Méthode de rendu relative à l'éclairage :
Choix de l'algorithme de lissage des couleurs résultant de l'éclairage, allant du plus simple (flat) au plus élaboré (gouraud).
Les propriétés de réflectance des surfaces par rapport à la lumière peuvent être définie par la fonction material('shiny' | 'dull' | 'metal' | [ka kd ks n sc]')
Ex (graphique ci-contre réalisé avec MATLAB)

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
  lightangle(hlight,az,10) % dir. éclairage
  pause(0.05)
end

6.4 Affichage et traitement d'images

MATLAB est également capable, ainsi qu'Octave depuis la version 3 (package octave-forge "image"), de lire, écrire, afficher, traiter des images dans les différents formats habituels (JPEG, PNG, TIFF, GIF, BMP...).

La présentation de ce domaine dépassant le cadre de ce cours, nous nous contentons d'énumérer ici les fonctions les plus importantes :

6.5 Sauvegarder et imprimer des figures

6.5.1 Imprimer une figure ou la sauvegarder sous forme de fichier graphique

La fonction print permet d'imprimer directement une figure. Elle permet en outre, ainsi que la fonction saveas, de sauvegarder la figure sous forme de fichier graphique dans un format spécifié (vectorisé ou raster) en vue de l'incorporer ensuite dans un document (alternative au copier/coller).

Rappelons encore ici la possibilité de récupérer une figure sous forme raster par copie d'écran, avec les outils du système d'exploitation (p.ex. la touche alt-PrintScreen qui copie l'image de la fenêtre courante dans le presse-papier).

a) print({handle,} 'fichier', '-ddevice' {,option(s)})
b) print({handle,} {-Pimprimante} {,option(s)})
  1. La figure courante (ou spécifiée par handle) est sauvegardée sur le fichier spécifié, au format défini par le paramètre device. Sous Octave, il est nécessaire de spécifier l'extension dans le nom de fichier, alors que celle-ci est automatiquement ajoutée par MATLAB (sur la base du paramètre device).
    Une alternative pour sauvegarder la figure consiste à utiliser le menu de fenêtre de figure : File > Export, File > Save

  2. La figure courante (ou spécifiée par handle) est imprimée sur l'imprimante par défaut (voir printopt) ou l'imprimante spécifiée.
    Une alternative pour imprimer la figure consiste à utiliser le menu de fenêtre de figure : File > Print
Paramètre device : valeurs possibles :
Remarque: sous Octave, il est possible d'omettre ce paramètre, le format étant alors déduit de l'extension du nom de fichier !

Vectorisé
svg : fichier SVG (Scalable Vector Graphics)
pdf : fichier Acrobat PDF
meta ou emf : sous Windows: copie la figure dans le presse-papier en format vectorisé avec preview (Microsoft Enhanced Metafile) ; sous Octave: génère fichier
ill : fichier au format Illustrator 88
hpgl : fichier au format HP-GL
Sous Octave, il existe encore différents formats liés à TeX/LaTeX (voir help print)

PostScript (vectorisé), nécessite de disposer d'une imprimante PostScript
ps, psc : fichier PostScript Level 1, respectivement noir-blanc ou couleur
ps2, psc2 : fichier PostScript Level 2, respectivement noir-blanc ou couleur
eps, epsc : fichier PostScript Encapsulé (EPSF) Level 1, respectivement noir-blanc ou couleur
eps2, epsc2 : fichier PostScript Encapsulé (EPSF) Level 2, respectivement noir-blanc ou couleur
Remarque: pour les fichiers eps* sous Octave, importés dans MS Office 2003 on voit le preview, alors qu'on ne le voit pas dans LibreOffice 3.x à 4.1

Raster
png : fichier PNG (Potable Network Graphics)
jpeg ou jpegnn ou jpg : fichier JPEG, avec niveau de qualité nn= 0 (la moins bonne) à 100 (la meilleure)
tiff : fichier TIFF
gif : fichier GIF

Spécifique à MATLAB sous Windows
bitmap : copie la figure dans le presse-papier Windows en format raster
setup ou -v : affiche fenêtre de dialogue d'impression Windows
win, winc : service d'impression Windows, respectivement noir-blanc ou couleur

Paramètre options : valeurs possibles :
'-rnnn' : définit la résolution nnn en points par pouce ; par défaut 150dpi pour PNG
'-Sxsize,ysize' : spécifie sous Octave, pour les formats PNG et SVG, la taille en pixels de l'image générée
'-portrait' ou '-landscape' : dans le cas de l'impression seulement, utilise l'orientation spécifiée (par défaut portrait)
'-tiff' : ajoute preview TIFF au fichier PostScript Encapsulé
'-append' : ajoute la figure au fichier PostScript (donc n'écrase pas fichier)


saveas(no_figure,'fichier' {,'format'} )
  saveas(handle,'fichier' {,'format'} )
Sauvegarde la figure no_figure (ou l'objet de graphique identifié par handle) sur le fichier spécifié et dans le format indiqué.
• les différents formats possibles correspondent grosso modo aux valeurs indiquées ci-dessus pour le paramètre device de la commande print
• si l'on omet le format, il est déduit de l'extension du nom du fichier
• si l'on omet l'extension dans le nom du fichier, elle sera automatiquement reprise du format spécifié


orient portrait | landscape | tall
Spécifie l'orientation du papier à l'impression (par défaut portrait) pour la figure courante.
Sans paramètre, cette commande indique l'orientation courante.
Le paramètre tall modifie l'aspect-ratio de la figure de façon qu'elle remplisse entièrement la page en orientation portrait.
[print_cmd, device] = printopt
Cette commande retourne :
print_cmd : la commande d'impression par défaut (sous Windows: COPY /B %s LPT1: ) qui sera utilisée par print dans le cas où l'on ne sauvegarde pas l'image sur un fichier
device : le périphérique d'impression (sous Windows: -dwin )
Pour modifier ces paramètres, il est nécessaire d'éditer le script MATLAB printopt.m


nb_polylines = dxfwrite('fichier', polyline1 {,polyline2 ...})
Spécifique à Octave et implémentée dans le package "plot" (qui ne semble cependant plus maintenu), cette fonction génère un fichier graphique au format AutoCAD DXF dans lequel sont graphées la(les) courbe(s) polyline1, polyline2... Ces courbes sont exprimées sous forme de tableaux à 2 colonnes (X/Y) ou 3 colonnes (X/Y/Z). On récupère sur la variable nb_polylines le nombre de courbes tracées.

6.5.2 Sauvegarder et recharger une figure ou un objet graphique

De façon analogue aux variables avec la commande save, MATLAB et Octave permettent de sauvegarder sur fichier avec la fonction hgsave une figure ou un objet graphique, puis le récupérer ultérieurement avec hgload pour l'afficher et le compléter. Sous Octave, ces deux fonctions sont implémentées depuis la version 4.0.
hgsave('fichier')       (handle graphics save)
hgsave(handle, 'fichier' {,'format'})
Sauvegarde la figure courante (ou l'objet graphique spécifié par handle) dans le fichier indiqué.
Sans indiquer d'extension à fichier, l'extension .fig sera ajoutée sous MATLAB, et l'extension .ofig sous Octave.
Le paramètre format peut prendre les valeurs : -v6 (correspond à MATLAB < 7), -v7 (correspond à MATLAB ≥ 7). Si l'on omet ce paramètre, MATLAB utilise -v7 et Octave utilise un autre format qui lui est propre.
Remarque : avec MATLAB 8.3 et Octave 4.0.0 nous n'avons pas réussi à échanger de tels fichiers d'un logiciel à l'autre, quel que soit le format utilisé. Qui est le coupable ?
handle = hgload('fichier')       (handle graphics load)
Récupére le handle de l'objet précédemment sauvegardé dans un fichier, et affiche cet objet dans une figure.


La technique ci-dessous est analogue, mais n'est implémentée que sous MATLAB :
saveas(handle,'fichier','fig')         (remarque: c'est l'option 'fig' qui n'est pas implémentée dans )
Sauvegarde l'objet graphique spécifié par handle dans le fichier indiqué.
Pour sauvegarder la figure entière, indiquer gcf à la place de handle. Sans indiquer d'extension au fichier, l'extension .fig sera ajoutée.
open('fichier')
Recharge et affiche dans une figure l'objet précédemment sauvegardé dans un fichier.

6.6 Handle Graphics

Les graphiques MATLAB/Octave sont constitués d'objets (systèmes d'axes, lignes, surfaces, textes...). Chaque objet est identifié par un handle auquel sont associés différents attributs (ou propriétés, properties). En modifiant ces attributs, on peut agir très finement sur l'apparence du graphique, voire même l'animer !

Ces objets sont organisés selon une hérarchie qui s'établit généralement ainsi (voir l'attribut type de ces handles) :

Cette hiérarchie d'objets transparaît lorsque l'on examine comment les handles sont reliés entre eux : On est donc en présence d'une "arborescence" d'objets et donc de handles (qui pourraient être assimilés aux branches d'un arbre) et d'attributs ou propriétés (qui seraient les feuilles au bout de ces branches). Chaque attribut porte un nom explicite qui est une chaîne de caractère non case-sensitive.

ATTENTION : sous MATLAB, depuis la version R2015 les handles ne sont plus des nombres (double précision) mais des objets !


Fonction et description
Exemple Illustration
A) Récupérer un handle :
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).
B) Afficher ou récupérer les attributs (propriétés) relatifs à un handle :
a) get(handle)
b) handle
c) var = get(handle, 'PropertyName')
d) structure = get(handle)
a) Affiche à l'écran les valeurs courantes de tous les attributs (propriétés) de l'objet spécifié par handle.
b) Depuis MATLAB R2015, cela affiche directement les principaux attributs de l'objet spécifié par handle.
c) Récupère sur var la valeur (PropertyValue) courante correspondant à l'attribut PropertyName spécifié.
d) Récupère sur une structure les valeurs courantes des différents attributs (propriétés) de l'objet spécifié par son handle.
C) Modifier les attributs (propriétés) relatifs à un handle :
a) set(handle, 'Property1Name', Property1Value, {'Property2Name', Property2Value, ...} )
b) handle.PropertyName = PropertyValue
Modifie des attributs (propriétés) spécifiées de l'objet désigné par son handle.

a) Le nom PropertyName 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 PropertyName est ici case-sensitive !

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

Ex 1 L'exemple ci-dessous illustre un cas simple d'utilisation des handles pour formater un graphique.
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
get(h1) % affiche tous les attributs de la courbe
 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


Ex 2 Animation ci-contre réalisée avec MATLAB ou Octave Qt & FLTK.

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 50 150];   % 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

Cliquer sur ce graphique pour voir l'animation !

Remarque: cette animation a été capturée avec le logiciel libre CamStudio,
puis convertie avi->gif-animé (pour affichage dans navigateur web)
Définir les propriétés d'un objet directement lors du dessin (sans passer par son handle) :
fonction_graphique (param. habituels... , 'PropertyName', PropertyValue, 'PropertyName', PropertyValue, ...)
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.
Ex 3 Le code ci-dessous produit exactement la même figure que celle de l' Ex 1 ci-dessus
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');
Et Octave serait même capable de réunir ces 2 plots en un seul ! Bug MATLAB ?
 

6.7 Animations et movies

Certaines fonctions de base MATLAB et Octave permettent de réaliser des animations interactives. On a vu, par exemple, la fonction view de rotation d'une vue 3D par déplacement de l'observateur, et l'on présente ci-après des fonctions de graphiques animés (comet...). Mais de façon plus générale, l'animation passe par l'exploitation des "handles graphics" (changer interactivement les attributs graphiques, la visibilité, voire les données elles-mêmes...).

On souhaite parfois aussi sauvegarder une animation sur un fichier indépendant de MATLAB/Octave ("movie" stand-alone dans un format vidéo standard), par exemple pour l'intégrer dans une présentation (OpenOffice.org/LibreOffice Impress, MS PowerPoint...).

6.7.1 Graphiques animés, ou fonctions d'animation de graphiques

Graphiques de type "comète"

Propre à MATLAB et simple à mettre en oeuvre, cette technique permet de tracer une courbe 2D ou 3D sous forme d'animation pour "visualiser" une trajectoire. Cela peut être très utile pour bien "comprendre" une courbe dont l'affichage est relativement complexe (enchevêtrement de lignes) en l'affichant de manière progressive, à l'image d'une "comète" laissant une trace derrière elle (la courbe).

A titre d'exemple, voyez vous-même la différence en affichant la courbe 3D suivante, successivement avec plot3 puis comet3 :
z= -10*pi:pi/250:10*pi; x= (cos(2*z).^2).*sin(z); y= (sin(2*z).^2).*cos(z);

Fonction et description
Exemple Illustration
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
Ex
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')
Cliquer sur ce graphique pour voir l'animation !

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

6.7.2 Animations de type "movie"

Réaliser une animation sous MATLAB/Octave consiste à assembler une séquence d'images dans un fichier vidéo.

A) Technique basée 'getframe/movie' sous MATLAB

Une animation de type "movie" s'élabore, sous MATLAB, de la façon suivante :
  1. le script génère, de façon itérative, autant d'images (graphiques) que nécessaire pour constituer une animation fluide
  2. à chaque itération, le graphique courant (figure) est "capturé" en tant que "frame" (pixmap) via la fonction getframe, et accumulé sur une immense "matrice-movie"
  3. une fois tous les frames capturés, l'animation peut directement être jouée (depuis le script ou en mode commande) en parcourant la "matrice-movie" avec la fonction movie ; pour être visualisée indépendemment de MATLAB, l'animation peut être sauvegardée sous forme de fichier-vidéo à l'aide des fonctions movie2avi (au format Windows AVI) ou qtwrite (au format QuickTime)

Fonction et description
Exemple Illustration
a) mov_mat(k) = getframe
b) mov_mat(k) = getframe(handle {,rect} )
"Capture" de l'image de la figure courante sous forme de "frame" :
Capture, sous forme de "movie-frame", de l'image de la figure courante, et enregistrement comme k-ème élément de la matrice-movie mov_mat. Tous les frames saisis doivent avoir la même dimension (largeur x hauteur), raison pour laquelle il ne pas modifier la taille de la fenêtre graphique au cours de l'élaboration de l'animation ! Dans la forme b), on spécifie le handle de la figure et l'on peut définir, par le vecteur rect de forme [gauche bas largeur hauteur], une portion de l'image (unités en pixels).
Il est important de noter que cette capture s'effectue au niveau raster ("pixmap"), et que la taille-mémoire occupée par le frame (et la matrice-frame) sera proportionelle à la surface (carré des dimensions) de la fenêtre de figure. La dimension originale de la fenêtre graphique dans laquelle s'élabore l'animation a donc beaucoup d'importance sur la quantité de mémoire-vive nécessaire pour l'élaboration du movie, de même que sur la qualité d'affichage ultérieure de l'animation (=> importance de trouver un bon compromis !).

Remarques par rapport à d'anciennes versions de MATLAB :
• depuis MATLAB 5.3, il n'est plus nécessaire de préallouer l'espace-mémoire nécessaire pour la matrice-movie avec la fonction moviein (fonction qui devient donc inutile)
• la fonction getframe remplace, depuis MATLAB 5.3, l'ancienne fonction capture (fonction qui est donc obsolète)

movie(mov_mat {, n {, fps } }
Visualisation de movie depuis MATLAB :
Joue l'animation préalablement élaborée dans la matrice-movie mov_mat. L'animation sera jouée n fois (par défaut 1x), à la cadence de fps frames par seconde (par défaut 12 frames/sec). Il est possible de spécifier avec un vecteur n le numéro des frames à jouer.
a) movie2avi(mov_mat, 'filename' {, param, value} )
b) qtwrite(mov_mat, colormap, 'filename')
Sauvegarde d'une animation MATLAB sous forme de fichier vidéo indépendant :
a) Sauvegarde l'animation mov_mat sur un fichier-vidéo au format Windows AVI (Audio Video Interleaved). Parmi les paramètres possibles (voir l'aide), on peut notamment spécifier une table de couleur, le type de compression (codec), le nombre de frames par secondes, la qualité... La fonction inverse d'importation aviread permettrait de lire un fichier AVI sur une matrice-movie.
b) Disponible uniquement sur macOS et nécessitant QuickTime, cette fonction sauvegarde l'animation mov_mat sur un fichier-vidéo au format QuickTime, en utilisant la table de couleurs colormap.

Remarques :
• Comme alternative à ces fonctions d'exportation de movie, on pourrait sauvegarder sur disque chaque frame sous forme de fichier-image avec les 2 instructions [img]=frame2im(mov_mat(k)); (voir description de cette fonction ci-dessous) et imwrite(img, ['image-' num2str(n+100) '.jpg'], 'jpg');, puis assembler les différents fichiers-image image-numéro.jpg ainsi produits en une animation (MPEG, QuickTime, GIF-animé, AVI...) avec l'un des nombreux utilitaires existant (commerciaux, tel que Animation Shop 3, ou gratuits...).
• Il est bien clair qu'une animation MATLAB peut aussi être sauvegardée, au niveau de sa "matrice-movie" mov_mat, sous forme d'un fichier de workspace (commande save mat-file mov_mat), puis être rechargée dans une session MATLAB ultérieure (avec load mat-file) et directement jouée (avec movie(mov_mat)) ; mais cette façon de procéder n'est pas efficace car la place mémoire/disque utilisée par la variable mov_mat est très importante (pas de compression) ; mieux vaut donc utiliser les formats vidéo classiques.

a) mov_mat(k) = im2frame(img {,colormap} )
b) [img {,colormap} ] = frame2im(mov_mat(k))
Conversion image <-> frame :
a) Conversion d'une image img en un frame de movie mov_mat(k), en utilisant la table de couleur courante ou la colormap spécifiée
b) et vice-versa
Ex (réalisé ici avec MATLAB)
nb_frames=50;          % nb frames animation
x=0:0.2:2*pi;  y=x;    % plage de valeurs en X et Y
[Xm,Ym]=meshgrid(x,y); % matrices grille X/Y

for n=1:nb_frames;
  z=cos(Xm).*sin(Ym).*sin(2*pi*n/nb_frames);
  surf(x,y,z)                   % aff. n-ième image
  view(45+(360*n/nb_frames), 30) % chang. azimut vue
  axis([0 2*pi 0 2*pi -1 1])     % cadrage axes
  axis('off')
  mov_mat(n)=getframe; % capture/enregistr. frame
end

movie(mov_mat,2)       % jouer 2x l'animation
Cliquer sur ce graphique pour voir l'animation !

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

B) Technique basée 'VideoWriter/avifile' ou fichiers-image, sous MATLAB ou Octave

Cette technique consiste à ajouter les "frames" dans le fichier vidéo au fur et à mesure qu'ils sont produits. Elle s'appuyait à l'origine sur la fonction avifile, mais depuis MATLAB R2015 celle-ci est remplacée par VideoWriter. Quant à Octave, le package "video" qui implémentait avifile n'est actuellement plus supporté, donc on recommande plutôt la technique illustrée par l'exemple 2 ci-dessous.

On présente ci-dessous 3 implémentations possibles, respectivement sous MATLAB, Octave Linux et Octave Windows.

1. Implémentation MATLAB (sous Windows ou Linux)
% Création/ouverture du fichier vidéo, ouverture fenêtre figure vide
   fich_video = VideoWriter('animation','MPEG-4')
   open(fich_video)
   fig=figure;
   
% Paramètres du graphique   
   nb_frames=50;          % nb frames animation
   x=0:0.2:2*pi;  y=x;    % plage de valeurs en X et Y
   [Xm,Ym]=meshgrid(x,y); % matrices grille X/Y
   
% Boucle de dessin des frames et insertion dans la vidéo
   for n=1:nb_frames;
     z=cos(Xm).*sin(Ym).*sin(2*pi*n/nb_frames);
     surf(x,y,z)                    % affichage n-ième image
     azimut=mod(45+(360*n/nb_frames),360);  % azimut modulo 360 degrés
     view(azimut, 30)               % changement azimut vue
     axis([0 2*pi 0 2*pi -1 1])     % cadrage axes
     axis('off')
     img_frame = getframe(fig);     % récupération frame
     writeVideo(fich_video, img_frame); % insertion frame
   end

% Fermeture fichier vidéo et fenêtre figure
   close(fich_video)
   close(fig)
   disp('La video est creee !')
      Voir aussi les fonctions aviinfo(file_name) et aviread(file_name, frame_no)
2. Implémentation Octave sous Linux
Pour assembler les fichiers-images en une vidéo, on illustre ici l'utilisation efficace sous Linux de l'outil en mode-commande ffmpeg. On n'a donc, dans ce cas, pas besoin des fonctions avifile et addframe présentées dans l'exemple suivant !
% Ouverture fenêtre figure vide
   fig=figure;     % ouverture fenêtre figure vide
   
% Création sous-répertoire dans lequel on va enregistrer fichiers frames   
   mkdir('frames');  
   
% Paramètres du graphique   
   nb_frames=50;          % nb frames animation
   x=0:0.2:2*pi;  y=x;    % plage de valeurs en X et Y
   [Xm,Ym]=meshgrid(x,y); % matrices grille X/Y
         
% Boucle de dessin des frames et sauvegarde sur disque
   for n=1:nb_frames;
     z=cos(Xm).*sin(Ym).*sin(2*pi*n/nb_frames);
     surf(x,y,z)                    % affichage n-ième image
     azimut=mod(45+(360*n/nb_frames),360);  % azimut modulo 360 degrés
     view(azimut, 30)               % changement azimut vue
     axis([0 2*pi 0 2*pi -1 1])     % cadrage axes
     axis('off')
     
     fprintf('%d ',n)     % indicateur de progression
     print('-dpng','-r80',sprintf('frames/frame-%04d.png',n))
       % sauvegarde frame sur fichier raster PNG, en résol. 80 dpi
   end
  
% Fermeture fenêtre figure
   close(fig)

% Assemblage de la vidéo (par outil Linux et non pas Octave)
   system('ffmpeg -f image2 -i frames/frame-%04d.png -vcodec mpeg4 animation.mp4');
   disp(''); bidon=input('Frames generes ; frapper <enter> pour assembler la video');
     % sous Ubuntu nécessite package "ffmpeg"
     % puis package "gstreamer0.10-ffmpeg" pour visualiser vidéo sous Totem
   disp('La video est assemblee, le dossier ''frames'' peut etre detruit !')
3. Implémentation Octave sous Windows
Attention : notez que cet exemple se base sur les fonctions avifile et addframe du package Octave "video" qui n'est actuellement plus officiellement supporté. Une évolution dans ce domaine est donc attendue.

La fonction getframe n'existant pas (encore) sous Octave 4.0, comme artifice on passe par une écriture temporaire des frames sur fichiers-disque. Le paramètre '-rdpi' (de la commande print de sauvegarde des frames) nous permet ici de diminuer la résolution (donc la taille) de la vidéo.

% Création/ouverture du fichier vidéo, ouverture fenêtre figure vide
   fich_video = avifile('animation.avi','compression','msmpeg4v2')  % sous Windows
     % faire   avifile('codecs')   pour liste des codecs utilisables
   fig=figure;     % ouverture fenêtre figure vide
   
% Création sous-répertoire dans lequel on va enregistrer fichiers frames   
   mkdir('frames');  
   
% Paramètres du graphique   
   nb_frames=50;          % nb frames animation
   x=0:0.2:2*pi;  y=x;    % plage de valeurs en X et Y
   [Xm,Ym]=meshgrid(x,y); % matrices grille X/Y
         
% Boucle de dessin des frames et insertion dans la vidéo
   for n=1:nb_frames;
     z=cos(Xm).*sin(Ym).*sin(2*pi*n/nb_frames);
     surf(x,y,z)                    % affichage n-ième image
     azimut=mod(45+(360*n/nb_frames),360);  % azimut modulo 360 degrés
     view(azimut, 30)               % changement azimut vue
     axis([0 2*pi 0 2*pi -1 1])     % cadrage axes
     axis('off')
       
     fprintf('%d ',n)     % indicateur de progression
     print('-dpng','-r80',sprintf('frames/frame-%04d.png',n))
        % sauvegarde frame sur fichier raster PNG, en résol. 80 dpi
     pause(0.1)   % sinon, risque que le fichier ne soit pas prêt pour lecture
     img_frame = imread(sprintf('frames/frame-%04d.png',n));
        % lecture image à partir fichier
        % => tableau de dim. HxLx3 d'entiers non signés de type uint8 (1 octet)
     img_frame = single(img_frame)/255 ;
        % normalisation des valeurs: uint8 [0 à 255] -> real-single [0 à 1]
     addframe(fich_video, img_frame);    % ajout frame à la vidéo
   end
  
% Fermeture fichier vidéo et fenêtre figure
   clear fich_video   % ce n'est, bizarrement, pas close qu'il faut utiliser !
   close(fig)
   disp('La video est assemblee, le dossier ''frames'' peut etre detruit !')

6.7.3 Animations basées sur l'utilisation des "handles graphics"

Basée sur les "handles graphics", l'animations de graphiques est plus complexe à maîtriser, mais c'est aussi la plus polyvalente et la plus puissante. Elle consiste, une fois un objet graphique dessiné, à utiliser ses "handles" pour en modifier les propriétés (généralement les valeurs 'xdata' et 'ydata'...) avec la commande MATLAB/Octave set(handle, 'PropertyName', PropertyValue, ...). En redessinant l'objet après chaque modification de propriétés, on anime ainsi interactivement le graphique.

La fonction rotate (présentée plus haut), qui permet de faire tourner un objet graphique désigné par son handle, peut également être utile dans le cadre d'animations.

6.7.4 Animations basées sur le changement des données de graphique ("refreshdata")

La technique ci-dessous s'appuie aussi sur les "handles graphics".

Fonction et description
Exemple Illustration
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é
Ex
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
Cliquer sur ce graphique pour voir l'animation !

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




Documentation CC BY-SA 4.0 / J.-D. BONJOUR () / EPFL-ENAC-IT / Rév. 26-09-2016       ↵ Table des matières