Kalibre edilmemiş bir yöntemle bir derinlik haritası elde etmeye çalışıyorum. SIFT ile karşılık gelen noktaları bularak ve ardından kullanarak temel matrisi elde edebilirim cv2.findFundamentalMat. Daha sonra cv2.stereoRectifyUncalibratedher görüntü için homografi matrislerini elde etmek için kullanıyorum . Sonunda cv2.warpPerspectiveeşitsizliği düzeltmek ve hesaplamak için kullanıyorum, ancak bu iyi bir derinlik haritası oluşturmuyor. Değerler çok yüksek, bu yüzden kullanmam warpPerspectivegerekip gerekmediğini veya aldığım homografi matrislerinden bir rotasyon matrisi hesaplamam gerekip gerekmediğini merak ediyorum stereoRectifyUncalibrated.

Düzeltmek için ile elde edilen homografi matrisi durumunda projektif matristen emin değilim stereoRectifyUncalibrated.

Kodun bir parçası:

#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()

Kalibre edilmemiş yöntemle düzeltilmiş resimler (ve warpPerspective):

Kalibre edilmiş yöntemle düzeltilmiş resimler şunlardır:

İki tür resim arasındaki farkın ne kadar önemli olduğunu bilmiyorum. Kalibre edilmiş yöntem için de hizalı görünmüyor.

Kalibre edilmemiş yöntemi kullanan eşitsizlik haritası:

Derinlikleri ile hesaplanır: C1[0,0]*T[0]/(disp) T den stereoCalibrate. Değerler çok yüksek.

------------ DAHA SONRA DÜZENLE ------------

Yeniden yapılandırma matrisini ( [Devernay97] , [Garcia01] ) "stereoRectifyUncalibrated" ile elde edilen homografi matrisiyle "monte etmeye" çalıştım, ancak sonuç yine de iyi değil. Bunu doğru yapıyor muyum?

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)

TLDR; Daha pürüzsüz kenarlı görüntüler için StereoSGBM (Yarı Küresel Blok Eşleştirme) kullanın ve daha da pürüzsüz olmasını istiyorsanız bazı son filtreleme kullanın

Ben kullanıyorum böylece OP, orijinal görüntüleri vermedi Tsukubagelen Middlebury veri setinin .

Normal StereoBM ile sonuç

StereoSGBM ile sonuç (ayarlanmış)

Edebiyatta bulabildiğim en iyi sonuç

Yayını bakın burada detaylar için.

Sonradan filtreleme örneği (aşağıdaki bağlantıya bakın)

Teori / OP'nin sorusundaki diğer düşünceler

Kalibre edilmiş düzeltilmiş resimlerinizin geniş siyah alanları, bunlar için kalibrasyonun çok iyi yapılmadığına inanmamı sağlar. Oyunda olabilecek çeşitli nedenler var, belki fiziksel kurulum, belki kalibrasyon yaptığınızda ışıklandırma, vb.Ancak bunun için pek çok kamera kalibrasyonu öğreticisi var ve benim anladığım kadarıyla bir yol soruyorsunuz. Kalibre edilmemiş bir kurulumdan daha iyi bir derinlik haritası elde edin (bu% 100 net değil, ancak başlık bunu destekliyor gibi görünüyor ve bence insanlar buraya bulmaya çalışacaklar).

