mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2025-06-07 17:44:04 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #15831 from alalek:fix_pylint_master

Browse Source
This commit is contained in:
Alexander Alekhin 2019-11-01 19:07:15 +03:00 committed by GitHub
commit 0ca5f68d72
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 41 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
modules/python/test/test_cuda.py
View File

@ -95,8 +95,8 @@ class cuda_test(NewOpenCVTests):
def test_cudabgsegm_existence(self): def test_cudabgsegm_existence(self):
#Test at least the existence of wrapped functions for now #Test at least the existence of wrapped functions for now
bgsub = cv.cuda.createBackgroundSubtractorMOG() _bgsub = cv.cuda.createBackgroundSubtractorMOG()
bgsub = cv.cuda.createBackgroundSubtractorMOG2() _bgsub = cv.cuda.createBackgroundSubtractorMOG2()
self.assertTrue(True) #It is sufficient that no exceptions have been there self.assertTrue(True) #It is sufficient that no exceptions have been there
@ -104,8 +104,8 @@ class cuda_test(NewOpenCVTests):
#Test at least the existence of wrapped functions for now #Test at least the existence of wrapped functions for now
try: try:
writer = cv.cudacodec.createVideoWriter("tmp", (128, 128), 30) _writer = cv.cudacodec.createVideoWriter("tmp", (128, 128), 30)
reader = cv.cudacodec.createVideoReader("tmp") _reader = cv.cudacodec.createVideoReader("tmp")
except cv.error as e: except cv.error as e:
self.assertEqual(e.code, cv.Error.StsNotImplemented) self.assertEqual(e.code, cv.Error.StsNotImplemented)
self.skipTest("NVCUVENC is not installed") self.skipTest("NVCUVENC is not installed")
@ -125,11 +125,11 @@ class cuda_test(NewOpenCVTests):
cuMat2 = cv.cuda.cvtColor(cuMat2, cv.COLOR_RGB2GRAY) cuMat2 = cv.cuda.cvtColor(cuMat2, cv.COLOR_RGB2GRAY)
fast = cv.cuda_FastFeatureDetector.create() fast = cv.cuda_FastFeatureDetector.create()
kps = fast.detectAsync(cuMat1) _kps = fast.detectAsync(cuMat1)
orb = cv.cuda_ORB.create() orb = cv.cuda_ORB.create()
kps1, descs1 = orb.detectAndComputeAsync(cuMat1, None) _kps1, descs1 = orb.detectAndComputeAsync(cuMat1, None)
kps2, descs2 = orb.detectAndComputeAsync(cuMat2, None) _kps2, descs2 = orb.detectAndComputeAsync(cuMat2, None)
bf = cv.cuda_DescriptorMatcher.createBFMatcher(cv.NORM_HAMMING) bf = cv.cuda_DescriptorMatcher.createBFMatcher(cv.NORM_HAMMING)
matches = bf.match(descs1, descs2) matches = bf.match(descs1, descs2)
@ -144,20 +144,20 @@ class cuda_test(NewOpenCVTests):
def test_cudafilters_existence(self): def test_cudafilters_existence(self):
#Test at least the existence of wrapped functions for now #Test at least the existence of wrapped functions for now
filter = cv.cuda.createBoxFilter(cv.CV_8UC1, -1, (3, 3)) _filter = cv.cuda.createBoxFilter(cv.CV_8UC1, -1, (3, 3))
filter = cv.cuda.createLinearFilter(cv.CV_8UC4, -1, np.eye(3)) _filter = cv.cuda.createLinearFilter(cv.CV_8UC4, -1, np.eye(3))
filter = cv.cuda.createLaplacianFilter(cv.CV_16UC1, -1, ksize=3) _filter = cv.cuda.createLaplacianFilter(cv.CV_16UC1, -1, ksize=3)
filter = cv.cuda.createSeparableLinearFilter(cv.CV_8UC1, -1, np.eye(3), np.eye(3)) _filter = cv.cuda.createSeparableLinearFilter(cv.CV_8UC1, -1, np.eye(3), np.eye(3))
filter = cv.cuda.createDerivFilter(cv.CV_8UC1, -1, 1, 1, 3) _filter = cv.cuda.createDerivFilter(cv.CV_8UC1, -1, 1, 1, 3)
filter = cv.cuda.createSobelFilter(cv.CV_8UC1, -1, 1, 1) _filter = cv.cuda.createSobelFilter(cv.CV_8UC1, -1, 1, 1)
filter = cv.cuda.createScharrFilter(cv.CV_8UC1, -1, 1, 0) _filter = cv.cuda.createScharrFilter(cv.CV_8UC1, -1, 1, 0)
filter = cv.cuda.createGaussianFilter(cv.CV_8UC1, -1, (3, 3), 16) _filter = cv.cuda.createGaussianFilter(cv.CV_8UC1, -1, (3, 3), 16)
filter = cv.cuda.createMorphologyFilter(cv.MORPH_DILATE, cv.CV_32FC1, np.eye(3)) _filter = cv.cuda.createMorphologyFilter(cv.MORPH_DILATE, cv.CV_32FC1, np.eye(3))
filter = cv.cuda.createBoxMaxFilter(cv.CV_8UC1, (3, 3)) _filter = cv.cuda.createBoxMaxFilter(cv.CV_8UC1, (3, 3))
filter = cv.cuda.createBoxMinFilter(cv.CV_8UC1, (3, 3)) _filter = cv.cuda.createBoxMinFilter(cv.CV_8UC1, (3, 3))
filter = cv.cuda.createRowSumFilter(cv.CV_8UC1, cv.CV_32FC1, 3) _filter = cv.cuda.createRowSumFilter(cv.CV_8UC1, cv.CV_32FC1, 3)
filter = cv.cuda.createColumnSumFilter(cv.CV_8UC1, cv.CV_32FC1, 3) _filter = cv.cuda.createColumnSumFilter(cv.CV_8UC1, cv.CV_32FC1, 3)
filter = cv.cuda.createMedianFilter(cv.CV_8UC1, 3) _filter = cv.cuda.createMedianFilter(cv.CV_8UC1, 3)
self.assertTrue(True) #It is sufficient that no exceptions have been there self.assertTrue(True) #It is sufficient that no exceptions have been there
@ -195,7 +195,7 @@ class cuda_test(NewOpenCVTests):
cv.cuda.meanShiftSegmentation(cuC4, 10, 5, 5).download() cv.cuda.meanShiftSegmentation(cuC4, 10, 5, 5).download()
clahe = cv.cuda.createCLAHE() clahe = cv.cuda.createCLAHE()
clahe.apply(cuC1, cv.cuda_Stream.Null()); clahe.apply(cuC1, cv.cuda_Stream.Null())
histLevels = cv.cuda.histEven(cuC3, 20, 0, 255) histLevels = cv.cuda.histEven(cuC3, 20, 0, 255)
cv.cuda.histRange(cuC1, histLevels) cv.cuda.histRange(cuC1, histLevels)

