matplotlib（mplot3d） - 如何在3D Plot中增加轴（拉伸）的大小？

Question

到目前为止，我有这个：

x,y,z = data.nonzero()    
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(x, y, z, zdir='z', c= 'red')
plt.savefig("plot.png")

创建：

我想要做的就是伸展它以使Z轴高9倍并保持X和Y相同。我想保留相同的坐标。

到目前为止，我试过这个人：

fig = plt.figure(figsize=(4.,35.))

但这只是延伸了plot.png图像。

Answer 1

下面的代码示例提供了一种相对于其他轴缩放每个轴的方法。但是，要这样做，您需要修改Axes3D.get_proj函数。以下是基于matplot lib提供的示例的示例：http://matplotlib.org/1.4.0/mpl_toolkits/mplot3d/tutorial.html#line-plots

（在这个答案的最后有一个较短的版本）

from mpl_toolkits.mplot3d.axes3d import Axes3D
from mpl_toolkits.mplot3d import proj3d

import matplotlib as mpl
import numpy as np
import matplotlib.pyplot as plt

#Make sure these are floating point values:                                                                                                                                                                                              
scale_x = 1.0
scale_y = 2.0
scale_z = 3.0

#Axes are scaled down to fit in scene                                                                                                                                                                                                    
max_scale=max(scale_x, scale_y, scale_z)

scale_x=scale_x/max_scale
scale_y=scale_y/max_scale
scale_z=scale_z/max_scale

#Create scaling matrix                                                                                                                                                                                                                   
scale = np.array([[scale_x,0,0,0],
                  [0,scale_y,0,0],
                  [0,0,scale_z,0],
                  [0,0,0,1]])
print scale

def get_proj_scale(self):
    """                                                                                                                                                                                                                                    
    Create the projection matrix from the current viewing position.                                                                                                                                                                        

    elev stores the elevation angle in the z plane                                                                                                                                                                                         
    azim stores the azimuth angle in the x,y plane                                                                                                                                                                                         

    dist is the distance of the eye viewing point from the object                                                                                                                                                                          
    point.                                                                                                                                                                                                                                 

    """
    relev, razim = np.pi * self.elev/180, np.pi * self.azim/180

    xmin, xmax = self.get_xlim3d()
    ymin, ymax = self.get_ylim3d()
    zmin, zmax = self.get_zlim3d()

    # transform to uniform world coordinates 0-1.0,0-1.0,0-1.0                                                                                                                                                                             
    worldM = proj3d.world_transformation(
        xmin, xmax,
        ymin, ymax,
        zmin, zmax)

    # look into the middle of the new coordinates                                                                                                                                                                                          
    R = np.array([0.5, 0.5, 0.5])

    xp = R[0] + np.cos(razim) * np.cos(relev) * self.dist
    yp = R[1] + np.sin(razim) * np.cos(relev) * self.dist
    zp = R[2] + np.sin(relev) * self.dist
    E = np.array((xp, yp, zp))

    self.eye = E
    self.vvec = R - E
    self.vvec = self.vvec / proj3d.mod(self.vvec)

    if abs(relev) > np.pi/2:
    # upside down                                                                                                                                                                                                                          
      V = np.array((0, 0, -1))
    else:
      V = np.array((0, 0, 1))
    zfront, zback = -self.dist, self.dist

    viewM = proj3d.view_transformation(E, R, V)
    perspM = proj3d.persp_transformation(zfront, zback)
    M0 = np.dot(viewM, worldM)
    M = np.dot(perspM, M0)

    return np.dot(M, scale);

Axes3D.get_proj=get_proj_scale

"""
You need to include all the code above.
From here on you should be able to plot as usual.
"""

mpl.rcParams['legend.fontsize'] = 10

fig = plt.figure(figsize=(5,5))
ax = fig.gca(projection='3d')
theta = np.linspace(-4 * np.pi, 4 * np.pi, 100)
z = np.linspace(-2, 2, 100)
r = z**2 + 1
x = r * np.sin(theta)
y = r * np.cos(theta)
ax.plot(x, y, z, label='parametric curve')
ax.legend()

