ベクトル化されたスライディングウィンドウのスライス上で関数を呼び出す方法は？

Question

私はオブジェクト検出のスライディングウィンドウ検索をベクトル化しようとしています。これまで私はnumpyの放送を使って私のメインイメージをスライスして、私が変数 'all_windows'に保存したウィンドウサイズのスライスにすることができました。実際の値が一致していることを確認しました。その点まで私は満足しています。

次の部分は問題が発生している部分です。 patchCleanNPredict（）関数を呼び出して同様のベクトル化された形式の関数に各ウィンドウを渡すことができるように、私は 'all_windows'配列にインデックスを付けたいと思います。

（[0,0]、[1,0]、[2,0] ...）などの2次元配列にスライスインデックスを含むnew_indxという配列を作成しようとしましたが、問題にぶつかる

私は各ウィンドウの信頼値の配列で終わることを望んでいます。以下のコードはPython 3.5で動作します。助けやアドバイスを事前に感謝します。

import numpy as np 

def patchCleanNPredict(patch): 
    # patch = cv2.resize()# shrink patches with opencv resize function 
    patch = np.resize(patch.flatten(),(1,np.shape(patch.flatten())[0])) # flatten the patch 
    print('patch: ',patch.shape) 
    # confidence = predict(patch) # fake function showing prediction intent 
    return # confidence 


window = (30,46)# window dimensions 
strideY = 10 
strideX = 10 

img = np.random.randint(0,245,(640,480)) # image that is being sliced by the windows 

indx = np.arange(0,img.shape[0]-window[1],strideY)[:,None]+np.arange(window[1]) 
vertical_windows = img[indx] 
print(vertical_windows.shape) # returns (60,46,480) 


vertical_windows = np.transpose(vertical_windows,(0,2,1)) 
indx = np.arange(0,vertical_windows.shape[1]-window[0],strideX)[:,None]+np.arange(window[0]) 
all_windows = vertical_windows[0:vertical_windows.shape[0],indx] 
all_windows = np.transpose(all_windows,(1,0,3,2)) 

print(all_windows.shape) # returns (45,60,46,30) 


data_patch_size = (int(window[0]/2),int(window[1]/2)) # size the windows will be shrunk to 

single_patch = all_windows[0,0,:,:] 
patchCleanNPredict(single_patch) # prints the flattened patch size (1,1380) 

new_indx = (1,1) # should this be an array of indices? 
patchCleanNPredict(all_windows[new_indx,:,:]) ## this is where I'm having trouble 

Answer 1

私はそれがすべて正常に放送するために取得するためにnp.transposeでリサイズと再配置の良い量を行うになってしまったベクトル化の方法ですべてのウィンドウの機能を評価します。以下のコードは動作し、ループが表示され、イメージウィンドウが文字化け/混同されていないことが確認されています。彼らは完全なスピードの実行のために削除/コメントされるだろう。

小さな免責事項：私は2次元マトリクス間でスライディングウィンドウのより洗練された実装が必要であると思っていますが、私は以下の例を見つけることができなかったので、また、頻繁な並べ替えやサイズ変更の中には、放送構文をより完全に理解して整理できるものもあります。

import numpy as np 
import cv2 


def Predict(flattened_patches): 
    # taking the mean of the flattened windows and then returning the 
    # index of the row (window) with the highest mean, a predicter would have the same syntax 
    results = flattened_patches.mean(1) 
    max_index = results.argmax() 
    return results, max_index 

## -------- image and sliding window setup ------------------------- 
AR = 1.45 # choose an aspect ratio to maintain throughout scaling steps 
win_h = 200 # window height 
win_w = int(win_h/AR) # window width 
window = (win_w,win_h)# window dimensions 
strideY = 100 
strideX = 100 

data_patch_size = (30,46) # size the windows will be shrunk to for object detection 

img = cv2.imread('picture6.png') # load an image to slide over 

cv2.namedWindow('image',cv2.WINDOW_NORMAL) 
cv2.resizeWindow("image",int(img.shape[1]/2),int(img.shape[0]/2)) # shrink the image viewing window if you have large images 

img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) 
## -------- end of, image and sliding window setup -------------------- 

## -------- sliding window vectorization steps -------------------------- 
num_vert_windows = len(np.arange(0,img.shape[0]-window[1],strideY)) # number of vertical windows that will be created 
indx = np.arange(0,img.shape[0]-window[1],strideY)[:,None]+np.arange(window[1]) # index that will be broadcasted across image 
vertical_windows = img[indx] # array of windows win_h tall and the full width of the image 

vertical_windows = np.transpose(vertical_windows,(0,2,1)) # transpose to prep for broadcasting 
num_horz_windows = len(np.arange(0,vertical_windows.shape[1]-window[0],strideX)) # number of horizontal windows that will be created 
indx = np.arange(0,vertical_windows.shape[1]-window[0],strideX)[:,None]+np.arange(window[0]) # index for broadcasting across vertical windows 
all_windows = vertical_windows[0:vertical_windows.shape[0],indx] # array of all the windows 
## -------- end of, sliding window vectorization ------------------------ 

## ------- The below code rearranges and flattens the windows into a single matrix of pixels in columns and each window 
## ------- in a row which makes evaluating a function over every window in a vectorized manner easier 

total_windows = num_vert_windows*num_horz_windows 

all_windows = np.transpose(all_windows,(3,2,1,0)) # rearrange for resizing and intuitive indexing 

print('all_windows shape as stored in 2d matrix:', all_windows.shape) 
for i in range(all_windows.shape[2]): # display windows for visual confirmation 
    for j in range(all_windows.shape[3]): 
     cv2.imshow('image',all_windows[:,:,i,j]) 
     cv2.waitKey(100) 

all_windows = np.resize(all_windows,(win_h,win_w,total_windows)) 
print('all_windows shape after folding into 1d vector:', all_windows.shape) 
for i in range(all_windows.shape[2]): # display windows for visual confirmation 
    cv2.imshow('image',all_windows[:,:,i]) 
    cv2.waitKey(100) 

# shrinking all the windows down to the size needed for object detect predictions 
small_windows = cv2.resize(all_windows[:,:,0:all_windows.shape[2]],data_patch_size,0,0,cv2.INTER_AREA) 
print('all_windows shape after shrinking to evaluation size:',small_windows.shape) 
for i in range(small_windows.shape[2]): # display windows for vis. conf. 
    cv2.imshow('image',small_windows[:,:,i]) 
    cv2.waitKey(100) 

# flattening and rearranging the window data so that the pixels are in columns and each window is a row 
flat_windows = np.resize(small_windows,(data_patch_size[0]*data_patch_size[1],total_windows)) 
flat_windows = np.transpose(flat_windows) 
print('shape of the window data to send to the predicter:',np.shape(flat_windows)) 

results, max_index = Predict(flat_windows) # get predictions on all the windows