Python 返回给定numpy阵列的探照灯矢量

考虑一个三维numpy数组

D

的尺寸，例如，（30 x 40 x 50）。对于每个体素

D[x，y，z]

我想存储一个包含一定半径内相邻体素的向量（包括

D[x，y，z]

本身）

（这里的示例是这样一个半径为2的球体的图片：）

有没有一种简单而快速的编码方法

我已经为它写了一个函数，但是它非常慢，空闲，最终崩溃，因为我存储向量的数据结构变得太大了

当前代码：

def searchlight(M_in):
    radius = 4
    [m,n,k] = M_in.shape
    M_out = np.zeros([m,n,k],dtype=object)
    count = 0
    for i in range(m):
        for j in range(n):
            for z in range(k):
                i_interval = list(range((i-4),(i+5)))
                j_interval = list(range((j-4),(j+5)))
                z_interval = list(range((z-4),(z+5)))                
                coordinates = list(itertools.product(i_interval,j_interval,z_interval))
                coordinates = [pair for pair in coordinates if ((abs(pair[0]-i)+abs(pair[1]-j)+abs(pair[2]-z))<=radius)]
                coordinates = [pair for pair in coordinates if ((pair[0]>=0) and (pair[1]>=0) and pair[2]>=0) and (pair[0]<m) and (pair[1]<n) and (pair[2]<k)]
                out = []
                for pair in coordinates:
                    out.append(M_in[pair[0],pair[1],pair[2]])
                M_out[i,j,z] = out
                count = count +1
    return M_out

def探照灯（M_英寸）：
半径=4
[m，n，k]=m_的形状
M_out=np.zero（[M，n，k]，dtype=object）
计数=0
对于范围内的i（m）：
对于范围（n）内的j：
对于范围（k）内的z：
i_间隔=列表（范围（（i-4）、（i+5）））
j_间隔=列表（范围（（j-4）、（j+5）））
z_间隔=列表（范围（（z-4）、（z+5）））
坐标=列表（itertools.product（i_区间、j_区间、z_区间））
坐标=[pair for pair in Coordination如果（（abs（pair[0]-i）+abs（pair[1]-j）+abs（pair[2]-z））=0和（pair[1]>=0）和（pair[0]，因为你说数据结构太大了，你可能需要为给定的体素实时计算向量。你可以很快做到这一点：

class SearchLight(object):
    def __init__(self, M_in, radius):
        self.M_in = M_in
        m, n, k = self.M_in.shape

        # compute the sphere coordinates centered at (0,0,0)
        # just like in your sample code
        i_interval = list(range(-radius,radius+1))
        j_interval = list(range(-radius,radius+1))
        z_interval = list(range(-radius,radius+1))
        coordinates = list(itertools.product(i_interval,j_interval,z_interval))
        coordinates = [pair for pair in coordinates if ((abs(pair[0])+abs(pair[1])+abs(pair[2]))<=radius)]

        # store those indices as a template
        self.sphere_indices = np.array(coordinates)

    def get_vector(self, i, j, k):

        # offset sphere coordinates by the requested centre.
        coordinates = self.sphere_indices + [i,j,k]
        # filter out of bounds coordinates
        coordinates = coordinates[(coordinates >= 0).all(1)]
        coordinates = coordinates[(coordinates < self.M_in.shape).all(1)]

        # use those coordinates to index the initial array.
        return self.M_in[coordinates[:,0], coordinates[:,1], coordinates[:,2]]

这应该给你相同的向量，你会从

M_out[i,j,k]

在示例代码中，无需将所有结果同时存储在内存中

这可能还可以进一步优化，特别是在坐标过滤方面，但可能没有必要。希望有帮助。
这里有一种方法可以做到这一点。为了提高效率，您需要使用Ndarray：这只考虑完整的体素。边必须“手动”管理

所有这些当然都是大量的内存。您必须将您的空间分割为
大数据或体素。
谢谢！这很有帮助，让我从不同的角度思考这个问题。谢谢！选择此选项是为了简洁和专注于优化。
M_out[i,j,k]

from pylab import *
a=rand(100,100,100) # the data
r=4
ra=range(-r,r+1)

sphere=array([[x,y,z] for x in ra for y in ra for z in ra if np.abs((x,y,z)).sum()<=r]) 
# the unit "sphere"

indcenters=array(meshgrid(*(range(r,n-r) for n in a.shape),indexing='ij'))
# indexes of the centers of the voxels. edges are cut.

all_inds=(indcenters[newaxis].T+sphere.T).T
#all the indexes.

voxels=np.stack([a[tuple(inds)] for inds in all_inds],-1)
# the voxels.
#voxels.shape is (92, 92, 92, 129)

light=voxels.sum(-1)
print(np.unravel_index(light.argmax(),light.shape))
#(33,72,64)