exemples — documentation SciPy Cookbook (2023)

#!/usr/bin/env mayavi2"""Ce script montre comment on peut scripter MayaVi et utiliser sesmodules liés aux contours. Remarquez la ligne magique en haut."""# Auteur : Prabhu Ramachandran # Copyright (c) 2005-2007, En Thought, Inc.# Licence : Style BSD.# Importations de bibliothèque standarddepuis os.path importer rejoindre, dirname# Importations de bibliothèques penséesimporter pensé.mayavidepuis enpensée.mayavi.sources.vtk_file_reader importer VTKFileReaderdepuis pensé.mayavi.filtres.seuil importer Seuildepuis pensé.mayavi.modules.outline importer Contourdepuis pensé.mayavi.modules.grid_plane importer GridPlanedepuis pensé.mayavi.modules.contour_grid_plane importer ContourGridPlanedepuis pensé.mayavi.modules.iso_surface importer IsoSurfacedepuis pensé.mayavi.modules.scalar_cut_plane importer ScalarCutPlanedéfinitivement contour(): """Le script lui-même. Nous n'avons pas besoin d'avoir défini une fonction maisavoir une fonction rend cela plus réutilisable.""" # 'mayavi' est toujours défini sur l'interpréteur. # Créez une nouvelle scène. mayavi.nouvelle_scène() # Lire un fichier de données VTK (ancien style). r = VTKFileReader() r.initialiser(rejoindre(dirname(pensé.mayavi.__déposer__), 'exemples', 'données', 'coeur.vtk')) mayavi.add_source(r) # Créez un plan pour les données. o = Contour() mayavi.add_module(o) # Créez trois modules de plan de grille simples. # Premier axe normal à 'x'. généraliste = GridPlane() mayavi.add_module(généraliste) # Second axe normal à 'y'. généraliste = GridPlane() mayavi.add_module(généraliste) généraliste.grille_plane.axe = 'y' # Troisième normale à l'axe 'z'. généraliste = GridPlane() mayavi.add_module(généraliste) généraliste.grille_plane.axe = 'z' # Créez un ContourGridPlane normal à l'axe 'x'. cgp = ContourGridPlane() mayavi.add_module(cgp) # Définissez la position au milieu des données. cgp.grille_plane.position = 15 # Un autre avec des contours pleins normaux à l'axe 'y'. cgp = ContourGridPlane() mayavi.add_module(cgp) # Définissez l'axe et la position au milieu des données. cgp.grille_plane.axe = 'y' cgp.grille_plane.position = 15 cgp.contour.contours_remplis = Vrai # Un module d'isosurface. iso = IsoSurface(calcul_normales=Vrai) mayavi.add_module(iso) iso.contour.contours = [220,0] # Un plan de coupe scalaire interactif. CP = ScalarCutPlane() mayavi.add_module(CP) CP.plan_implicite.normal = 0,0,1si __nom__ == '__principal__': contour()

#!/usr/bin/env mayavi2"""Ce script illustre l'utilisation d'un VectorCutPlane, divisant lepipeline à l'aide d'un filtre MaskPoints, puis affichage des données filtréesavec le module Glyphe."""# Auteur : Prabhu Ramachandran # Copyright (c) 2005-2007, En Thought, Inc.# Licence : Style BSD.# Importations de bibliothèque standarddepuis os.path importer rejoindre, dirname# Importations de bibliothèques penséesimporter pensé.mayavidepuis enpensée.mayavi.sources.vtk_xml_file_reader importer VTKXMLFileReaderVTKXMLFileReaderdepuis pensé.mayavi.modules.outline importer Contourdepuis pensé.mayavi.modules.glyph importer Glyphedepuis pensé.mayavi.modules.vector_cut_plane importer Plan De Coupe De Vecteurdepuis pensé.mayavi.modules.vectors importer Vecteursdepuis pensé.mayavi.filters.mask_points importer MasquePointsdéfinitivement glyphe(): """Le script lui-même. Nous n'avons pas besoin d'avoir défini une fonction maisavoir une fonction rend cela plus réutilisable.""" # 'mayavi' est toujours défini sur l'interpréteur. # Créez une nouvelle scène VTK. mayavi.nouvelle_scène() # Lire un fichier de données VTK (ancien style). r = VTKXMLFileReaderVTKXMLFileReader() r.initialiser(rejoindre(dirname(pensé.mayavi.__déposer__), 'exemples', 'données', 'fire_ug.vtu')) mayavi.add_source(r) # Créez un contour et un plan de coupe vectoriel. mayavi.add_module(Contour()) v = Plan De Coupe De Vecteur() mayavi.add_module(v) v.glyphe.Mode de couleur = 'color_by_scalar' # Masquez maintenant les points et affichez les glyphes (nous pourrions aussi utiliser # Les vecteurs mais les glyphes sont un peu plus génériques) m = MasquePoints() m.filtre.ensemble(on_ratio=dix, mode_aléatoire=Vrai) mayavi.add_filter(m) g = Glyphe() mayavi.add_module(g) # Notez que cela ajoute le module à la sortie filtrée. g.glyphe.échelle_mode = 'échelle_par_vecteur' # Utilisez les flèches pour afficher les scalaires. g.glyphe.source_glyphe = g.glyphe.liste_glyphes[1]si __nom__ == '__principal__': glyphe()

