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

2026-07-29 23:33:05 +04:00 · 2017-12-11 12:55:03 +03:00
parent 9665dde678
commit 5560db73bf
162 changed files with 2083 additions and 2084 deletions
@@ -23,7 +23,7 @@ will be useful in understanding further topics like Histogram Back-Projection.
 2D Histogram in OpenCV
 ----------------------

-It is quite simple and calculated using the same function, **cv2.calcHist()**. For color histograms,
+It is quite simple and calculated using the same function, **cv.calcHist()**. For color histograms,
 we need to convert the image from BGR to HSV. (Remember, for 1D histogram, we converted from BGR to
 Grayscale). For 2D histograms, its parameters will be modified as follows:

@@ -34,13 +34,13 @@ Grayscale). For 2D histograms, its parameters will be modified as follows:

 Now check the code below:
@code{.py}
-import cv2
 import numpy as np
+import cv2 as cv

-img = cv2.imread('home.jpg')
-hsv = cv2.cvtColor(img,cv2.COLOR_BGR2HSV)
+img = cv.imread('home.jpg')
+hsv = cv.cvtColor(img,cv.COLOR_BGR2HSV)

-hist = cv2.calcHist([hsv], [0, 1], None, [180, 256], [0, 180, 0, 256])
+hist = cv.calcHist([hsv], [0, 1], None, [180, 256], [0, 180, 0, 256])
@endcode
 That's it.

@@ -50,12 +50,12 @@ That's it.
 Numpy also provides a specific function for this : **np.histogram2d()**. (Remember, for 1D histogram
 we used **np.histogram()** ).
@code{.py}
-import cv2
 import numpy as np
+import cv2 as cv
 from matplotlib import pyplot as plt

-img = cv2.imread('home.jpg')
-hsv = cv2.cvtColor(img,cv2.COLOR_BGR2HSV)
+img = cv.imread('home.jpg')
+hsv = cv.cvtColor(img,cv.COLOR_BGR2HSV)

 hist, xbins, ybins = np.histogram2d(h.ravel(),s.ravel(),[180,256],[[0,180],[0,256]])
@endcode
@@ -67,10 +67,10 @@ Now we can check how to plot this color histogram.
 Plotting 2D Histograms
 ----------------------

-### Method - 1 : Using cv2.imshow()
+### Method - 1 : Using cv.imshow()

 The result we get is a two dimensional array of size 180x256. So we can show them as we do normally,
-using cv2.imshow() function. It will be a grayscale image and it won't give much idea what colors
+using cv.imshow() function. It will be a grayscale image and it won't give much idea what colors
 are there, unless you know the Hue values of different colors.

 ### Method - 2 : Using Matplotlib
@@ -84,13 +84,13 @@ I prefer this method. It is simple and better.

 Consider code:
@code{.py}
-import cv2
 import numpy as np
+import cv2 as cv
 from matplotlib import pyplot as plt

-img = cv2.imread('home.jpg')
-hsv = cv2.cvtColor(img,cv2.COLOR_BGR2HSV)
-hist = cv2.calcHist( [hsv], [0, 1], None, [180, 256], [0, 180, 0, 256] )
+img = cv.imread('home.jpg')
+hsv = cv.cvtColor(img,cv.COLOR_BGR2HSV)
+hist = cv.calcHist( [hsv], [0, 1], None, [180, 256], [0, 180, 0, 256] )

 plt.imshow(hist,interpolation = 'nearest')
 plt.show()
@@ -33,82 +33,81 @@ Algorithm in Numpy
 -#  First we need to calculate the color histogram of both the object we need to find (let it be
    'M') and the image where we are going to search (let it be 'I').
@code{.py}
-import cv2
 import numpy as np
-from matplotlib import pyplot as plt
+import cv2 as cvfrom matplotlib import pyplot as plt

 #roi is the object or region of object we need to find
