F

MENUCours Outils et Méthodes pour la Physique

Ce tutoriel présente les outils graphiques de MuPAD. Dans un premier temps, nous passons en revue les commandes permettant de saisir les notions essentielles. Nous abordons ensuite, via une Foire Aux Questions quelques astuces ou concepts plus subtils en matière de graphisme et d’animation.

Notions essentielles

FONCTION À UNE VARIABLE

Syntaxe

Soit la fonction réelle \(f\,:\, x\mapsto f(x)\). Le graphe de \(f\) est l'ensemble des points M(\(x,y\)) du plan cartésien tel que \(y=f(x)\). Sous MuPAD, la manière la plus simple de tracer le graphe d'une fonction est d'utiliser la commande plotfunc2d ou plot::Function2d dont la syntaxe est :
plotfunc2d(f, x = xmin .. xmax,Options):
plot(plot::Function2d(f, x =xmin .. xmax,Options)):

où f est une fonction, expression ou procédure qui renvoi un nombre.

Exemple : tracé d'un sinus

courbe 1

Ces 4 codes donnent le même résultat (cf. Fig-1)

f:=x->sin(x): plotfunc2d(f, x = 0..2*PI); plotfunc2d(sin(x), x = 0..2*PI); plot(plot::Function2d(sin(x), x = 0..2*PI)); toto:=proc(x) begin return(sin(x)) end_proc: plotfunc2d(toto(titi), titi = 0..2*PI);

Options intéressantes :

FONCTION À DEUX VARIABLES

Syntaxe

Soit la fonction réelle \(f\,:\,(x,y)\mapsto f(x,y)\). Le graphe de \(f\) est l'ensemble des points M(\(x,y,z\)) de l'espace cartésien tel que \(z = f(x,y)\). Sous MuPAD, ce graphe s'obtient à l'aide de la routine plotfunc3d ou plot::Function3d.

La syntaxe est la suivante :

plotfunc3d(f, x=xmin..xmax, y=ymin..ymax, Options):
plot(plot::Function3d(f, x=xmin..xmax, y=ymin..ymax, Options)):

Exemple

Traçons la surface d'équation \(z=\sin(x^2 + y^2)\) sur le domaine [-2,2]x[-2,2] (cf. figure 2)

plotfunc3d(sin(x^2 + y^2), x = -2..2, y = -2..2);
courbe 2

Options intéressantes

COURBES ET SURFACES IMPLICITES

Syntaxe

Si l’on cherche l’ensemble des points M\((x,y)\) tel que \(f(x,y)=0\), on utilisera la routine plot::Implicit2d.
Dans le cas où l’on cherche l’ensemble des points M\((x,y,z)\) tel que \(f(x,y,z)=0\), on utilisera la routine plot::Implicit3d.

La syntaxe est la suivante : plot(plot::Implicit2d(f, x = xmin .. xmax, y = ymin .. ymax, Options)) ; où f est une fonction de deux variables (ou une procédure) qui renvoie un nombre réel.

Exemple

figure 1

Considérons la surface \(f(x,y,z)=\min(x^2 + y^2 + z^2 - 2, -z)=0\).

Que représente-t-elle ? Lorsque \(x^2 + y^2 + z^2 \gt 2\), \(f(x,y,z)=0\) que si \(z=0\). Lorsque \(x^2 + y^2 + z^2 \lt 2\), \(f(x)=0\) n' a pas de solution. Enfin lorsque \(x^2 + y^2 + z^2 = 2\), \(f(x)=0\) que si \(z\leq 0\). En d'autres termes, la surface est la réunion d'une demi-sphère de rayon \(\sqrt{2}\) centrée en (0,0,0) dans l'espace \(z\leq 0\) et du plan \(xOy\) percé d'un trou circulaire de rayon \(\sqrt{2}\) centrée en (0,0,0). Vérifions avec MuPAD en tapant :