plt.show()

标准输出：

按（1,2,3）缩放：

按（1,1,3）缩放：

我特别喜欢这种方法的原因， 交换z和x，缩放（3,1,1）：

以下是较短版本的代码。

from mpl_toolkits.mplot3d.axes3d import Axes3D
from mpl_toolkits.mplot3d import proj3d

import matplotlib as mpl
import numpy as np
import matplotlib.pyplot as plt

mpl.rcParams['legend.fontsize'] = 10

fig = plt.figure(figsize=(5,5))
ax = fig.gca(projection='3d')
theta = np.linspace(-4 * np.pi, 4 * np.pi, 100)
z = np.linspace(-2, 2, 100)
r = z**2 + 1
x = r * np.sin(theta)
y = r * np.cos(theta)


"""                                                                                                                                                    
Scaling is done from here...                                                                                                                           
"""
x_scale=1
y_scale=1
z_scale=2

scale=np.diag([x_scale, y_scale, z_scale, 1.0])
scale=scale*(1.0/scale.max())
scale[3,3]=1.0

def short_proj():
  return np.dot(Axes3D.get_proj(ax), scale)

ax.get_proj=short_proj
"""                                                                                                                                                    
to here                                                                                                                                                
"""

ax.plot(z, y, x, label='parametric curve')
ax.legend()

plt.show()

Answer 2

请注意，下面的答案简化了补丁，但使用与@ChristianSarofeen的答案相同的基本原则。

解决方案

正如其他答案中已经指出的那样，它不是当前在matplotlib中实现的功能。但是，由于您要求的只是一个 3D转换，可以应用于matplotlib使用的现有投影矩阵，并且由于Python的精彩功能，这个问题可以通过一个简单的<强> oneliner ：

ax.get_proj = lambda: np.dot(Axes3D.get_proj(ax), np.diag([scale_x, scale_y, scale_z, 1]))

其中scale_x，scale_y和scale_z是从0到1的值，它们会相应地沿着每个轴重新缩放绘图。 ax只是可以使用ax = fig.gca(projection='3d')

获得的3D轴

解释

为了解释，get_proj的函数Axes3D从当前观看位置生成投影矩阵。将其乘以缩放矩阵：

scale_x, 0,       0
0,       scale_y, 0
0,       0,       scale_z
0,       0,       1

包括缩放到渲染器使用的投影中。所以，我们在这里做的是用原始get_proj函数替换原始get_proj的结果并将其乘以缩放矩阵的表达式。

实施例

使用标准参数函数示例说明结果：

from mpl_toolkits.mplot3d import Axes3D
import numpy as np
import matplotlib.pyplot as plt

fig = plt.figure()
ax = fig.gca(projection='3d')
theta = np.linspace(-4 * np.pi, 4 * np.pi, 100)
z = np.linspace(-2, 2, 100)
r = z ** 2 + 1
x = r * np.sin(theta)
y = r * np.cos(theta)

# OUR ONE LINER ADDED HERE:
ax.get_proj = lambda: np.dot(Axes3D.get_proj(ax), np.diag([0.5, 0.5, 1, 1]))

ax.plot(x, y, z)
plt.show()

对于值0.5, 0.5, 1，我们得到：

对于值0.2, 1.0, 0.2，我们得到：

Answer 3

我看起来默认情况下，mplot3d会在很高的情节的顶部和底部留下相当多的空间。但是，您可以使用fig.subplots_adjust欺骗它填充该空间，并将正常绘图区域的顶部和底部延伸出来（即top > 1和bottom < 0）。您的特定情节可能需要一些试验和错误。

我为x，y和z创建了一些随机数组，其限制与你的情节相似，并且发现下面的参数（bottom=-0.15，top = 1.2）似乎工作正常。

您可能还想更改ax.view_init以设置一个漂亮的视角。

import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import axes3d
from numpy import random

