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

doc/py_tutorials/py_feature2d/py_brief/py_brief.markdown

@@ -52,16 +52,16 @@ detector is called STAR detector in OpenCV)
 note, that you need [opencv contrib](https://github.com/opencv/opencv_contrib)) to use this.
 @code{.py}
 import numpy as np
-import cv2
+import cv2 as cv
 from matplotlib import pyplot as plt
 
-img = cv2.imread('simple.jpg',0)
+img = cv.imread('simple.jpg',0)
 
 # Initiate FAST detector
-star = cv2.xfeatures2d.StarDetector_create()
+star = cv.xfeatures2d.StarDetector_create()
 
 # Initiate BRIEF extractor
-brief = cv2.xfeatures2d.BriefDescriptorExtractor_create()
+brief = cv.xfeatures2d.BriefDescriptorExtractor_create()
 
 # find the keypoints with STAR
 kp = star.detect(img,None)

doc/py_tutorials/py_feature2d/py_fast/py_fast.markdown

@@ -90,22 +90,22 @@ FAST Feature Detector in OpenCV
 It is called as any other feature detector in OpenCV. If you want, you can specify the threshold,
 whether non-maximum suppression to be applied or not, the neighborhood to be used etc.
 
-For the neighborhood, three flags are defined, cv2.FAST_FEATURE_DETECTOR_TYPE_5_8,
-cv2.FAST_FEATURE_DETECTOR_TYPE_7_12 and cv2.FAST_FEATURE_DETECTOR_TYPE_9_16. Below is a
+For the neighborhood, three flags are defined, cv.FAST_FEATURE_DETECTOR_TYPE_5_8,
+cv.FAST_FEATURE_DETECTOR_TYPE_7_12 and cv.FAST_FEATURE_DETECTOR_TYPE_9_16. Below is a
 simple code on how to detect and draw the FAST feature points.
 @code{.py}
 import numpy as np
-import cv2
+import cv2 as cv
 from matplotlib import pyplot as plt
 
-img = cv2.imread('simple.jpg',0)
+img = cv.imread('simple.jpg',0)
 
 # Initiate FAST object with default values
-fast = cv2.FastFeatureDetector_create()
+fast = cv.FastFeatureDetector_create()
 
 # find and draw the keypoints
 kp = fast.detect(img,None)
-img2 = cv2.drawKeypoints(img, kp, None, color=(255,0,0))
+img2 = cv.drawKeypoints(img, kp, None, color=(255,0,0))
 
 # Print all default params
 print( "Threshold: {}".format(fast.getThreshold()) )
@@ -113,7 +113,7 @@ print( "nonmaxSuppression:{}".format(fast.getNonmaxSuppression()) )
 print( "neighborhood: {}".format(fast.getType()) )
 print( "Total Keypoints with nonmaxSuppression: {}".format(len(kp)) )
 
-cv2.imwrite('fast_true.png',img2)
+cv.imwrite('fast_true.png',img2)
 
 # Disable nonmaxSuppression
 fast.setNonmaxSuppression(0)
@@ -121,9 +121,9 @@ kp = fast.detect(img,None)
 
 print( "Total Keypoints without nonmaxSuppression: {}".format(len(kp)) )
 
-img3 = cv2.drawKeypoints(img, kp, None, color=(255,0,0))
+img3 = cv.drawKeypoints(img, kp, None, color=(255,0,0))
 
-cv2.imwrite('fast_false.png',img3)
+cv.imwrite('fast_false.png',img3)
 @endcode
 See the results. First image shows FAST with nonmaxSuppression and second one without
 nonmaxSuppression:

doc/py_tutorials/py_feature2d/py_feature_homography/py_feature_homography.markdown

@@ -16,15 +16,15 @@ another trainImage, found the features in that image too and we found the best m
 In short, we found locations of some parts of an object in another cluttered image. This information
 is sufficient to find the object exactly on the trainImage.
 
-For that, we can use a function from calib3d module, ie **cv2.findHomography()**. If we pass the set
+For that, we can use a function from calib3d module, ie **cv.findHomography()**. If we pass the set
 of points from both the images, it will find the perpective transformation of that object. Then we
-can use **cv2.perspectiveTransform()** to find the object. It needs atleast four correct points to
+can use **cv.perspectiveTransform()** to find the object. It needs atleast four correct points to
 find the transformation.
 
 We have seen that there can be some possible errors while matching which may affect the result. To
 solve this problem, algorithm uses RANSAC or LEAST_MEDIAN (which can be decided by the flags). So
 good matches which provide correct estimation are called inliers and remaining are called outliers.
-**cv2.findHomography()** returns a mask which specifies the inlier and outlier points.
+**cv.findHomography()** returns a mask which specifies the inlier and outlier points.
 
 So let's do it !!!
 
@@ -35,16 +35,16 @@ First, as usual, let's find SIFT features in images and apply the ratio test to
 matches.
 @code{.py}
 import numpy as np
-import cv2
+import cv2 as cv
 from matplotlib import pyplot as plt
 
 MIN_MATCH_COUNT = 10
 
-img1 = cv2.imread('box.png',0)          # queryImage
-img2 = cv2.imread('box_in_scene.png',0) # trainImage
+img1 = cv.imread('box.png',0)          # queryImage
+img2 = cv.imread('box_in_scene.png',0) # trainImage
 
 # Initiate SIFT detector
-sift = cv2.xfeatures2d.SIFT_create()
+sift = cv.xfeatures2d.SIFT_create()
 
 # find the keypoints and descriptors with SIFT
 kp1, des1 = sift.detectAndCompute(img1,None)
@@ -54,7 +54,7 @@ FLANN_INDEX_KDTREE = 1
 index_params = dict(algorithm = FLANN_INDEX_KDTREE, trees = 5)
 search_params = dict(checks = 50)
 
-flann = cv2.FlannBasedMatcher(index_params, search_params)
+flann = cv.FlannBasedMatcher(index_params, search_params)
 
 matches = flann.knnMatch(des1,des2,k=2)
 
@@ -75,14 +75,14 @@ if len(good)>MIN_MATCH_COUNT:
     src_pts = np.float32([ kp1[m.queryIdx].pt for m in good ]).reshape(-1,1,2)
     dst_pts = np.float32([ kp2[m.trainIdx].pt for m in good ]).reshape(-1,1,2)
 
-    M, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC,5.0)
+    M, mask = cv.findHomography(src_pts, dst_pts, cv.RANSAC,5.0)
     matchesMask = mask.ravel().tolist()
 
     h,w,d = img1.shape
     pts = np.float32([ [0,0],[0,h-1],[w-1,h-1],[w-1,0] ]).reshape(-1,1,2)