plot(plot::Implicit3d(min(x^2+y^2+z^2- 2,-z),x=-2..2,y=-2..2,z=-1.5..0.5));

Options intéressantes

COURBES PARAMÉTRIQUES

Syntaxe

La routine plot::Curve2d permet de tracer la courbe paramétrique d’équation \([x(t),y(t)]\) où \(t\) est le paramètre variant entre tmin et tmax.
La routine plot::Curve3d permet, quant à elle, le tracé de la courbe paramétrique d’équation \([x(t),y(t),z(t)]\).
La syntaxe est la suivante :

plot(plot::Curve2d([x(t), y(t)], t=tmin..tmax,Mesh=N)); plot(plot::Curve3d([x(t), y(t), z(t)],t=tmin..tmax, Mesh=N));

où N est le nombre de points calculés.

Exemples

La spirale d'Archimède a pour équation paramétrique \[ \left\{ \begin{array}{rcl} x(t)&=& t\cos(t)\\ y(t)&=& t\sin(t) \end{array} \right. \] ce qui donne le code suivant :

plot(plot::Curve2d([t*cos(t), t*sin(t)], t = 0..35,Mesh=500));

La figure ci-contre montre le résultat.

Pour une hélice s’enroulant sur une sphère on écrira :

plot(plot::Curve3d([sin(theta)*cos(20*theta),sin(theta)*sin(20*theta),cos(theta)],theta=0..PI,Mesh=1000));
figure 2 figure 3
Spirale d'Archimède et hélice sphérique.

Autres systèmes de coordonnées

Si l’on connaît l’équation de la courbe dans d’autres systèmes de coordonnées on peut utiliser des routines spécifiques :

figure 4

Par exemple, si l'on veut représenter une hélice d’équation: \[ \left\{ \begin{array}{rcl} r(t)& =& 1\\ \phi(t)& =& t\\ z(t)& =& t/10 \end{array} \right. \] on écrira :

plot(plot::Cylindrical([1, t, 0.1*t], t = 0..5*PI,z=0..2*PI,Mesh=[50,50]));

LA COULEUR

La couleur est définie à l’aide des attributs Color, PointColor, LineColor ou FillColor suivant le type de routine utilisée (voir l’aide). Dans MuPAD, la couleur est exprimée dans la base RGB ou RGBa.

RGB

Acronyme de Red-Green-Blue pour Rouge-Vert-Bleu. D’après le principe de la Trichromie, toute couleur se décompose en trois composantes RGB. Le blanc contient autant de rouge, de vert et de bleu tandis que le jaune contient autant de rouge et de vert mais pas de bleu. La valeur d’une couleur s’écrit

RGB::[r,g,b]

où les composantes r, g, b sont comprises entre 0 et 1.

Si l’on veut qu’une figure soit jaune et d’intensité maximale on écrira :

fig::Color:=RGB::[1,1,0]

Remarque

Certaines couleurs sont prédéfinies. Par exemple le jaune se note aussi

RGB::Yellow

RGB\(a\) :

On peut aussi définir une transparence pour chaque figure puisque l’on peut être amené à les superposer. C’est pourquoi on définit un paramètre d’opacité \(a\) compris entre 0 et 1 (\(a\) car la transparence est assurée à l’aide d’une couche dite couche alpha). Pour \(a=0\), la figure est complètement transparente c’est-à-dire invisible ; pour \(a=1\) elle est opaque et pour \(0\lt a \lt 1\), la figure est semi-transparente.

Par exemple si l’on veut qu’une figure soit jaune avec une transparence de 50%, on écrira:
fig::Color:=RGB::[1,1,0,0.5]
ou bien
fig::Color:=RGB::Yellow.[0.5]

Fonction Couleur

figure de diffraction

l’option FillColorFunction permet de paramètrer la couleur de chaque pixel en fonction des variables (x,y,z etc...).

