问题:

Numpy's meshgrid is very useful for converting two vectors to a coordinate grid. What is the easiest way to extend this to three dimensions? So given three vectors x, y, and z, construct 3x3D arrays (instead of 2x2D arrays) which can be used as coordinates.

回答1:

Here is the source code of 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

It is fairly simple to understand. I extended the pattern to an arbitrary number of dimensions, but this code is by no means optimized (and not thoroughly error-checked either), but you get what you pay for. Hope it helps:

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)

回答2:

Numpy (as of 1.8 I think) now supports higher that 2D generation of position grids with meshgrid. One important addition which really helped me is the ability to chose the indexing order (either xy or ij for Cartesian or matrix indexing respectively), which I verified with the following example:

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_)

回答3:

Can you show us how you are using np.meshgrid? There is a very good chance that you really don't need meshgrid because numpy broadcasting can do the same thing without generating a repetitive array.

For example,

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]]

The point is that S=X+Y can and should be replaced by s=x+y[:,np.newaxis] because the latter does not require (possibly large) repetitive arrays to be formed. It also generalizes to higher dimensions (more axes) easily. You just add np.newaxis where needed to effect broadcasting as necessary.

See http://www.scipy.org/EricsBroadcastingDoc for more on numpy broadcasting.

回答4:

i think what you want is

X, Y, Z = numpy.mgrid[-10:10:100j, -10:10:100j, -10:10:100j]

for example.

回答5:

Here is a multidimensional version of meshgrid that I wrote:

def ndmesh(*args):    args = map(np.asarray,args)    return np.broadcast_arrays(*[x[(slice(None),)+(None,)*i] for i, x in enumerate(args)])

Note that the returned arrays are views of the original array data, so changing the original arrays will affect the coordinate arrays.

回答6:

Instead of writing a new function, numpy.ix_ should do what you want.

Here is an example from the documentation:

>>> ixgrid = np.ix_([0,1], [2,4]) >>> ixgrid (array([[0],    [1]]), array([[2, 4]])) >>> ixgrid[0].shape, ixgrid[1].shape ((2, 1), (1, 2))'

转载请标明出处:Numpy meshgrid in 3D

文章来源: Numpy meshgrid in 3D

标签

meshgrid