为我的用例努力理解 Numpy 矢量化

Question

I understand the basics of how vectorization works, but I'm struggling to see how to apply that knowledge to my use case. I have a working algorithm for some image processing. However, the particular algorithm that I'm working with doesn't process the entire image as there is a border to account for the "window" that gets shifted around the image.

I'm trying to use this to better understand Numpy's vectorization, but I can't figure out how to account for the window and the border. Below is what I have in vanilla python (with the actual algorithm redacted, I'm only asking for help on how to vectorize). I looked into np.fromfunction and a few other options, but have had no luck. Any suggestions would be welcome at this point.

half_k = np.int(np.floor(k_size / 2));
U = np.zeros(img_a.shape, dtype=np.float64);
V = np.zeros(img_b.shape, dtype=np.float64);
for y in range(half_k, img_a.shape[0] - half_k):
    for x in range(half_k, img_a.shape[1] - half_k):
        # init variables for window calc goes here

        for j in range(y - half_k, y + half_k + 1):
            for i in range(x - half_k, x + half_k + 1):
                # stuff init-ed above gets added to here

        # final calc on things calculated in windows goes here
        U[y][x] = one_of_the_window_calculations
        V[y][x] = the_other_one
return U, V

Answer 1

I think you can create an array of the indices of the patches with a function like this get_patch_idx in the first place

def get_patch_idx(ind,array_shape,step):
    
    row_nums,col_nums = array_shape
    col_idx = ind-(ind//col_nums)*col_nums if ind%col_nums !=0 else col_nums
    row_idx = ind//col_nums if ind%col_nums !=0 else ind//col_nums

    if col_idx+step==col_nums or row_idx+step==row_nums or col_idx-step==-1 or row_idx-step==-1: raise ValueError
    
    upper = [(row_idx-1)*col_nums+col_idx-1,(row_idx-1)*col_nums+col_idx,(row_idx-1)*col_nums+col_idx+1]
    middle = [row_idx*col_nums+col_idx-1,row_idx*col_nums+col_idx,row_idx*col_nums+col_idx+1]
    lower = [(row_idx+1)*col_nums+col_idx-1,(row_idx+1)*col_nums+col_idx,(row_idx+1)*col_nums+col_idx+1]
    
    return [upper,middle,lower]

Assume you have an (10,8) array, and half_k is 1

test = np.linspace(1,80,80).reshape(10,8)*2
mask = np.linspace(0,79,80).reshape(10,8)[1:-1,1:-1].ravel().astype(np.int)

in which the indices in mask are allowed, then you can create an array of indices of the patches

patches_inds = np.array([get_patch_idx(ind,test.shape,1) for ind in mask])

with this patches_inds , patches of the original array test can be sliced with np.take

patches = np.take(test,patches_inds)

This will bypass for loop efficiently.