Трехмерная сетка из регулярно расположенных точек

Question

Я хочу создать список, содержащий трехмерные координаты сетки регулярно расположенных точек, каждая из которых состоит из трехэлементного кортежа. Я ищу совет о наиболее эффективном способе сделать это.

Например, в C ++ я просто зацикливаюсь на трех вложенных циклах, по одному для каждой координаты. В Matlab я бы, вероятно, использовал функцию meshgrid (которая делала бы это одной командой). Я читал о meshgrid и mgrid в Python, и я также читал, что использование правил вещания numpy более эффективно. Мне кажется, что использование функции zip в сочетании с правилами широковещательной трансляции может быть наиболее эффективным способом, но zip, похоже, не перегружен в numpy.

Answer 1

Вместо meshgrid и mgrid вы можете использовать ogrid, который является "редкой" версией mgrid. Таким образом, только измерение, вдоль которого изменяются значения, заполняется. Остальные просто передаются. При этом для больших сеток используется гораздо меньше памяти, чем для не разреженных альтернатив.

Например:

>>> import numpy as np
>>> x, y = np.ogrid[-1:2, -2:3]
>>> x
array([[-1],
      [ 0],
      [ 1]])
>>> y
array([[-2, -1,  0,  1,  2]])
>>> x**2 + y**2
array([[5, 2, 1, 2, 5],
      [4, 1, 0, 1, 4],
      [5, 2, 1, 2, 5]])

Answer 2

Использование ndindex:

import numpy as np
ind=np.ndindex(3,3,2)
for i in ind:
    print(i)

# (0, 0, 0)
# (0, 0, 1)
# (0, 1, 0)
# (0, 1, 1)
# (0, 2, 0)
# (0, 2, 1)
# (1, 0, 0)
# (1, 0, 1)
# (1, 1, 0)
# (1, 1, 1)
# (1, 2, 0)
# (1, 2, 1)
# (2, 0, 0)
# (2, 0, 1)
# (2, 1, 0)
# (2, 1, 1)
# (2, 2, 0)
# (2, 2, 1)

Answer 3

Я бы сказал, пойти с meshgrid или mgrid, в частности, если вам нужны нецелые координаты. Я удивлен, что правила вещания Numpy были бы более эффективными, поскольку meshgrid был разработан специально для проблемы, которую вы хотите решить.

Answer 4

для сеток с несколькими d (больше 2), используйте numpy.lib.index_tricks.nd_grid примерно так:

import numpy
grid = numpy.lib.index_tricks.nd_grid()
g1 = grid[:3,:3,:3]
g2 = grid[0:1:0.5, 0:1, 0:2]
g3 = grid[0:1:3j, 0:1:2j, 0:2:2j]

, где g1 имеет значения x [0,1,2] и g2 имеет значения x [0, .5], и g3 имеет значения x [0.0,0.5,1.0] (3j определяет количество шагов вместо шага. См. документацию для более подробной информации.

Answer 5

Вот эффективный вариант, аналогичный вашему решению C ++, которое я использовал для той же цели:

import numpy, itertools, collections
def grid(xmin, xmax, xstep, ymin, ymax, ystep, zmin, zmax, zstep):
    "return nested tuples of grid-sampled coordinates that include maxima"
    return collections.deque( itertools.product( 
        numpy.arange(xmin, xmax+xstep, xstep).tolist(),
        numpy.arange(ymin, ymax+ystep, ystep).tolist(),
        numpy.arange(zmin, zmax+zstep, zstep).tolist() ) )

Производительность лучше всего (в моих тестах) при использовании a.tolist (), как показано выше, но вы можете вместо этого использовать a.flat и отбросить deque (), чтобы получить итератор, который будет пропускать память. Конечно, вы также можете использовать простой старый tuple () или list () вместо deque () для небольшого снижения производительности (опять же, в моих тестах).