-    dst = cv2.perspectiveTransform(pts,M)
+    dst = cv.perspectiveTransform(pts,M)
 
-    img2 = cv2.polylines(img2,[np.int32(dst)],True,255,3, cv2.LINE_AA)
+    img2 = cv.polylines(img2,[np.int32(dst)],True,255,3, cv.LINE_AA)
 
 else:
     print( "Not enough matches are found - {}/{}".format(len(good), MIN_MATCH_COUNT) )
@@ -95,7 +95,7 @@ draw_params = dict(matchColor = (0,255,0), # draw matches in green color
                    matchesMask = matchesMask, # draw only inliers
                    flags = 2)
 
-img3 = cv2.drawMatches(img1,kp1,img2,kp2,good,None,**draw_params)
+img3 = cv.drawMatches(img1,kp1,img2,kp2,good,None,**draw_params)
 
 plt.imshow(img3, 'gray'),plt.show()
 @endcode

doc/py_tutorials/py_feature2d/py_features_harris/py_features_harris.markdown

@@ -7,7 +7,7 @@ Goal
 In this chapter,
 
 -   We will understand the concepts behind Harris Corner Detection.
--   We will see the functions: **cv2.cornerHarris()**, **cv2.cornerSubPix()**
+-   We will see the functions: **cv.cornerHarris()**, **cv.cornerSubPix()**
 
 Theory
 ------
