`matplotlib.tri`#

Fonctions de grille triangulaire non structurées.

classe matplotlib.tri. Triangulation ( x , y , triangles = None , mask = None ) [source] #

Une grille triangulaire non structurée composée de npoints points et de ntri triangles. Les triangles peuvent être soit spécifiés par l'utilisateur, soit générés automatiquement à l'aide d'une triangulation de Delaunay.

Paramètres :

x, y (npoints,) en forme de tableau: Coordonnées des points de la grille.
triangles (ntri, 3) comme un tableau d'entiers, facultatif: Pour chaque triangle, les indices des trois points qui composent le triangle, ordonnés dans le sens inverse des aiguilles d'une montre. Si non spécifié, la triangulation de Delaunay est calculée.
masque (ntri,) semblable à un tableau de booléens, facultatif: Quels triangles sont masqués.

Remarques

Pour qu'une triangulation soit valide, elle ne doit pas avoir de points en double, de triangles formés à partir de points colinéaires ou de triangles qui se chevauchent.

Attributs :

triangles (ntri, 3) tableau d'entiers: Pour chaque triangle, les indices des trois points qui composent le triangle, ordonnés dans le sens inverse des aiguilles d'une montre. Si vous souhaitez prendre en compte le masque , utilisez get_masked_trianglesplutôt.
masque (ntri, 3) tableau de bool: Triangles masqués.
is_delaunay booléen: Si la triangulation est une triangulation de Delaunay calculée (où les triangles n'ont pas été spécifiés) ou non.

calculate_plane_coefficients ( z ) [source] #: Calculez les coefficients d'équation de plan pour tous les triangles non masqués à partir des coordonnées du point (x, y) et du tableau z spécifié de la forme (npoints). Le tableau renvoyé a la forme (npoints, 3) et permet de calculer la valeur z à la position (x, y) dans le triangle tri à l'aide de .z = array[tri, 0] * x + array[tri, 1] * y + array[tri, 2]

bords de propriété #

Renvoie un tableau d'entiers de forme (arêtes, 2) contenant toutes les arêtes des triangles non masqués.

Chaque ligne définit une arête par son index de point de départ et son index de point final. Chaque arête n'apparaît qu'une seule fois, c'est-à-dire que pour une arête entre les points i et j , il n'y aura que soit (i, j) soit (j, i) .

get_cpp_triangulation ( ) [source] #: Renvoie l'objet C++ Triangulation sous-jacent, en le créant si nécessaire.

statique get_from_args_and_kwargs ( * args , ** kwargs ) [source] #

Renvoie un objet Triangulation à partir des args et kwargs, et des args et kwargs restants avec les valeurs consommées supprimées.

Il existe deux alternatives : soit le premier argument est un objet Triangulation, auquel cas il est renvoyé, soit les args et kwargs suffisent à créer une nouvelle Triangulation à renvoyer. Dans ce dernier cas, voir Triangulation.__init__ pour les args et kwargs possibles.

get_masked_triangles ( ) [source] #: Renvoie un tableau de triangles en tenant compte du masque.

get_trifinder ( ) [source] #: Renvoie la valeur par défaut matplotlib.tri.TriFinderde cette triangulation, en la créant si nécessaire. Cela permet de partager facilement le même objet TriFinder.

voisins de la propriété #

Renvoie un tableau d'entiers de forme (ntri, 3) contenant des triangles voisins.

Pour chaque triangle, les indices des trois triangles qui partagent les mêmes arêtes, ou -1 s'il n'y a pas de tel triangle voisin. est le triangle voisin de l'arête d'indice de point à indice de point .neighbors[i, j]triangles[i, j]triangles[i, (j+1)%3]

set_mask ( masque ) [source] #

Définissez ou effacez la matrice de masques.

Paramètres :

masque Aucun ou bool tableau de longueur ntri

classe matplotlib.tri. TriContourSet ( ax , * args , ** kwargs ) [source] #

Socles :ContourSet

Créez et stockez un ensemble de lignes de contour ou de régions remplies pour une grille triangulaire.

Cette classe n'est généralement pas instanciée directement par l'utilisateur mais par tricontouret tricontourf.

Attributs :

hacheAxes: L'objet Axes dans lequel les contours sont dessinés.
collections silent_listde PathCollections: Le Artists représentant le contour. Il s'agit d'une liste de PathCollections pour les contours linéaires et remplis.
tableau de niveaux: Les valeurs des niveaux de contour.
tableau de couches: Identiques aux niveaux pour les contours de lignes ; à mi-chemin entre les niveaux pour les contours remplis. Voir ContourSet._process_colors.

Dessinez des lignes de contour de grille triangulaires ou des régions remplies, selon que le mot-clé arg filled est False (par défaut) ou True.

Le premier argument de l'initialiseur doit être un Axes objet. Les arguments restants et les arguments de mots clés sont décrits dans la docstring de tricontour.

classe matplotlib.tri. TriFinder ( triangulation ) [source] #

Classe de base abstraite pour les classes utilisées pour trouver les triangles d'une triangulation dans lesquels se trouvent les points (x, y).

Plutôt que d'instancier un objet d'une classe dérivée de TriFinder, il est généralement préférable d'utiliser la fonction Triangulation.get_trifinder.

Les classes dérivées implémentent __call__(x, y) où x et y sont des coordonnées de point de type tableau de la même forme.

classe matplotlib.tri. TrapezoidMapTriFinder ( triangulation ) [source] #

Socles :TriFinder

TriFinderclasse implémentée à l'aide de l'algorithme de carte trapézoïdale du livre "Computational Geometry, Algorithms and Applications", deuxième édition, par M. de Berg, M. van Kreveld, M. Overmars et O. Schwarzkopf.

La triangulation doit être valide, c'est-à-dire qu'elle ne doit pas avoir de points en double, de triangles formés à partir de points colinéaires ou de triangles qui se chevauchent. L'algorithme a une certaine tolérance aux triangles formés à partir de points colinéaires, mais il ne faut pas s'y fier.

classe matplotlib.tri. TriInterpolator ( triangulation , z , trifinder = None ) [source] #

Classe de base abstraite pour les classes utilisées pour interpoler sur une grille triangulaire.

Les classes dérivées implémentent les méthodes suivantes :

__call__(x, y), où x, y sont des coordonnées ponctuelles de type tableau de la même forme, et qui renvoie un tableau masqué de la même forme contenant les valeurs z interpolées.
gradient(x, y), où x, y sont des coordonnées ponctuelles de type tableau de même forme, et qui renvoie une liste de 2 tableaux masqués de même forme contenant les 2 dérivées de l'interpolateur (dérivées des valeurs z interpolées par rapport à x et y).

classe matplotlib.tri. LinearTriInterpolator ( triangulation , z , trifinder = None ) [source] #

Socles :TriInterpolator

Interpolateur linéaire sur une grille triangulaire.

Chaque triangle est représenté par un plan de sorte qu'une valeur interpolée au point (x, y) se trouve sur le plan du triangle contenant (x, y). Les valeurs interpolées sont donc continues à travers la triangulation, mais leurs premières dérivées sont discontinues aux bords entre les triangles.

Paramètres :

triangulationTriangulation: La triangulation sur laquelle interpoler.
z (npoints,) en forme de tableau: Tableau de valeurs, définies aux points de la grille, entre lesquelles interpoler.
trimètre TriFinder, en option: Si cela n'est pas spécifié, le TriFinder par défaut de la triangulation sera utilisé en appelant Triangulation.get_trifinder.

Méthodes

`__appel__` (x, y)	(Renvoie des valeurs interpolées aux points (x, y).)
`dégradé` (x, y)	(Renvoie les dérivées interpolées aux points (x, y).)

dégradé ( x , y ) [source] #

Renvoie une liste de 2 tableaux masqués contenant des dérivées interpolées aux points (x, y) spécifiés.

Paramètres :

x, y comme un tableau: coordonnées x et y de la même forme et de n'importe quel nombre de dimensions.

Retours :

dzdx, dzdy np.ma.array: 2 tableaux masqués de même forme que x et y ; les valeurs correspondant aux points (x, y) en dehors de la triangulation sont masquées. Le premier tableau retourné contient les valeurs de \(\frac{\partial z}{\partial x}\)et le second ceux de \(\frac{\partial z}{\partial y}\).

classe matplotlib.tri. CubicTriInterpolator ( triangulation , z , kind = 'min_E' , trifinder = None , dz = None ) [source] #

Socles :TriInterpolator

Interpolateur cubique sur une grille triangulaire.

En une dimension - sur un segment - une fonction d'interpolation cubique est définie par les valeurs de la fonction et de sa dérivée aux deux extrémités. C'est presque la même chose en 2D à l'intérieur d'un triangle, sauf que les valeurs de la fonction et ses 2 dérivées doivent être définies à chaque nœud du triangle.

Le CubicTriInterpolator prend la valeur de la fonction à chaque nœud - fournie par l'utilisateur - et calcule en interne la valeur des dérivées, ce qui donne une interpolation douce. (En tant que fonctionnalité spéciale, l'utilisateur peut également imposer la valeur des dérivées à chaque nœud, mais ce n'est pas censé être l'usage courant.)

