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
#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")
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)
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
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)
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
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
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:
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
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
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:
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")
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":
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=[]
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)):
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)
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())