SAD立体匹配算法SW滑动窗口python程序

直入主题

window_half_size_SW=int(window_size_SW/2)
os.chdir(r'C:\Users\86198\Desktop\learn\AAAAAAAAAAAA相机程序\下载的双目图像')
lraw=np.asanyarray(Image.open(r"scene1.row3.col1.ppm"))
rraw=np.asanyarray(Image.open(r"scene1.row3.col3.ppm"))
limg= cv.cvtColor(lraw,cv.COLOR_BGR2GRAY)
rimg= cv.cvtColor(rraw,cv.COLOR_BGR2GRAY)
limg=np.asanyarray(limg,dtype=np.double)
rimg=np.asanyarray(rimg,dtype=np.double)
img_size=np.shape(limg)[0:2]
tic1=time.time()
imgDiff=np.zeros((img_size[0],img_size[1],maxDisparity))
e = np.zeros(img_size)
for i in range(0,maxDisparity):
    e[:,i:img_size[1]]=np.abs(rimg[:,0:(img_size[1]-i)]- limg[:,i:img_size[1]]) #视差为多少，那么生成的图像就会少多少像素列,e负责计算视差为i时，两张图整体的差距
    e2=np.zeros(img_size) #计算窗口内的和
    for x in range((window_size),(img_size[0]-window_size)):
        for y in range((window_size),(img_size[1]-window_size)):
            e2[x,y]=np.sum(e[(x-window_size):(x+window_size),(y-window_size):(y+window_size)])
            #其实相当于用111 111 111的卷积核去卷积，如果用tensorflow会不会更快一些，其实就是先做差再加和以及先加和再做差的关系
    imgDiff[:,:,i]=e2



errMap=np.ones((img_size[0],img_size[1],maxDisparity))*100000

# min_errorMap=np.zeros(img_size)


for i in range(maxDisparity):
    for x in range(window_half_size_SW+window_size,img_size[0]-window_half_size_SW-window_size):
        for y in range(window_half_size_SW+window_size,img_size[1]-window_half_size_SW-window_size):
            SW_err_list=[(x-1,x-1,x-1,x,x,x,x+1,x+1,x+1),(y-1,y,y+1,y-1,y,y+1,y-1,y,y+1),(i,i,i,i,i,i,i,i,i)]            
            min_test=np.min(imgDiff[SW_err_list])
            
            
            if imgDiff[x,y,i]>min_test:
                index_pre_minerr=np.argmin(imgDiff[SW_err_list])
                index_after_minerr= [SW_err_list[0][index_pre_minerr],SW_err_list[1][index_pre_minerr],SW_err_list[2][index_pre_minerr]]
                errMap[x,y,i]=imgDiff[      index_after_minerr[0],index_after_minerr[1],index_after_minerr[2]    ]
# errMap[:,:,0]=imgDiff[:,:,0]
# errMap[:,:,-1]=imgDiff[:,:,-1]
dispMap=np.zeros(img_size)      
for x in range(0,img_size[0]):
    for y in range(0,img_size[1]):
        val=np.sort(errMap[x,y,:])
        # min_errorMap[x,y]=val[0]
        # if min_errorMap[x,y]==0:
        #     min_errorMap[x,y]=100000
        val_id=np.argsort(errMap[x,y,:])
        dispMap[x,y]=val_id[0]/maxDisparity*255#其实dispmap计算的是视差的大小，如果视差大，那么就相当于两张图片中同样物品的位移大，就是距离
disp_fix= dispMap.copy()
            # disp_fix[x,y]=np.min([x-window_half_size_SW:x+window_half_size_SW,y-window_half_size_SW:y+window_half_size_SW])
# disp_fix= dispMap.copy()
# for x in range(window_half_size_SW,img_size[0]-window_half_size_SW):
#     for y in range(window_half_size_SW,img_size[1]-window_half_size_SW):
#         for i in range(-window_half_size_SW,window_half_size_SW+1):
#             for j in range(-window_half_size_SW,window_half_size_SW+1):
#                 if  min_errorMap[x,y]>min_errorMap[x+i,y+j]:
#                     min_errorMap[x,y]=min_errorMap[x+i,y+j]
#                     disp_fix[x,y]=dispMap[x+i,y+j]
plt.imshow(disp_fix)
plt.show()
dispMap=np.array(dispMap,dtype=np.uint8)
# bi_demo(dispMap)
print('用时:',time.time()-tic1)

运行效果

用时: 65.38784909248352