# Make some random data with similar limits to the OP's example
x,y,z=random.rand(3,100)
z*=250
y*=800
y+=900
x*=350
x+=1200

fig=plt.figure(figsize=(4,35))

# Set the bottom and top outside the actual figure limits, 
# to stretch the 3D axis
fig.subplots_adjust(bottom=-0.15,top=1.2)

ax = fig.add_subplot(111, projection='3d')

# Change the viewing angle to an agreeable one
ax.view_init(2,None)

ax.scatter(x, y, z, zdir='z', c= 'red')
plt.savefig("plot.png")

Answer 4

听起来你正试图调整情节的规模。我认为没有办法将线性比例扩展到用户规范，但您可以使用set_yscale()，set_xscale()，set_zscale()来改变比例相互尊重。

直观地，set_yscale(log)，set_xscale(log)，set_zscale(linear)可能会解决您的问题。

一个可能更好的选择：指定一个拉伸，将它们全部设置为具有相同日志基础的symlog，然后根据您的规范指定Z轴的symlog比例linscalex/linscaley kwargs。

更多信息：

http://matplotlib.org/mpl_toolkits/mplot3d/api.html

Answer 5

我在搜索类似的问题时发现了这一点。经过一番实验后，也许我可以在这里分享一些我的初步研究结果..matplotlib库是VAST !! （我是新人）。请注意，这个问题非常类似，我想要的只是视觉上的＃39;拉伸图表而不扭曲它。

背景故事（仅显示关键代码段，以避免对知道库的人造成不必要的混乱，如果您需要可运行的代码，请发表评论）： 我有三个1-d nararray分别代表X，Y和Z数据点。很明显我不能使用plot_surface（因为它需要每个昏暗的2d ndarray）所以我去了非常有用的plot_trisurf：

fig = plt.figure()
ax = Axes3D(fig)
3d_surf_obj = ax.plot_trisurf(X, Y, Z_defl, cmap=cm.jet,linewidth=0,antialiased=True)

你可以把这个情节想象成一个在波浪中变形的浮动驳船...正如你所看到的，轴伸展使它在视觉上非常具有欺骗性（请注意，x应该比y长x6倍＆gt;＆gt; ;＆gt;＆gt;＆gt; z）。虽然情节点是正确的，但我想要一些更直观，更舒适的东西。至少。正在寻找A QUICK FIX，如果可以的话。长话短说，我发现了一些成功...＆＃39; figure.figsize＆＃39;一般设置（参见下面的代码段）。

    matplotlib.rcParams.update({'font.serif': 'Times New Roman',
                                'font.size': 10.0,
                                'axes.labelsize': 'Medium',
                                'axes.labelweight': 'normal',
                                'axes.linewidth': 0.8,
                                 ###########################################
                                 # THIS IS THE IMPORTANT ONE FOR STRETCHING
                                 # default is [6,4] but...i changed it to
                                'figure.figsize':[15,5]   # THIS ONE #
                              })

对于[15,5]，我有类似......

非常整洁!!

所以我开始推动它......并且在决定在那里定居之前起来[20,6] ..

如果您想尝试在视觉上拉伸垂直轴，请尝试使用...... [7,10]这样的比率，在这种情况下，我会给...

不要太破旧！

应该为视觉能力做到这一点。

Answer 6

就我而言，我想将 z 轴拉伸 2 次以获得更好的点可见性

from mpl_toolkits import mplot3d
from mpl_toolkits.mplot3d import Axes3D

import matplotlib.pyplot as plt
# plt.rcParams["figure.figsize"] = (10,200)
# plt.rcParams["figure.autolayout"] = True
ax = plt.axes(projection='3d')
ax.set_box_aspect(aspect = (1,1,2))

ax.plot(dataX,dataY,dataZ)

Answer 7

将所有z值乘以9，

ax.scatter(x, y, 9*z, zdir='z', c= 'red')

然后给出z轴自定义绘图标签和间距。

ax.ZTick = [0,-9*50, -9*100, -9*150, -9*200];
ax.ZTickLabel = {'0','-50','-100','-150','-200'};