matplotlib (égal unité de longueur): avec "égales" ratio d'aspect de l'axe z n'est pas égal à x et y

Lorsque j'ai créé l'égalité de rapport d'aspect pour la 3d graphique de l'axe z ne change pas "égales". Donc, c':

fig = pylab.figure()
mesFig = fig.gca(projection='3d', adjustable='box')
mesFig.axis('equal')
mesFig.plot(xC, yC, zC, 'r.')
mesFig.plot(xO, yO, zO, 'b.')
pyplot.show()

me donne les éléments suivants:
matplotlib (égal unité de longueur): avec

où, évidemment, de l'unité de longueur de l'axe z n'est pas égal à x et y des parts.

Comment puis-je faire l'unité de longueur de chacun des trois axes de l'égalité? Toutes les solutions que j'ai pu trouver ne fonctionne pas. Merci.

InformationsquelleAutor | 2012-12-03

56

Je crois matplotlib n'a pas encore réglé correctement l'égalité de l'axe en 3D... Mais j'ai trouvé un truc il y a quelques temps (je ne me souviens plus où) que j'ai adapté à l'utiliser. Le concept est de créer un faux cubes de la boîte englobante autour de vos données.
Vous pouvez le tester avec le code suivant:
```
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm
import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure()
ax = fig.gca(projection='3d')
ax.set_aspect('equal')
X = np.random.rand(100)*10+5
Y = np.random.rand(100)*5+2.5
Z = np.random.rand(100)*50+25
scat = ax.scatter(X, Y, Z)
# Create cubic bounding box to simulate equal aspect ratio
max_range = np.array([X.max()-X.min(), Y.max()-Y.min(), Z.max()-Z.min()]).max()
Xb = 0.5*max_range*np.mgrid[-1:2:2,-1:2:2,-1:2:2][0].flatten() + 0.5*(X.max()+X.min())
Yb = 0.5*max_range*np.mgrid[-1:2:2,-1:2:2,-1:2:2][1].flatten() + 0.5*(Y.max()+Y.min())
Zb = 0.5*max_range*np.mgrid[-1:2:2,-1:2:2,-1:2:2][2].flatten() + 0.5*(Z.max()+Z.min())
# Comment or uncomment following both lines to test the fake bounding box:
for xb, yb, zb in zip(Xb, Yb, Zb):
ax.plot([xb], [yb], [zb], 'w')
plt.grid()
plt.show()
```
z données sont environ un ordre de grandeur plus grand que x et y, mais même avec une égale option d'axe, matplotlib autoscale axe z:

Mais si vous ajoutez de la boîte englobante, vous obtenir une bonne mise à l'échelle:
- Je vous remercie. Il fonctionne très bien!
- Dans ce cas, vous n'avez même pas besoin de la equal de l'instruction, il sera toujours égale.
- Vous devriez vous méfier avec l'appel d'une variable "scat"...
- Cela fonctionne bien si vous tracez un seul ensemble de données, mais que lorsqu'il y a plusieurs ensembles de données de tous sur le même graphique 3d? En question, il y a 2 jeux de données donc c'est une chose simple à combiner entre eux, mais qui pourrait se déraisonnable rapidement si le traçage de plusieurs jeux de données différents.
- J'ai été tracé jusqu'à cinq ensembles de données dans un graphique avec ces solutions et il a bien fonctionné pour moi.
- Cela fonctionne parfaitement. Pour ceux qui veulent ce dans la forme d'une fonction, qui prend un axe de l'objet et effectue les opérations ci-dessus, je les encourage à consulter @karlo réponse ci-dessous. Il est un peu plus propre solution.
- J'ai trouvé ce qui n'a pas de travail pour moi, sans la equal déclaration.
InformationsquelleAutor Remy F
42