Paramètres :

triangulationTriangulation

La triangulation sur laquelle interpoler.

z (npoints,) en forme de tableau

Tableau de valeurs, définies aux points de la grille, entre lesquelles interpoler.

genre {'min_E', 'geom', 'utilisateur'}, facultatif

Choix de l'algorithme de lissage, afin de calculer les dérivées interpolantes (par défaut 'min_E') :

if 'min_E' : (par défaut) Les dérivées à chaque nœud sont calculées pour minimiser une énergie de flexion.
if 'geom' : les dérivées à chaque nœud sont calculées comme une moyenne pondérée des normales du triangle pertinent. A utiliser pour l'optimisation de la vitesse (grandes grilles).
si 'utilisateur' : L'utilisateur fournit l'argument dz , aucun calcul n'est donc nécessaire.

trimètre TriFinder, en option

S'il n'est pas spécifié, le TriFinder par défaut de la triangulation sera utilisé en appelant Triangulation.get_trifinder.

dz tuple de tableau-likes (dzdx, dzdy), facultatif

Utilisé uniquement si kind ='user'. Dans ce cas, dz doit être fourni sous la forme (dzdx, dzdy) où dzdx, dzdy sont des tableaux de la même forme que z et sont les premières dérivées interpolantes aux points de triangulation .