Pour illustrer comment fonctionne cette option, cherchons à représenter la figure de diffraction obtenue après le passage d'une onde plane monochromatique à travers une pupille carrée.

f:=(x,y)->abs(sin(x)/x*(sin(y)/y)): g:=plot::Function3d(1,x=-7..7,y=-7..7,CameraDirection=[0,0,50],FillColorFunction=[f(x,y),f(x,y),f(x,y)],Mesh=[40,40]): g::XLinesVisible:=FALSE;fig::YLinesVisible:=FALSE; plot(fig,Header="diffraction par une pupille carrée")

La première ligne définit la fonction donnant la répartition de l’intensité lumineuse sur un écran (L’intensité correspond en réalité à $f^{2}(x,y)$ mais dans ce cas on ne voit pas les taches secondaires de diffraction). La deuxième trace un plan \(z=1\) que l’on regarde d’un point de l’axe z. Chaque pixel est gris d’intensité proportionnel à $f(x,y)$. La troisième ligne permet d'enlever le maillage présent par défaut. Enfin, la dernière ligne affiche le résultat et donne un titre.

LES ANIMATIONS

Chaque routine graphique attend un certain nombre de plages de valeurs sous la forme x=xmin..xmax. Par exemple la routine

plot::Function2d(f(x), x = xmin..xmax)

attend une plage de valeurs. Si vous ajoutez une nouvelle plage de valeur de la forme a=amin..amax, MuPAD interprétera a comme un paramètre d’animation : MuPAD produira (par défaut) 50 images correspondantes au 50 valeurs de a régulièrement (par défaut) espacées dans l’intervalle amin..amax.

Exemple : courbe de Lissajous

Définition des fonctions x et y

x:= t -> sin(3*t):y:= t -> cos(5*t): p:= plot::Point2d([x(t), y(t)], t = 0..2*PI):

[x(t),y(t)] repère un point dont la position dépend du paramètre t. L’objet p est donc une animation: il s’agit d’un point qui parcours une courbe de lissajous.

c:= plot::Curve2d([x(t), y(t)], t = 0..tmax, tmax = 0..2*PI):

Ici, tmax est un paramètre. L’objet c est aussi une animation : on obtient le tracé progressif de la courbe de lissajous. Pour finir, on trace les deux animations en même temps.

plot(c, p);
animation

Option intéressante

Frames : permet de fixer le nombre de calques constituant l’animation.

Notions avancées

OBJETS GRAPHIQUES ET ATTRIBUTS

Sous MuPAD, on distingue les notions suivantes:

  1. le canevas, cadre dans lequel on trouve la ou les scènes graphiques ;
  2. la scène graphique dans laquelle on trouve la ou les figures ;
  3. la figure obtenue à l’aide d’une routine du type plot::routine().

Scène graphique

Si fig1 et fig2 sont deux figures, on peut alors les rassembler dans une même scène en faisant :

plot(fig1,fig2,Options):

Commençons par ce premier exemple :

Exemple

Scene1
Une scène graphique constituée de plusieurs objets graphiques.

Définition de la fonction f.

f:= x -> x*sin(x): x0:= 1.2: dx:= 1:

définition de l’objet fig1. Il s’agit du graphe de f entre 0 et 2π.

fig1:= plot::Function2d(f(x), x = 0..2*PI):

définition de l’objet fig2. Il s’agit d’un point de la courbe à l’abcisse x0.

fig2:= plot::Point2d(x0, f(x0)):

définition de l’objet fig3. Il s’agit d’une ligne tangente à la courbe et passant par le point d’abcisse x0.

fig3:= plot::Line2d([x0 - dx, f(x0) - f’(x0)*dx], [x0 + dx, f(x0) + f’(x0)*dx]):

les trois figures sont tracées dans la même scène (cf. Fig 1).

plot(fig1, fig2, fig3);

Chaque objet graphique peut recevoir un certain nombre d’attributs sous la forme d’options mis en argument dans la routine. Par exemple, si je veux une courbe noire je peux écrire :