J'ai simplifié Remy F de la solution à l'aide de la set_x/y/zlim fonctions.
```
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm
import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure()
ax = fig.gca(projection='3d')
ax.set_aspect('equal')
X = np.random.rand(100)*10+5
Y = np.random.rand(100)*5+2.5
Z = np.random.rand(100)*50+25
scat = ax.scatter(X, Y, Z)
max_range = np.array([X.max()-X.min(), Y.max()-Y.min(), Z.max()-Z.min()]).max() / 2.0
mid_x = (X.max()+X.min()) * 0.5
mid_y = (Y.max()+Y.min()) * 0.5
mid_z = (Z.max()+Z.min()) * 0.5
ax.set_xlim(mid_x - max_range, mid_x + max_range)
ax.set_ylim(mid_y - max_range, mid_y + max_range)
ax.set_zlim(mid_z - max_range, mid_z + max_range)
plt.show()
```
- Coutures fonctionne bien. Merci.
- J'aime la simplification du code. Juste être conscient que certains (très peu) les points de données ne peut pas obtenir de tracé. Par exemple, supposons que X=[0, 0, 0, 100] de sorte que X. moyenne()=25. Si max_range sort à 100 (de X), alors vous êtes x 25 +- 50, de sorte que [-25, 75] et vous allez manquer les X[3] point de données. L'idée est très agréable et facile à modifier pour vous assurer d'obtenir tous les points.
- Attention, en utilisant des moyens comme le centre n'est pas correct. Vous devriez utiliser quelque chose comme midpoint_x = np.mean([X.max(),X.min()]) et ensuite définir les limites de midpoint_x +/- max_range. En utilisant la moyenne ne fonctionne que si la moyenne est situé au milieu de la base de données, ce qui n'est pas toujours vrai. Aussi, un conseil: vous pouvez mettre à l'échelle max_range pour rendre le graphique look plus agréable si il y a des points à proximité ou sur les limites.
- Merci, a fait une mise à jour.
InformationsquelleAutor tauran
37

J'aime les solutions ci-dessus, mais ils ont l'inconvénient que vous avez besoin de garder une trace de la plages et des moyens sur l'ensemble de vos données. Cela pourrait être gênant si vous avez plusieurs jeux de données qui seront représentés ensemble. Pour résoudre ce problème, j'ai fait usage de la hache.get_[xyz]lim3d() les méthodes et mettre le tout dans une fonction autonome qui peut être appelé une seule fois avant d'appeler le plt.show(). Voici la nouvelle version:
```
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm
import matplotlib.pyplot as plt
import numpy as np
def set_axes_equal(ax):
'''Make axes of 3D plot have equal scale so that spheres appear as spheres,
cubes as cubes, etc..  This is one possible solution to Matplotlib's
ax.set_aspect('equal') and ax.axis('equal') not working for 3D.
Input
ax: a matplotlib axis, e.g., as output from plt.gca().
'''
x_limits = ax.get_xlim3d()
y_limits = ax.get_ylim3d()
z_limits = ax.get_zlim3d()
x_range = abs(x_limits[1] - x_limits[0])
x_middle = np.mean(x_limits)
y_range = abs(y_limits[1] - y_limits[0])
y_middle = np.mean(y_limits)
z_range = abs(z_limits[1] - z_limits[0])
z_middle = np.mean(z_limits)
# The plot bounding box is a sphere in the sense of the infinity
# norm, hence I call half the max range the plot radius.
plot_radius = 0.5*max([x_range, y_range, z_range])
ax.set_xlim3d([x_middle - plot_radius, x_middle + plot_radius])
ax.set_ylim3d([y_middle - plot_radius, y_middle + plot_radius])
ax.set_zlim3d([z_middle - plot_radius, z_middle + plot_radius])
fig = plt.figure()
ax = fig.gca(projection='3d')
ax.set_aspect('equal')
X = np.random.rand(100)*10+5
Y = np.random.rand(100)*5+2.5
Z = np.random.rand(100)*50+25
scat = ax.scatter(X, Y, Z)
set_axes_equal(ax)
plt.show()
```
- Merci pour une autre version. Je n'ai pas le temps de tester ça maintenant, mais je vais y revenir plus tard.
- Être conscient que l'utilisation de moyens comme le point central ne fonctionne pas dans tous les cas, vous devez utiliser les milieux. Voir mon commentaire sur tauran de réponse.
- Mon code ci-dessus ne prennent pas la moyenne des données, il prend la moyenne de l'actuel tracé de limites. Ma fonction est ainsi la garantie de garder en vue les points qui ont été en vue, selon le tracé des limites fixées avant il a été appelé. Si l'utilisateur a déjà fixé des limites de la parcelle de manière trop restrictive pour voir tous les points de données, qui est une question distincte. Ma fonction permet plus de flexibilité, car vous pouvez afficher qu'un sous-ensemble de données. Tout ce que je fais est d'élargir les limites de l'axe, donc le ratio est de 1:1:1.
- Une autre façon de le dire: si vous prenez une moyenne de seulement 2 points, à savoir les limites sur un seul axe, alors que la moyenne EST le point central. Donc, autant que je peux dire, Dalum de la fonction ci-dessous doivent être mathématiquement équivalente à la mienne et il n'y avait rien de `réparer".
- Ah, my bad! Je n'ai pas vu que votre x_mean était en fait pas le dire, mais le milieu. Votre code doit fonctionner correctement, alors, mais je suggère de renommer les variables, et pour une raison quelconque, j'ai fait la même erreur dans ma réponse ci-dessous. 😉
- Bon appel sur la dénomination. J'ai renommé *_mean à *_middle.
- Largement supérieur à la solution retenue, qui est un gâchis lorsque vous commencez à avoir beaucoup d'objets de nature différente.
InformationsquelleAutor karlo

