def __init__(self, min_disparity=16, num_disp=96, sad_window_size=3,
uniqueness=10, speckle_window_size=100, speckle_range=32,
p1=216, p2=864, max_disparity=1, full_dp=False,
settings=None):
"""Instantiate private variables and call superclass initializer."""
#: Minimum number of disparities. Normally 0, can be adjusted as
#: needed
self._min_disparity = min_disparity
#: Number of disparities
self._num_disp = num_disp
#: Matched block size
self._sad_window_size = sad_window_size
#: Uniqueness ratio for found matches
self._uniqueness = uniqueness
#: Maximum size of smooth disparity regions to invalid by noise
self._speckle_window_size = speckle_window_size
#: Maximum disparity range within connected component
self._speckle_range = speckle_range
#: Penalty on disparity change by +-1 between neighbor pixels
self._P1 = p1
#: Penalty on disparity change by multiple neighbor pixels
self._P2 = p2
#: Maximum left-right disparity. 0 to disable check
self._max_disparity = max_disparity
#: Boolean to use full-scale two-pass dynamic algorithm
self._full_dp = full_dp
#: StereoSGBM whose state is controlled
self._block_matcher = cv2.StereoSGBM()
super(StereoSGBM, self).__init__(settings)
def main():
# 左右画像をグレースケールで取得
gray_l = cv2.imread("left.png",0)
gray_r = cv2.imread("right.png",0)
# 画像のヒストグラム平坦化・平滑化
gray_l = cv2.GaussianBlur( cv2.equalizeHist(gray_l),(5,5), 0)
gray_r = cv2.GaussianBlur( cv2.equalizeHist(gray_r),(5,5), 0)
# セミグローバルブロックマッチング
window_size = 7
stereo = cv2.StereoSGBM(
minDisparity = 0, # 視差の下限
numDisparities = 64, # 最大の上限
SADWindowSize = window_size,# SADの窓サイズ
uniquenessRatio = 10, # パーセント単位で表現されるマージン
speckleWindowSize = 0, # 視差領域の最大サイズ
speckleRange = 16, # それぞれの連結成分における最大視差値
disp12MaxDiff = 0, # left-right 視差チェックにおけて許容される最大の差
P1 = 8*3*window_size**2, # 視差のなめらかさを制御するパラメータ1
P2 = 32*3*window_size**2, # 視差のなめらかさを制御するパラメータ2
fullDP = False # 完全な2パス動的計画法を使うならTrue
)
# 視差を求める
disp = stereo.compute(gray_l, gray_r)
# 視差データを8bitデータに変換(imshowで表示させるため)
disp = cv2.normalize(disp, alpha=0, beta=255, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_8U)
cv2.imshow("disp",disp) # 視差画像の表示
cv2.waitKey(0)
cv2.destroyAllWindows()
def DistanceMeasure(self,x,y):
# 根据更正map对图片进行重构
img1_rectified = cv2.remap(self.left_image, camera_configs.left_map1, camera_configs.left_map2, cv2.INTER_LINEAR)
img2_rectified = cv2.remap(self.right_image, camera_configs.right_map1, camera_configs.right_map2, cv2.INTER_LINEAR)
# 将图片置为灰度图，为StereoBM作准备
imgL = cv2.cvtColor(img1_rectified, cv2.COLOR_BGR2GRAY)
imgR = cv2.cvtColor(img2_rectified, cv2.COLOR_BGR2GRAY)
# 两个trackbar用来调节不同的参数查看效果
num = cv2.getTrackbarPos("num", "depth")
blockSize = cv2.getTrackbarPos("blockSize", "depth")
if blockSize % 2 == 0:
blockSize += 1
if blockSize < 5:
blockSize = 5
# 根据Block Maching方法生成差异图（opencv里也提供了SGBM/Semi-Global Block Matching算法，有兴趣可以试试）
stereo = cv2.StereoSGBM(minDisparity = 16,numDisparities = 128,SADWindowSize = 3,uniquenessRatio = 10,
speckleWindowSize = 100,speckleRange = 16,disp12MaxDiff = -1,P1 = 8*3*3**2,P2 = 32*3*3**2,fullDP = False)
disparity = stereo.compute(imgL, imgR)
disp = cv2.normalize(disparity, disparity, alpha=0, beta=255, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_8U)
# 将图片扩展至3d空间中，其z方向的值则为当前的距离
threeD = cv2.reprojectImageTo3D(disparity.astype(np.float32) / 16., camera_configs.Q)
return threeD[x][y]
def main():
leftdir = sys.argv[1]
rightdir = sys.argv[2]
for i in range(500):
print("{:04d}".format(i))
leftimg = cv2.imread(leftdir + "000000" +"{:04d}".format(i) + ".png")
rightimg = cv2.imread(rightdir + "000000" +"{:04d}".format(i) + ".png")
bl = 0.537
focal = 718.856
height, width, chan = leftimg.shape
gray0 = cv2.cvtColor(leftimg, cv2.COLOR_BGR2GRAY)
gray1 = cv2.cvtColor(rightimg, cv2.COLOR_BGR2GRAY)
window_size = 9#3 #5
min_disp = 0#48 #32
num_disp = 320-min_disp
stereo = cv2.StereoSGBM(minDisparity = min_disp,
numDisparities = 192,#num_disp,
SADWindowSize = window_size,
uniquenessRatio = 5,#10,
speckleWindowSize = 100,
speckleRange = 32,
disp12MaxDiff = 1,
P1 = 8*3*window_size**2,
P2 = 32*3*window_size**2,
fullDP = 1)#False)
disp = stereo.compute(gray0, gray1).astype(np.float32) / 16.0
writePFM(sys.argv[3] + "000000" + "{:04d}".format(i) + ".pfm", disp)
def disparity_map(image_left, image_right):
"""Compute the disparity images for image_left and image_right.
Arguments:
image_left, image_right: rectified stereo image pair.
Returns:
an single-channel image containing disparities in pixels,
with respect to image_left's input pixels.
"""
sbm = cv2.StereoSGBM()
sbm.SADWindowSize = 3
sbm.numberOfDisparities = 256
sbm.preFilterCap = 16
sbm.minDisparity = 2
sbm.uniquenessRatio = 10
sbm.speckleWindowSize = 150
sbm.speckleRange = 1
sbm.disp12MaxDiff = 1
sbm.fullDP = True
sbm.P1 = 8 * image_left.shape[2] * (sbm.SADWindowSize**2)
sbm.P2 = 32 * image_left.shape[2] * (sbm.SADWindowSize**2)
disparity = sbm.compute(image_left, image_right)
disparity_visual = cv2.normalize(disparity,
alpha=0,
beta=255,
norm_type=cv2.cv.CV_MINMAX,
dtype=cv2.cv.CV_8U)
return disparity_visual
def disparity_map(image_left, image_right):
"""
Compute the disparity images for image_left and image_right.
Arguments:
image_left, image_right: rectified stereo image pair.
Returns:
an single-channel image containing disparities in pixels,
with respect to image_left's input pixels.
"""
# Set up the disparity calculator
stereo = cv2.StereoSGBM(minDisparity=20,
numDisparities=512,
SADWindowSize=7,
uniquenessRatio=5,
speckleWindowSize=100,
speckleRange=5,
disp12MaxDiff=1,
P1=8 * 3 * 7**2,
P2=32 * 3 * 7**2,
fullDP=False)
# Calculate disparity
disparity = stereo.compute(image_left, image_right).astype(
np.float32) / 16.0
# Convert the disparity image into a single channel image
disparity = np.uint8(disparity)
return disparity
def process(self):
if self.image == None or self.left_image == None or self.right_image == None:
return
# disparity settings
window_size = 1
min_disp = 32
num_disp = 112 - min_disp
stereo = cv2.StereoSGBM(minDisparity=min_disp,
numDisparities=num_disp,
SADWindowSize=window_size,
uniquenessRatio=10,
speckleWindowSize=100,
speckleRange=32,
disp12MaxDiff=1,
P1=8 * 3 * window_size**2,
P2=32 * 3 * window_size**2,
fullDP=False)
disparity = stereo.compute(self.left_image,
self.right_image).astype(np.float32)
disparity = (disparity - min_disp) / num_disp
cv2.imshow('left', self.left_image)
cv2.imshow('right', self.right_image)
cv2.imshow('disparity', disparity)
self.image = None
self.left_image = None
self.right_image = None
def getDepth(self, image, image2):
grayScaleFullImage = cv.CreateImage((image.width, image.height), 8, 1)
cv.CvtColor(image, grayScaleFullImage, cv.CV_BGR2GRAY)
grayScaleFullImage2 = cv.CreateImage((image2.width, image2.height), 8, 1)
cv.CvtColor(image2, grayScaleFullImage2, cv.CV_BGR2GRAY)
[mat_w, mat_h] = self.size
r = cv.CreateMat(mat_h, mat_w, cv.CV_8UC1)
r2 = cv.CreateMat(mat_h, mat_w, cv.CV_8UC1)
print type(r)
print type(image)
print type(self.map1x)
print cv.GetSize(r)
print cv.GetSize(self.map1x)
cv.Remap(grayScaleFullImage, r, self.map1x, self.map1y)
cv.Remap(grayScaleFullImage2, r2, self.map2x, self.map2y)
cv.ShowImage("win3", r)
cv.ShowImage("win4", r2)
#stereo_match that comes in opencv
# disparity range is tuned for 'aloe' image pair
window_size = 3
min_disp = 16
num_disp = 112 - min_disp
stereo = cv2.StereoSGBM(minDisparity=min_disp,
numDisparities=num_disp,
SADWindowSize=window_size,
uniquenessRatio=10,
speckleWindowSize=100,
speckleRange=32,
disp12MaxDiff=1,
P1=8 * 3 * window_size ** 2,
P2=32 * 3 * window_size ** 2,
fullDP=False
)
print 'computing disparity...'
disp = stereo.compute(np.asarray(r), np.asarray(r2)).astype(np.float32) / 16.0
print 'generating 3d point cloud...'
points = cv2.reprojectImageTo3D(disp, np.asarray(self.Q))
colors = cv2.cvtColor(np.asarray(r), cv2.COLOR_GRAY2RGB)
mask = disp > disp.min()
out_points = points[mask]
out_colors = colors[mask]
# Resulting .ply file cam be easily viewed using MeshLab ( http://meshlab.sourceforge.net
out_fn = 'out.ply'
write_ply('out.ply', out_points, out_colors)
print '%s saved' % 'out.ply'
cv2.imshow('disparity', (disp - min_disp) / num_disp)
def do_disparity(self):
if not (self.lframe is None or self.rframe is None):
window_size = 3
min_disp = 16
num_disp = 112 - min_disp
stereo = cv2.StereoSGBM(minDisparity=min_disp,
numDisparities=num_disp,
SADWindowSize=window_size,
uniquenessRatio=10,
speckleWindowSize=100,
speckleRange=32,
disp12MaxDiff=1,
P1=8 * 3 * window_size**2,
P2=32 * 3 * window_size**2,
fullDP=False)
disp = stereo.compute(self.lframe, self.rframe).astype(
np.float32) / 16.0
dbprint('generating 3d point cloud...')
h, w = self.lframe.shape[:2]
f = 0.8 * w # guess for focal length
Q = np.float32([
[1, 0, 0, -0.5 * w],
[0, -1, 0, 0.5 * h], # turn points 180 deg around x-axis,
[0, 0, 0, -f], # so that y-axis looks up
[0, 0, 1, 0]
])
points = cv2.reprojectImageTo3D(disp, Q)
colors = cv2.cvtColor(self.lframe, cv2.COLOR_BGR2RGB)
mask = disp > disp.min()
self.verts = points[mask]
self.colors = colors[mask]
self.disparity = (disp - min_disp) / num_disp
def semiGlobalBlockMatch(self):
"""
A typical correspondence algorithm consists of following three stages:
Pre-filtering to normalize the image brightness and enhance texture
Matching points along horizontal lines in local windows
Post-filtering to eliminate bad matches
"""
SADWindowSize = 3
stereo = cv2.StereoSGBM()
stereo.minDisparity = 0
stereo.numberOfDisparities = self.ndisparities # 96
stereo.SADWindowSize = SADWindowSize # 13
stereo.disp12MaxDiff = 1 # -1
stereo.speckleWindowSize = 100 # 0 # 350
stereo.speckleRange = 32 # 2
stereo.P1 = SADWindowSize * SADWindowSize * 8 # 4 * numChannel * SADWindowSize * SADWindowSize
stereo.P2 = SADWindowSize * SADWindowSize * 32 # 32 * numChannel * SADWindowSize * SADWindowSize
stereo.uniquenessRatio = 10
stereo.preFilterCap = 63
stereo.fullDP = True
disparity = stereo.compute(self.grayL, self.grayR) / 16.
disparity = disparity - np.amin(disparity)
return disparity
def disparity_map(image_left, image_right):
"""Compute the disparity images for image_left and image_right.
Arguments:
image_left, image_right: rectified stereo image pair.
Returns:
an single-channel image containing disparities in pixels,
with respect to image_left's input pixels.
"""
grayleft = cv2.cvtColor(image_left, cv2.COLOR_BGR2GRAY)
grayright = cv2.cvtColor(image_right, cv2.COLOR_BGR2GRAY)
c, r = grayleft.shape
# grayleft = cv2.cv.fromarray(grayleft)
# grayright = cv2.cv.fromarray(grayright)
s = cv2.StereoSGBM()
s.SADWindowSize = 11
s.preFilterCap = 10
s.minDisparity = 5
s.numberOfDisparities = 14 * 16
s.disp12MaxDiff = 1
s.fullDP = False
s.P1 = 8 * 3 * s.SADWindowSize * s.SADWindowSize
s.P2 = 32 * 3 * s.SADWindowSize * s.SADWindowSize
s.uniquenessRatio = 12
disparity = s.compute(grayleft, grayright)
# cv2.cv.FindStereoCorrespondenceBM(grayleft, grayright, disparity, sbm)
disparity_visual = cv2.cv.CreateMat(c, r, cv2.cv.CV_8U)
cv2.cv.Normalize(cv2.cv.fromarray(disparity), disparity_visual, 0, 255,
cv2.cv.CV_MINMAX)
disparity_visual = np.array(disparity_visual)
# cv2.imshow("f", disparity_visual)
return disparity_visual
def __init__(self, master=None):
tk.Frame.__init__(self, master)
self.grid()
self.imgL = ImageTk.PhotoImage(Image.open("small.png"))
self.imgR = ImageTk.PhotoImage(Image.open("small2.png"))
self.rawL = self.imgL
self.rawR = self.imgR
self.cvImgR = ""
self.cvImgL = ""
self.showRaw = True
self.showEdge = False
self.showDisp = False
self.Q = cv.Load("Q.xml")
self.mx1 = np.asarray(cv.Load("mx1.xml"))
self.my1 = np.asarray(cv.Load("my1.xml"))
self.mx2 = np.asarray(cv.Load("mx2.xml"))
self.my2 = np.asarray(cv.Load("my2.xml"))
self.stereo = cv2.StereoSGBM()
self.stereo.SADWindowSize = 9
self.stereo.numberOfDisparities = 96
self.stereo.preFilterCap = 63
self.stereo.minDisparity = -21
self.stereo.uniquenessRatio = 7
self.stereo.speckleWindowSize = 0
self.stereo.speckleRange = 8
self.stereo.disp12MaxDiff = 1
self.stereo.fullDP = False
#holder varriables for the sliders
self.SADWindowSizeScale = 9
self.numberOfDisparitiesScale = 96
self.preFilterCapScale = 63
self.minDisparityScale = -21
self.uniquenessRatioScale = 7
self.speckleWindowSizeScale = 0
self.speckleRangeScale = 8
self.disp12MaxDiffScale = 1
self.fullDP = False
self.createWidgets()
self.SADWindowSizeSlider.set(self.stereo.SADWindowSize)
self.numberOfDisparitiesSlider.set(self.stereo.numberOfDisparities)
self.preFilterCapSlider.set(self.stereo.preFilterCap)
self.minDisparitySlider.set(self.stereo.minDisparity)
self.uniquenessRatioSlider.set(self.stereo.uniquenessRatio)
self.speckleWindowSizeSlider.set(self.stereo.speckleWindowSize)
self.speckleRangeSlider.set(self.stereo.speckleRange)
self.disp12MaxDiffSlider.set(self.stereo.disp12MaxDiff)
self.bind("<Up>", self.arwU)
self.bind("<Down>", self.arwD)
self.bind("<Left>", self.arwL)
self.bind("<Right>", self.arwR)
self.bind("<Button-1>", self.mouseCallback)
self.bind("<Key>", self.keyCallback)
self.after(500, self.updateCamera)
def __init__(self, params=default_params):
self.params = params
# Initilize stereo semi-global block matching
self.sgbm = cv2.StereoSGBM(**self.params)
# Re-map process
self.process = self.compute
def __init__(self, is_sgbm=False):
# fixed parameters for current camera
# StereoSGBM([minDisparity, numDisparities, SADWindowSize[, P1[, P2[, disp12MaxDiff[, preFilterCap[, uniquenessRatio[, speckleWindowSize[, speckleRange[, fullDP]]]]]]]]]) -> <StereoSGBM object>
if is_sgbm:
self.bm = cv2.StereoSGBM(0, 128, 15, 200, 400, 0, 9, 15, 100, 4,
False)
else:
self.bm = cv2.StereoBM(cv2.STEREO_BM_BASIC_PRESET, 128,
45) #preset, ndisp, SADWindowSize
self.is_sgbm = is_sgbm
def calc(self):
img_left = cv2.pyrDown(cv2.imread(path.join(FOLDER, 'aloeL.jpg')))
img_right = cv2.pyrDown(cv2.imread(path.join(FOLDER, 'aloeR.jpg')))
img_left = cv2.cvtColor(img_left, cv2.COLOR_BGR2RGB)
img_right = cv2.cvtColor(img_right, cv2.COLOR_BGR2RGB)
stereo_parameters = dict(
SADWindowSize=5,
numDisparities=192,
preFilterCap=4,
minDisparity=-24,
uniquenessRatio=1,
speckleWindowSize=150,
speckleRange=2,
disp12MaxDiff=10,
fullDP=False,
P1=600,
P2=2400)
stereo = cv2.StereoSGBM(**stereo_parameters)
disparity = stereo.compute(img_left, img_right).astype(np.float32) / 16
h, w = img_left.shape[:2]
ygrid, xgrid = np.mgrid[:h, :w]
ygrid = ygrid.astype(np.float32)
xgrid = xgrid.astype(np.float32)
Bf = w * 0.8
x = (xgrid - w * 0.5)
y = (ygrid - h * 0.5)
d = (disparity + 1e-6)
z = (Bf / d).ravel()
x = (x / d).ravel()
y = -(y / d).ravel()
mask = (z > 0) & (z < 30)
points = np.c_[x, y, z][mask]
colors = img_left.reshape(-1, 3)[mask]
poly = tvtk.PolyData()
poly.points = points
poly.verts = np.arange(len(points)).reshape(-1, 1)
poly.point_data.scalars = colors.astype(np.uint8)
mapper = tvtk.PolyDataMapper()
mapper.set_input_data(poly)
actor = tvtk.Actor(mapper=mapper)
self.scene.add_actor(actor)
self.scene.camera.position = (0, 20, -60)
self.scene.camera.view_up = 0, 1, 0
self.scene.render()
self.axes.clear()
self.axes.imshow(disparity)
self.figure.canvas.draw()
def replace_bm(self):
"""Replace ``block_matcher`` with current values."""
self.block_matcher = cv2.StereoSGBM(minDisparity=self._min_disparity,
numDisparities=self._num_disp,
SADWindowSize=self._sad_window_size,
uniquenessRatio=self._uniqueness,
speckleWindowSize=self._speckle_window_size,
speckleRange=self._speckle_range,
disp12MaxDiff=self._max_disparity,
P1=self._P1,
P2=self._P2,
fullDP=self._full_dp)
def testStereoAlgo(I0, I1, winSize, numDisp):
'''
Fonction calculant et affichant la carte de disparité avec 4 algorighmes:
BM : algorithme de bloque matching stereo simple
SGBM1 : algorithme sgbm avec une faible régularisaion
SGBM2 : algorithme sgbm avec une régularisation moyenne
SGMB3 : algorithme sgbm avec une forte régularisation
winSize = taille de la fenêtre de corrélation
numDisp = nombre d'hypothèse de disparités
'''
print(numDisp)
bm = cv2.StereoBM(cv2.STEREO_BM_BASIC_PRESET, numDisp, winSize)
disp1 = bm.compute(I0, I1).astype(np.float32) / 16.
sgbm = cv2.StereoSGBM(0, numDisp, winSize, P1=0, P2=5)
disp2 = sgbm.compute(I0, I1).astype(np.float32) / 16.
sgbm2 = cv2.StereoSGBM(0,
numDisp,
winSize,
P1=10,
P2=500,
speckleWindowSize=51,
speckleRange=1)
disp3 = sgbm2.compute(I0, I1).astype(np.float32) / 16.
sgbm3 = cv2.StereoSGBM(0,
numDisp,
winSize,
P1=5000,
P2=10000,
speckleWindowSize=51,
speckleRange=1)
disp4 = sgbm3.compute(I0, I1).astype(np.float32) / 16.
figure()
disp = np.concatenate(
[np.concatenate([disp1, disp3]),
np.concatenate([disp2, disp4])],
axis=1)
imshow(disp, vmin=0, vmax=numDisp)
colorbar()
title('resultat [[BM ,SGBM1],[SGBM 2, SGBM3]]')
def getDisparity(imgLeft, imgRight, method="BM"):
gray_left = cv2.cvtColor(imgLeft, cv.CV_BGR2GRAY)
gray_right = cv2.cvtColor(imgRight, cv.CV_BGR2GRAY)
print gray_left.shape
c, r = gray_left.shape
if method == "BM":
sbm = cv.CreateStereoBMState()
disparity = cv.CreateMat(c, r, cv.CV_32F)
sbm.SADWindowSize = 5
sbm.preFilterType = 1
sbm.preFilterSize = 5
sbm.preFilterCap = 30
sbm.minDisparity = 0
sbm.numberOfDisparities = 16
sbm.textureThreshold = 0
sbm.uniquenessRatio = 0
sbm.speckleRange = 2
sbm.speckleWindowSize = 100
gray_left = cv.fromarray(gray_left)
gray_right = cv.fromarray(gray_right)
cv.FindStereoCorrespondenceBM(gray_left, gray_right, disparity, sbm)
disparity_visual = cv.CreateMat(c, r, cv.CV_8U)
cv.Normalize(disparity, disparity_visual, 0, 255, cv.CV_MINMAX)
disparity_visual = np.array(disparity_visual)
elif method == "SGBM":
sbm = cv2.StereoSGBM()
sbm.SADWindowSize = 5
#Matched block size. It must be an odd number >=1 . Normally, it should be somewhere in the 3..11 range.
sbm.numberOfDisparities = 16
#con valori piu alti tipo 112 viene il contorno nero
sbm.preFilterCap = 1
sbm.minDisparity = 0
#con altri valori smongola
sbm.uniquenessRatio = 7
sbm.speckleWindowSize = 100
sbm.speckleRange = 2
sbm.disp12MaxDiff = 1
sbm.fullDP = False
#a True runna il full-scale two-pass dynamic programming algorithm
disparity = sbm.compute(gray_left, gray_right)
disparity_visual = cv2.normalize(disparity,
alpha=0,
beta=255,
norm_type=cv2.cv.CV_MINMAX,
dtype=cv2.cv.CV_8U)
return disparity_visual
def calc_disparity(left_image, right_image):
window_size = 3
min_disp = 1
num_disp = 16 * 2
stereo = cv2.StereoSGBM(minDisparity=min_disp,
numDisparities=num_disp,
SADWindowSize=window_size,
uniquenessRatio=10,
speckleWindowSize=100,
speckleRange=32,
disp12MaxDiff=1,
P1=8 * 3 * window_size**2,
P2=32 * 3 * window_size**2,
fullDP=False)
return stereo.compute(left_image, right_image).astype(np.float32) / 16.0
def getDisparity(imgLeft, imgRight, method="BM"):
gray_left = cv2.cvtColor(imgLeft, cv.CV_BGR2GRAY)
gray_right = cv2.cvtColor(imgRight, cv.CV_BGR2GRAY)
print gray_left.shape
c, r = gray_left.shape
if method == "BM":
sbm = cv.CreateStereoBMState()
disparity = cv.CreateMat(c, r, cv.CV_32F)
sbm.SADWindowSize = 9
sbm.preFilterType = 1
sbm.preFilterSize = 5
sbm.preFilterCap = 61
sbm.minDisparity = -39
sbm.numberOfDisparities = 112
sbm.textureThreshold = 507
sbm.uniquenessRatio = 0
sbm.speckleRange = 8
sbm.speckleWindowSize = 0
gray_left = cv.fromarray(gray_left)
gray_right = cv.fromarray(gray_right)
cv.FindStereoCorrespondenceBM(gray_left, gray_right, disparity, sbm)
disparity_visual = cv.CreateMat(c, r, cv.CV_8U)
cv.Normalize(disparity, disparity_visual, 0, 255, cv.CV_MINMAX)
disparity_visual = np.array(disparity_visual)
elif method == "SGBM":
sbm = cv2.StereoSGBM()
sbm.SADWindowSize = 9
sbm.numberOfDisparities = 96
sbm.preFilterCap = 63
sbm.minDisparity = -21
sbm.uniquenessRatio = 7
sbm.speckleWindowSize = 0
sbm.speckleRange = 8
sbm.disp12MaxDiff = 1
sbm.fullDP = False
disparity = sbm.compute(gray_left, gray_right)
disparity_visual = cv2.normalize(disparity,
alpha=0,
beta=255,
norm_type=cv2.cv.CV_MINMAX,
dtype=cv2.cv.CV_8U)
return disparity_visual
def stereosgbm(config, left_image, right_image):
#l_t = cv2.pyrDown(left_image)
#r_t = cv2.pyrDown(right_image)
stereo = cv2.StereoSGBM(
config.stereosgbm.min_disparity, config.stereosgbm.num_disparities,
config.stereosgbm.sad_window_size, config.stereosgbm.p1,
config.stereosgbm.p2, config.stereosgbm.disp12_max_diff,
config.stereosgbm.prefilter_cap, config.stereosgbm.uniqueness_ratio,
config.stereosgbm.speckle_window_size, config.stereosgbm.speckle_range,
config.stereosgbm.full_dp)
disparity = stereo.compute(left_image, right_image)
disparity *= 255 / (disparity.min() - disparity.max())
disparity = disparity.astype(numpy.uint8)
return disparity
def stereo_process(imgL, imgR, outprefix):
# disparity range is tuned for 'aloe' image pair
window_size = 3
min_disp = 16
num_disp = 112 - min_disp
stereo = cv2.StereoSGBM(minDisparity=min_disp,
numDisparities=num_disp,
SADWindowSize=window_size,
uniquenessRatio=10,
speckleWindowSize=100,
speckleRange=32,
disp12MaxDiff=1,
P1=8 * 3 * window_size**2,
P2=32 * 3 * window_size**2,
fullDP=False)
print 'computing disparity...'
disp = stereo.compute(imgL, imgR).astype(np.float32) / 16.0
print 'generating 3d point cloud...',
h, w = imgL.shape[:2]
f = 0.8 * w # guess for focal length
Q = np.float32([
[1, 0, 0, -0.5 * w],
[0, -1, 0, 0.5 * h], # turn points 180 deg around x-axis,
[0, 0, 0, -f], # so that y-axis looks up
[0, 0, 1, 0]
])
points = cv2.reprojectImageTo3D(disp, Q)
colors = cv2.cvtColor(imgL, cv2.COLOR_BGR2RGB)
mask = disp > disp.min()
out_points = points[mask]
out_colors = colors[mask]
if (outprefix):
out_fn = outprefix + '.ply'
write_ply(out_fn, out_points, out_colors)
print '%s saved' % out_fn
cv2.imshow('left', imgL)
cv2.imshow('disparity', (disp - min_disp) / num_disp)
cv2.waitKey()
cv2.destroyAllWindows()
def doTheThing(l, r):
print(os.path.isfile(l))
print(os.path.isfile(r))
print('loading images...')
imgL = cv2.pyrDown(cv2.imread(l))
imgR = cv2.pyrDown(cv2.imread(r))
window_size = 3
min_disp = 16
num_disp = 112 - min_disp
stereo = cv2.StereoSGBM(minDisparity=min_disp,
SADWindowSize=window_size,
numDisparities=num_disp,
P1=8 * 3 * window_size**2,
P2=32 * 3 * window_size**2,
disp12MaxDiff=1,
uniquenessRatio=10,
speckleWindowSize=100,
speckleRange=32)
print('computing disparity...')
disp = stereo.compute(imgL, imgR).astype(np.float32) / 16.0
saveModel(disp)
print('generating 3d point cloud...')
h, w = imgL.shape[:2]
f = 0.8 * w # guess for focal length
Q = np.float32([
[1, 0, 0, -0.5 * w],
[0, -1, 0, 0.5 * h], # turn points 180 deg around x-axis,
[0, 0, 0, -f], # so that y-axis looks up
[0, 0, 1, 0]
])
points = cv2.reprojectImageTo3D(disp, Q)
colors = cv2.cvtColor(imgL, cv2.COLOR_BGR2RGB)
mask = disp > disp.min()
out_points = points[mask]
out_colors = colors[mask]
out_fn = saveFolder + 'out.ply'
sides, faces = findFaces(out_points, disp)
write_ply(out_fn, out_points, out_colors, faces, sides)
print('%s saved' % 'out.ply')
def __init__(self, bm_type='bm'):
self.bm_type = bm_type
unitDisparity = 15
numberOfDisaprities = unitDisparity * 16
if bm_type == 'bm':
bm = cv2.StereoBM().create()
# bm.setROI1(validPixROI1)
# bm.setROI2(validPixROI2)
bm.setBlockSize(21)
bm.setPreFilterCap(13)
bm.setMinDisparity(0)
bm.setNumDisparities(numberOfDisaprities)
bm.setTextureThreshold(20)
bm.setUniquenessRatio(10)
bm.setSpeckleWindowSize(19)
bm.setSpeckleRange(32)
bm.setDisp12MaxDiff(5)
self.bm = bm
elif bm_type == 'sgbm':
bm = cv2.StereoSGBM().create()
SADWindowSize = 11
mindisparity = 0
ndisparities = 64
bm.setMinDisparity(0)
bm.setNumDisparities(64)
bm.setBlockSize(SADWindowSize)
channel = 1
P1 = 8 * channel * SADWindowSize * SADWindowSize
P2 = 32 * channel * SADWindowSize * SADWindowSize
bm.setP1(P1)
bm.setP2(P2)
bm.setPreFilterCap(15)
bm.setUniquenessRatio(10)
bm.setSpeckleRange(2)
bm.setSpeckleWindowSize(100)
bm.setDisp12MaxDiff(cv2.STEREO_SGBM_MODE_SGBM)
self.bm = bm
else:
raise AssertionError('bm_type must be select in sgbm and bm')
def compute():
#stereo = cv2.StereoBM(cv2.STEREO_BM_BASIC_PRESET, disp, size)
stereo = cv2.StereoSGBM(0,
disp,
size,
P1=8 * 1 * size * size,
P2=32 * 1 * size * size,
disp12MaxDiff=1,
preFilterCap=63,
uniquenessRatio=10,
speckleWindowSize=100,
speckleRange=32,
fullDP=True)
disparity = stereo.compute(imgL, imgR)
image = cv2.normalize(disparity,
alpha=0,
beta=255,
norm_type=cv2.NORM_MINMAX,
dtype=cv2.CV_8U)
cv2.imshow('depth', image)
def estimateDisparity(image_left,image_right,method='SGBM'):
if method=='SGBM':
import cv2
disparityrange=[0,15]
ndisparities=int(np.ceil(disparityrange[1]-disparityrange[0]) )
ndisparities=16*int(np.ceil(float(ndisparities)/16))
minDisparity=int(np.floor(disparityrange[0]))
#stereo = cv2.StereoBM(cv2.STEREO_BM_BASIC_PRESET,ndisparities=ndisparities, SADWindowSize=15)
#stereo = cv2.StereoSGBM(minDisparity=mindisparity,numDisparities=ndisparities, SADWindowSize=15,P1=10000,P2=0)
stereo = cv2.StereoSGBM(minDisparity=minDisparity,numDisparities=ndisparities, SADWindowSize=3,P1=30,P2=30)
right_disparity = stereo.compute(image_left[:,:,0],image_right[:,:,0])# does not work in color...
right_disparity=right_disparity/16.
elif method=='BM':
stereo = cv2.StereoBM(cv2.STEREO_BM_BASIC_PRESET,ndisparities=ndisparities, SADWindowSize=5)
right_disparity = stereo.compute(image_left[:,:,0],image_right[:,:,0],disptype=cv2.CV_32F)# does not work in color...
return right_disparity
def doThings(self):
sgbm = cv2.StereoSGBM()
sgbm.SADWindowSize, maxDisp, sgbm.preFilterCap, sgbm.minDisparity, \
sgbm.uniquenessRatio, sgbm.speckleWindowSize, sgbm.P1, sgbm.P2, \
sgbm.speckleRange = [v for v, _ in self.params.itervalues()]
sgbm.numberOfDisparities = maxDisp - sgbm.minDisparity
sgbm.disp12MaxDiff = 1
sgbm.fullDP = True
self.disp = sgbm.compute(np.rot90(self.top_r, 1),
np.rot90(self.bottom_r, 1)).astype(
np.float32) / 16.0
self.disp = np.rot90(self.disp, 3)
disp8 = (self.disp - sgbm.minDisparity) / sgbm.numberOfDisparities
self.roi_mask = np.zeros_like(self.disp).astype(np.bool)
self.roi_mask[self.roi[1]:self.roi[3], self.roi[0]:self.roi[2]] = True
# dispRgb = cv2.cvtColor(disp8, cv2.COLOR_GRAY2RGB)
dispRgb = utility.get_heatmap(disp8)
self.mask = self.disp > self.disp.min()
dispRgb[~(self.mask * self.roi_mask)] = [255, 255, 255]
disp_small = cv2.resize(dispRgb,
(dispRgb.shape[1] / 2, dispRgb.shape[0] / 2))
cv2.imshow(self.winname, disp_small)
def stereoSGBM(self, img_left, img_right):
stereo = cv2.StereoSGBM(minDisparity=0,
numDisparities=self._max_disparity,
SADWindowSize=self._sad_winsize,
uniquenessRatio=self._uniqueness_ratio,
P1=self._P1,
P2=self._P2,
speckleWindowSize=self._speckle_winsize,
speckleRange=self._speckle_range)
disp_left = stereo.compute(img_left, img_right)
disp_left_visual = np.zeros((img_left.shape[0], img_left.shape[1]),
np.uint8)
disp_left_visual = cv2.normalize(disp_left,
alpha=0,
beta=self._max_disparity,
norm_type=cv2.cv.CV_MINMAX,
dtype=cv2.cv.CV_8U)
img_foreground, disp_foreground = self.extractForeground(
disp_left_visual, img_left, self._fgnd_disp_thresh)
return (disp_left_visual, disp_foreground, img_foreground)
def createBM():
global stereo
global P1
global P2
global size
global disp
P1 = P1 * size * size
P2 = P2 * size * size
#stereo = cv2.StereoBM(cv2.STEREO_BM_BASIC_PRESET, disp, size)
stereo = cv2.StereoSGBM(
0,
disp,
size,
P1=P1, #*size*size,
P2=P2, #*size*size,
disp12MaxDiff=15,
preFilterCap=67,
uniquenessRatio=15,
speckleWindowSize=100,
speckleRange=10,
fullDP=True)
def processInput():
print ""
if inputArgs.left == "" or inputArgs.right == "":
print "Missing images!"
quit()
# here we go ...
# load image pair
img_l = cv2.imread(inputArgs.left)
img_r = cv2.imread(inputArgs.right)
if img_l == None or img_r == None:
print "Missing images!"
quit()
# disparity range
window_size = 5
min_disp = 16
num_disp = 112 - min_disp
stereo = cv2.StereoSGBM(minDisparity=min_disp,
numDisparities=num_disp,
SADWindowSize=window_size,
uniquenessRatio=10,
speckleWindowSize=100,
speckleRange=32,
disp12MaxDiff=1,
P1=8 * 3 * window_size**2,
P2=32 * 3 * window_size**2,
fullDP=False)
print 'Computing disparity ...'
disp = stereo.compute(img_l, img_r).astype(np.float32) / 16.0
cv2.imwrite(inputArgs.name + "_disparity.jpg", disp)
