Pergunta
meshgrid de Numpy é muito útil para converter dois vetores a uma grade de coordenadas. Qual é a maneira mais fácil de estender isso para três dimensões? Assim, dado três vectores x, y, e z, matrizes de construo 3x3D (em vez de matrizes 2x2D) que pode ser usado como coordenadas.
Solução
Aqui está o código fonte de meshgrid:
def meshgrid(x,y):
"""
Return coordinate matrices from two coordinate vectors.
Parameters
----------
x, y : ndarray
Two 1-D arrays representing the x and y coordinates of a grid.
Returns
-------
X, Y : ndarray
For vectors `x`, `y` with lengths ``Nx=len(x)`` and ``Ny=len(y)``,
return `X`, `Y` where `X` and `Y` are ``(Ny, Nx)`` shaped arrays
with the elements of `x` and y repeated to fill the matrix along
the first dimension for `x`, the second for `y`.
See Also
--------
index_tricks.mgrid : Construct a multi-dimensional "meshgrid"
using indexing notation.
index_tricks.ogrid : Construct an open multi-dimensional "meshgrid"
using indexing notation.
Examples
--------
>>> X, Y = np.meshgrid([1,2,3], [4,5,6,7])
>>> X
array([[1, 2, 3],
[1, 2, 3],
[1, 2, 3],
[1, 2, 3]])
>>> Y
array([[4, 4, 4],
[5, 5, 5],
[6, 6, 6],
[7, 7, 7]])
`meshgrid` is very useful to evaluate functions on a grid.
>>> x = np.arange(-5, 5, 0.1)
>>> y = np.arange(-5, 5, 0.1)
>>> xx, yy = np.meshgrid(x, y)
>>> z = np.sin(xx**2+yy**2)/(xx**2+yy**2)
"""
x = asarray(x)
y = asarray(y)
numRows, numCols = len(y), len(x) # yes, reversed
x = x.reshape(1,numCols)
X = x.repeat(numRows, axis=0)
y = y.reshape(numRows,1)
Y = y.repeat(numCols, axis=1)
return X, Y
É bastante simples de entender. Eu estendi o padrão para um número arbitrário de dimensões, mas este código não é de forma otimizada (e não completamente de erros verificados tanto), mas você recebe o que você paga. Espero que ajude:
def meshgrid2(*arrs):
arrs = tuple(reversed(arrs)) #edit
lens = map(len, arrs)
dim = len(arrs)
sz = 1
for s in lens:
sz*=s
ans = []
for i, arr in enumerate(arrs):
slc = [1]*dim
slc[i] = lens[i]
arr2 = asarray(arr).reshape(slc)
for j, sz in enumerate(lens):
if j!=i:
arr2 = arr2.repeat(sz, axis=j)
ans.append(arr2)
return tuple(ans)
Outras dicas
Numpy (a partir de 1,8 eu acho) agora suporta mais elevada que a geração 2D de redes de posição com meshgrid . Uma adição importante que realmente me ajudou é a capacidade de escolher a ordem de indexação (ou xy
ou ij
para cartesiana ou matriz indexação respectivamente), o que eu verifiquei com o seguinte exemplo:
import numpy as np
x_ = np.linspace(0., 1., 10)
y_ = np.linspace(1., 2., 20)
z_ = np.linspace(3., 4., 30)
x, y, z = np.meshgrid(x_, y_, z_, indexing='ij')
assert np.all(x[:,0,0] == x_)
assert np.all(y[0,:,0] == y_)
assert np.all(z[0,0,:] == z_)
Você pode nos mostrar como você está usando np.meshgrid? Há uma boa chance de que você realmente não precisa meshgrid porque difusão numpy pode fazer a mesma coisa sem gerar uma matriz repetitivo.
Por exemplo,
import numpy as np
x=np.arange(2)
y=np.arange(3)
[X,Y] = np.meshgrid(x,y)
S=X+Y
print(S.shape)
# (3, 2)
# Note that meshgrid associates y with the 0-axis, and x with the 1-axis.
print(S)
# [[0 1]
# [1 2]
# [2 3]]
s=np.empty((3,2))
print(s.shape)
# (3, 2)
# x.shape is (2,).
# y.shape is (3,).
# x's shape is broadcasted to (3,2)
# y varies along the 0-axis, so to get its shape broadcasted, we first upgrade it to
# have shape (3,1), using np.newaxis. Arrays of shape (3,1) can be broadcasted to
# arrays of shape (3,2).
s=x+y[:,np.newaxis]
print(s)
# [[0 1]
# [1 2]
# [2 3]]
O ponto é que pode S=X+Y
e deve ser substituído por s=x+y[:,np.newaxis]
porque
esta última não necessita de grandes (possivelmente) conjuntos repetitivos para ser formada. É também generaliza para dimensões maiores (mais eixos) de forma fácil. Basta adicionar np.newaxis
onde for necessário para efeitos de transmissão, se necessário.
Consulte http://www.scipy.org/EricsBroadcastingDoc para mais sobre a radiodifusão numpy.
eu acho que você quer é
X, Y, Z = numpy.mgrid[-10:10:100j, -10:10:100j, -10:10:100j]
por exemplo.
Aqui está uma versão multidimensional da meshgrid que eu escrevi:
def ndmesh(*args):
args = map(np.asarray,args)
return np.broadcast_arrays(*[x[(slice(None),)+(None,)*i] for i, x in enumerate(args)])
Note que as matrizes retornados são vistas dos dados da matriz original, para mudar as matrizes originais afetará as matrizes de coordenadas.
Em vez de escrever uma nova função, numpy.ix_ deve fazer o que quiser.
Aqui está um exemplo da documentação:
>>> ixgrid = np.ix_([0,1], [2,4])
>>> ixgrid
(array([[0],
[1]]), array([[2, 4]]))
>>> ixgrid[0].shape, ixgrid[1].shape
((2, 1), (1, 2))'