-roi = cv2.imread('rose_red.png')
-hsv = cv2.cvtColor(roi,cv2.COLOR_BGR2HSV)
+roi = cv.imread('rose_red.png')
+hsv = cv.cvtColor(roi,cv.COLOR_BGR2HSV)

 #target is the image we search in
-target = cv2.imread('rose.png')
-hsvt = cv2.cvtColor(target,cv2.COLOR_BGR2HSV)
+target = cv.imread('rose.png')
+hsvt = cv.cvtColor(target,cv.COLOR_BGR2HSV)

 # Find the histograms using calcHist. Can be done with np.histogram2d also
-M = cv2.calcHist([hsv],[0, 1], None, [180, 256], [0, 180, 0, 256] )
-I = cv2.calcHist([hsvt],[0, 1], None, [180, 256], [0, 180, 0, 256] )
+M = cv.calcHist([hsv],[0, 1], None, [180, 256], [0, 180, 0, 256] )
+I = cv.calcHist([hsvt],[0, 1], None, [180, 256], [0, 180, 0, 256] )
@endcode
 2.  Find the ratio \f$R = \frac{M}{I}\f$. Then backproject R, ie use R as palette and create a new image
    with every pixel as its corresponding probability of being target. ie B(x,y) = R[h(x,y),s(x,y)]
    where h is hue and s is saturation of the pixel at (x,y). After that apply the condition
    \f$B(x,y) = min[B(x,y), 1]\f$.
@code{.py}
-h,s,v = cv2.split(hsvt)
+h,s,v = cv.split(hsvt)
 B = R[h.ravel(),s.ravel()]
 B = np.minimum(B,1)
 B = B.reshape(hsvt.shape[:2])
@endcode
 3.  Now apply a convolution with a circular disc, \f$B = D \ast B\f$, where D is the disc kernel.
@code{.py}
-disc = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(5,5))
-cv2.filter2D(B,-1,disc,B)
+disc = cv.getStructuringElement(cv.MORPH_ELLIPSE,(5,5))
+cv.filter2D(B,-1,disc,B)
 B = np.uint8(B)
-cv2.normalize(B,B,0,255,cv2.NORM_MINMAX)
+cv.normalize(B,B,0,255,cv.NORM_MINMAX)
@endcode
 4.  Now the location of maximum intensity gives us the location of object. If we are expecting a
    region in the image, thresholding for a suitable value gives a nice result.
@code{.py}
-ret,thresh = cv2.threshold(B,50,255,0)
+ret,thresh = cv.threshold(B,50,255,0)
@endcode
 That's it !!

 Backprojection in OpenCV
 ------------------------

-OpenCV provides an inbuilt function **cv2.calcBackProject()**. Its parameters are almost same as the
-**cv2.calcHist()** function. One of its parameter is histogram which is histogram of the object and
+OpenCV provides an inbuilt function **cv.calcBackProject()**. Its parameters are almost same as the
+**cv.calcHist()** function. One of its parameter is histogram which is histogram of the object and
 we have to find it. Also, the object histogram should be normalized before passing on to the
 backproject function. It returns the probability image. Then we convolve the image with a disc
 kernel and apply threshold. Below is my code and output :
@code{.py}
-import cv2
 import numpy as np
+import cv2 as cv

-roi = cv2.imread('rose_red.png')
-hsv = cv2.cvtColor(roi,cv2.COLOR_BGR2HSV)
+roi = cv.imread('rose_red.png')
+hsv = cv.cvtColor(roi,cv.COLOR_BGR2HSV)

-target = cv2.imread('rose.png')
-hsvt = cv2.cvtColor(target,cv2.COLOR_BGR2HSV)
+target = cv.imread('rose.png')
+hsvt = cv.cvtColor(target,cv.COLOR_BGR2HSV)

 # calculating object histogram
-roihist = cv2.calcHist([hsv],[0, 1], None, [180, 256], [0, 180, 0, 256] )
+roihist = cv.calcHist([hsv],[0, 1], None, [180, 256], [0, 180, 0, 256] )

 # normalize histogram and apply backprojection