fig1:=plot::Function2d(f(x), x = 0..2*PI,Color=RGB::Black)

Il y a cependant plus court. En effet on peut utiliser la syntaxe suivante : objet::attribut:=valeur de l’attribut

Exemple

fig1::Color:= RGB::Black:

la courbe sera noire.

fig2::PointSize:= 2.0*unit::mm:

le point aura un diamètre de 2 mm.

fig3::Color:= RGB::Red:

la tangente sera rouge.

plot(fig1,fig2,fig3,GridVisible=TRUE):

les trois figures sont tracées dans la même scène qui dispose d’une grille (cf.Fig 2).

Scene2
Exemple 2.

Canevas

Jusqu’ici nous avons manipulé une scène contenant une ou plusieurs figures. On peut définir plusieurs scènes à l’aide de plot::Scene2d et les disposer en canevas à l’aide de plot::Canvas.

Exemple de canevas graphique

for i from 1 to 6 do scene[i]:= plot::Scene2d(plot::Curve2d([cos(theta+0.25*PI),cos(i*theta)], theta = 0..2*PI)): end_for

Définition de 6 scènes graphiques à l’aide d’une boucle.

C:=(plot::Canvas(scene[i] $ i=1..6));

Définition du canevas formé de ces 6 scènes.

C::Header:="Courbes de Lissajous": C::BorderWidth:=0.5*unit::mm:C::HeaderFont =["Times New Roman", Bold, 18]:

Définition de l’entête, de sa police de caractère et de la bordure du canevas.

plot(C);

Affichage du canevas.(cf. Fig 3)

Courbes de Lissajous

ÉQUATIONS DIFFÉRENTIELLES ORDINAIRES (ODE)

Nous décrivons ici la routine plot::Ode2d qui permet de représenter la solution d'une équation différentielle ordinaire avec condition initiales (problème de Cauchy).

Remarque

On note \(f´(t)\) la dérivée première de \(f\) à l'instant \(t\) et \(f^{(n)}\) la dérivée n-ième de \(f\) à l'instant \(t\)