#!/usr/bin/envpython"""Ce script montre comment utiliser le framework MayaVisans afficher l'interface utilisateur de MayaVi. Remarque : regardez à la fin de ce fichier pourvoir comment le plugin non gui est choisi au lieu de l'interface graphique par défautplug-in Mayavi."""# Auteur : Prabhu Ramachandran # Copyright (c) 2005, En Thought, Inc.# Licence : Style BSD.# Sur les systèmes avec plusieurs installations wx installées, choisissez-en une qui fonctionne# avec les bibliothèques dont Mayavi dépend.essayer: importer wxversion wxversion.assurerMinimal('2.6')sauf Erreur d'importation: passer# Importations de bibliothèque standardimporter systèmedepuis os.path importer rejoindre, dirname# Importations de bibliothèques penséesdepuis pensé.mayavi.app importer Mayavi, NONGUI_PLUGIN_DEFINITIONSclasse MonApp(Mayavi): définitivement courir(soi): """ Ceci est exécuté une fois que l'interface graphique de l'application a démarré.*Assurez-vous que toutes les autres importations spécifiques à MayaVi sont effectuées ici !*""" # Diverses importations pour faire différentes choses. depuis enpensée.mayavi.sources.vtk_file_reader importer VTKFileReader depuis pensé.mayavi.modules.outline importer Contour depuis pensé.mayavi.modules.axes importer Haches depuis pensé.mayavi.modules.grid_plane importer GridPlane depuis pensé.mayavi.modules.image_plane_widget importer ImagePlaneWidget depuis pensé.mayavi.modules.text importer Texte depuis pensé.mayavi.modules.contour_grid_plane importer ContourGridPlane depuis pensé.mayavi.modules.iso_surface importer IsoSurface scénario = soi.scénario # Créez une nouvelle scène. scénario.nouvelle_scène() # Lire un fichier de données VTK (ancien style). r = VTKFileReader() r.initialiser('données/coeur.vtk') r.initialiser(rejoindre(dirname(__déposer__), 'données', 'coeur.vtk')) scénario.add_source(r) # Mettez du texte. t = Texte(texte='Règles MayaVi!', x_position=0,2, y_position=0,9, largeur=0,8) t.propriété.couleur = 1, 1, 0 # Jaune vif, ouais ! scénario.add_module(t) # Créez un plan pour les données. o = Contour() scénario.add_module(o) # Créer un axe pour les données. un = Haches() scénario.add_module(un) # Créez trois modules de plan de grille simples. # Premier axe normal à 'x'. généraliste = GridPlane() scénario.add_module(généraliste) # Second axe normal à 'y'. généraliste = GridPlane() généraliste.grille_plane.axe = 'y' scénario.add_module(généraliste) # Troisième normale à l'axe 'z'. généraliste = GridPlane() scénario.add_module(généraliste) généraliste.grille_plane.axe = 'z' # Créez un ImagePlaneWidget. IPW = ImagePlaneWidget() scénario.add_module(IPW) # Définissez la position au milieu des données. IPW.IPW.slice_position = 16 # Créez un ContourGridPlane normal à l'axe 'x'. cgp = ContourGridPlane() scénario.add_module(cgp) # Définissez la position au milieu des données. cgp.grille_plane.axe = 'y' cgp.grille_plane.position = 15 # Un module d'isosurface. iso = IsoSurface(calcul_normales=Vrai) scénario.add_module(iso) iso.contour.contours = [200,0] # Définissez la vue. s = scénario.moteur.scène_actuelle came = s.scène.caméra came.azimut(45) came.élévation(15) s.rendre()si __nom__ == '__principal__': m = MonApp() # Notez comment nous modifions les plugins qui ne sont chargés qu'ici. m.principal(plugin_defs=NONGUI_PLUGIN_DEFINITIONS)