-cv2.normalize(roihist,roihist,0,255,cv2.NORM_MINMAX)
-dst = cv2.calcBackProject([hsvt],[0,1],roihist,[0,180,0,256],1)
+cv.normalize(roihist,roihist,0,255,cv.NORM_MINMAX)
+dst = cv.calcBackProject([hsvt],[0,1],roihist,[0,180,0,256],1)

 # Now convolute with circular disc
-disc = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(5,5))
-cv2.filter2D(dst,-1,disc,dst)
+disc = cv.getStructuringElement(cv.MORPH_ELLIPSE,(5,5))
+cv.filter2D(dst,-1,disc,dst)

 # threshold and binary AND
-ret,thresh = cv2.threshold(dst,50,255,0)
-thresh = cv2.merge((thresh,thresh,thresh))
-res = cv2.bitwise_and(target,thresh)
+ret,thresh = cv.threshold(dst,50,255,0)
+thresh = cv.merge((thresh,thresh,thresh))
+res = cv.bitwise_and(target,thresh)

 res = np.vstack((target,thresh,res))
-cv2.imwrite('res.jpg',res)
+cv.imwrite('res.jpg',res)
@endcode
 Below is one example I worked with. I used the region inside blue rectangle as sample object and I
 wanted to extract the full ground.
@@ -7,7 +7,7 @@ Goal
 Learn to
    -   Find histograms, using both OpenCV and Numpy functions
    -   Plot histograms, using OpenCV and Matplotlib functions
-    -   You will see these functions : **cv2.calcHist()**, **np.histogram()** etc.
+    -   You will see these functions : **cv.calcHist()**, **np.histogram()** etc.

 Theory
 ------
@@ -57,10 +57,10 @@ intensity values.

 ### 1. Histogram Calculation in OpenCV

-So now we use **cv2.calcHist()** function to find the histogram. Let's familiarize with the function
+So now we use **cv.calcHist()** function to find the histogram. Let's familiarize with the function
 and its parameters :

-<center><em>cv2.calcHist(images, channels, mask, histSize, ranges[, hist[, accumulate]])</em></center>
+<center><em>cv.calcHist(images, channels, mask, histSize, ranges[, hist[, accumulate]])</em></center>

 -#  images : it is the source image of type uint8 or float32. it should be given in square brackets,
    ie, "[img]".
@@ -78,8 +78,8 @@ and its parameters :
 So let's start with a sample image. Simply load an image in grayscale mode and find its full
 histogram.
@code{.py}
-img = cv2.imread('home.jpg',0)
-hist = cv2.calcHist([img],[0],None,[256],[0,256])
+img = cv.imread('home.jpg',0)
+hist = cv.calcHist([img],[0],None,[256],[0,256])
@endcode
 hist is a 256x1 array, each value corresponds to number of pixels in that image with its
 corresponding pixel value.
@@ -118,11 +118,11 @@ Matplotlib comes with a histogram plotting function : matplotlib.pyplot.hist()
 It directly finds the histogram and plot it. You need not use calcHist() or np.histogram() function
 to find the histogram. See the code below:
@code{.py}
-import cv2
 import numpy as np
+import cv2 as cv
 from matplotlib import pyplot as plt

-img = cv2.imread('home.jpg',0)
+img = cv.imread('home.jpg',0)
 plt.hist(img.ravel(),256,[0,256]); plt.show()
@endcode
 You will get a plot as below :
@@ -132,14 +132,14 @@ You will get a plot as below :
 Or you can use normal plot of matplotlib, which would be good for BGR plot. For that, you need to
 find the histogram data first. Try below code:
@code{.py}
-import cv2
 import numpy as np
+import cv2 as cv
 from matplotlib import pyplot as plt

-img = cv2.imread('home.jpg')
+img = cv.imread('home.jpg')
 color = ('b','g','r')
 for i,col in enumerate(color):
