Merge pull request #1483 from alalek:python_cv2_to_cv

Author: vpisarev

modules/bgsegm/samples/evaluation.py

@@ -1,5 +1,5 @@
 import argparse
-import cv2
+import cv2 as cv
 import glob
 import numpy as np
 import os
@@ -12,15 +12,15 @@
 
 
 ALGORITHMS_TO_EVALUATE = [
-    (cv2.bgsegm.createBackgroundSubtractorMOG, 'MOG', {}),
-    (cv2.bgsegm.createBackgroundSubtractorGMG, 'GMG', {}),
-    (cv2.bgsegm.createBackgroundSubtractorCNT, 'CNT', {}),
-    (cv2.bgsegm.createBackgroundSubtractorLSBP, 'LSBP-vanilla', {'nSamples': 20, 'LSBPRadius': 4, 'Tlower': 2.0, 'Tupper': 200.0, 'Tinc': 1.0, 'Tdec': 0.05, 'Rscale': 5.0, 'Rincdec': 0.05, 'LSBPthreshold': 8}),
-    (cv2.bgsegm.createBackgroundSubtractorLSBP, 'LSBP-speed', {'nSamples': 10, 'LSBPRadius': 16, 'Tlower': 2.0, 'Tupper': 32.0, 'Tinc': 1.0, 'Tdec': 0.05, 'Rscale': 10.0, 'Rincdec': 0.005, 'LSBPthreshold': 8}),
-    (cv2.bgsegm.createBackgroundSubtractorLSBP, 'LSBP-quality', {'nSamples': 20, 'LSBPRadius': 16, 'Tlower': 2.0, 'Tupper': 32.0, 'Tinc': 1.0, 'Tdec': 0.05, 'Rscale': 10.0, 'Rincdec': 0.005, 'LSBPthreshold': 8}),
-    (cv2.bgsegm.createBackgroundSubtractorLSBP, 'LSBP-camera-motion-compensation', {'mc': 1}),
-    (cv2.bgsegm.createBackgroundSubtractorGSOC, 'GSOC', {}),
-    (cv2.bgsegm.createBackgroundSubtractorGSOC, 'GSOC-camera-motion-compensation', {'mc': 1})
+    (cv.bgsegm.createBackgroundSubtractorMOG, 'MOG', {}),
+    (cv.bgsegm.createBackgroundSubtractorGMG, 'GMG', {}),
+    (cv.bgsegm.createBackgroundSubtractorCNT, 'CNT', {}),
+    (cv.bgsegm.createBackgroundSubtractorLSBP, 'LSBP-vanilla', {'nSamples': 20, 'LSBPRadius': 4, 'Tlower': 2.0, 'Tupper': 200.0, 'Tinc': 1.0, 'Tdec': 0.05, 'Rscale': 5.0, 'Rincdec': 0.05, 'LSBPthreshold': 8}),
+    (cv.bgsegm.createBackgroundSubtractorLSBP, 'LSBP-speed', {'nSamples': 10, 'LSBPRadius': 16, 'Tlower': 2.0, 'Tupper': 32.0, 'Tinc': 1.0, 'Tdec': 0.05, 'Rscale': 10.0, 'Rincdec': 0.005, 'LSBPthreshold': 8}),
+    (cv.bgsegm.createBackgroundSubtractorLSBP, 'LSBP-quality', {'nSamples': 20, 'LSBPRadius': 16, 'Tlower': 2.0, 'Tupper': 32.0, 'Tinc': 1.0, 'Tdec': 0.05, 'Rscale': 10.0, 'Rincdec': 0.005, 'LSBPthreshold': 8}),
+    (cv.bgsegm.createBackgroundSubtractorLSBP, 'LSBP-camera-motion-compensation', {'mc': 1}),
+    (cv.bgsegm.createBackgroundSubtractorGSOC, 'GSOC', {}),
+    (cv.bgsegm.createBackgroundSubtractorGSOC, 'GSOC-camera-motion-compensation', {'mc': 1})
 ]
 
 
@@ -54,14 +54,14 @@ def evaluate_algorithm(gt, frames, algo, algo_arguments):
     t_start = time.time()
 
     for i in range(len(gt)):
