मैं एक अनसाल्टेड विधि के साथ एक गहराई नक्शा प्राप्त करने की कोशिश कर रहा हूं। मैं SIFT के साथ संवाददाता बिंदुओं का पता लगाकर और फिर उपयोग करके मूलभूत मैट्रिक्स प्राप्त कर सकता हूं cv2.findFundamentalMat। मैं तब cv2.stereoRectifyUncalibratedप्रत्येक छवि के लिए होमोग्राफी मैट्रीस प्राप्त करने के लिए उपयोग करता हूं । अंत में मैं cv2.warpPerspectiveअसमानता को ठीक करने और गणना करने के लिए उपयोग करता हूं , लेकिन यह एक अच्छी गहराई मानचित्र नहीं बनाता है। मान बहुत अधिक हैं, इसलिए मैं सोच रहा हूं कि क्या मुझे उपयोग करना है warpPerspectiveया यदि मुझे मेरे साथ मिली होमोग्राफी मैट्रिसेस से रोटेशन मैट्रिक्स की गणना करनी है stereoRectifyUncalibrated।
मैं stereoRectifyUncalibratedसुधार करने के लिए प्राप्त होमोग्राफी मैट्रिक्स के मामले के साथ अनुमानित मैट्रिक्स के बारे में निश्चित नहीं हूं ।
कोड का एक हिस्सा:
#Obtainment of the correspondent point with SIFT
sift = cv2.SIFT()
###find the keypoints and descriptors with SIFT
kp1, des1 = sift.detectAndCompute(dst1,None)
kp2, des2 = sift.detectAndCompute(dst2,None)
###FLANN parameters
FLANN_INDEX_KDTREE = 0
index_params = dict(algorithm = FLANN_INDEX_KDTREE, trees = 5)
search_params = dict(checks=50)
flann = cv2.FlannBasedMatcher(index_params,search_params)
matches = flann.knnMatch(des1,des2,k=2)
good = []
pts1 = []
pts2 = []
###ratio test as per Lowe's paper
for i,(m,n) in enumerate(matches):
if m.distance < 0.8*n.distance:
good.append(m)
pts2.append(kp2[m.trainIdx].pt)
pts1.append(kp1[m.queryIdx].pt)
pts1 = np.array(pts1)
pts2 = np.array(pts2)
#Computation of the fundamental matrix
F,mask= cv2.findFundamentalMat(pts1,pts2,cv2.FM_LMEDS)
# Obtainment of the rectification matrix and use of the warpPerspective to transform them...
pts1 = pts1[:,:][mask.ravel()==1]
pts2 = pts2[:,:][mask.ravel()==1]
pts1 = np.int32(pts1)
pts2 = np.int32(pts2)
p1fNew = pts1.reshape((pts1.shape[0] * 2, 1))
p2fNew = pts2.reshape((pts2.shape[0] * 2, 1))
retBool ,rectmat1, rectmat2 = cv2.stereoRectifyUncalibrated(p1fNew,p2fNew,F,(2048,2048))
dst11 = cv2.warpPerspective(dst1,rectmat1,(2048,2048))
dst22 = cv2.warpPerspective(dst2,rectmat2,(2048,2048))
#calculation of the disparity
stereo = cv2.StereoBM(cv2.STEREO_BM_BASIC_PRESET,ndisparities=16*10, SADWindowSize=9)
disp = stereo.compute(dst22.astype(uint8), dst11.astype(uint8)).astype(np.float32)
plt.imshow(disp);plt.colorbar();plt.clim(0,400)#;plt.show()
plt.savefig("0gauche.png")
#plot depth by using disparity focal length `C1[0,0]` from stereo calibration and `T[0]` the distance between cameras
plt.imshow(C1[0,0]*T[0]/(disp),cmap='hot');plt.clim(-0,500);plt.colorbar();plt.show()
यहाँ अनसालिडेटेड विधि (और warpPerspective) के साथ सुधारित चित्र दिए गए हैं :
यहाँ कैलिब्रेटेड विधि से सुधारित चित्र दिए गए हैं:
मुझे नहीं पता कि दोनों प्रकार के चित्रों के बीच अंतर कितना महत्वपूर्ण है। और कैलिब्रेटेड विधि के लिए, यह गठबंधन नहीं लगता है।
असमान विधि का उपयोग कर विषमता नक्शा:
गहराई की गणना C1[0,0]*T[0]/(disp)
टी के साथ: के साथ की जाती है stereoCalibrate। मान बहुत अधिक हैं।
------------ EDIT LATER ------------
मैंने पुनर्निर्माण स्टीरियो मैट्रिक्स ( [Devernay97] , [गार्सिया01] ) को "स्टीरियोइरेक्टीफाईनलनरीब्रेटेड" के साथ प्राप्त होमोग्राफी मैट्रिक्स के साथ "माउंट" करने की कोशिश की, लेकिन परिणाम अभी भी अच्छा नहीं है। क्या मैं यह सही ढंग से कर रहा हूं?
Y=np.arange(0,2048)
X=np.arange(0,2048)
(XX_field,YY_field)=np.meshgrid(X,Y)
#I mount the X, Y and disparity in a same 3D array
stock = np.concatenate((np.expand_dims(XX_field,2),np.expand_dims(YY_field,2)),axis=2)
XY_disp = np.concatenate((stock,np.expand_dims(disp,2)),axis=2)
XY_disp_reshape = XY_disp.reshape(XY_disp.shape[0]*XY_disp.shape[1],3)
Ts = np.hstack((np.zeros((3,3)),T_0)) #i use only the translations obtained with the rectified calibration...Is it correct?
# I establish the projective matrix with the homography matrix
P11 = np.dot(rectmat1,C1)
P1 = np.vstack((np.hstack((P11,np.zeros((3,1)))),np.zeros((1,4))))
P1[3,3] = 1
# P1 = np.dot(C1,np.hstack((np.identity(3),np.zeros((3,1)))))
P22 = np.dot(np.dot(rectmat2,C2),Ts)
P2 = np.vstack((P22,np.zeros((1,4))))
P2[3,3] = 1
lambda_t = cv2.norm(P1[0,:].T)/cv2.norm(P2[0,:].T)
#I define the reconstruction matrix
Q = np.zeros((4,4))
Q[0,:] = P1[0,:].T
Q[1,:] = P1[1,:].T
Q[2,:] = lambda_t*P2[1,:].T - P1[1,:].T
Q[3,:] = P1[2,:].T
#I do the calculation to get my 3D coordinates
test = []
for i in range(0,XY_disp_reshape.shape[0]):
a = np.dot(inv(Q),np.expand_dims(np.concatenate((XY_disp_reshape[i,:],np.ones((1))),axis=0),axis=1))
test.append(a)
test = np.asarray(test)
XYZ = test[:,:,0].reshape(XY_disp.shape[0],XY_disp.shape[1],4)