-    histr = cv2.calcHist([img],[i],None,[256],[0,256])
+    histr = cv.calcHist([img],[i],None,[256],[0,256])
    plt.plot(histr,color = col)
    plt.xlim([0,256])
 plt.show()
@@ -154,28 +154,28 @@ should be due to the sky)
 ### 2. Using OpenCV

 Well, here you adjust the values of histograms along with its bin values to look like x,y
-coordinates so that you can draw it using cv2.line() or cv2.polyline() function to generate same
+coordinates so that you can draw it using cv.line() or cv.polyline() function to generate same
 image as above. This is already available with OpenCV-Python2 official samples. Check the
 code at samples/python/hist.py.

 Application of Mask
 -------------------

-We used cv2.calcHist() to find the histogram of the full image. What if you want to find histograms
+We used cv.calcHist() to find the histogram of the full image. What if you want to find histograms
 of some regions of an image? Just create a mask image with white color on the region you want to
 find histogram and black otherwise. Then pass this as the mask.
@code{.py}
-img = cv2.imread('home.jpg',0)
+img = cv.imread('home.jpg',0)

 # create a mask
 mask = np.zeros(img.shape[:2], np.uint8)
 mask[100:300, 100:400] = 255
-masked_img = cv2.bitwise_and(img,img,mask = mask)
+masked_img = cv.bitwise_and(img,img,mask = mask)

 # Calculate histogram with mask and without mask
 # Check third argument for mask
-hist_full = cv2.calcHist([img],[0],None,[256],[0,256])
-hist_mask = cv2.calcHist([img],[0],mask,[256],[0,256])
+hist_full = cv.calcHist([img],[0],None,[256],[0,256])
+hist_mask = cv.calcHist([img],[0],mask,[256],[0,256])

 plt.subplot(221), plt.imshow(img, 'gray')
 plt.subplot(222), plt.imshow(mask,'gray')
@@ -26,11 +26,11 @@ a very good explanation with worked out examples, so that you would understand a
 after reading that. Instead, here we will see its Numpy implementation. After that, we will see
 OpenCV function.
@code{.py}
-import cv2
 import numpy as np
+import cv2 as cv
 from matplotlib import pyplot as plt

-img = cv2.imread('wiki.jpg',0)
+img = cv.imread('wiki.jpg',0)

 hist,bins = np.histogram(img.flatten(),256,[0,256])

@@ -76,15 +76,15 @@ histogram equalized to make them all with same lighting conditions.
 Histograms Equalization in OpenCV
 ---------------------------------

-OpenCV has a function to do this, **cv2.equalizeHist()**. Its input is just grayscale image and
+OpenCV has a function to do this, **cv.equalizeHist()**. Its input is just grayscale image and
 output is our histogram equalized image.

 Below is a simple code snippet showing its usage for same image we used :
@code{.py}
-img = cv2.imread('wiki.jpg',0)
-equ = cv2.equalizeHist(img)
+img = cv.imread('wiki.jpg',0)
+equ = cv.equalizeHist(img)
 res = np.hstack((img,equ)) #stacking images side-by-side
-cv2.imwrite('res.png',res)
+cv.imwrite('res.png',res)
@endcode
 ![image](images/equalization_opencv.jpg)

@@ -122,15 +122,15 @@ applied.
 Below code snippet shows how to apply CLAHE in OpenCV:
@code{.py}
 import numpy as np
-import cv2
+import cv2 as cv

-img = cv2.imread('tsukuba_l.png',0)
+img = cv.imread('tsukuba_l.png',0)

 # create a CLAHE object (Arguments are optional).
-clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
+clahe = cv.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
 cl1 = clahe.apply(img)

-cv2.imwrite('clahe_2.jpg',cl1)
+cv.imwrite('clahe_2.jpg',cl1)
@endcode
 See the result below and compare it with results above, especially the statue region: