mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2024-11-27 12:40:05 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

pylint: eliminate warnings

Browse Source
This commit is contained in:
Alexander Alekhin 2019-11-01 18:59:35 +03:00
parent 469addeca3
commit 48073e6d95
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):
#Test at least the existence of wrapped functions for now
bgsub = cv.cuda.createBackgroundSubtractorMOG()
bgsub = cv.cuda.createBackgroundSubtractorMOG2()
_bgsub = cv.cuda.createBackgroundSubtractorMOG()
_bgsub = cv.cuda.createBackgroundSubtractorMOG2()
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
try:
writer = cv.cudacodec.createVideoWriter("tmp", (128, 128), 30)
reader = cv.cudacodec.createVideoReader("tmp")
_writer = cv.cudacodec.createVideoWriter("tmp", (128, 128), 30)
_reader = cv.cudacodec.createVideoReader("tmp")
except cv.error as e:
self.assertEqual(e.code, cv.Error.StsNotImplemented)
self.skipTest("NVCUVENC is not installed")
@ -125,11 +125,11 @@ class cuda_test(NewOpenCVTests):
cuMat2 = cv.cuda.cvtColor(cuMat2, cv.COLOR_RGB2GRAY)
fast = cv.cuda_FastFeatureDetector.create()
kps = fast.detectAsync(cuMat1)
_kps = fast.detectAsync(cuMat1)
orb = cv.cuda_ORB.create()
kps1, descs1 = orb.detectAndComputeAsync(cuMat1, None)
kps2, descs2 = orb.detectAndComputeAsync(cuMat2, None)
_kps1, descs1 = orb.detectAndComputeAsync(cuMat1, None)
_kps2, descs2 = orb.detectAndComputeAsync(cuMat2, None)
bf = cv.cuda_DescriptorMatcher.createBFMatcher(cv.NORM_HAMMING)
matches = bf.match(descs1, descs2)
@ -144,20 +144,20 @@ class cuda_test(NewOpenCVTests):
def test_cudafilters_existence(self):
#Test at least the existence of wrapped functions for now
filter = cv.cuda.createBoxFilter(cv.CV_8UC1, -1, (3, 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.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.createSobelFilter(cv.CV_8UC1, -1, 1, 1)
filter = cv.cuda.createScharrFilter(cv.CV_8UC1, -1, 1, 0)
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.createBoxMaxFilter(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.createColumnSumFilter(cv.CV_8UC1, cv.CV_32FC1, 3)
filter = cv.cuda.createMedianFilter(cv.CV_8UC1, 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.createLaplacianFilter(cv.CV_16UC1, -1, ksize=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.createSobelFilter(cv.CV_8UC1, -1, 1, 1)
_filter = cv.cuda.createScharrFilter(cv.CV_8UC1, -1, 1, 0)
_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.createBoxMaxFilter(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.createColumnSumFilter(cv.CV_8UC1, cv.CV_32FC1, 3)
_filter = cv.cuda.createMedianFilter(cv.CV_8UC1, 3)
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()
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)
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)
vis = cv.cvtColor(img, cv.COLOR_GRAY2BGR)
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)
return vis
@ -66,7 +66,7 @@ def main():
fn = 0
cam = video.create_capture(fn)
ret, prev = cam.read()
_ret, prev = cam.read()
prevgray = cv.cvtColor(prev, cv.COLOR_BGR2GRAY)
show_hsv = False
show_glitch = False
@ -78,7 +78,7 @@ def main():
flow = None
while True:
ret, img = cam.read()
_ret, img = cam.read()
gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
if flow is not None and use_temporal_propagation:
#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)
sys.exit(-1)
cv.imwrite(args.output, pano);
cv.imwrite(args.output, pano)
print("stitching completed successfully. %s saved!" % args.output)
print('Done')

30
samples/python/stitching_detailed.py
View File

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