Adapté de @karlo réponse pour rendre les choses encore plus propre:

def set_axes_radius(ax, origin, radius):
ax.set_xlim3d([origin[0] - radius, origin[0] + radius])
ax.set_ylim3d([origin[1] - radius, origin[1] + radius])
ax.set_zlim3d([origin[2] - radius, origin[2] + radius])
def set_axes_equal(ax):
'''Make axes of 3D plot have equal scale so that spheres appear as spheres,
cubes as cubes, etc..  This is one possible solution to Matplotlib's
ax.set_aspect('equal') and ax.axis('equal') not working for 3D.
Input
ax: a matplotlib axis, e.g., as output from plt.gca().
'''
limits = np.array([
ax.get_xlim3d(),
ax.get_ylim3d(),
ax.get_zlim3d(),
])
origin = np.mean(limits, axis=1)
radius = 0.5 * np.max(np.abs(limits[:, 1] - limits[:, 0]))
set_axes_radius(ax, origin, radius)

Utilisation:

fig = plt.figure()
ax = fig.gca(projection='3d')
ax.set_aspect('equal')         # important!
# ...draw here...
set_axes_equal(ax)             # important!
plt.show()

Cette série de réponses, et des améliorations progressives, ce est pourquoi Débordement de Pile existe. Vraiment du bon matos!

InformationsquelleAutor Mateen Ulhaq

EDIT: user2525140 du code devrait fonctionner parfaitement bien, même si cette réponse soi-disant tenté de fixer un non-existant erreur. La réponse ci-dessous est juste un doublon (de rechange) application:

def set_aspect_equal_3d(ax):
"""Fix equal aspect bug for 3D plots."""
xlim = ax.get_xlim3d()
ylim = ax.get_ylim3d()
zlim = ax.get_zlim3d()
from numpy import mean
xmean = mean(xlim)
ymean = mean(ylim)
zmean = mean(zlim)
plot_radius = max([abs(lim - mean_)
for lims, mean_ in ((xlim, xmean),
(ylim, ymean),
(zlim, zmean))
for lim in lims])
ax.set_xlim3d([xmean - plot_radius, xmean + plot_radius])
ax.set_ylim3d([ymean - plot_radius, ymean + plot_radius])
ax.set_zlim3d([zmean - plot_radius, zmean + plot_radius])

Vous avez encore le besoin de le faire: ax.set_aspect('equal') ou la tique valeurs peuvent être vissé vers le haut. Sinon bonne solution. Merci,

InformationsquelleAutor dalum

Vous devez vous connecter pour publier un commentaire.