Préparation des graphiques avec Mathematica

Cette chapitre concerne l'utilisation de Mathematica pour la préparation et la conversion des graphiques produits avec l'aide de Mathematica. Par conséquent, le lecteur est censé avoir une connaissance de base de Mathematica et d'avoir la possibilité d'exécuter des commandes Mathematica.

Produire des graphiques avec Mathematica

Il y a quelques commandes de construction pour produire des graphiques tri-dimensionnels avec Mathematica: Plot3D, ParametricPlot3D et ListPlot3D. Les graphiques tri-dimensionnels peuvent aussi se construire par combinaison avec des primitives graphiques telles que Point, Line, Polygon etc. dans un objet Graphics3D. Il existe également plusieurs packages standard comme Graphics`ContourPlot3D`, Graphics`Graphics3D`, Graphics`PlotField3D`, Graphics`Polyhedra`, Graphics`Shapes` ou Graphics`SurfaceOfRevolution` avec d'autres commandes et d' objets tri-dimensionnels.

Quoi qu'il en soit, dans bien des cas, un objet Graphics3D est produit, doit être converti dans une InputForm appropriée afin d'être affiché par LiveGraphics3D. Cette conversion est expliquée dans le paragraphe Convertir des objets Graphics3D, dans le paragraphe Convertir des animations il est décrit la combinaision de plusieurs objets Graphics3D dans une animation. Enfin le paragraphe Convertir d'autres objets graphiques décrit comment convertir d'autres types d'objets graphiques de Mathematica en objets Graphics3D. (Cela couvre ContourGraphics, DensityGraphics et SurfaceGraphics.)

Dans certains cas, un prétraitement des graphiques Mathematica est plus approprié, par exemple, lorsqu'il y a des intersections de polygônes. Avec Eric W. Weisstein j'ai écrit le package Mathematica LiveGraphics3D.m qui s'attaque à ses problèmes. Eric a également écrit une petite démo pour cela: LiveGraphics3DDemo.nb.

Généralement, LiveGraphics3D sera seulement utilisé pour afficher des graphiques calculés par Mathematica. Toutefois, la définition Graphics3D pour une applet LiveGraphics3D peut également être modifié (ou même créée) manuellement. De plus, LiveGraphics peut également être utilisé pour trouver de bonnes valeurs aux options Graphics3D: ViewPoint et ViewVertical (voir
ci-dessus).

Convertir des objets Graphics3D

Afin d'afficher tout objet Graphics3D, ContourGraphics, DensityGraphics ou SurfaceGraphics avec LiveGraphics3D, ils doivent être convertis dans une InputForm appropriée. C'est ce que l'on peut faire avec la fonction LiveForm tel que définie ci-dessous. La fonction convertit également les listes d'objets Graphics3D en animations et remplace toutes les SequenceForms en StringForms pour éviter les problèmes avec la mise en forme des SequenceForm.

LiveForm[graphics_, animOpts___] := 
   Module[{graphics3d = Switch[graphics, _ContourGraphics, 
   Graphics3D[SurfaceGraphics[graphics]], _DensityGraphics, 
   Graphics3D[SurfaceGraphics[graphics]], _SurfaceGraphics, 
   Graphics3D[graphics], _, graphics]//.SequenceForm[x___]:>
   StringForm[StringJoin[Table["``", {Length[{x}]}]], x]}, 
   Switch[graphics3d, _List, HoldForm[ShowAnimation][
   Map[LiveForm, graphics3d], InputForm[N[Flatten[{animOpts}]]]], 
   _, InputForm[N[graphics3d]]]];

Nouveauté de la version 1.90: La fonction a été légèrement mise à jour, en particulier pour éviter des problèmes avec SequenceForms.

Si g est un objet Graphics3D (par exemple retourné par ParametricPlot3D) puis l'InputForm sera générée par LiveForm[g]. Le résultat peut être collé dans un fichier, dont le nom est utilisé comme la valeur du paramètre LiveGraphics3D INPUT_FILE (voir l'exemple ci-dessous).

La valeur d'INPUT_FILE devrait être le nom d'un fichier contenant une InputForm d'un objet LiveGraphics3D. Certes, nous pouvons écrire un tel fichier dans Mathematica. Voici une fonction pour se faire:

WriteLiveForm[filename_, graphics_, animOpts___] := 
    Module[{ps,x}, ps=Unprotect[Real]; Format[x_Real, InputForm] := 
    OutputForm[NumberForm[x, 5, NumberFormat -> (If[#3 == "", #1, 
    SequenceForm[#1, "*^", #3]] &)]]; Protect@@ps;
    WriteString[filename, ToString[LiveForm[graphics, animOpts],
    CharacterEncoding->None]]; Close[filename];
    ps=Unprotect[Real]; Format[x_Real, InputForm] =.; Protect@@ps;];

Si g estencore un objet Graphics3D puis WriteLiveForm["test.m", g] va l'écrire dans une InputForm appropriée de g dans un fichier appellé test.m dans le répertoire courant. (la fonction de Mathematica Directory[] va afficher le nom du répertoire courant, FileNames[] va lister les noms des fichiers présents et SetDirectory["directoy name"] va les changer.)

Si LiveGraphics3D n'accepte pas une entrée cela affiche un message d'erreur incluant la partie critique de l'InputForm. Toutefois tous objets Graphics3D corrects accepté par Mathematica et convertis comme décrit ci-dessus sauront travailler sans difficultés.

Toutefois dans certains cas, LiveGraphics3D n'affiche pas les graphiques exactement de la même manière que Mathematica ne le ferait. Toutes les différences et les limites sont énumérés dans l'annexe Limitations.  

Convertir des animations

Il existe deux types d'animations dans LiveGraphics3D. (Les simples filaires ne sont pas considérées comme une animation ici!) La première consiste à animer une liste d'objets Graphics3D similairement à la commande Mathematica ShowAnimation. La syntaxe pour préciser cette liste est ShowAnimation[gl, opts] avec gl qui sera une liste d'objets Graphics3D et opts une liste (ou séquence) d'options Graphics3D ou d'options Mathematica's Cell, AnimationDirection et AnimationDisplayTime. (La liste d'objets Graphics3D peut être facilement produite avec la commande Table de Mathematica.) AnimationDirection sera faite de Forward, Backward, ou ForwardBackward; AnimationDisplayTime précise le minimum de temps que chaque image est affichée en secondes.

La fonction LiveForm[gl, opts] voir ci-dessous pourra produire la forme nécessaire; la fonction WriteLiveForm[filename, gl, opts] voir ci-dessous pourra être écrite dans un fichier.

Depuis la version 1.00 il existe un autre moyen de spécifier une animation, si c'est une animation d'un objet Graphics3D cela sera paramétré par un paramètre de temps. Ceci est similaire à la commande Animate dans Mathematica. Les détails à propos des graphiques paramétrés sont décrit ci-dessous. La syntaxe de la commande Animate dans LiveGraphics3D est Animate[g, {var, from, to, step}, opts] où g est un objet Graphics3D paramétré, var est une variable de temps, from est sa valeur de départ, to la valeur maximale, step la taille du pas de temps, et opts une liste ou séquence d'options d'animation comme décrite ci-dessus. Notez que le paramètre de temps var doit être déclaré dans un paramètre d'applet INDEPENDENT_VARIABLES, bien que la valeur initiale soit spécifiée par from. (Voir ci-dessous pour une explication de INDEPENDENT_VARIABLES.)

La définition suivante (en addition à la précédente définition pour LiveForm) pourra produire une forme appropriée lorsqu'il sont appellés avec LiveForm[g, {var, from, to, step}, opts]. (De même, WriteLiveForm va utiliser cette fonction pour écrire l'expression dans un fichier.)

LiveForm[graphics_, {var_, from_, to_, step_}, animOpts___] := 
    Module[{},HoldForm[Animate][LiveForm[graphics], 
    InputForm[N[{var,from,to,step}]],InputForm[N[Flatten[{animOpts}]]]]];

Convertir des graphiques bi-dimensionnels

De simple graphiques bi-dimensionnels (objets Graphics) peuvent être convertis en graphiques tri-dimensionnel avec la commande Mathematica StackGraphics du package Graphics`Graphics3D` et un règlage approprié de l'option ViewPoint. Toutefois, afin d'éviter toutes complications, chaque graphiques bi-dimensionnels sera construit en tri-dimensionnel avec toutes ses coordonnées z à 0 (zéro). Afin d'éviter d'avoir des rotations de graphiques bi-dimensionnels le paramètre d'applet MOUSE_DRAG_ACTION doit être règlé sur NONE.

Convertir d'autres objets graphiques

ContourGraphics, DensityGraphics, et SurfaceGraphics doivent être convertis en objects Graphics3D avant de pouvoir être utilisé avec LiveGraphics3D. Ceci est automatiquement ralisé par les fonctions LiveForm et WriteLiveForm définies ci-dessous.

Le tableau suivant contient plusieurs fonctions standard de Mathematica, le type retourné de leurs grahiques et la commande pour convertir en object s'appelle g pour ce type dans un objet Graphics3D. (ParametricPlot3D renvoie l'objet Graphics3D, ce qui n'est pas listé ici.)

Graphiques paramétrés (nouveautés dans la version 1.00)

Les graphiques paramétrées sont des objets Graphics3D qui contiennent des expressions mathématiques avec des variables indéfinies, par exemple Graphics3D[{Point[{x, y, 0.5*x}]}]. L'affichage et la manipulation interactive de ces graphiques est supportée par LiveGraphics3D depuis la version 1.00. La prestation basique de ces graphiques paramétrésest la possibilité d'interagir avec leurs points de glissement, par exemple lorsque l'utilisateur glisse certains points, LiveGraphics3D va mettre à jour la scène en conséquence. Une introduction aux graphiques paramétrés avec LiveGraphics3D est donnée dans mon discours Manipulation Directe des Graphiques Paramétrés, lorsque que je l'ai présenté à la Mathematica Developer Conference de 2001. Ceux-ci sont aussi documentés par plusieurs exemples disponibles de graphiques paramétrés. Le reste de cette section (dans cet ordre) l'initialisation et la définition des variables et les détails au sujet de l'évaluation et des spécifications des expressions dans LiveGraphics3D.

Comme indiqué plus haut, les graphiques paramétrés peuvent contenir des expressions avec des variables, par exemple le x et y  dans cet exemple Graphics3D[{Point[{x, y, 0.5*x}]}]. Toutes les variables ont été initialisées ou définies avec l'aide des paramètres d'applet INDEPENDENT_VARIABLES et  DEPENDENT_VARIABLES. (Ces déclarations sont nécessaires parce que l'affichage initial des graphiques nécessite valeurs pour toutes les variables pour pouvoir évaluer toutes les expressions.)

La différence entre les variables indépendantes et dépendantes est que les variables indépendantes peuvent être manipulés par l'utilisateur, tandis que chaque variables dépendantes a définit une dépendance à l'égard des autres variables, ce qui est toujours appliqué; ainsi l'utilisateur ne peut pas manipuler directement les variables dépendantes. La manipulation des variables indépendantes est possible en faisant glisser le Point des primitives avec au moins une coordonnée qui est spécifiée directement dans la variable indépendante. Lorsque l'utilisateur déplace un tel point, les correspondances de la variable indépendante change de valeur en accord avec sa nouvelle position

Le paramètre d'applet INDEPENDENT_VARIABLES doit être réglé sur une liste de règles de la forme {identifier->number, ...}, par exemple {x->0, hello->3.1415}. Cette liste définit les valeurs initiales pour toutes les variables indépendantes. DEPENDENT_VARIABLES définit les variables dépendantes et de leurs dépendances. Sa valeur doit être une liste de règles de la forme {identifier->expression, ...},  par exemple {y->2*x, siny->Sin[y], aConstant->5, x->If[x<0,0,x]}. Les expressions sont de simples expressions Mathematica comme décrites ci-dessous. Notez que toute variable dépendante peut dépendre de toute variable indépendante, par exemple; Dans cet exemple, la variable dépendante y dépend de la variable indépendante x. Une variable dépendante peut dépendre aussi de précédentes variables dépendantes, par exemple la deuxième variable dépendante Siny dépend de la première variable dépendante y. Une variable dépendante peut également être réglée à une valeur constante, par exemple aConstant-> 5. Comme les variables dépendantes ne peuvent pas être manipulées par l'utilisateur, ces variables sont en fait des constantes.

Utilisation avancées de DEPENDENT_VARIABLES: Les règles dans DEPENDENT_VARIABLES sont actuellement utilisées pour assigner de nouvelles valeurs à toutes les valriables dépendantes afin que rien des variables indépendantes ne puissent être manipulée par l'utilisateur. Ces affectations sont effectuées de façon séquentielle par l'évaluation de l'expression du côté droit de chaque état et la variable sur le côté gauche au résultat. Dans certains cas, il est pratique d'utiliser également ces missions pour les variables indépendantes, par exemple dans notre exemple, la règle x->If[x<0,0,x] règlage de x à 0 lorsque l'utilisateur tente de "glisser" vers une valeur négative. (Notez ceci: xINDEPENDENT_VARIABLES.) il peut y avoir n'importe quel nombre de règles pour une variable indépendante dans la liste des DEPENDENT_VARIABLES; seulement, il ne peut y avoir qu'une seule règle pour chaque variable dépendante. (Il est pratique d'avoir de multiples règles pour une variable indépendante, il n'y a pas de raison pour que cela soit identique pour les variables dépendantes.) 

Les graphiques paramétrés peuvent contenir des expressions Mathematica simples au lieu de coordonnées au sein des primitives et sur le coté droit (on the right-hand side) des règles dans les DEPENDENT_VARIABLES, mais nulle part ailleurs (nowhere else). En particulier, vous pouvez utiliser une expression au lieu de n'importe quelle coordonnée dans un Point, Polygon, ou Line (ligne) primitive. Vous pouvez aussi utiliser les expressions dans un second argument d'une primitive de Text. Cependant, vous ne pouvez pas mettre une expression autour de primitives mentionnées, ou au sein d'une primitive Cuboid ou tout autre directive, ex. RGBColor, ou option, ex. ViewPoint.

Expressions spéciales (new in version 1.80): Le premier argument d'un primitive Text ne peut pas être une expression; cependant, vous pouvez spécifier un nom de variable. Cette variable est ensuite évaluée et sa valeur numérique est inscrite. (Pour les expressions générales, définissez une nouvelle variable dépendante. Si vous voulez spécifier le nom de la variable elle-même, utilisez des guillemets.) Le niveau(level)-primitif If est la seule fonction que vous pouvez utiliser en dehors d'une primitive; ex., If[x < 0, {RGBColor[1,0,0], Point[{x,0,0}]}, {RGBColor[0,0,1], Point[{x,1,0}]}]. Il y a deux importantes restrictions pour le niveau-primitive If: Premièrement, le premier argument ne doit pas être une expression (Booléenne) et tousles autres arguments doivent être des listes de primitives et directives. (Un seule primitive ou directive est automatiquement convertie en une liste pour un élément; donc, aucune directive dans un argument peut avoir un effet sur l'extérieur de cet argument. Les listes récursives et les niveaux-primitifs Ifs sont permis.) Deuxièmement, aucune primitives se trouvant dans de "false" branches d'un niveau-primitif If ne sera retiré; mais elles ne seront tout simplement pas affichées; cependant, tout les autres calculs seront encore éxécutés même s'il ne sont pas nécessaire. (Donc, il n'y a tout simplement pas de différence de vitesses comparé à l'affichage de toutes les primitives de toutes les branches.)

Les expressions dans les graphiques paramétrés doivent être assez simples. Toutes les variables doivent être chiffres en virgule flottante. (Les valeurs Booléennes sont représentées par 0. (False) et 1. (True).) Cela implique que les variables ne peuvent être des nombres complexes ou des nombres rationnels, ou des autres objets, ex. Lists. Si une expression évalue à une valeur complexe (ou à un résultat indéfini), If any expression evaluates to a complex value (or an undefined result), la totalité de l'évaluation échoue et LiveGraphics3D utilise un ensemble de règles prioritaires de valeurs pour que l'évaluation des variables indépendantes soit conduite avec succès. La syntaxe des expressions se résume à quelques éléments: les nombres, les variables, les operators, et les built-in functions.

Les règles lexicales pour les nombres et des variables suivent les conventions Mathematica habituelles. Toute variable doit être soit une variable indépendante, c'est-à-dire qu'elle se produit dans la liste prévue par INDEPENDENT_VARIABLES, ou une variable dépendante, c'est-à-dire qu'elle se produit dans la liste prévue par DEPENDENT_VARIABLES, ou c'est l'une des constantes mathématique "built-in". (Le paramètre temps d'un objet Animate doit être inclus dans la liste des variables indépendantes.)

Les opérateurs de Mathematica supportés par LiveGraphics3D sont énumérés dans le tableau ci-dessous.

LiveGraphics3D supporte un certain nombre de fonctions Mathematica, en particulier les fonctions énumérées dans le navigateur de l'aide, en catégorie "Mathematical Functions". En particulier, la plupart des fonctions incluses dans les sous-catégories "Basic Arithmetic", "Mathematical Constants", "Numerical Functions", et "Elementary Functions" sont prises en charge (supportées). Quelques autres fonctions mathématiques et non-mathématiques sont aussi supportées. Il est à noter que tous les arguments et les résultats sont limités à des valeurs réelles, c'est-à-dire, si tout argument ou le résultat est un complexe, la fonction échouera. Les tableaux ci-dessous listent les fonctions supportées. Il est à noter que seulement le nombre indiqué d'arguments est pris en charge. Notez également que certaines fonctions ne sont qu'à peu près estimées, en particulier les factorial-related functions.

Mise en forme du texte (Nouveau dans la version 1.90)

Dans LiveGraphics3D, le premier argument du Text primitif est limitée à un très petit sous-ensemble des expressions Mathematica. Ce sous-ensemble convient pour de simples expressions de graphiques avec notation mathématique mais ne prend pas en charge une expression d'équations complexes. Les mêmes restrictions sont aussi appliquées aux expressions de texte spécifié dans les options PlotLabel, AxesLabel et Ticks. Basiquement, une expression de texte représente une chaine (entre double-guillemets: "..."; ou entre deux paires de guillemets simples: ''...''), un nombre, un identifiant (qui est évalué par un nombre dans le cas de variables spécifiées par les paramètrese de l'applet INDEPENDENT_VARIABLES ou DEPENDENT_VARIABLES), ou l'une de ces fonctions de mise en forme StyleForm, HoldForm, SequenceForm, StringForm, Subscript, Superscript, Subsuperscript, Underscript, Overscript, Underoverscript, UnderBar, OverBar, OverVector, OverHat, OverTilde et OverDot. La plupart des arguments de ces fonctions peuvent aussi être des expressions de texte. Une description plus formelle de la grammaire des expressions pour le texte dans LiveGraphics3D est donnée dans le tableau ci-dessous, tableau qui comprend également la liste des options valides pour StyleForm (et pour l'option Graphics3D : TextStyle). Pour de plus amples informations sur ces fonctions, veuillez consulter la documentation de Mathematica. Ici nous traiterons seulement des différences spécifiques pour LiveGraphics3D.

Note sur le texte mis en forme fonctions dans Mathematica: Pour utiliser les fonctions de formatage de texte tels que  StringForm, Subscript, etc. dans Mathematica pour LiveGraphics3D, vous ne devez pas utiliser la fonction Format parce que les fonctions de mise en forme du texte n'apparaîtront pas dans l'InputForm d'un symbole mis en forme de cette façon. Au lieu de cela, vous devez définir directement un symbole de séparation avec la fonction de mise en forme du texte, ex.:

symB[i_,t_] := StringForm["`1`(`2`)", Subscript["B", i], t]

Avec cette définition, symB[n, x] sera généralement inscrite comme ceci B_n(x) dans Mathematica mais l'InputForm pourra être StringForm["`1`(`2`)", Subscript["B", n], x]. Cette InputForm sera envoyée dans LiveGraphics3D, InputForm qui sera inscrite comme B_n(x).

Note concernant overscripts, underscripts, et baseline shifts: Toutes les fonctions de mise en forme et en particulier UnderBar, OverBar, etc. peuvent seulement se rapprocher approximativement des fonctions Mathematica. La première raison est que la mise en oeuvre dans LiveGraphics3D utiliste d'autres fontes que Mathematica pour le support d'autres plateforms et fontes. Un autre raison est pour l'applet, l'incapacité à déterminer la hauteur d'un caractère individuel; par conséquent, Overscript et Underscript choisiront d'office des écarts de travail trop important afin de garantir le non-chevauchement des caractères avec le paramètre par défaut ScriptBaselineShifts->{0.6, 0.9, Automatic, Automatic}. Pour UnderBar, OverBar, etc. LiveGraphics3D choisira differentes baseline shifts (défault dans ce cas: ScriptBaselineShifts->{0.6, 0.9, 0.9, 1.2}) afin de mieux se rapprocher du rendu dans Mathematica. Ces changements pourraient être trop petits ou trop grands en fonction d'une plateforme spécifique, la fontes choisie, et les caractères. Afin de remédier à ce problème, LiveGraphics3D vous permet de spécifier un troisième et un quatrième numéro dans la liste figurant à l'option ScriptBaselineShifts. Ces chiffres ont la même signification que le premier et le deuxième élément mais pour Overscript et Underscript au lieu de Subscripts et superscripts. Les unités des quatre numéros sont censés être à la hauteur d'un "x", qui est estimé par la moitié de la hauteur maximale (hauteur montante) de n'importe quel caractère dans la fonte (la police d'écriture).

Exemples: OverVector["v"] est internalement représenté par

StyleForm[Overscript["v","\[RightArrow]"], ScriptBaselineShifts->{0.6, 0.9, 0.9, 1.2}]

StyleForm[OverVector["v"], ScriptBaselineShifts->{0.6, 0.9, 0.9, 1.0}]

StyleForm[Overscript["v","\[RightVector]"],ScriptBaselineShifts->{0.6, 0.9, 0.9, 1.0}]

Remarque concernant les caractères spéciaux: Il existe de nombreux caractères spéciaux dans Mathematica qui ne peuvent être rendus par LiveGraphics3D. Néanmoins, LiveGraphics3D enverra le bon unicode pour la plupart des caractères spéciaux à la Machine Virtuelle Java. Si l'unicode est supporté par la police employée par la machine virtuelle Java, au moins un caractère similaire sera rendu. Toutefois, de nombreux caractères de Mathematica sont des caractères Unicode d'applications spécifiques, donc, il n'y a presque aucune chance de les rendre correctement.

Remarque concernant les fontes de subsitutions: L'option StyleForm : FontSubstitutions émulera le nom de fonte sans utiliser les noms originaux. Par défaut c'est {"Times"->"TimesRoman", "TimesNewRoman"->"TimesRoman", "Roman"->"TimesRoman", "Arial"->"Helvetica", "Geneva"->"Helvetica", "System"->"Helvetica", "CourierNew"->"Courier", "Typewriter"->"Courier", "Monotype"->"Courier"}. "TimesRoman", "Helvetica", et "Courier" sont des familles de fontes standards pour Java 1.0. Dans Java 1.1, les familles de fontes standards sont "Serif", "SansSerif", et "Monospaced"; mais les noms de Java 1.0 sont probablement supportées par d'autres Machines Virtuelles Java. Si vous spéfiez d'autres FontSubstitions assurez-vous d'avoir bien pris en compte la substitution de "Times" par "TimesRoman" parce que la documentation Mathematica recommande le nom "Times" pour une fonte sherif, tandis que d'autres machines virtuelles Java utilisent en fait une fonte SansSherif lorsqu'une applet demande la fonte "Times".Depuis que LiveGraphics3D travaille sans vérification des retour de fontes par la Machinee Virtuelle Java, il est tout à fait dangereux de demander une police sauf "TimesRoman", "Helvetica", et "Courier"; donc, toutes FontSubstitutions saura émuler un des trois noms (ou une des trois variantes de Java 1.1 alternatives "Serif", "SansSerif", and "Monospaced").

Remarque concernant les URLs: L'option non-Mathematica URL peut être configurée dans une chaine contenant l'URL. Si c'est spécifié cela change la primitive text à l'intérieur de l'hyperlink.(S'il y a plusieurs options  URL dans un primitive text, une option est choisie par l'applet.) En outre, la chaîne ", target =" être jointe, suivie par une spécification "cible" ("target") (comme dans l'attribut target de la balise HTML A ). Voici un exemple:

Text[StyleForm["Mathematica\.ae", 
FontFamily->"Times", 
FontSlant->"Italic",
FontSize->20,
URL->"http://www.wolfram.com,target=_self"], 
{1,1,0}, {0,-1}]

   Par Martin Kraus. Certains droits réservés. (Traduction FR 06/2008, Franck Vernel).

◄◄ précédent  ▲▲ haut de page ▲▲  suivant ►► 

©2008 webmaster.