#!/usr/bin/env mayavi2"""Ce script montre comment créer un tableau numpy de données etvisualisez-le sous forme de données d'image à l'aide de quelques modules."""# Auteur : Prabhu Ramachandran # Copyright (c) 2005-2007, En Thought, Inc.# Licence : Style BSD.# Importations de bibliothèque standardimporter enought.util.scipyx comme scipy# Importations de bibliothèques penséesdepuis pensé.mayavi.sources.array_source importer TableauSourcedepuis pensé.mayavi.modules.outline importer Contourdepuis pensé.mayavi.modules.image_plane_widget importer ImagePlaneWidgetdéfinitivement make_data(assombrit=(128, 128, 128)): """ Crée des données de tableau simples des dimensions données à testeravec.""" np = assombrit[0]*assombrit[1]*assombrit[2] # Créez des scalaires à rendre. X, y, z = scipy.ogrille[-5:5:assombrit[0]*1j,-5:5:assombrit[1]*1j,-5:5:assombrit[2]*1j] X = X.astype('F') y = y.astype('F') z = z.astype('F') scalaires = (scipy.péché(X*y*z)/(X*y*z)) retour scipy.transposer(scalaires).copie() # Cela rend les données contiguës.définitivement view_numpy(): """Exemple montrant comment afficher un tableau numpy 3D dans mayavi2.""" # 'mayavi' est toujours défini sur l'interpréteur. mayavi.nouvelle_scène() # Créez les données et ajoutez-les au pipeline. données = make_data() src = TableauSource(transpose_input_array=FAUX) src.données_scalaires = données mayavi.add_source(src) # Visualisez les données. o = Contour() mayavi.add_module(o) IPW = ImagePlaneWidget() mayavi.add_module(IPW) IPW.module_manager.scalaire_lut_manager.show_scalar_bar = Vrai ipw_y = ImagePlaneWidget() mayavi.add_module(ipw_y) ipw_y.IPW.plane_orientation = 'y_axes'si __nom__ == '__principal__': view_numpy()

#!/usr/bin/env mayavi2"""Ce script montre comment on peut scripter MayaVi pour afficherlignes de courant et une surface iso."""# Auteur : Prabhu Ramachandran # Copyright (c) 2005-2007, En Thought, Inc.# Licence : Style BSD.# Importations de bibliothèque standarddepuis os.path importer rejoindre, dirname# Importations de bibliothèques penséesdepuis enpensée.mayavi.sources.vtk_xml_file_reader importer VTKXMLFileReaderVTKXMLFileReaderdepuis pensé.mayavi.modules.outline importer Contourdepuis pensé.mayavi.modules.streamline importer Rationaliserdepuis pensé.mayavi.modules.iso_surface importer IsoSurfacedéfinitivement setup_data(nom de famille): """Étant donné un nom de fichier XML VTK `fname`, cela crée un mayavi2lecteur pour cela et l'ajoute au pipeline. Il renvoie le lecteurcréé.""" mayavi.nouvelle_scène() r = VTKXMLFileReaderVTKXMLFileReader() r.initialiser(nom de famille) mayavi.add_source(r) retour rdéfinitivement rationaliser(): """ Configure le pipeline mayavi pour la visualisation.""" # Créez un plan pour les données. o = Contour() mayavi.add_module(o) s = Rationaliser(rationaliser_type='tube') mayavi.add_module(s) s.stream_tracer.direction_intégration = 'les deux' s.graine.widget.centre = 3.5, 0,625, 1.25 s.module_manager.scalaire_lut_manager.show_scalar_bar = Vrai je = IsoSurface() mayavi.add_module(je) je.contour.contours[0] = 550 je.acteur.propriété.opacité = 0,5si __nom__ == '__principal__': importer pensé.mayavi nom de famille = rejoindre(dirname(pensé.mayavi.__déposer__), 'exemples', 'données', 'fire_ug.vtu') r = setup_data(nom de famille) rationaliser()