Remarques

Cette note est un peu technique et détaille comment l'interpolation cubique est calculée.

L'interpolation est basée sur un schéma de subdivision Clough-Tocher du maillage de triangulation (pour plus de clarté, chaque triangle de la grille sera divisé en 3 triangles enfants, et sur chaque triangle enfant la fonction interpolée est un polynôme cubique des 2 coordonnées). Cette technique est issue de l'analyse FEM (Finite Element Method) ; l'élément utilisé est un élément Hsieh-Clough-Tocher (HCT) réduit. Ses fonctions de forme sont décrites dans [1] . La fonction assemblée est garantie C1-lisse, c'est-à-dire qu'elle est continue et que ses dérivées premières sont également continues (c'est facile à montrer à l'intérieur des triangles mais c'est aussi vrai lors du croisement des arêtes).

Dans le cas par défaut ( kind ='min_E'), l'interpolant minimise une énergie de courbure sur l'espace fonctionnel généré par les fonctions de forme des éléments HCT - avec des valeurs imposées mais des dérivées arbitraires à chaque nœud. La fonctionnelle minimisée est l'intégrale de la courbure dite totale (implémentation basée sur un algorithme de [2] - PCG sparse solver) :

\[E(z) = \frac{1}{2} \int_{\Omega} \left( \left( \frac{\partial^2{z}}{\partial{x}^2} \right)^2 + \left( \frac{\partial^2{z}}{\partial{y}^2} \right)^2 + 2\left( \frac{\partial^2{z}}{\partial{y}\partial{x}} \right)^2 \right) dx\,dy\]

Si le cas kind ='geom' est choisi par l'utilisateur, une approximation géométrique simple est utilisée (moyenne pondérée des vecteurs normaux du triangle), ce qui pourrait améliorer la vitesse sur de très grandes grilles.

Références

[ 1 ]

Michel Bernadou, Kamal Hassan, "Fonctions de base pour les triangles généraux de Hsieh-Clough-Tocher, complets ou réduits.", International Journal for Numerical Methods in Engineering, 17(5):784 - 789. 2.01.