@@ -35,7 +35,7 @@ where
                                      I_x I_y & I_y I_y \end{bmatrix}\f]
 
 Here, \f$I_x\f$ and \f$I_y\f$ are image derivatives in x and y directions respectively. (Can be easily found
-out using **cv2.Sobel()**).
+out using **cv.Sobel()**).
 
 Then comes the main part. After this, they created a score, basically an equation, which will
 determine if a window can contain a corner or not.
@@ -65,7 +65,7 @@ suitable give you the corners in the image. We will do it with a simple image.
 Harris Corner Detector in OpenCV
 --------------------------------
 
-OpenCV has the function **cv2.cornerHarris()** for this purpose. Its arguments are :
+OpenCV has the function **cv.cornerHarris()** for this purpose. Its arguments are :
 
 -   **img** - Input image, it should be grayscale and float32 type.
 -   **blockSize** - It is the size of neighbourhood considered for corner detection
@@ -74,25 +74,25 @@ OpenCV has the function **cv2.cornerHarris()** for this purpose. Its arguments a
 
 See the example below:
 @code{.py}
-import cv2
 import numpy as np
+import cv2 as cv
 
 filename = 'chessboard.png'
-img = cv2.imread(filename)
-gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
+img = cv.imread(filename)
+gray = cv.cvtColor(img,cv.COLOR_BGR2GRAY)
 
 gray = np.float32(gray)
-dst = cv2.cornerHarris(gray,2,3,0.04)
+dst = cv.cornerHarris(gray,2,3,0.04)
 
 #result is dilated for marking the corners, not important
-dst = cv2.dilate(dst,None)
+dst = cv.dilate(dst,None)
 
 # Threshold for an optimal value, it may vary depending on the image.
 img[dst>0.01*dst.max()]=[0,0,255]
 
-cv2.imshow('dst',img)
-if cv2.waitKey(0) & 0xff == 27:
-    cv2.destroyAllWindows()
+cv.imshow('dst',img)
+if cv.waitKey(0) & 0xff == 27:
+    cv.destroyAllWindows()
 @endcode
 Below are the three results:
 
@@ -102,7 +102,7 @@ Corner with SubPixel Accuracy
 -----------------------------
 
 Sometimes, you may need to find the corners with maximum accuracy. OpenCV comes with a function
-**cv2.cornerSubPix()** which further refines the corners detected with sub-pixel accuracy. Below is
+**cv.cornerSubPix()** which further refines the corners detected with sub-pixel accuracy. Below is
 an example. As usual, we need to find the harris corners first. Then we pass the centroids of these
 corners (There may be a bunch of pixels at a corner, we take their centroid) to refine them. Harris
 corners are marked in red pixels and refined corners are marked in green pixels. For this function,
@@ -110,26 +110,26 @@ we have to define the criteria when to stop the iteration. We stop it after a sp
 iteration or a certain accuracy is achieved, whichever occurs first. We also need to define the size
 of neighbourhood it would search for corners.
 @code{.py}
-import cv2
 import numpy as np
+import cv2 as cv
 
 filename = 'chessboard2.jpg'
-img = cv2.imread(filename)
-gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
+img = cv.imread(filename)
+gray = cv.cvtColor(img,cv.COLOR_BGR2GRAY)
 
 # find Harris corners
 gray = np.float32(gray)
-dst = cv2.cornerHarris(gray,2,3,0.04)
-dst = cv2.dilate(dst,None)
-ret, dst = cv2.threshold(dst,0.01*dst.max(),255,0)
+dst = cv.cornerHarris(gray,2,3,0.04)
+dst = cv.dilate(dst,None)
+ret, dst = cv.threshold(dst,0.01*dst.max(),255,0)
 dst = np.uint8(dst)
 
 # find centroids