6
samples/python/dis_opt_flow.py
View File

@ -30,7 +30,7 @@ def draw_flow(img, flow, step=16):
lines = np.int32(lines + 0.5) lines = np.int32(lines + 0.5)
vis = cv.cvtColor(img, cv.COLOR_GRAY2BGR) vis = cv.cvtColor(img, cv.COLOR_GRAY2BGR)
cv.polylines(vis, lines, 0, (0, 255, 0)) cv.polylines(vis, lines, 0, (0, 255, 0))
for (x1, y1), (x2, y2) in lines: for (x1, y1), (_x2, _y2) in lines:
cv.circle(vis, (x1, y1), 1, (0, 255, 0), -1) cv.circle(vis, (x1, y1), 1, (0, 255, 0), -1)
return vis return vis
@ -66,7 +66,7 @@ def main():
fn = 0 fn = 0
cam = video.create_capture(fn) cam = video.create_capture(fn)
ret, prev = cam.read() _ret, prev = cam.read()
prevgray = cv.cvtColor(prev, cv.COLOR_BGR2GRAY) prevgray = cv.cvtColor(prev, cv.COLOR_BGR2GRAY)
show_hsv = False show_hsv = False
show_glitch = False show_glitch = False
@ -78,7 +78,7 @@ def main():
flow = None flow = None
while True: while True:
ret, img = cam.read() _ret, img = cam.read()
gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY) gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
if flow is not None and use_temporal_propagation: if flow is not None and use_temporal_propagation:
#warp previous flow to get an initial approximation for the current flow: #warp previous flow to get an initial approximation for the current flow:

