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

doc/py_tutorials/py_ml/py_kmeans/py_kmeans_opencv/py_kmeans_opencv.markdown

@@ -4,7 +4,7 @@ K-Means Clustering in OpenCV {#tutorial_py_kmeans_opencv}
 Goal
 ----
 
--   Learn to use **cv2.kmeans()** function in OpenCV for data clustering
+-   Learn to use **cv.kmeans()** function in OpenCV for data clustering
 
 Understanding Parameters
 ------------------------
@@ -16,9 +16,9 @@ Understanding Parameters
 -#  **nclusters(K)** : Number of clusters required at end
 -#  **criteria** : It is the iteration termination criteria. When this criteria is satisfied, algorithm iteration stops. Actually, it should be a tuple of 3 parameters. They are \`( type, max_iter, epsilon )\`:
         -#  type of termination criteria. It has 3 flags as below:
-            - **cv2.TERM_CRITERIA_EPS** - stop the algorithm iteration if specified accuracy, *epsilon*, is reached.
-            - **cv2.TERM_CRITERIA_MAX_ITER** - stop the algorithm after the specified number of iterations, *max_iter*.
-            - **cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER** - stop the iteration when any of the above condition is met.
+            - **cv.TERM_CRITERIA_EPS** - stop the algorithm iteration if specified accuracy, *epsilon*, is reached.
+            - **cv.TERM_CRITERIA_MAX_ITER** - stop the algorithm after the specified number of iterations, *max_iter*.
+            - **cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER** - stop the iteration when any of the above condition is met.
         -#  max_iter - An integer specifying maximum number of iterations.
         -#  epsilon - Required accuracy
 
@@ -26,7 +26,7 @@ Understanding Parameters
     initial labellings. The algorithm returns the labels that yield the best compactness. This
     compactness is returned as output.
 -#  **flags** : This flag is used to specify how initial centers are taken. Normally two flags are
-    used for this : **cv2.KMEANS_PP_CENTERS** and **cv2.KMEANS_RANDOM_CENTERS**.
+    used for this : **cv.KMEANS_PP_CENTERS** and **cv.KMEANS_RANDOM_CENTERS**.
 
 ### Output parameters
 
@@ -47,7 +47,7 @@ t-shirt problem where you use only height of people to decide the size of t-shir
 So we start by creating data and plot it in Matplotlib
 @code{.py}
 import numpy as np
-import cv2
+import cv2 as cv
 from matplotlib import pyplot as plt
 
 x = np.random.randint(25,100,25)
@@ -70,13 +70,13 @@ that, whenever 10 iterations of algorithm is ran, or an accuracy of epsilon = 1.
 the algorithm and return the answer.
 @code{.py}
 # Define criteria = ( type, max_iter = 10 , epsilon = 1.0 )
-criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 10, 1.0)
+criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, 10, 1.0)
 
 # Set flags (Just to avoid line break in the code)
-flags = cv2.KMEANS_RANDOM_CENTERS
+flags = cv.KMEANS_RANDOM_CENTERS
 
 # Apply KMeans
-compactness,labels,centers = cv2.kmeans(z,2,None,criteria,10,flags)
+compactness,labels,centers = cv.kmeans(z,2,None,criteria,10,flags)
 @endcode
 This gives us the compactness, labels and centers. In this case, I got centers as 60 and 207. Labels
 will have the same size as that of test data where each data will be labelled as '0','1','2' etc.
@@ -117,7 +117,7 @@ Check image below:
 Now I am directly moving to the code:
 @code{.py}
 import numpy as np
-import cv2
+import cv2 as cv
 from matplotlib import pyplot as plt
 
 X = np.random.randint(25,50,(25,2))
@@ -128,8 +128,8 @@ Z = np.vstack((X,Y))
 Z = np.float32(Z)
 
 # define criteria and apply kmeans()
-criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 10, 1.0)
-ret,label,center=cv2.kmeans(Z,2,None,criteria,10,cv2.KMEANS_RANDOM_CENTERS)
+criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, 10, 1.0)
+ret,label,center=cv.kmeans(Z,2,None,criteria,10,cv.KMEANS_RANDOM_CENTERS)
 
 # Now separate the data, Note the flatten()
 A = Z[label.ravel()==0]
@@ -161,27 +161,27 @@ specified number of colors. And again we need to reshape it back to the shape of
 Below is the code:
 @code{.py}
 import numpy as np