-        frame = np.uint8(cv2.imread(frames[i], cv2.IMREAD_COLOR))
+        frame = np.uint8(cv.imread(frames[i], cv.IMREAD_COLOR))
         mask.append(bgs.apply(frame))
 
     average_duration = (time.time() - t_start) / len(gt)
     average_precision, average_recall, average_f1, average_accuracy = [], [], [], []
 
     for i in range(len(gt)):
-        gt_mask = np.uint8(cv2.imread(gt[i], cv2.IMREAD_GRAYSCALE))
+        gt_mask = np.uint8(cv.imread(gt[i], cv.IMREAD_GRAYSCALE))
         roi = ((gt_mask == 255) | (gt_mask == 0))
         if roi.sum() > 0:
             gt_answer, answer = gt_mask[roi], mask[i][roi]

modules/bgsegm/samples/viz.py

@@ -1,5 +1,5 @@
 import numpy as np
-import cv2
+import cv2 as cv
 import argparse
 import os
 
@@ -17,22 +17,22 @@ def main():
     f = map(lambda x: os.path.join(args.frames, x), os.listdir(args.frames))
     f.sort()
 
-    gt = np.uint8(map(lambda x: cv2.imread(x, cv2.IMREAD_GRAYSCALE), gt))
-    f = np.uint8(map(lambda x: cv2.imread(x, cv2.IMREAD_COLOR), f))
+    gt = np.uint8(map(lambda x: cv.imread(x, cv.IMREAD_GRAYSCALE), gt))
+    f = np.uint8(map(lambda x: cv.imread(x, cv.IMREAD_COLOR), f))
 
     if not args.lsbp:
-        bgs = cv2.bgsegm.createBackgroundSubtractorGSOC()
+        bgs = cv.bgsegm.createBackgroundSubtractorGSOC()
     else:
-        bgs = cv2.bgsegm.createBackgroundSubtractorLSBP()
+        bgs = cv.bgsegm.createBackgroundSubtractorLSBP()
 
     for i in xrange(f.shape[0]):
-        cv2.imshow('Frame', f[i])
-        cv2.imshow('Ground-truth', gt[i])
+        cv.imshow('Frame', f[i])
+        cv.imshow('Ground-truth', gt[i])
         mask = bgs.apply(f[i])
         bg = bgs.getBackgroundImage()
-        cv2.imshow('BG', bg)
-        cv2.imshow('Output mask', mask)
-        k = cv2.waitKey(0)
+        cv.imshow('BG', bg)
+        cv.imshow('Output mask', mask)
+        k = cv.waitKey(0)
         if k == 27:
             break
 

modules/bgsegm/samples/viz_synthetic_seq.py

@@ -1,4 +1,4 @@
-import cv2
+import cv2 as cv
 import argparse
 
 
@@ -9,15 +9,15 @@ def main():
     argparser.add_argument('-o', '--obj', help='Object image. It must be strictly smaller than background.', required=True)
     args = argparser.parse_args()
 
-    bg = cv2.imread(args.background)
-    obj = cv2.imread(args.obj)
-    generator = cv2.bgsegm.createSyntheticSequenceGenerator(bg, obj)
+    bg = cv.imread(args.background)
+    obj = cv.imread(args.obj)
+    generator = cv.bgsegm.createSyntheticSequenceGenerator(bg, obj)
 
     while True:
         frame, mask = generator.getNextFrame()
-        cv2.imshow('Generated frame', frame)
-        cv2.imshow('Generated mask', mask)
-        k = cv2.waitKey(int(1000.0 / 30))
+        cv.imshow('Generated frame', frame)
+        cv.imshow('Generated mask', mask)
+        k = cv.waitKey(int(1000.0 / 30))
         if k == 27:
             break
 

modules/bioinspired/doc/retina.markdown