2
samples/python/stitching.py
View File

@ -50,7 +50,7 @@ def main():
print("Can't stitch images, error code = %d" % status) print("Can't stitch images, error code = %d" % status)
sys.exit(-1) sys.exit(-1)
cv.imwrite(args.output, pano); cv.imwrite(args.output, pano)
print("stitching completed successfully. %s saved!" % args.output) print("stitching completed successfully. %s saved!" % args.output)
print('Done') print('Done')

30
samples/python/stitching_detailed.py
View File

@ -48,7 +48,7 @@ def main():
args = parser.parse_args() args = parser.parse_args()
img_names=args.img_names img_names=args.img_names
print(img_names) print(img_names)
preview = args.preview _preview = args.preview
try_cuda = args.try_cuda try_cuda = args.try_cuda
work_megapix = args.work_megapix work_megapix = args.work_megapix
seam_megapix = args.seam_megapix seam_megapix = args.seam_megapix
@ -84,7 +84,7 @@ def main():
print("Bad exposure compensation method") print("Bad exposure compensation method")
exit() exit()
expos_comp_nr_feeds = args.expos_comp_nr_feeds expos_comp_nr_feeds = args.expos_comp_nr_feeds
expos_comp_nr_filtering = args.expos_comp_nr_filtering _expos_comp_nr_filtering = args.expos_comp_nr_filtering
expos_comp_block_size = args.expos_comp_block_size expos_comp_block_size = args.expos_comp_block_size
match_conf = args.match_conf match_conf = args.match_conf
seam_find_type = args.seam seam_find_type = args.seam
@ -118,7 +118,7 @@ def main():
images=[] images=[]
is_work_scale_set = False is_work_scale_set = False
is_seam_scale_set = False is_seam_scale_set = False
is_compose_scale_set = False; is_compose_scale_set = False
for name in img_names: for name in img_names:
full_img = cv.imread(cv.samples.findFile(name)) full_img = cv.imread(cv.samples.findFile(name))
if full_img is None: if full_img is None:
@ -163,9 +163,9 @@ def main():
img_names_subset.append(img_names[indices[i,0]]) img_names_subset.append(img_names[indices[i,0]])
img_subset.append(images[indices[i,0]]) img_subset.append(images[indices[i,0]])
full_img_sizes_subset.append(full_img_sizes[indices[i,0]]) full_img_sizes_subset.append(full_img_sizes[indices[i,0]])
images = img_subset; images = img_subset
img_names = img_names_subset; img_names = img_names_subset
full_img_sizes = full_img_sizes_subset; full_img_sizes = full_img_sizes_subset
num_images = len(img_names) num_images = len(img_names)
if num_images < 2: if num_images < 2:
print("Need more images") print("Need more images")
@ -266,7 +266,7 @@ def main():
if seam_find_type == "no": if seam_find_type == "no":
seam_finder = cv.detail.SeamFinder_createDefault(cv.detail.SeamFinder_NO) seam_finder = cv.detail.SeamFinder_createDefault(cv.detail.SeamFinder_NO)
elif seam_find_type == "voronoi": elif seam_find_type == "voronoi":
seam_finder = cv.detail.SeamFinder_createDefault(cv.detail.SeamFinder_VORONOI_SEAM); seam_finder = cv.detail.SeamFinder_createDefault(cv.detail.SeamFinder_VORONOI_SEAM)
elif seam_find_type == "gc_color": elif seam_find_type == "gc_color":
seam_finder = cv.detail_GraphCutSeamFinder("COST_COLOR") seam_finder = cv.detail_GraphCutSeamFinder("COST_COLOR")
elif seam_find_type == "gc_colorgrad": elif seam_find_type == "gc_colorgrad":
@ -279,7 +279,7 @@ def main():
print("Can't create the following seam finder ",seam_find_type) print("Can't create the following seam finder ",seam_find_type)
exit() exit()
seam_finder.find(images_warped_f, corners,masks_warped ) seam_finder.find(images_warped_f, corners,masks_warped )
imgListe=[] _imgListe=[]
compose_scale=1 compose_scale=1
corners=[] corners=[]
sizes=[] sizes=[]
@ -294,8 +294,8 @@ def main():
if not is_compose_scale_set: if not is_compose_scale_set:
if compose_megapix > 0: if compose_megapix > 0:
compose_scale = min(1.0, np.sqrt(compose_megapix * 1e6 / (full_img.shape[0]*full_img.shape[1]))) compose_scale = min(1.0, np.sqrt(compose_megapix * 1e6 / (full_img.shape[0]*full_img.shape[1])))
is_compose_scale_set = True; is_compose_scale_set = True
compose_work_aspect = compose_scale / work_scale; compose_work_aspect = compose_scale / work_scale
warped_image_scale *= compose_work_aspect warped_image_scale *= compose_work_aspect
warper = cv.PyRotationWarper(warp_type,warped_image_scale) warper = cv.PyRotationWarper(warp_type,warped_image_scale)
for i in range(0,len(img_names)): for i in range(0,len(img_names)):
@ -304,14 +304,14 @@ def main():
cameras[i].ppy *= compose_work_aspect cameras[i].ppy *= compose_work_aspect
sz = (full_img_sizes[i][0] * compose_scale,full_img_sizes[i][1]* compose_scale) sz = (full_img_sizes[i][0] * compose_scale,full_img_sizes[i][1]* compose_scale)
K = cameras[i].K().astype(np.float32) K = cameras[i].K().astype(np.float32)
roi = warper.warpRoi(sz, K, cameras[i].R); roi = warper.warpRoi(sz, K, cameras[i].R)
corners.append(roi[0:2]) corners.append(roi[0:2])
sizes.append(roi[2:4]) sizes.append(roi[2:4])
if abs(compose_scale - 1) > 1e-1: if abs(compose_scale - 1) > 1e-1:
img =cv.resize(src=full_img, dsize=None, fx=compose_scale, fy=compose_scale, interpolation=cv.INTER_LINEAR_EXACT) img =cv.resize(src=full_img, dsize=None, fx=compose_scale, fy=compose_scale, interpolation=cv.INTER_LINEAR_EXACT)
else: else:
img = full_img; img = full_img
img_size = (img.shape[1],img.shape[0]); _img_size = (img.shape[1],img.shape[0])
K=cameras[idx].K().astype(np.float32) K=cameras[idx].K().astype(np.float32)
corner,image_warped =warper.warp(img,K,cameras[idx].R,cv.INTER_LINEAR, cv.BORDER_REFLECT) corner,image_warped =warper.warp(img,K,cameras[idx].R,cv.INTER_LINEAR, cv.BORDER_REFLECT)
mask =255*np.ones((img.shape[0],img.shape[1]),np.uint8) mask =255*np.ones((img.shape[0],img.shape[1]),np.uint8)
@ -341,9 +341,9 @@ def main():
if timelapse: if timelapse:
matones=np.ones((image_warped_s.shape[0],image_warped_s.shape[1]), np.uint8) matones=np.ones((image_warped_s.shape[0],image_warped_s.shape[1]), np.uint8)
timelapser.process(image_warped_s, matones, corners[idx]) timelapser.process(image_warped_s, matones, corners[idx])
pos_s = img_names[idx].rfind("/"); pos_s = img_names[idx].rfind("/")
if pos_s == -1: if pos_s == -1:
fixedFileName = "fixed_" + img_names[idx]; fixedFileName = "fixed_" + img_names[idx]
else: else:
fixedFileName = img_names[idx][:pos_s + 1 ]+"fixed_" + img_names[idx][pos_s + 1: ] fixedFileName = img_names[idx][:pos_s + 1 ]+"fixed_" + img_names[idx][pos_s + 1: ]
cv.imwrite(fixedFileName, timelapser.getDst()) cv.imwrite(fixedFileName, timelapser.getDst())