python: 'cv2.' -> 'cv.' via 'import cv2 as cv'

doc/py_tutorials/py_calib3d/py_pose/py_pose.markdown

@@ -24,8 +24,8 @@ should feel like it is perpendicular to our chessboard plane.
 First, let's load the camera matrix and distortion coefficients from the previous calibration
 result.
 @code{.py}
-import cv2
 import numpy as np
+import cv2 as cv
 import glob
 
 # Load previously saved data
@@ -33,13 +33,13 @@ with np.load('B.npz') as X:
     mtx, dist, _, _ = [X[i] for i in ('mtx','dist','rvecs','tvecs')]
 @endcode
 Now let's create a function, draw which takes the corners in the chessboard (obtained using
-**cv2.findChessboardCorners()**) and **axis points** to draw a 3D axis.
+**cv.findChessboardCorners()**) and **axis points** to draw a 3D axis.
 @code{.py}
 def draw(img, corners, imgpts):
     corner = tuple(corners[0].ravel())
-    img = cv2.line(img, corner, tuple(imgpts[0].ravel()), (255,0,0), 5)
-    img = cv2.line(img, corner, tuple(imgpts[1].ravel()), (0,255,0), 5)
-    img = cv2.line(img, corner, tuple(imgpts[2].ravel()), (0,0,255), 5)
+    img = cv.line(img, corner, tuple(imgpts[0].ravel()), (255,0,0), 5)
+    img = cv.line(img, corner, tuple(imgpts[1].ravel()), (0,255,0), 5)
+    img = cv.line(img, corner, tuple(imgpts[2].ravel()), (0,0,255), 5)
     return img
 @endcode
 Then as in previous case, we create termination criteria, object points (3D points of corners in
@@ -48,7 +48,7 @@ of length 3 (units will be in terms of chess square size since we calibrated bas
 our X axis is drawn from (0,0,0) to (3,0,0), so for Y axis. For Z axis, it is drawn from (0,0,0) to
 (0,0,-3). Negative denotes it is drawn towards the camera.
 @code{.py}
-criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)
+criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, 30, 0.001)
 objp = np.zeros((6*7,3), np.float32)
 objp[:,:2] = np.mgrid[0:7,0:6].T.reshape(-1,2)
 
@@ -56,32 +56,32 @@ axis = np.float32([[3,0,0], [0,3,0], [0,0,-3]]).reshape(-1,3)
 @endcode
 Now, as usual, we load each image. Search for 7x6 grid. If found, we refine it with subcorner
 pixels. Then to calculate the rotation and translation, we use the function,
-**cv2.solvePnPRansac()**. Once we those transformation matrices, we use them to project our **axis
+**cv.solvePnPRansac()**. Once we those transformation matrices, we use them to project our **axis
 points** to the image plane. In simple words, we find the points on image plane corresponding to
 each of (3,0,0),(0,3,0),(0,0,3) in 3D space. Once we get them, we draw lines from the first corner
 to each of these points using our draw() function. Done !!!
 @code{.py}
 for fname in glob.glob('left*.jpg'):
-    img = cv2.imread(fname)
-    gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
-    ret, corners = cv2.findChessboardCorners(gray, (7,6),None)
+    img = cv.imread(fname)
+    gray = cv.cvtColor(img,cv.COLOR_BGR2GRAY)
+    ret, corners = cv.findChessboardCorners(gray, (7,6),None)
 
     if ret == True:
-        corners2 = cv2.cornerSubPix(gray,corners,(11,11),(-1,-1),criteria)
+        corners2 = cv.cornerSubPix(gray,corners,(11,11),(-1,-1),criteria)
 
         # Find the rotation and translation vectors.
-        ret,rvecs, tvecs, inliers = cv2.solvePnP(objp, corners2, mtx, dist)
+        ret,rvecs, tvecs, inliers = cv.solvePnP(objp, corners2, mtx, dist)
 
         # project 3D points to image plane
-        imgpts, jac = cv2.projectPoints(axis, rvecs, tvecs, mtx, dist)
+        imgpts, jac = cv.projectPoints(axis, rvecs, tvecs, mtx, dist)
 
         img = draw(img,corners2,imgpts)
-        cv2.imshow('img',img)
-        k = cv2.waitKey(0) & 0xFF
+        cv.imshow('img',img)
+        k = cv.waitKey(0) & 0xFF
         if k == ord('s'):
-            cv2.imwrite(fname[:6]+'.png', img)
+            cv.imwrite(fname[:6]+'.png', img)
 
-cv2.destroyAllWindows()
+cv.destroyAllWindows()
 @endcode
 See some results below. Notice that each axis is 3 squares long.:
 
@@ -97,14 +97,14 @@ def draw(img, corners, imgpts):
     imgpts = np.int32(imgpts).reshape(-1,2)
 
     # draw ground floor in green
-    img = cv2.drawContours(img, [imgpts[:4]],-1,(0,255,0),-3)
+    img = cv.drawContours(img, [imgpts[:4]],-1,(0,255,0),-3)
 
     # draw pillars in blue color
     for i,j in zip(range(4),range(4,8)):
-        img = cv2.line(img, tuple(imgpts[i]), tuple(imgpts[j]),(255),3)
+        img = cv.line(img, tuple(imgpts[i]), tuple(imgpts[j]),(255),3)
 
     # draw top layer in red color
-    img = cv2.drawContours(img, [imgpts[4:]],-1,(0,0,255),3)
+    img = cv.drawContours(img, [imgpts[4:]],-1,(0,0,255),3)
 
     return img
 @endcode