У меня это до сих пор:
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.
Ниже приведен пример кода, позволяющий масштабировать каждую ось относительно других. Однако для этого вам необходимо изменить функцию 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):
Причина, по которой мне особенно нравится этот метод, Swap 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()
Обратите внимание, что приведенный ниже ответ упрощает патч, но использует тот же базовый принцип, что и ответ @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 - это просто 3D-оси, которые можно получить с помощью ax = fig.gca(projection='3d')
Чтобы объяснить, функция get_proj of 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 получаем:
Похоже, что по умолчанию 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 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")
Похоже, вы пытаетесь настроить масштаб графика. Я не думаю, что есть способ растянуть линейную шкалу на пользовательские спецификации, но вы можете использовать set_yscale(), set_xscale(), set_zscale() для изменения масштабов относительно друг друга.
Интуитивно, set_yscale(log), set_xscale(log), set_zscale(linear) могут решить ваши проблемы.
Скорее всего, лучший вариант: укажите растяжку, установите все их в symlog с той же базой журнала, а затем укажите шкалу символов Z-оси с помощью linscalex/linscaley kwargs к вашим спецификациям.
Подробнее здесь:
Умножьте все ваши значения 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'};