返回给定numpy数组的探照灯向量

Question

Consider a 3D numpy array D of dimension, say, (30 x 40 x 50). For each voxel D[x,y,z] I want to store a vector that contains neighboring voxels within a certain radius (including the D[x,y,z] itself).

(As an example here is a picture of such a sphere of radius 2: https://puu.sh/wwIYW/e3bd63ceae.png )

Is there a simple and fast way to code this?

I have written a function for it, but it is painfully slow and IDLE eventually crashes because the data structure I store the vectors in becomes too large.

Current code:

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

Answer 1

Since you say the data structure is too large, you'll likely have to compute the vector on the fly for a given voxel. You can do this pretty quickly though:

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

To use the object on a given array you can simply do:

sl = SearchLight(M_in, 4)
# get vector of values for voxel i,j,k
vector = sl.get_vector(i,j,k)

This should give you the same vector you would get from

M_out[i,j,k]

in your sample code, without storing all the results at once in memory.

This can also probably be further optimized, particularly in terms of the coordinate filtering, but it may not be necessary. Hope that helps.

Answer 2

Here a way to do that. For efficiency, you need therefore to use ndarrays : This only take in account complete voxels. Edges must be managed "by hand".

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)

All the costly operations are vectorized. Comprehension lists are prefered for clarity in external loop.

You can now perform vectorized operations on voxels. for exemple the brightest voxel :

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

All of this is of course extensive in memory. you must split your space for big data or voxels.