Considérons une équation différentielle du premier ordre de la forme : \begin{equation} Y´= F(t,Y) \label{equadiff1} \end{equation} avec \(Y\) une fonction réelle ou vectorielle de \(t\). \(Y´\) représente la dérivée de \(Y\) par rapport à \(t\). Rappelons qu’une équation différentielle d'ordre \(n\) du type : \begin{equation} x^{(n)}=f(t,x,x',x'',..,x^{n-1}) \label{equadiff2} \end{equation} peut se mettre sous la forme \eqref{equadiff1} si l’on pose les vecteurs suivants : \[ \begin{array}{rcl} Y & =& [x,x',x'',\ldots,x^{(n-1)}]\\ F & =& [Y_2,Y_3,\ldots,f(t,Y_{i=1..n})] \end{array} \]

Exemple : le pendule simple

Quelle est l'ODE d'un pendule simple amorti de pulsation propre \(\omega_0=1\;\mathrm{rad.s^{-1}}\) et de facteur de qualité \(Q=5\) ?

L'angle du pendule \(\theta(t)\) obéit à l’équation différentielle suivante : \[\theta''(t) = - \sin\theta(t) - 0,2\theta'\] équation différentielle qui peut se mettre sous la forme \eqref{equadiff1} à condition de poser \[\begin{array}{rcl} Y & =& [\theta(t),\theta'(t)]\\ F & =& [Y_2,-\sin Y_1 - 0,2Y_2] \end{array} \]

La routine plot::Ode2d permet de représenter les solutions d’une équation différentielle du premier ordre de la forme \eqref{equadiff1}. La syntaxe est la suivante :

plot(plot::Ode2d(F, [Automatic,t0,t1,δt],Y0));

où F désigne le vecteur de l'ODE \eqref{equadiff1} et Y0 le vecteur Y pour \(t=\)t0. Cette commande permet de tracer (par défaut) les valeurs des \(Y_n\) en différents instants t0, t0 + δt,..., t1. Les points sont reliés par une courbe spline (par défaut).

Exemple

Reprenons le cas du pendule simple avec comme conditions initiales \(\theta(0)=0\) et \(\theta'(0)=3,5\;\mathrm{rad.s^{-1}}\). Il faut donc taper :

F:= proc(t, Y) begin [Y[2], -sin(Y[1])-0.2*Y[2]] end_proc:

Définition de F

Y0:= [0,3.5]:

Conditions initiales

plot(plot::Ode2d(F,[Automatic,0,40,1],Y0))

Tracé de Y1(t) et Y2(t)(voir figure 1)

trajectoires du pendule simple
en bleu, \(\theta(t)\) et en rouge la vitesse angulaire \(\theta'(t)\).

Si l’on veut représenter les solutions dans un autre espace que \([t,Y_n]\), on peut utiliser des projecteurs que l'on définit comme suit:

Trajectoire de phase
Trajectoire de phase.
G:(t,Y)->[x(t,Y),y(t,Y)];

L’appel de ce projecteur permettra d’obtenir les points solutions dans l’espace [x,y]. Dans notre exemple, si l’on veut tracer la trajectoire de phase dans l’espace des phases \([\theta, \theta']\), il faut écrire :

G1:= (t, Y) -> [Y[1], Y[2]]: //Tracé de la trajectoire de phase (voir figure 2) plot(plot::Ode2d(F,[Automatic,0,40,0.1],Y0, [G1,Style=Lines,Color=RGB::Black]));

Options intéressantes

COMMENT TRANSFORMER UNE IMAGE BITMAP ?

Avant toute chose, il faut importer une image pour pouvoir la travailler ensuite. Les formats autorisés sont: BMP, DCX, DDS, WAD, GIF, ICO, JPG, LIF, MDL, PCD, PCX, PIC, PIX, PNG, PNM, PSD, PSP, PXR, RAW, SGI, TGA, TIF, WAL, XPM. Si filename est le nom d'une image de largeur \(w\) pixels et de hauteur \(h\) pixels, la syntaxe est la suivante :

import::readbitmap(filename)

Cette importation définit une matrice \(M\) qui contient \(N=w\,h\) codes couleurs correspondants aux \(N\) pixels de l'image. Par exemple \(M[i,j]\) retourne le code [R,G,B] du pixel de coordonnées \((i,j)\).

Exemple

[w, h, img] := import::readbitmap("/home/jimmy/Desktop/logoAMP.png"):

w stocke la valeur de la largeur, h celle de la hauteur et img est le nom de la matrice des couleurs.

image originale
Sortie graphique.

Pour générer une sortie graphique il faut utiliser la routine plot::Raster(img). D'ailleurs, toute matrice dont les éléments sont des vecteurs à 3 composantes peuvent avoir une représentation graphique à l'aide de cette routine. La syntaxe est la suivante :

plot(plot::Raster(img));

La largeur et la hauteur sont donnés par :

float(w);float(h); Math0Math1

img[i,j] renvoie le code couleur du pixel \((i,j)\) sous forme d'un vecteur [R,G,B]. Par exemple le pixel de coordonnées (173,173) est blanc puisque :

img[173,173]; Math2
image modifiée
Sortie graphique de l'image modifiée.

On peut vouloir modifier l'image initiale. Par exemple, si je veux faire la transformation [R,G,B]➜[B,R,G] (permutation circulaire des codes couleurs), j'écrirais :

image2:=array(1..h,1..w): for i from 1 to h do for j from 1 to w do image2[i, j]:= [img[i,j][3],img[i,j][1],img[i,j][2]]: end_for: end_for: plot(plot::Raster(image2));

Vous aimez ?