-ret, labels, stats, centroids = cv2.connectedComponentsWithStats(dst)
+ret, labels, stats, centroids = cv.connectedComponentsWithStats(dst)
 
 # define the criteria to stop and refine the corners
-criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 100, 0.001)
-corners = cv2.cornerSubPix(gray,np.float32(centroids),(5,5),(-1,-1),criteria)
+criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, 100, 0.001)
+corners = cv.cornerSubPix(gray,np.float32(centroids),(5,5),(-1,-1),criteria)
 
 # Now draw them
 res = np.hstack((centroids,corners))
@@ -137,7 +137,7 @@ res = np.int0(res)
 img[res[:,1],res[:,0]]=[0,0,255]
 img[res[:,3],res[:,2]] = [0,255,0]
 
-cv2.imwrite('subpixel5.png',img)
+cv.imwrite('subpixel5.png',img)
 @endcode
 Below is the result, where some important locations are shown in zoomed window to visualize:
 

doc/py_tutorials/py_feature2d/py_matcher/py_matcher.markdown

@@ -15,11 +15,11 @@ Brute-Force matcher is simple. It takes the descriptor of one feature in first s
 with all other features in second set using some distance calculation. And the closest one is
 returned.
 
-For BF matcher, first we have to create the BFMatcher object using **cv2.BFMatcher()**. It takes two
+For BF matcher, first we have to create the BFMatcher object using **cv.BFMatcher()**. It takes two
 optional params. First one is normType. It specifies the distance measurement to be used. By
-default, it is cv2.NORM_L2. It is good for SIFT, SURF etc (cv2.NORM_L1 is also there). For binary
-string based descriptors like ORB, BRIEF, BRISK etc, cv2.NORM_HAMMING should be used, which used
-Hamming distance as measurement. If ORB is using WTA_K == 3 or 4, cv2.NORM_HAMMING2 should be
+default, it is cv.NORM_L2. It is good for SIFT, SURF etc (cv.NORM_L1 is also there). For binary
+string based descriptors like ORB, BRIEF, BRISK etc, cv.NORM_HAMMING should be used, which used
+Hamming distance as measurement. If ORB is using WTA_K == 3 or 4, cv.NORM_HAMMING2 should be
 used.
 
 Second param is boolean variable, crossCheck which is false by default. If it is true, Matcher
@@ -32,9 +32,9 @@ Once it is created, two important methods are *BFMatcher.match()* and *BFMatcher
 one returns the best match. Second method returns k best matches where k is specified by the user.
 It may be useful when we need to do additional work on that.
 
-Like we used cv2.drawKeypoints() to draw keypoints, **cv2.drawMatches()** helps us to draw the
+Like we used cv.drawKeypoints() to draw keypoints, **cv.drawMatches()** helps us to draw the
 matches. It stacks two images horizontally and draw lines from first image to second image showing
-best matches. There is also **cv2.drawMatchesKnn** which draws all the k best matches. If k=2, it
+best matches. There is also **cv.drawMatchesKnn** which draws all the k best matches. If k=2, it
 will draw two match-lines for each keypoint. So we have to pass a mask if we want to selectively
 draw it.
 
@@ -50,27 +50,27 @@ We are using ORB descriptors to match features. So let's start with loading imag
 descriptors etc.
 @code{.py}
 import numpy as np
-import cv2
+import cv2 as cv
 import matplotlib.pyplot as plt
 
-img1 = cv2.imread('box.png',0)          # queryImage
-img2 = cv2.imread('box_in_scene.png',0) # trainImage
+img1 = cv.imread('box.png',0)          # queryImage
+img2 = cv.imread('box_in_scene.png',0) # trainImage
 
 # Initiate ORB detector
-orb = cv2.ORB_create()
+orb = cv.ORB_create()
 
 # find the keypoints and descriptors with ORB
 kp1, des1 = orb.detectAndCompute(img1,None)
 kp2, des2 = orb.detectAndCompute(img2,None)
 @endcode
