Pourquoi ne pyplot.contour() exiger de Z à un tableau 2D?

La matplotlib.pyplot.contour() fonction prend 3 entrée tableaux X, Y et Z.

Les tableaux X et Y spécifier les x et y des coordonnées des points, tandis que Z spécifie la valeur correspondante de la fonction d'intérêts évalués à les points.

Je comprends que np.meshgrid() permet de produire facilement des tableaux qui servent d'arguments à contour():

X = np.arange(0,5,0.01)
Y = np.arange(0,3,0.01)

X_grid, Y_grid = np.meshgrid(X,Y)
Z_grid = X_grid**2 + Y_grid**2

plt.contour(X_grid, Y_grid, Z_grid)  # Works fine

Cela fonctionne bien. Et idéalement, cela fonctionne très bien aussi:

plt.contour(X, Y, Z_grid)  # Works fine too

Cependant, pourquoi le Z entrée nécessaire être un 2D-tableau?

Pourquoi est quelque chose comme rejetée, même si elle précise tout de même des données alignées de manière appropriée?

plt.contour(X_grid.ravel(), Y_grid.ravel(), Z_grid.ravel())  # Disallowed

Aussi, ce sont la sémantique lorsque seulement Z est indiqué (sans le correspondant X et Y)?

linspace ne peut pas avoir un flotteur pour sa troisième argument (optionnel) dans votre exemple.
Merci, corrigé l'erreur.

OriginalL'auteur dhrumeel | 2017-02-04

  1. 6

    Regardant la documentation de contour, on trouve que il ya un couple de méthodes pour appeler cette fonction, par exemple contour(Z) ou contour(X,Y,Z). Ainsi, vous constaterez qu'il ne nécessite pas de X ou Y valeurs d'être présent à tous.

    Toutefois, dans le but de tracer un contour, le sous-jacentes de la grille doit être connue de la fonction. Matplotlib est contour est basé sur une grille rectangulaire. Mais tout de même, permettant contour(z), avec z être un tableau 1D, il serait impossible de savoir comment le champ doit être tracée. Dans le cas de contour(Z) où Z est un tableau 2D, sa forme sans ambiguïté définit la grille de départ de l'intrigue.

    Une fois que la grille est connu, il est plutôt pas d'importance si l'option X et Y tableaux sont aplaties ou pas; qui est en fait ce que la documentation nous dit:

    X et Y doivent être tous les deux 2-D avec la même forme de Z, ou ils doivent être tous les deux 1-D tels que len(X) est le nombre de colonnes dans Z et len(Y) est le nombre de lignes dans Z.

    Il est également assez évident que quelque chose comme
    plt.contour(X_grid.ravel(), Y_grid.ravel(), Z_grid.ravel()) ne peut pas produire un tracé de contour, car toutes les informations au sujet de la forme de grille est perdu et il n'y a pas de chemin le contour de la fonction pourrait savoir comment interpréter les données. E. g. si len(Z_grid.ravel()) == 12, le sous-jacentes de la grille de la forme peut être l'une des (1,12), (2,6), (3,4), (4,3), (6,2), (12,1).

    Une voie possible pour sortir peut, bien entendu, pour permettre tableaux 1D et introduire un argument shape, comme plt.contour(x,y,z, shape=(6,2)). Ce n'est cependant pas le cas, de sorte que vous avez à vivre avec le fait que Z doit être en 2D.

    Toutefois, si vous êtes à la recherche d'un moyen d'obtenir un countour parcelle aplati (a défilé) des tableaux, c'est possible en utilisant plt.tricontour().

    plt.tricontour(X_grid.ravel(), Y_grid.ravel(), Z_grid.ravel())

    Ici une grille triangulaire sera produite en interne à l'aide d'un Delaunay Triangualation. Par conséquent, même complètement aléatoire des points obtenir un joli résultat, comme on peut le voir dans l'image ci-dessous, où c'est par rapport à la même aléatoire des points de contour.

    Pourquoi ne pyplot.contour() exiger de Z à un tableau 2D?

    (Ici, c'est le code pour produire cette image)

    Merci pour la réponse. Je suis d'accord que les informations sur la forme de grille est perdu lorsque Z est passé comme seul argument. Toutefois, dans le cas de plt.contour(X_grid.ravel(), Y_grid.ravel(), Z_grid.ravel()), nous avons simplement besoin d'examiner l'éventail des valeurs dans les deux premières entrées des tableaux, et qui permettraient de déterminer le tracé des points de la grille.
    Malheureusement, votre commentaire est incorrect. Considérez les points suivants 12-élément 1D listes: x = [-0.04 1.04 2.02 0.03 1. 1.93 0.01 1.06 1.94 -0.07 0.99 1.95]; y= [ 0.04 0.17 0.14 1.9 1.85 1.74 3.61 3.69 3.51 5.23 5.33 5.27]; z = [-0.04 0.85 0.89 -0.01 -0.23 -0.16 -0.01 -0.74 -0.87 -0.03 0.48 0.49] la forme de la grille de plt.contour(x,y,z) pourriez-vous en déduire? (Ceux-ci sont des points valides et ont été fabriqués à partir de 2D tableaux à l'aide de ravel).
    Ok j'ai essayé des tracés de contour par le remodelage de vos données à (3,4), (4,3), (6,2) etc., et j'obtiens des résultats différents dans tous les cas. Donc, je comprends votre point, mais je ne comprends toujours pas où "extra" de l'information pour les contours. Dans tous les cas, nous sommes en définissant explicitement les x et y les coordonnées des points correspondant à la hauteur du relief à ces points. Donc, plt.contour() est en quelque sorte l'aide de la "orientation" des points dans le tableau ainsi que leurs emplacements réels, basés sur leurs valeurs de coordonnées?
    Oui, il y a quelques intrinsèque hypothèse sur l'ordre des points sur la grille. Voir Ilya de la réponse et le lien vers le code qui y est. J'ai mis à jour la réponse à incluce tricontour qui acutally accepte a défilé en tableaux.
    Upvoted pour plt.tricontour, ne savent pas à ce sujet.

    OriginalL'auteur ImportanceOfBeingErnest

  2. 2

    Le code d'un algorithme derrière plt.contour peut être trouvé dans _countour.cpp. Il est plutôt compliqué, C-code, de sorte qu'il est difficile de suivre avec précision, mais si je devais essayer de faire quelques contours de génération de code, je le ferais de la manière suivante. Choisir un certain point (x, y) à la frontière et de fixer son z-valeur. Itérer sur la proximité de points et de sélection que celui pour lequel la valeur z est le plus proche de la valeur z du premier point. Continuer d'itération pour nouveau point, choisir proximité avec le z-valeur la plus proche à la valeur souhaitée (mais assurez-vous de ne pas revenir sur un point que vous venez de visiter, si vous devez vous rendre dans une "direction"), et continuer jusqu'à ce que vous obtenez un cycle ou d'atteindre certains frontière.

    Il semble que quelque chose de proche (mais un peu plus complexe) est mis en œuvre dans _counter.cpp.

    Comme vous le voyez sur la description informelle de l'algorithme, de procéder, vous devez trouver un point qui est "à proximité" de l'actuel. Il est facile à faire si vous avez une grille rectangulaire de points (besoin d'environ 4 ou 8 itérations comme ceci: (x[i+1][j], y[i+1][j]), (x[i][j+1], y[i][j+1]), (x[i-1][j], y[i-1][j]) et ainsi de suite). Mais si vous avez quelques points choisis au hasard (sans ordre particulier), ce problème devient difficile: il faut itérer sur tous les points que vous avez à découvrir à proximité les uns et passer à l'étape suivante. Le la complexité de cette étape est O(n), où n est un certain nombre de points (en général, un carré de la taille d'une image). Ainsi, un algorithme devient beaucoup plus lent, si vous n'avez pas de grille rectangulaire.

    C'est pourquoi vous avez réellement besoin de trois 2d-tableaux correpsponds de x, y et z de certains points situés au-dessus de certaines grille rectangulaire.

    Comme vous l'avez mentionner, x's et y's peut être 1d-tableaux. Dans ce cas, le correspondant 2d-les tableaux sont reconstruits avec meshgrid. Toutefois, dans ce cas, vous devez avoir z en 2d-tableau de toute façon.

    Si seulement z est spécifié, x et y sont range's de durée appropriée.

    MODIFIER. Vous pouvez essayer de "faux" à deux dimensions x, y et z tableaux de telle manière que x et y ne prend pas la forme d'une grille rectangulaire de vérifier si mes hypothèses sont correctes.

    import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline

x = np.random.uniform(-3, 3, size=10000)
y = np.random.uniform(-3, 3, size=10000)
z = x**2 + y**2
X, Y, Z = (u.reshape(100, 100) for u in (x, y, z))
plt.contour(X, Y, Z)

    Pourquoi ne pyplot.contour() exiger de Z à un tableau 2D?

    Comme vous le voyez, l'image ne ressemble pas à quelque chose de correct graphique si (x, y, z)'s sont juste quelques-uns des points aléatoires.

    Maintenant, supposons que x est triée comme une étape de prétraitement comme @dhrummel suggère dans les commentaires. Notez que nous ne pouvons pas trier x et y simultanément comme ils ne sont pas indépendants (nous voulons préserver les mêmes points).

    x = np.random.uniform(-3, 3, size=10000)
y = np.random.uniform(-3, 3, size=10000)
z = x**2 + y**2
xyz = np.array([x, y, z]).T
x, y, z = xyz[xyz[:, 0].argsort()].T
assert (x == np.sort(x)).all()
X, Y, Z = (u.reshape(100, 100) for u in (x, y, z))
plt.contour(X, Y, Z)

    Pourquoi ne pyplot.contour() exiger de Z à un tableau 2D?

    Encore une fois, l'image est incorrecte, due au fait que y's ne sont pas triés (dans chaque colonne), puisqu'ils étaient si nous avions grille rectangulaire au lieu de quelques points aléatoires.

    Merci pour la réponse. Je vois votre point de vue sur la façon dont la grille rend plus facile pour le contour de faire le tracé. Je me demande si cela peut être réalisé simplement en triant le X et Y entrée tableaux de façon appropriée, comme une étape de prétraitement.
    J'ai ajouté quelques exemples d'aborder cette question. En général, le problème avec le tri, c'est que vous ne pouvez pas trier X et Y simultanément. Cependant, pour faire de l'algorithme de travail vous avez besoin que i, j point de votre matrice est proche de i±1, j±1. À cette fin, vous disposez d'x et d'y être triés dans chaque ligne/colonne. Il est impossible à atteindre si vous avez juste quelques points aléatoires, sans structure rectangulaire.
    Merci, vos exemples de clarifier le point de la perfection. Il semble donc comme un postulat caché de l'algorithme qui contour et contourf utiliser que les entrées sont bien ordonnés dans une grille.

    OriginalL'auteur Ilya V. Schurov

  3. 0

    La raison pour X et Y être en 2D, est le suivant.
    Z correspond à chaque (x,y) les coordonnées dans les axes du système de "profondeur" pour créer un graphique 3D avec x,y et z les coordonnées.

    Maintenant, supposons que nous voulons faire le point sur un point arbitraire dans le système d'axes.
    Nous pouvons le faire en fournissant les coordonnées x et y (x,y) pour ce point.Par exemple (0,0).
    Considérons maintenant la "ligne" avec la valeur de x 1. Sur cette ligne, il y a un certain nombre de n, les valeurs de y, qui ressemble à qch comme:

    Pourquoi ne pyplot.contour() exiger de Z à un tableau 2D?

    Si nous traçons ces lignes pour toutes les valeurs x et y les valeurs qui nous permettra d'obtenir qch. comme:

    Pourquoi ne pyplot.contour() exiger de Z à un tableau 2D?

    Comme vous pouvez le voir, nous avons une annotation 2D qui est composé de 2 2D tableaux, un pour les valeurs de x qui a la forme:

    1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10
#--> Two dimensional x values array

    et un pour les valeurs de y qui a la forme:

    10 10 10 10 10 10 10 10 10 10
9 9 9 9 9 9 9 9 9 9 
8 8 8 8 8 8 8 8 8 8
...
1 1 1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0 0 0
#--> Two dimensional y values array

    Les deux ensemble fournit l' (x,y) les coordonnées de chaque point dans le système de coordonnées. Maintenant, nous pouvons tracer pour chaque point de la "profondeur" signifie que la valeur de Z (coordonnée z).
    Maintenant, il est également évident pourquoi la variable Z doit être à 2 dimensions avec la forme (len(x),len(y)), car sinon il ne peut pas fournir une valeur pour tous les points.

    Ce comportement peut être réalisé en donnant 2D (x,y, et z de tableaux à la fonction OU à l': fournir 1D x et y les matrices de la fonction et de la fonction crée en interne le maillage 2D de valeurs x et y avec qch. comme X,Y=np.meshgrid(x,y) néanmoins, z doit être en deux dimensions.

    OriginalL'auteur 2Obe

  4. 0

    Laissez-moi vous expliquer de façon simple, depuis que j'ai pensé Z ne doit pas être en 2D. contourf() besoins de X et Y construire son propre espace, et la relation Z(X,Y) pour construire un espace complet, plutôt que de simplement en utilisant plusieurs points avec les 1D X,Y,Z de l'information.

    OriginalL'auteur Wey Shi