@@ -4,7 +4,7 @@ Bioinspired Module Retina Introduction {#bioinspired_retina}
 Retina class overview
 ---------------------
 
-@note do not forget that the retina model is included in the following namespace : cv::bioinspired with C++ and in cv2.bioinspired with Python
+@note do not forget that the retina model is included in the following namespace : cv::bioinspired with C++ and in cv.bioinspired with Python
 
 ### Introduction
 
@@ -425,14 +425,14 @@ Python version
 
 @code{.py}
 #import OpenCV module
-import cv2 
+import cv2 as cv
 
 #setup webcam reader
-videoHandler = cv2.VideoCapture(0)
+videoHandler = cv.VideoCapture(0)
 succeed, inputImage=videoHandler.read()
 
 #allocate a retina instance with input size equal to the one of the loaded image
-retina = cv2.bioinspired.createRetina((inputImage.shape[1], inputImage.shape[0]))
+retina = cv.bioinspired.createRetina((inputImage.shape[1], inputImage.shape[0]))
 
 #retina parameters management methods use sample
 #-> save current (here default) retina parameters to a xml file (you may use it only one time to get the file and modify it)
@@ -446,7 +446,7 @@ while stillProcess is True:
 
 	#grab a new frame and display it
 	stillProcess, inputImage=videoHandler.read()
-	cv2.imshow('input frame', inputImage)
+	cv.imshow('input frame', inputImage)
 
 	#run retina on the input image
 	retina.run(inputImage)
@@ -456,11 +456,11 @@ while stillProcess is True:
 	retinaOut_magno=retina.getMagno()
 
 	#draw retina outputs
-	cv2.imshow('retina parvo out', retinaOut_parvo)
-	cv2.imshow('retina magno out', retinaOut_magno)
+	cv.imshow('retina parvo out', retinaOut_parvo)
+	cv.imshow('retina magno out', retinaOut_magno)
 
 	#wait a little to let the time for figures to be drawn
-	cv2.waitKey(2)
+	cv.waitKey(2)
 @endcode
 
 

modules/bioinspired/tutorials/retina_illusion/retina_illusion.markdown

@@ -117,10 +117,10 @@ iterations. This is an arbitrary number that we found experimentally to be (more
 enough
 
 @code{.py}
-import cv2
+import cv2 as cv
 
-inputImage = cv2.imread('checkershadow_illusion4med.jpg', 1)
-retina = cv2.bioinspired.createRetina((inputImage.shape[1], inputImage.shape[0]))
+inputImage = cv.imread('checkershadow_illusion4med.jpg', 1)
+retina = cv.bioinspired.createRetina((inputImage.shape[1], inputImage.shape[0]))
 
 # the retina object is created with default parameters. If you want to read
 # the parameters from an external XML file, uncomment the next line
@@ -134,15 +134,15 @@ for i in range(20):
 retinaOut_parvo = retina.getParvo()
 
 # show both the original image and the processed one
-cv2.imshow('image', inputImage)
-cv2.imshow('retina parvo out', retinaOut_parvo)
+cv.imshow('image', inputImage)
+cv.imshow('retina parvo out', retinaOut_parvo)
 
 # wait for a key to be pressed and exit
-cv2.waitKey(0)
-cv2.destroyAllWindows()
+cv.waitKey(0)
+cv.destroyAllWindows()
 
 # write the output image on a file
-cv2.imwrite('checkershadow_parvo.png', retinaOut_parvo)
+cv.imwrite('checkershadow_parvo.png', retinaOut_parvo)
 @endcode
 
 Whatever method you used to process the image, you should end up

modules/optflow/samples/motempl.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python
 import numpy as np
-import cv2
+import cv2 as cv
 
 MHI_DURATION = 0.5
 DEFAULT_THRESHOLD = 32
@@ -12,12 +12,12 @@ def nothing(dummy):
     pass
 
 def draw_motion_comp(vis, (x, y, w, h), angle, color):
-    cv2.rectangle(vis, (x, y), (x+w, y+h), (0, 255, 0))
+    cv.rectangle(vis, (x, y), (x+w, y+h), (0, 255, 0))
     r = min(w/2, h/2)
     cx, cy = x+w/2, y+h/2
     angle = angle*np.pi/180
-    cv2.circle(vis, (cx, cy), r, color, 3)
-    cv2.line(vis, (cx, cy), (int(cx+np.cos(angle)*r), int(cy+np.sin(angle)*r)), color, 3)
+    cv.circle(vis, (cx, cy), r, color, 3)
+    cv.line(vis, (cx, cy), (int(cx+np.cos(angle)*r), int(cy+np.sin(angle)*r)), color, 3)
 
 if __name__ == '__main__':
     import sys
@@ -26,12 +26,12 @@ def draw_motion_comp(vis, (x, y, w, h), angle, color):
     except:
         video_src = 0
 
-    cv2.namedWindow('motempl')
+    cv.namedWindow('motempl')
     visuals = ['input', 'frame_diff', 'motion_hist', 'grad_orient']
-    cv2.createTrackbar('visual', 'motempl', 2, len(visuals)-1, nothing)
-    cv2.createTrackbar('threshold', 'motempl', DEFAULT_THRESHOLD, 255, nothing)
+    cv.createTrackbar('visual', 'motempl', 2, len(visuals)-1, nothing)
+    cv.createTrackbar('threshold', 'motempl', DEFAULT_THRESHOLD, 255, nothing)
 
-    cam = cv2.VideoCapture(video_src)
+    cam = cv.VideoCapture(video_src)
     if not cam.isOpened():
         print("could not open video_src " + str(video_src) + " !\n")
         sys.exit(1)
@@ -48,27 +48,27 @@ def draw_motion_comp(vis, (x, y, w, h), angle, color):
         ret, frame = cam.read()
         if ret == False:
             break
-        frame_diff = cv2.absdiff(frame, prev_frame)
-        gray_diff = cv2.cvtColor(frame_diff, cv2.COLOR_BGR2GRAY)
-        thrs = cv2.getTrackbarPos('threshold', 'motempl')
-        ret, motion_mask = cv2.threshold(gray_diff, thrs, 1, cv2.THRESH_BINARY)
-        timestamp = cv2.getTickCount() / cv2.getTickFrequency()
-        cv2.motempl.updateMotionHistory(motion_mask, motion_history, timestamp, MHI_DURATION)
-        mg_mask, mg_orient = cv2.motempl.calcMotionGradient( motion_history, MAX_TIME_DELTA, MIN_TIME_DELTA, apertureSize=5 )
-        seg_mask, seg_bounds = cv2.motempl.segmentMotion(motion_history, timestamp, MAX_TIME_DELTA)
+        frame_diff = cv.absdiff(frame, prev_frame)
+        gray_diff = cv.cvtColor(frame_diff, cv.COLOR_BGR2GRAY)
+        thrs = cv.getTrackbarPos('threshold', 'motempl')
+        ret, motion_mask = cv.threshold(gray_diff, thrs, 1, cv.THRESH_BINARY)
+        timestamp = cv.getTickCount() / cv.getTickFrequency()
+        cv.motempl.updateMotionHistory(motion_mask, motion_history, timestamp, MHI_DURATION)
+        mg_mask, mg_orient = cv.motempl.calcMotionGradient( motion_history, MAX_TIME_DELTA, MIN_TIME_DELTA, apertureSize=5 )
+        seg_mask, seg_bounds = cv.motempl.segmentMotion(motion_history, timestamp, MAX_TIME_DELTA)
 
-        visual_name = visuals[cv2.getTrackbarPos('visual', 'motempl')]
+        visual_name = visuals[cv.getTrackbarPos('visual', 'motempl')]
         if visual_name == 'input':
             vis = frame.copy()
         elif visual_name == 'frame_diff':
             vis = frame_diff.copy()
         elif visual_name == 'motion_hist':
             vis = np.uint8(np.clip((motion_history-(timestamp-MHI_DURATION)) / MHI_DURATION, 0, 1)*255)
-            vis = cv2.cvtColor(vis, cv2.COLOR_GRAY2BGR)
+            vis = cv.cvtColor(vis, cv.COLOR_GRAY2BGR)
         elif visual_name == 'grad_orient':
             hsv[:,:,0] = mg_orient/2
             hsv[:,:,2] = mg_mask*255
-            vis = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
+            vis = cv.cvtColor(hsv, cv.COLOR_HSV2BGR)
 
         for i, rect in enumerate([(0, 0, w, h)] + list(seg_bounds)):
             x, y, rw, rh = rect
@@ -79,16 +79,16 @@ def draw_motion_comp(vis, (x, y, w, h), angle, color):
             orient_roi = mg_orient     [y:y+rh,x:x+rw]
             mask_roi   = mg_mask       [y:y+rh,x:x+rw]
             mhi_roi    = motion_history[y:y+rh,x:x+rw]
-            if cv2.norm(silh_roi, cv2.NORM_L1) < area*0.05:
+            if cv.norm(silh_roi, cv.NORM_L1) < area*0.05:
                 continue
-            angle = cv2.motempl.calcGlobalOrientation(orient_roi, mask_roi, mhi_roi, timestamp, MHI_DURATION)
+            angle = cv.motempl.calcGlobalOrientation(orient_roi, mask_roi, mhi_roi, timestamp, MHI_DURATION)
             color = ((255, 0, 0), (0, 0, 255))[i == 0]
             draw_motion_comp(vis, rect, angle, color)
 
-        cv2.putText(vis, visual_name, (20, 20), cv2.FONT_HERSHEY_PLAIN, 1.0, (200,0,0))
-        cv2.imshow('motempl', vis)
+        cv.putText(vis, visual_name, (20, 20), cv.FONT_HERSHEY_PLAIN, 1.0, (200,0,0))
+        cv.imshow('motempl', vis)
 
         prev_frame = frame.copy()
-        if 0xFF & cv2.waitKey(5) == 27:
+        if 0xFF & cv.waitKey(5) == 27:
             break
-    cv2.destroyAllWindows()
+    cv.destroyAllWindows()

modules/optflow/src/learn_prior.py

@@ -3,7 +3,7 @@
 import os
 import sys
 import numpy as np
-import cv2
+import cv2 as cv
 import struct
 import argparse
 from math import sqrt
@@ -73,7 +73,7 @@ def load_flo(flo):
 
 def get_w(m):
     s = m.shape
-    w = cv2.dct(m)
+    w = cv.dct(m)
     w *= 2.0 / sqrt(s[0] * s[1])
     #w[0,0] *= 0.5
     w[:, 0] *= sqrt(0.5)

modules/ovis/samples/aruco_ar_demo.py

@@ -1,35 +1,35 @@
-import cv2
 import numpy as np
+import cv2 as cv
 
 # aruco
-adict = cv2.aruco.Dictionary_get(cv2.aruco.DICT_4X4_50)
-cv2.imshow("marker", cv2.aruco.drawMarker(adict, 0, 400))
+adict = cv.aruco.Dictionary_get(cv.aruco.DICT_4X4_50)
+cv.imshow("marker", cv.aruco.drawMarker(adict, 0, 400))
 
 # random calibration data. your mileage may vary.
 imsize = (800, 600)
-K = cv2.getDefaultNewCameraMatrix(np.diag([800, 800, 1]), imsize, True)
+K = cv.getDefaultNewCameraMatrix(np.diag([800, 800, 1]), imsize, True)
 
 # AR scene
-cv2.ovis.addResourceLocation("packs/Sinbad.zip") # shipped with Ogre
+cv.ovis.addResourceLocation("packs/Sinbad.zip") # shipped with Ogre
 
-win = cv2.ovis.createWindow("arucoAR", imsize, flags=0)
+win = cv.ovis.createWindow("arucoAR", imsize, flags=0)
 win.createEntity("figure", "Sinbad.mesh", (0, 0, -5), (-1.57, 0, 0))
 win.createLightEntity("sun", (0, 0, -100))
 
 # video capture
-cap = cv2.VideoCapture(0)
-cap.set(cv2.CAP_PROP_FRAME_WIDTH, imsize[0])
-cap.set(cv2.CAP_PROP_FRAME_HEIGHT, imsize[1])
+cap = cv.VideoCapture(0)
+cap.set(cv.CAP_PROP_FRAME_WIDTH, imsize[0])
+cap.set(cv.CAP_PROP_FRAME_HEIGHT, imsize[1])
 
-while cv2.ovis.renderOneFrame():
+while cv.ovis.renderOneFrame():
     img = cap.read()[1]
     win.setBackground(img)
-    corners, ids = cv2.aruco.detectMarkers(img, adict)[:2]
+    corners, ids = cv.aruco.detectMarkers(img, adict)[:2]
 
-    cv2.waitKey(1)
+    cv.waitKey(1)
 
     if ids is None:
         continue
 
-    rvecs, tvecs = cv2.aruco.estimatePoseSingleMarkers(corners, 5, K, None)[:2]
+    rvecs, tvecs = cv.aruco.estimatePoseSingleMarkers(corners, 5, K, None)[:2]
     win.setCameraPose(tvecs[0].ravel(), rvecs[0].ravel(), invert=True)