#!/usr/bin/envpython"""Ce script montre comment on peut scripter MayaVi, définir sa taille,créez une nouvelle scène VTK et créez quelques modules simples."""# Auteur : Prabhu Ramachandran # Copyright (c) 2005, En Thought, Inc.# Licence : Style BSD.# Sur les systèmes avec plusieurs installations wx installées, choisissez-en une qui fonctionne# avec les bibliothèques dont Mayavi dépend.essayer: importer wxversion wxversion.assurerMinimal('2.6')sauf Erreur d'importation: passer# Importations de bibliothèque standardimporter systèmedepuis os.path importer rejoindre, dirname# Importations de bibliothèques penséesdepuis pensé.mayavi.app importer Mayaviclasse MonApp(Mayavi): définitivement courir(soi): """ Ceci est exécuté une fois que l'interface graphique de l'application a démarré.*Assurez-vous que toutes les autres importations spécifiques à MayaVi sont effectuées ici !*""" # Diverses importations pour faire différentes choses. depuis enpensée.mayavi.sources.vtk_file_reader importer VTKFileReader depuis pensé.mayavi.filtres.seuil importer Seuil depuis pensé.mayavi.modules.outline importer Contour depuis pensé.mayavi.modules.axes importer Haches depuis pensé.mayavi.modules.grid_plane importer GridPlane depuis pensé.mayavi.modules.image_plane_widget importer ImagePlaneWidget depuis pensé.mayavi.modules.text importer Texte scénario = soi.scénario # Créez une nouvelle scène. scénario.nouvelle_scène() # Lire un fichier de données VTK (ancien style). r = VTKFileReader() r.initialiser(rejoindre(dirname(__déposer__), 'données', 'coeur.vtk')) scénario.add_source(r) # Mettez du texte. t = Texte(texte='Règles MayaVi!', x_position=0,2, y_position=0,9, largeur=0,8) t.propriété.couleur = 1, 1, 0 # Jaune vif, ouais ! scénario.add_module(t) # Créez un plan pour les données. o = Contour() scénario.add_module(o) # Créer un axe pour les données. un = Haches() scénario.add_module(un) # Créez un axe d'orientation pour la scène. Cela ne fonctionne qu'avec # VTK-4.5 et supérieur, c'est pourquoi nous avons le bloc try. essayer: depuis pensé.mayavi.modules.orientation_axes importer Axes d'orientation sauf Erreur d'importation: passer autre: un = Axes d'orientation() un.marqueur.set_viewport(0.0, 0,8, 0,2, 1.0) scénario.add_module(un) # Créez trois modules de plan de grille simples. # Premier axe normal à 'x'. généraliste = GridPlane() scénario.add_module(généraliste) # Second axe normal à 'y'. généraliste = GridPlane() généraliste.grille_plane.axe = 'y' scénario.add_module(généraliste) # Troisième normale à l'axe 'z'. généraliste = GridPlane() scénario.add_module(généraliste) généraliste.grille_plane.axe = 'z' # Créez un ImagePlaneWidget. IPW = ImagePlaneWidget() scénario.add_module(IPW) # Définissez la position au milieu des données. IPW.IPW.slice_position = 16si __nom__ == '__principal__': un = MonApp() un.principal()

#!/usr/bin/env mayavi2"""Montre comment afficher les données créées par `enought.tvtk.tools.mlab` avecmayavi2."""# Auteur : Prabhu Ramachandran # Copyright (c) 2006-2007, En Thought Inc.# Licence : Style BSD.importer numpydepuis enpensée.tvtk.tools importer mlabdepuis pensé.mayavi.sources.vtk_data_source importer VTKDataSourcedepuis pensé.mayavi.filters.warp_scalar importer WarpScalairedepuis pensé.mayavi.modules.outline importer Contourdepuis pensé.mayavi.modules.surface importer Surfacedéfinitivement F(X, y): """Certaines fonctions de test.""" retour numpy.péché(X*y)/(X*y)définitivement make_data(): """ Faites des tests de données numpy et créez un objet de données TVTK à partir de celles-cique nous allons visualiser.""" X = numpy.arranger(-7., 7.05, 0,1) y = numpy.arranger(-5., 5.05, 0,05) s = mlab.SurfRegular(X, y, F) retour s.donnéesdéfinitivement add_data(tvtk_data): """Ajoutez un objet de données TVTK `tvtk_data` au pipeline mayavi.""" d = VTKDataSource() d.données = tvtk_data mayavi.add_source(d)définitivement surf_regular(): """Visualisez maintenant les données comme dans mlab.""" w = WarpScalaire() mayavi.add_filter(w) o = Contour() s = Surface() mayavi.add_module(o) mayavi.add_module(s)si __nom__ == '__principal__': mayavi.nouvelle_scène() d = make_data() add_data(d) surf_regular()