Temel yaklaşımınız doğrudur, ancak sonuçlar kesinlikle iyileştirilebilir. Bu derinlik haritalama biçimi, en yüksek kalitede haritalar üretenlerden değildir (özellikle kalibre edilmemiş olanlar). En büyük gelişme muhtemelen farklı bir stereo eşleştirme algoritması kullanmaktan kaynaklanacaktır. Aydınlatma da önemli bir etkiye sahip olabilir. Doğru görüntü (en azından çıplak gözüme) daha az aydınlatılmış gibi görünüyor ve bu da rekonstrüksiyona engel olabilir. İlk önce diğeriyle aynı seviyeye kadar parlaklaştırmayı deneyebilir veya mümkünse yeni görüntüler toplayabilirsiniz. Buradan itibaren, orijinal kameralara erişiminizin olmadığını varsayacağım, bu yüzden kapsam dışında olacak şekilde yeni görüntüler toplamayı, kurulumu değiştirmeyi veya kalibrasyon gerçekleştirmeyi düşüneceğim. (Kurulum ve kameralara erişiminiz varsa,

StereoBMİşe yarayan, ancak StereoSGBMbu uygulama için çok daha uygun olan eşitsizliği (derinlik haritası) hesaplamak için kullandınız (daha düzgün kenarları daha iyi idare eder). Farkı aşağıda görebilirsiniz.

Bu makale , farklılıkları daha derinlemesine açıklamaktadır:

Blok eşleştirme, yüksek dokulu görüntülere odaklanır (bir ağacın resmini düşünün) ve yarı küresel blok eşleştirme, alt piksel seviyesi eşleştirmesine ve daha pürüzsüz dokulara (bir koridorun resmini düşünün) odaklanır.

Herhangi bir açık dahili kamera parametresi, kamera kurulumuyla ilgili ayrıntılar (odak mesafesi, kameralar arasındaki mesafe, nesneye olan mesafe vb.), Görüntüde bilinen bir boyut veya hareket (hareketten yapıyı kullanmak için ) olmadan, yalnızca yansıtmalı bir dönüşüme kadar 3B yeniden yapılandırma elde edin; bir ölçek hissine veya zorunlu olarak rotasyona sahip olmayacaksınız, ancak yine de göreceli bir derinlik haritası oluşturabilirsiniz. Uygun kamera kalibrasyonu ile giderilebilecek bazı namlu ve diğer bozulmalardan büyük olasılıkla muzdarip olacaksınız, ancak kameralar korkunç olmadığı (lens sistemi çok bozuk olmadığı) ve güzel bir şekilde kurulduğu sürece onsuz makul sonuçlar elde edebilirsiniz. kanonik yapılandırmaya yakın(bu, temelde, optik eksenlerinin olabildiğince paralel olacak şekilde yönlendirildikleri ve görüş alanlarının yeterince örtüştüğü anlamına gelir). Bununla birlikte, kalibre edilmemiş yöntemle tamamen düzeltilmiş görüntüler elde etmeyi başardığı için bu, OPs sorunu gibi görünmüyor.

Temel Prosedür

1. Her iki görüntüde de Temel Matrisi hesaplamak için kullanabileceğiniz en az 5 iyi eşleşen nokta bulun (istediğiniz herhangi bir detektörü ve eşleştiriciyi kullanabilirsiniz, FLANN'i tuttum ama tespit yapmak için ORB'yi kullandım çünkü SIFT, OpenCV'nin ana sürümünde değil 4.2.0 için)
2. Temel Matrisi, F ile hesaplayın findFundamentalMat
3. stereoRectifyUncalibratedVe ile resimlerinizin bozulmasını önleyinwarpPerspective
4. Eşitsizliği Hesapla (Derinlik Haritası) ile StereoSGBM

Sonuçlar çok daha iyi:

ORB ve FLANN ile eşleşir

Bozulmamış görüntüler (sola, sonra sağa)

Eşitsizlik

StereoBM

Bu sonuç, OP sorunlarına benziyor (beneklenme, boşluklar, bazı alanlarda yanlış derinlikler).

StereoSGBM (ayarlanmış)

Bu sonuç çok daha iyi görünüyor ve OP ile aşağı yukarı aynı yöntemi kullanıyor, eksi son eşitsizlik hesaplaması, bana OP'nin görüntülerinde benzer iyileştirmeler göreceğini düşündürüyor.

Sonradan filtreleme

Orada bu konuda iyi makale OpenCV docs. Gerçekten düzgün haritalara ihtiyacınız varsa bakmanızı tavsiye ederim.

Yukarıdaki örnek resimleri sahneden çerçevesi 1 olan ambush_2bölgesindeki MPI Sintel Veri Dizisi .

Tam kod (OpenCV 4.2.0'da test edildi):

import cv2
import numpy as np
import matplotlib.pyplot as plt

imgL = cv2.imread("tsukuba_l.png", cv2.IMREAD_GRAYSCALE)  # left image
imgR = cv2.imread("tsukuba_r.png", cv2.IMREAD_GRAYSCALE)  # right image


def get_keypoints_and_descriptors(imgL, imgR):
    """Use ORB detector and FLANN matcher to get keypoints, descritpors,
    and corresponding matches that will be good for computing
    homography.
    """
    orb = cv2.ORB_create()
    kp1, des1 = orb.detectAndCompute(imgL, None)
    kp2, des2 = orb.detectAndCompute(imgR, None)

    ############## Using FLANN matcher ##############
    # Each keypoint of the first image is matched with a number of
    # keypoints from the second image. k=2 means keep the 2 best matches
    # for each keypoint (best matches = the ones with the smallest
    # distance measurement).
    FLANN_INDEX_LSH = 6
    index_params = dict(
        algorithm=FLANN_INDEX_LSH,
        table_number=6,  # 12
        key_size=12,  # 20
        multi_probe_level=1,
    )  # 2
    search_params = dict(checks=50)  # or pass empty dictionary
    flann = cv2.FlannBasedMatcher(index_params, search_params)
    flann_match_pairs = flann.knnMatch(des1, des2, k=2)
    return kp1, des1, kp2, des2, flann_match_pairs


def lowes_ratio_test(matches, ratio_threshold=0.6):
    """Filter matches using the Lowe's ratio test.

    The ratio test checks if matches are ambiguous and should be
    removed by checking that the two distances are sufficiently
    different. If they are not, then the match at that keypoint is
    ignored.

    /programming/51197091/how-does-the-lowes-ratio-test-work
    """
    filtered_matches = []
    for m, n in matches:
        if m.distance < ratio_threshold * n.distance:
            filtered_matches.append(m)
    return filtered_matches


def draw_matches(imgL, imgR, kp1, des1, kp2, des2, flann_match_pairs):
    """Draw the first 8 mathces between the left and right images."""
    # https://docs.opencv.org/4.2.0/d4/d5d/group__features2d__draw.html
    # https://docs.opencv.org/2.4/modules/features2d/doc/common_interfaces_of_descriptor_matchers.html
    img = cv2.drawMatches(
        imgL,
        kp1,
        imgR,
        kp2,
        flann_match_pairs[:8],
        None,
        flags=cv2.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS,
    )
    cv2.imshow("Matches", img)
    cv2.imwrite("ORB_FLANN_Matches.png", img)
    cv2.waitKey(0)


def compute_fundamental_matrix(matches, kp1, kp2, method=cv2.FM_RANSAC):
    """Use the set of good mathces to estimate the Fundamental Matrix.

    See  https://en.wikipedia.org/wiki/Eight-point_algorithm#The_normalized_eight-point_algorithm
    for more info.
    """
    pts1, pts2 = [], []
    fundamental_matrix, inliers = None, None
    for m in matches[:8]:
        pts1.append(kp1[m.queryIdx].pt)
        pts2.append(kp2[m.trainIdx].pt)
    if pts1 and pts2:
        # You can play with the Threshold and confidence values here
        # until you get something that gives you reasonable results. I
        # used the defaults
        fundamental_matrix, inliers = cv2.findFundamentalMat(
            np.float32(pts1),
            np.float32(pts2),
            method=method,
            # ransacReprojThreshold=3,
            # confidence=0.99,
        )
    return fundamental_matrix, inliers, pts1, pts2


############## Find good keypoints to use ##############
kp1, des1, kp2, des2, flann_match_pairs = get_keypoints_and_descriptors(imgL, imgR)
good_matches = lowes_ratio_test(flann_match_pairs, 0.2)
draw_matches(imgL, imgR, kp1, des1, kp2, des2, good_matches)


############## Compute Fundamental Matrix ##############
F, I, points1, points2 = compute_fundamental_matrix(good_matches, kp1, kp2)


############## Stereo rectify uncalibrated ##############
h1, w1 = imgL.shape
h2, w2 = imgR.shape
thresh = 0
_, H1, H2 = cv2.stereoRectifyUncalibrated(
    np.float32(points1), np.float32(points2), F, imgSize=(w1, h1), threshold=thresh,
)

############## Undistort (Rectify) ##############
imgL_undistorted = cv2.warpPerspective(imgL, H1, (w1, h1))
imgR_undistorted = cv2.warpPerspective(imgR, H2, (w2, h2))
cv2.imwrite("undistorted_L.png", imgL_undistorted)
cv2.imwrite("undistorted_R.png", imgR_undistorted)

############## Calculate Disparity (Depth Map) ##############

# Using StereoBM
stereo = cv2.StereoBM_create(numDisparities=16, blockSize=15)
disparity_BM = stereo.compute(imgL_undistorted, imgR_undistorted)
plt.imshow(disparity_BM, "gray")
plt.colorbar()
plt.show()

# Using StereoSGBM
# Set disparity parameters. Note: disparity range is tuned according to
#  specific parameters obtained through trial and error.
win_size = 2
min_disp = -4
max_disp = 9
num_disp = max_disp - min_disp  # Needs to be divisible by 16
stereo = cv2.StereoSGBM_create(
    minDisparity=min_disp,
    numDisparities=num_disp,
    blockSize=5,
    uniquenessRatio=5,
    speckleWindowSize=5,
    speckleRange=5,
    disp12MaxDiff=2,
    P1=8 * 3 * win_size ** 2,
    P2=32 * 3 * win_size ** 2,
)
disparity_SGBM = stereo.compute(imgL_undistorted, imgR_undistorted)
plt.imshow(disparity_SGBM, "gray")
plt.colorbar()
plt.show()

Düşük kaliteyle sonuçlanan Depth Channelve Disparity Channelbizi düşük kaliteli stereo sekansa götüren birkaç olası sorun olabilir . İşte bu sorunlardan 6'sı:

Olası sorun I

• Eksik Formül

Bir sözcüğün uncalibratedima ettiği gibi, stereoRectifyUncalibratedörnek yöntemi, stereo çiftinizin iç parametrelerini ve ortamdaki göreceli konumunu bilmediğiniz veya bilemediğiniz durumda sizin için bir düzeltme dönüşümleri hesaplar.

cv.StereoRectifyUncalibrated(pts1, pts2, fm, imgSize, rhm1, rhm2, thres)

nerede:

# pts1    –> an array of feature points in a first camera
# pts2    –> an array of feature points in a first camera
# fm      –> input fundamental matrix
# imgSize -> size of an image
# rhm1    -> output rectification homography matrix for a first image
# rhm2    -> output rectification homography matrix for a second image
# thres   –> optional threshold used to filter out outliers

Yönteminiz şu şekilde görünüyor:

cv2.StereoRectifyUncalibrated(p1fNew, p2fNew, F, (2048, 2048))

Yani, hesaba üç parametre almazlar: rhm1, rhm2ve thres. Eğer a ise threshold > 0, epipolar geometriye uymayan tüm nokta çiftleri homografiler hesaplanmadan önce reddedilir. Aksi takdirde, tüm puanlar değişken olarak kabul edilir. Bu formül şuna benzer:

(pts2[i]^t * fm * pts1[i]) > thres

# t   –> translation vector between coordinate systems of cameras

Bu nedenle, eksik bir formül hesaplamasından dolayı görsel yanlışlıkların ortaya çıkabileceğine inanıyorum.

Kamera Kalibrasyonu ve 3D Yeniden Yapılandırmayı resmi kaynakta okuyabilirsiniz .

Olası sorun II

• Eksenlerarası Mesafe

interaxial distanceSol ve sağ kamera lensleri arasında sağlam olmalıdır not greater than 200 mm. Ne zaman interaxial distancedaha büyüktür interocularmesafe, etkisi denir hyperstereoscopyya hyperdivergenceve sahnedeki derinlik abartı değil, aynı zamanda izleyicinin fiziksel rahatsızlık değil sadece sonuçlanır. Bu konu hakkında daha fazla bilgi edinmek için Autodesk'in Stereoskopik Film Yapımı Teknik Raporunu okuyun .

Olası sorun III

• Paralel ve Parmaklı Kamera modu

Disparity MapYanlış Kamera Modu hesaplaması nedeniyle sonuçta görsel yanlışlıklar meydana gelebilir. Birçok stereograf tercih eder, Toe-In camera modeancak örneğin Pixar tercih eder Parallel camera mode.

Olası sorun IV

• Dikey hizalama

Stereoskopide, dikey bir kayma meydana gelirse (görünümlerden biri 1 mm yukarı kaydırılsa bile), güçlü bir stereo deneyimini bozar. Bu nedenle, oluşturmadan önce Disparity Mapstereo çiftinizin sol ve sağ görünümlerinin uygun şekilde hizalandığından emin olmalısınız. Stereo'da 15 yaygın problemle ilgili Technicolor Sterreoscopic Whitepaper'a bakın .

Stereo Doğrultma Matrisi:

   ┌                  ┐
   |  f   0   cx  tx  |
   |  0   f   cy  ty  |   # use "ty" value to fix vertical shift in one image
   |  0   0   1   0   |
   └                  ┘

İşte bir StereoRectifyyöntem:

cv.StereoRectify(cameraMatrix1, cameraMatrix2, distCoeffs1, distCoeffs2, imageSize, R, T, R1, R2, P1, P2, Q=None, flags=CV_CALIB_ZERO_DISPARITY, alpha=-1, newImageSize=(0, 0)) -> (roi1, roi2)

Olası sorun V

• Lens Bozulması

Lens Bozulması, stereo kompozisyonda çok önemli bir konudur. Bir oluşturmadan önce, Disparity Mapsol ve sağ görünümleri bozmanız gerekir, bundan sonra bir eşitsizlik kanalı oluşturmalı ve ardından her iki görünümü de yeniden bozmalısınız.

Olası sorun VI

• Kenar yumuşatma içermeyen düşük kaliteli Derinlik kanalı

Yüksek kalite oluşturmak için önceden üretilmiş olması Disparity Mapgereken sol ve sağ tarafa ihtiyacınız vardır Depth Channels. 3B pakette çalışırken, tek bir tıklama ile yüksek kaliteli bir Derinlik Kanalı (keskin kenarlı) oluşturabilirsiniz. Ancak, video dizisinden yüksek kaliteli derinlikli bir kanal oluşturmak kolay değildir çünkü stereo çiftinin, gelecekteki hareketten derinlik algoritması için bir ilk veri üretmek üzere ortamınızda hareket etmesi gerekir. Bir karede hareket yoksa, derinlik kanalı son derece zayıf olacaktır.

Ayrıca, Depthkanalın kendisinin bir dezavantajı daha vardır - kenarları kenar yumuşatması olmadığı için RGB'nin kenarlarıyla eşleşmez .

Eşitsizlik kanalı kod pasajı:

Burada, bir oluşturmak için hızlı bir yaklaşımı temsil etmek istiyorum Disparity Map:

import numpy as np
import cv2 as cv
from matplotlib import pyplot as plt

imageLeft = cv.imread('paris_left.png', 0)
imageRight = cv.imread('paris_right.png', 0)
stereo = cv.StereoBM_create(numDisparities=16, blockSize=15)
disparity = stereo.compute(imageLeft, imageRight)
plt.imshow(disparity, 'gray')
plt.show()