[ 2 ]

CT Kelley, "Méthodes itératives d'optimisation".

Méthodes

`__appel__` (x, y)	(Renvoie des valeurs interpolées aux points (x, y).)
`dégradé` (x, y)	(Renvoie les dérivées interpolées aux points (x, y).)

dégradé ( x , y ) [source] #

Renvoie une liste de 2 tableaux masqués contenant des dérivées interpolées aux points (x, y) spécifiés.

Paramètres :

x, y comme un tableau: coordonnées x et y de la même forme et de n'importe quel nombre de dimensions.

Retours :

dzdx, dzdy np.ma.array: 2 tableaux masqués de même forme que x et y ; les valeurs correspondant aux points (x, y) en dehors de la triangulation sont masquées. Le premier tableau retourné contient les valeurs de \(\frac{\partial z}{\partial x}\)et le second ceux de \(\frac{\partial z}{\partial y}\).

classe matplotlib.tri. TriRefiner ( triangulation ) [source] #

Classe de base abstraite pour les classes implémentant le raffinement du maillage.

Un TriRefiner encapsule un objet Triangulation et fournit des outils pour le raffinement et l'interpolation du maillage.

Les classes dérivées doivent implémenter :

refine_triangulation(return_tri_index=False, **kwargs), où les arguments mot-clé facultatifs kwargs sont définis dans chaque implémentation concrète de TriRefiner, et qui renvoie :
- une triangulation raffinée,
- éventuellement (selon return_tri_index ), pour chaque point de la triangulation raffinée : l'indice du triangle de triangulation initial auquel il appartient.
refine_field(z, triinterpolator=None, **kwargs), où:
- z tableau de valeurs de champ (à affiner) défini aux noeuds de triangulation de base,
- triinterpolator est un facultatif TriInterpolator,
- les autres arguments mot-clé facultatifs kwargs sont définis dans chaque implémentation concrète de TriRefiner ;
et qui renvoie (sous forme de tuple) un maillage triangulaire raffiné et les valeurs interpolées du champ aux nœuds de triangulation raffinés.

classe matplotlib.tri. UniformTriRefiner ( triangulation ) [source] #

Socles :TriRefiner

Raffinement uniforme du maillage par subdivisions récursives.

Paramètres :

triangulationTriangulation: La triangulation encapsulée (à affiner)

affiner_field ( z , triinterpolator = None , subdiv = 3 ) [source] #

Affiner un champ défini sur la triangulation encapsulée.

Paramètres :

z (npoints,) en forme de tableau: Valeurs du champ à raffiner, définies aux nœuds de la triangulation encapsulée. ( n_pointsest le nombre de points dans la triangulation initiale)
triinterpolateur TriInterpolator, facultatif: Interpolateur utilisé pour l'interpolation de champ. S'il n'est pas spécifié, un CubicTriInterpolatorsera utilisé.
subdiv entier , par défaut : 3: Niveau de récurrence pour la subdivision. Chaque triangle est divisé en 4**subdivtriangles enfants.

Retours :

refi_triTriangulation: La triangulation raffinée retournée.
refi_z Tableau 1D de longueur : nombre de nœuds refi_tri .: Le champ interpolé renvoyé (aux nœuds refi_tri ).

affiner_triangulation ( return_tri_index = False , subdiv = 3 ) [source] #

Calculer une triangulation uniformément raffinée refi_triangulation du encapsulé triangulation.

Cette fonction affine la triangulation encapsulée en divisant chaque triangle père en 4 sous-triangles enfants construits sur les nœuds médians des arêtes, en récursant les temps de subdiv . Au final, chaque triangle est donc divisé en 4**subdivtriangles enfants.

Paramètres :

return_tri_index bool, par défaut : False: Indique si une table d'index indiquant l'index du triangle père de chaque point est renvoyée.
subdiv entier , par défaut : 3: Niveau de récurrence pour la subdivision. Chaque triangle est divisé en 4**subdivtriangles enfants ; par conséquent, la valeur par défaut donne 64 sous-triangles raffinés pour chaque triangle de la triangulation initiale.

Retours :