-import cv2
+import cv2 as cv
 
-img = cv2.imread('home.jpg')
+img = cv.imread('home.jpg')
 Z = img.reshape((-1,3))
 
 # convert to np.float32
 Z = np.float32(Z)
 
 # define criteria, number of clusters(K) and apply kmeans()
-criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 10, 1.0)
+criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, 10, 1.0)
 K = 8
-ret,label,center=cv2.kmeans(Z,K,None,criteria,10,cv2.KMEANS_RANDOM_CENTERS)
+ret,label,center=cv.kmeans(Z,K,None,criteria,10,cv.KMEANS_RANDOM_CENTERS)
 
 # Now convert back into uint8, and make original image
 center = np.uint8(center)
 res = center[label.flatten()]
 res2 = res.reshape((img.shape))
 
-cv2.imshow('res2',res2)
-cv2.waitKey(0)
-cv2.destroyAllWindows()
+cv.imshow('res2',res2)
+cv.waitKey(0)
+cv.destroyAllWindows()
 @endcode
 See the result below for K=8:
 

doc/py_tutorials/py_ml/py_knn/py_knn_opencv/py_knn_opencv.markdown

@@ -20,11 +20,11 @@ pixels. It is the simplest feature set we can create. We use first 250 samples o
 train_data, and next 250 samples as test_data. So let's prepare them first.
 @code{.py}
 import numpy as np
-import cv2
+import cv2 as cv
 from matplotlib import pyplot as plt
 
-img = cv2.imread('digits.png')
-gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
+img = cv.imread('digits.png')
+gray = cv.cvtColor(img,cv.COLOR_BGR2GRAY)
 
 # Now we split the image to 5000 cells, each 20x20 size
 cells = [np.hsplit(row,100) for row in np.vsplit(gray,50)]
@@ -42,8 +42,8 @@ train_labels = np.repeat(k,250)[:,np.newaxis]
 test_labels = train_labels.copy()
 
 # Initiate kNN, train the data, then test it with test data for k=1
-knn = cv2.ml.KNearest_create()
-knn.train(train, cv2.ml.ROW_SAMPLE, train_labels)
+knn = cv.ml.KNearest_create()
+knn.train(train, cv.ml.ROW_SAMPLE, train_labels)
 ret,result,neighbours,dist = knn.findNearest(test,k=5)
 
 # Now we check the accuracy of classification
@@ -87,7 +87,7 @@ There are 20000 samples available, so we take first 10000 data as training sampl
 10000 as test samples. We should change the alphabets to ascii characters because we can't work with
 alphabets directly.
 @code{.py}
-import cv2
+import cv2 as cv
 import numpy as np
 import matplotlib.pyplot as plt
 
@@ -103,8 +103,8 @@ responses, trainData = np.hsplit(train,[1])
 labels, testData = np.hsplit(test,[1])
 
 # Initiate the kNN, classify, measure accuracy.
-knn = cv2.ml.KNearest_create()
-knn.train(trainData, cv2.ml.ROW_SAMPLE, responses)
+knn = cv.ml.KNearest_create()
+knn.train(trainData, cv.ml.ROW_SAMPLE, responses)
 ret, result, neighbours, dist = knn.findNearest(testData, k=5)
 
 correct = np.count_nonzero(result == labels)

doc/py_tutorials/py_ml/py_knn/py_knn_understanding/py_knn_understanding.markdown

@@ -73,7 +73,7 @@ We do all these with the help of Random Number Generator in Numpy.
 Then we plot it with the help of Matplotlib. Red families are shown as Red Triangles and Blue
 families are shown as Blue Squares.
 @code{.py}
-import cv2
+import cv2 as cv
 import numpy as np
 import matplotlib.pyplot as plt
 
@@ -114,8 +114,8 @@ So let's see how it works. New comer is marked in green color.
 newcomer = np.random.randint(0,100,(1,2)).astype(np.float32)
 plt.scatter(newcomer[:,0],newcomer[:,1],80,'g','o')
 
-knn = cv2.ml.KNearest_create()
-knn.train(trainData, cv2.ml.ROW_SAMPLE, responses)
+knn = cv.ml.KNearest_create()
+knn.train(trainData, cv.ml.ROW_SAMPLE, responses)
 ret, results, neighbours ,dist = knn.findNearest(newcomer, 3)
 
 print( "result:  {}\n".format(results) )