-Next we create a BFMatcher object with distance measurement cv2.NORM_HAMMING (since we are using
+Next we create a BFMatcher object with distance measurement cv.NORM_HAMMING (since we are using
 ORB) and crossCheck is switched on for better results. Then we use Matcher.match() method to get the
 best matches in two images. We sort them in ascending order of their distances so that best matches
 (with low distance) come to front. Then we draw only first 10 matches (Just for sake of visibility.
 You can increase it as you like)
 @code{.py}
 # create BFMatcher object
-bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
+bf = cv.BFMatcher(cv.NORM_HAMMING, crossCheck=True)
 
 # Match descriptors.
 matches = bf.match(des1,des2)
@@ -79,7 +79,7 @@ matches = bf.match(des1,des2)
 matches = sorted(matches, key = lambda x:x.distance)
 
 # Draw first 10 matches.
-img3 = cv2.drawMatches(img1,kp1,img2,kp2,matches[:10], flags=2)
+img3 = cv.drawMatches(img1,kp1,img2,kp2,matches[:10], flags=2)
 
 plt.imshow(img3),plt.show()
 @endcode
@@ -103,21 +103,21 @@ This time, we will use BFMatcher.knnMatch() to get k best matches. In this examp
 so that we can apply ratio test explained by D.Lowe in his paper.
 @code{.py}
 import numpy as np
-import cv2
+import cv2 as cv
 from matplotlib import pyplot as plt
 
-img1 = cv2.imread('box.png',0)          # queryImage
-img2 = cv2.imread('box_in_scene.png',0) # trainImage
+img1 = cv.imread('box.png',0)          # queryImage
+img2 = cv.imread('box_in_scene.png',0) # trainImage
 
 # Initiate SIFT detector
-sift = cv2.SIFT()
+sift = cv.SIFT()
 
 # find the keypoints and descriptors with SIFT
 kp1, des1 = sift.detectAndCompute(img1,None)
 kp2, des2 = sift.detectAndCompute(img2,None)
 
 # BFMatcher with default params
-bf = cv2.BFMatcher()
+bf = cv.BFMatcher()
 matches = bf.knnMatch(des1,des2, k=2)
 
 # Apply ratio test
@@ -126,8 +126,8 @@ for m,n in matches:
     if m.distance < 0.75*n.distance:
         good.append([m])
 
-# cv2.drawMatchesKnn expects list of lists as matches.
-img3 = cv2.drawMatchesKnn(img1,kp1,img2,kp2,good,flags=2)
+# cv.drawMatchesKnn expects list of lists as matches.
+img3 = cv.drawMatchesKnn(img1,kp1,img2,kp2,good,flags=2)
 
 plt.imshow(img3),plt.show()
 @endcode
@@ -167,14 +167,14 @@ you want to change the value, pass search_params = dict(checks=100).
 With these informations, we are good to go.
 @code{.py}
 import numpy as np
-import cv2
+import cv2 as cv
 from matplotlib import pyplot as plt
 
-img1 = cv2.imread('box.png',0)          # queryImage
-img2 = cv2.imread('box_in_scene.png',0) # trainImage
+img1 = cv.imread('box.png',0)          # queryImage
+img2 = cv.imread('box_in_scene.png',0) # trainImage
 
 # Initiate SIFT detector
-sift = cv2.SIFT()
+sift = cv.SIFT()
 
 # find the keypoints and descriptors with SIFT
 kp1, des1 = sift.detectAndCompute(img1,None)
@@ -185,7 +185,7 @@ FLANN_INDEX_KDTREE = 1
 index_params = dict(algorithm = FLANN_INDEX_KDTREE, trees = 5)
 search_params = dict(checks=50)   # or pass empty dictionary
 
-flann = cv2.FlannBasedMatcher(index_params,search_params)
+flann = cv.FlannBasedMatcher(index_params,search_params)
 
 matches = flann.knnMatch(des1,des2,k=2)
 
@@ -202,7 +202,7 @@ draw_params = dict(matchColor = (0,255,0),
                    matchesMask = matchesMask,
                    flags = 0)
 
-img3 = cv2.drawMatchesKnn(img1,kp1,img2,kp2,matches,None,**draw_params)
+img3 = cv.drawMatchesKnn(img1,kp1,img2,kp2,matches,None,**draw_params)
 
 plt.imshow(img3,),plt.show()
 @endcode

doc/py_tutorials/py_feature2d/py_orb/py_orb.markdown

@@ -52,7 +52,7 @@ choice in low-power devices for panorama stitching etc.
 ORB in OpenCV
 -------------
 
-As usual, we have to create an ORB object with the function, **cv2.ORB()** or using feature2d common
+As usual, we have to create an ORB object with the function, **cv.ORB()** or using feature2d common
 interface. It has a number of optional parameters. Most useful ones are nFeatures which denotes
 maximum number of features to be retained (by default 500), scoreType which denotes whether Harris
 score or FAST score to rank the features (by default, Harris score) etc. Another parameter, WTA_K
@@ -64,13 +64,13 @@ is defined by NORM_HAMMING2.
 Below is a simple code which shows the use of ORB.
 @code{.py}
 import numpy as np
-import cv2
+import cv2 as cv
 from matplotlib import pyplot as plt
 
-img = cv2.imread('simple.jpg',0)
+img = cv.imread('simple.jpg',0)
 
 # Initiate ORB detector
-orb = cv2.ORB_create()
+orb = cv.ORB_create()
 
 # find the keypoints with ORB
 kp = orb.detect(img,None)
@@ -79,7 +79,7 @@ kp = orb.detect(img,None)
 kp, des = orb.compute(img, kp)
 
 # draw only keypoints location,not size and orientation
-img2 = cv2.drawKeypoints(img, kp, None, color=(0,255,0), flags=0)
+img2 = cv.drawKeypoints(img, kp, None, color=(0,255,0), flags=0)
 plt.imshow(img2), plt.show()
 @endcode
 See the result below:

doc/py_tutorials/py_feature2d/py_shi_tomasi/py_shi_tomasi.markdown

@@ -7,7 +7,7 @@ Goal
 In this chapter,
 
 -   We will learn about the another corner detector: Shi-Tomasi Corner Detector
--   We will see the function: **cv2.goodFeaturesToTrack()**
+-   We will see the function: **cv.goodFeaturesToTrack()**
 
 Theory
 ------
@@ -33,7 +33,7 @@ From the figure, you can see that only when \f$\lambda_1\f$ and \f$\lambda_2\f$
 Code
 ----
 
-OpenCV has a function, **cv2.goodFeaturesToTrack()**. It finds N strongest corners in the image by
+OpenCV has a function, **cv.goodFeaturesToTrack()**. It finds N strongest corners in the image by
 Shi-Tomasi method (or Harris Corner Detection, if you specify it). As usual, image should be a
 grayscale image. Then you specify number of corners you want to find. Then you specify the quality
 level, which is a value between 0-1, which denotes the minimum quality of corner below which
@@ -47,18 +47,18 @@ minimum distance and returns N strongest corners.
 In below example, we will try to find 25 best corners:
 @code{.py}
 import numpy as np
-import cv2
+import cv2 as cv
 from matplotlib import pyplot as plt
 
-img = cv2.imread('blox.jpg')
-gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
+img = cv.imread('blox.jpg')
+gray = cv.cvtColor(img,cv.COLOR_BGR2GRAY)
 
-corners = cv2.goodFeaturesToTrack(gray,25,0.01,10)
+corners = cv.goodFeaturesToTrack(gray,25,0.01,10)
 corners = np.int0(corners)
 
 for i in corners:
     x,y = i.ravel()
-    cv2.circle(img,(x,y),3,255,-1)
+    cv.circle(img,(x,y),3,255,-1)
 
 plt.imshow(img),plt.show()
 @endcode

doc/py_tutorials/py_feature2d/py_sift_intro/py_sift_intro.markdown

@@ -113,30 +113,30 @@ So now let's see SIFT functionalities available in OpenCV. Let's start with keyp
 draw them. First we have to construct a SIFT object. We can pass different parameters to it which
 are optional and they are well explained in docs.
 @code{.py}
-import cv2
 import numpy as np
+import cv2 as cv
 
-img = cv2.imread('home.jpg')
-gray= cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
+img = cv.imread('home.jpg')
+gray= cv.cvtColor(img,cv.COLOR_BGR2GRAY)
 
-sift = cv2.xfeatures2d.SIFT_create()
+sift = cv.xfeatures2d.SIFT_create()
 kp = sift.detect(gray,None)
 
-img=cv2.drawKeypoints(gray,kp,img)
+img=cv.drawKeypoints(gray,kp,img)
 
-cv2.imwrite('sift_keypoints.jpg',img)
+cv.imwrite('sift_keypoints.jpg',img)
 @endcode
 **sift.detect()** function finds the keypoint in the images. You can pass a mask if you want to
 search only a part of image. Each keypoint is a special structure which has many attributes like its
 (x,y) coordinates, size of the meaningful neighbourhood, angle which specifies its orientation,
 response that specifies strength of keypoints etc.
 
-OpenCV also provides **cv2.drawKeyPoints()** function which draws the small circles on the locations
-of keypoints. If you pass a flag, **cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS** to it, it will
+OpenCV also provides **cv.drawKeyPoints()** function which draws the small circles on the locations
+of keypoints. If you pass a flag, **cv.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS** to it, it will
 draw a circle with size of keypoint and it will even show its orientation. See below example.
 @code{.py}
-img=cv2.drawKeypoints(gray,kp,img,flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
-cv2.imwrite('sift_keypoints.jpg',img)
+img=cv.drawKeypoints(gray,kp,img,flags=cv.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
+cv.imwrite('sift_keypoints.jpg',img)
 @endcode
 See the two results below:
 
@@ -151,7 +151,7 @@ Now to calculate the descriptor, OpenCV provides two methods.
 
 We will see the second method:
 @code{.py}
-sift = cv2.xfeatures2d.SIFT_create()
+sift = cv.xfeatures2d.SIFT_create()
 kp, des = sift.detectAndCompute(gray,None)
 @endcode
 Here kp will be a list of keypoints and des is a numpy array of shape

doc/py_tutorials/py_feature2d/py_surf_intro/py_surf_intro.markdown

@@ -76,11 +76,11 @@ and descriptors.
 First we will see a simple demo on how to find SURF keypoints and descriptors and draw it. All
 examples are shown in Python terminal since it is just same as SIFT only.
 @code{.py}
->>> img = cv2.imread('fly.png',0)
+>>> img = cv.imread('fly.png',0)
 
 # Create SURF object. You can specify params here or later.
 # Here I set Hessian Threshold to 400
->>> surf = cv2.xfeatures2d.SURF_create(400)
+>>> surf = cv.xfeatures2d.SURF_create(400)
 
 # Find keypoints and descriptors directly
 >>> kp, des = surf.detectAndCompute(img,None)
@@ -107,7 +107,7 @@ While matching, we may need all those features, but not now. So we increase the
 @endcode
 It is less than 50. Let's draw it on the image.
 @code{.py}
->>> img2 = cv2.drawKeypoints(img,kp,None,(255,0,0),4)
+>>> img2 = cv.drawKeypoints(img,kp,None,(255,0,0),4)
 
 >>> plt.imshow(img2),plt.show()
 @endcode
@@ -126,7 +126,7 @@ False
 
 # Recompute the feature points and draw it
 >>> kp = surf.detect(img,None)
->>> img2 = cv2.drawKeypoints(img,kp,None,(255,0,0),4)
+>>> img2 = cv.drawKeypoints(img,kp,None,(255,0,0),4)
 
 >>> plt.imshow(img2),plt.show()
 @endcode