refi_triangulationTriangulation: La triangulation raffinée.
tableau d' entiers found_index: Indice de la triangulation initiale contenant le triangle, pour chaque point de refi_triangulation . Renvoyé uniquement si return_tri_index est défini sur True.

classe matplotlib.tri. TriAnalyzer ( triangulation ) [source] #

Définir les outils de base pour l'analyse et l'amélioration du maillage triangulaire.

Un TriAnalyzer encapsule un Triangulationobjet et fournit des outils de base pour l'analyse et l'amélioration du maillage.

Paramètres :

triangulationTriangulation: La triangulation encapsulée à analyser.

Attributs :

scale_factors: Facteurs pour redimensionner la triangulation dans un carré unitaire.

circle_ratios ( rescale = True ) [source] #

Renvoie une mesure de la planéité des triangles de triangulation.

Le rapport du rayon du cercle inscrit sur le rayon du cercle circonscrit est un indicateur largement utilisé de la planéité d'un triangle. C'est toujours et uniquement pour les triangles équilatéraux. Les rapports de cercle inférieurs à 0,01 indiquent des triangles très plats.<= 0.5== 0.5

Pour éviter des valeurs trop basses dues à une différence d'échelle entre les 2 axes, le maillage triangulaire peut d'abord être redimensionné pour s'adapter à l'intérieur d'un carré unitaire avec scale_factors(Seulement si redimensionner est True, qui est sa valeur par défaut).

Paramètres :

redimensionner bool, par défaut : vrai: Si True, redimensionner en interne (basé sur scale_factors), de sorte que les triangles (non masqués) tiennent exactement à l'intérieur d'un maillage carré unitaire.

Retours :

tableau masqué: Rapport du rayon du cercle inscrit sur le rayon du cercle circonscrit, pour chaque triangle "remis à l'échelle" de la triangulation encapsulée. Les valeurs correspondant aux triangles masqués sont masquées.

get_flat_tri_mask ( min_circle_ratio = 0.01 , rescale = True ) [source] #

Éliminez les triangles de bordure trop plats de la triangulation.

Retourne un masque new_mask qui permet de nettoyer la triangulation encapsulée de ses triangles plats bordés (en fonction de leur circle_ratios()). Ce masque est destiné à être appliqué ultérieurement à la triangulation à l'aide de Triangulation.set_mask. new_mask est une extension du masque de triangulation initial dans le sens où un triangle initialement masqué restera masqué.

Le tableau new_mask est calculé de manière récursive ; à chaque étape, les triangles plats sont supprimés uniquement s'ils partagent un côté avec la bordure de maillage actuelle. Ainsi, aucun nouveau trou dans le domaine triangulé ne sera créé.

Paramètres :

min_circle_ratio flottant, par défaut : 0,01: Les triangles de bordure avec un rapport de rayons incircle/circumcircle r/R seront supprimés si r/R < min_circle_ratio .
redimensionner bool, par défaut : vrai: Si True, commencez par redimensionner en interne (en fonction de scale_factors) afin que les triangles (non masqués) s'adaptent exactement à l'intérieur d'un maillage carré unitaire. Cette remise à l'échelle tient compte de la différence d'échelle qui peut exister entre les 2 axes.

Retours :

tableau de bool: Masque à appliquer sur la triangulation encapsulée. Tous les triangles initialement masqués restent masqués dans le new_mask .

Remarques

La logique derrière cette fonction est qu'une triangulation de Delaunay - d'un ensemble de points non structuré - contient parfois des triangles presque plats à sa frontière, conduisant à des artefacts dans les tracés (en particulier pour les contours à haute résolution). Masqué avec new_mask calculé , la triangulation encapsulée ne contiendrait plus de triangles de bordure non masqués avec un rapport de cercle inférieur à min_circle_ratio , améliorant ainsi la qualité du maillage pour les tracés ou l'interpolation suivants.

propriété scale_factors #

Facteurs pour redimensionner la triangulation dans un carré unitaire.

Retours :

(flotter, flotter): Facteurs d'échelle (kx, ky) pour que la triangulation tienne exactement à l'intérieur d'un carré unité.[triangulation.x * kx, triangulation.y * ky]

matplotlib.tri#

`matplotlib.tri`#