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

2026-07-30 15:53:03 +04:00 · 2017-12-11 12:55:03 +03:00
parent 9665dde678
commit 5560db73bf
162 changed files with 2083 additions and 2084 deletions
@@ -16,17 +16,17 @@ Image moments help you to calculate some features like center of mass of the obj
 object etc. Check out the wikipedia page on [Image
 Moments](http://en.wikipedia.org/wiki/Image_moment)

-The function **cv2.moments()** gives a dictionary of all moment values calculated. See below:
+The function **cv.moments()** gives a dictionary of all moment values calculated. See below:
@code{.py}
-import cv2
 import numpy as np
+import cv2 as cv

-img = cv2.imread('star.jpg',0)
-ret,thresh = cv2.threshold(img,127,255,0)
-im2,contours,hierarchy = cv2.findContours(thresh, 1, 2)
+img = cv.imread('star.jpg',0)
+ret,thresh = cv.threshold(img,127,255,0)
+im2,contours,hierarchy = cv.findContours(thresh, 1, 2)

 cnt = contours[0]
-M = cv2.moments(cnt)
+M = cv.moments(cnt)
 print( M )
@endcode
 From this moments, you can extract useful data like area, centroid etc. Centroid is given by the
@@ -40,18 +40,18 @@ cy = int(M['m01']/M['m00'])
 2. Contour Area
 ---------------

-Contour area is given by the function **cv2.contourArea()** or from moments, **M['m00']**.
+Contour area is given by the function **cv.contourArea()** or from moments, **M['m00']**.
@code{.py}
-area = cv2.contourArea(cnt)
+area = cv.contourArea(cnt)
@endcode

 3. Contour Perimeter
 --------------------

-It is also called arc length. It can be found out using **cv2.arcLength()** function. Second
+It is also called arc length. It can be found out using **cv.arcLength()** function. Second
 argument specify whether shape is a closed contour (if passed True), or just a curve.
@code{.py}
-perimeter = cv2.arcLength(cnt,True)
+perimeter = cv.arcLength(cnt,True)
@endcode

 4. Contour Approximation
@@ -68,8 +68,8 @@ you can use this function to approximate the shape. In this, second argument is
 which is maximum distance from contour to approximated contour. It is an accuracy parameter. A wise
 selection of epsilon is needed to get the correct output.
@code{.py}
-epsilon = 0.1*cv2.arcLength(cnt,True)
-approx = cv2.approxPolyDP(cnt,epsilon,True)
+epsilon = 0.1*cv.arcLength(cnt,True)
+approx = cv.approxPolyDP(cnt,epsilon,True)
@endcode
 Below, in second image, green line shows the approximated curve for epsilon = 10% of arc length.
 Third image shows the same for epsilon = 1% of the arc length. Third argument specifies whether
@@ -81,7 +81,7 @@ curve is closed or not.
 --------------

 Convex Hull will look similar to contour approximation, but it is not (Both may provide same results
-in some cases). Here, **cv2.convexHull()** function checks a curve for convexity defects and
+in some cases). Here, **cv.convexHull()** function checks a curve for convexity defects and
 corrects it. Generally speaking, convex curves are the curves which are always bulged out, or
 at-least flat. And if it is bulged inside, it is called convexity defects. For example, check the
 below image of hand. Red line shows the convex hull of hand. The double-sided arrow marks shows the
@@ -91,7 +91,7 @@ convexity defects, which are the local maximum deviations of hull from contours.

 There is a little bit things to discuss about it its syntax:
@code{.py}
-hull = cv2.convexHull(points[, hull[, clockwise[, returnPoints]]
+hull = cv.convexHull(points[, hull[, clockwise[, returnPoints]]
@endcode
 Arguments details:

@@ -104,7 +104,7 @@ Arguments details:

 So to get a convex hull as in above image, following is sufficient:
@code{.py}
-hull = cv2.convexHull(cnt)
+hull = cv.convexHull(cnt)
@endcode
 But if you want to find convexity defects, you need to pass returnPoints = False. To understand it,
 we will take the rectangle image above. First I found its contour as cnt. Now I found its convex
@@ -119,10 +119,10 @@ You will see it again when we discuss about convexity defects.
 6. Checking Convexity
 ---------------------

-There is a function to check if a curve is convex or not, **cv2.isContourConvex()**. It just return
+There is a function to check if a curve is convex or not, **cv.isContourConvex()**. It just return
 whether True or False. Not a big deal.
@code{.py}
-k = cv2.isContourConvex(cnt)
+k = cv.isContourConvex(cnt)
@endcode

 7. Bounding Rectangle
@@ -133,25 +133,25 @@ There are two types of bounding rectangles.
 ### 7.a. Straight Bounding Rectangle

 It is a straight rectangle, it doesn't consider the rotation of the object. So area of the bounding
-rectangle won't be minimum. It is found by the function **cv2.boundingRect()**.
+rectangle won't be minimum. It is found by the function **cv.boundingRect()**.

 Let (x,y) be the top-left coordinate of the rectangle and (w,h) be its width and height.
@code{.py}
-x,y,w,h = cv2.boundingRect(cnt)
-cv2.rectangle(img,(x,y),(x+w,y+h),(0,255,0),2)
+x,y,w,h = cv.boundingRect(cnt)
+cv.rectangle(img,(x,y),(x+w,y+h),(0,255,0),2)
@endcode

 ### 7.b. Rotated Rectangle

 Here, bounding rectangle is drawn with minimum area, so it considers the rotation also. The function
-used is **cv2.minAreaRect()**. It returns a Box2D structure which contains following detals - (
+used is **cv.minAreaRect()**. It returns a Box2D structure which contains following detals - (
 center (x,y), (width, height), angle of rotation ). But to draw this rectangle, we need 4 corners of
-the rectangle. It is obtained by the function **cv2.boxPoints()**
+the rectangle. It is obtained by the function **cv.boxPoints()**
@code{.py}
-rect = cv2.minAreaRect(cnt)
-box = cv2.boxPoints(rect)
+rect = cv.minAreaRect(cnt)
+box = cv.boxPoints(rect)
 box = np.int0(box)
-cv2.drawContours(img,[box],0,(0,0,255),2)
+cv.drawContours(img,[box],0,(0,0,255),2)
@endcode
 Both the rectangles are shown in a single image. Green rectangle shows the normal bounding rect. Red
 rectangle is the rotated rect.
@@ -161,13 +161,13 @@ rectangle is the rotated rect.
 8. Minimum Enclosing Circle
 ---------------------------

-Next we find the circumcircle of an object using the function **cv2.minEnclosingCircle()**. It is a
+Next we find the circumcircle of an object using the function **cv.minEnclosingCircle()**. It is a
 circle which completely covers the object with minimum area.
@code{.py}
-(x,y),radius = cv2.minEnclosingCircle(cnt)
+(x,y),radius = cv.minEnclosingCircle(cnt)
 center = (int(x),int(y))
 radius = int(radius)
-cv2.circle(img,center,radius,(0,255,0),2)
+cv.circle(img,center,radius,(0,255,0),2)
@endcode
 ![image](images/circumcircle.png)

@@ -177,8 +177,8 @@ cv2.circle(img,center,radius,(0,255,0),2)
 Next one is to fit an ellipse to an object. It returns the rotated rectangle in which the ellipse is
 inscribed.
@code{.py}
-ellipse = cv2.fitEllipse(cnt)
-cv2.ellipse(img,ellipse,(0,255,0),2)
+ellipse = cv.fitEllipse(cnt)
+cv.ellipse(img,ellipse,(0,255,0),2)
@endcode
 ![image](images/fitellipse.png)

@@ -189,10 +189,10 @@ Similarly we can fit a line to a set of points. Below image contains a set of wh
 approximate a straight line to it.
@code{.py}
 rows,cols = img.shape[:2]
-[vx,vy,x,y] = cv2.fitLine(cnt, cv2.DIST_L2,0,0.01,0.01)
+[vx,vy,x,y] = cv.fitLine(cnt, cv.DIST_L2,0,0.01,0.01)
 lefty = int((-x*vy/vx) + y)
 righty = int(((cols-x)*vy/vx)+y)
-cv2.line(img,(cols-1,righty),(0,lefty),(0,255,0),2)
+cv.line(img,(cols-1,righty),(0,lefty),(0,255,0),2)
@endcode
 ![image](images/fitline.jpg)

@@ -15,7 +15,7 @@ It is the ratio of width to height of bounding rect of the object.

 \f[Aspect \; Ratio = \frac{Width}{Height}\f]
@code{.py}
-x,y,w,h = cv2.boundingRect(cnt)
+x,y,w,h = cv.boundingRect(cnt)
 aspect_ratio = float(w)/h
@endcode

@@ -26,8 +26,8 @@ Extent is the ratio of contour area to bounding rectangle area.

 \f[Extent = \frac{Object \; Area}{Bounding \; Rectangle \; Area}\f]
@code{.py}
-area = cv2.contourArea(cnt)
-x,y,w,h = cv2.boundingRect(cnt)
+area = cv.contourArea(cnt)
+x,y,w,h = cv.boundingRect(cnt)
 rect_area = w*h
 extent = float(area)/rect_area
@endcode
@@ -39,9 +39,9 @@ Solidity is the ratio of contour area to its convex hull area.

 \f[Solidity = \frac{Contour \; Area}{Convex \; Hull \; Area}\f]
@code{.py}
-area = cv2.contourArea(cnt)
-hull = cv2.convexHull(cnt)
-hull_area = cv2.contourArea(hull)
+area = cv.contourArea(cnt)
+hull = cv.convexHull(cnt)
+hull_area = cv.contourArea(hull)
 solidity = float(area)/hull_area
@endcode

@@ -52,7 +52,7 @@ Equivalent Diameter is the diameter of the circle whose area is same as the cont

 \f[Equivalent \; Diameter = \sqrt{\frac{4 \times Contour \; Area}{\pi}}\f]
@code{.py}
-area = cv2.contourArea(cnt)
+area = cv.contourArea(cnt)
 equi_diameter = np.sqrt(4*area/np.pi)
@endcode

@@ -62,7 +62,7 @@ equi_diameter = np.sqrt(4*area/np.pi)
 Orientation is the angle at which object is directed. Following method also gives the Major Axis and
 Minor Axis lengths.
@code{.py}
-(x,y),(MA,ma),angle = cv2.fitEllipse(cnt)
+(x,y),(MA,ma),angle = cv.fitEllipse(cnt)
@endcode

 6. Mask and Pixel Points
@@ -71,9 +71,9 @@ Minor Axis lengths.
 In some cases, we may need all the points which comprises that object. It can be done as follows:
@code{.py}
 mask = np.zeros(imgray.shape,np.uint8)
-cv2.drawContours(mask,[cnt],0,255,-1)
+cv.drawContours(mask,[cnt],0,255,-1)
 pixelpoints = np.transpose(np.nonzero(mask))
-#pixelpoints = cv2.findNonZero(mask)
+#pixelpoints = cv.findNonZero(mask)
@endcode
 Here, two methods, one using Numpy functions, next one using OpenCV function (last commented line)
 are given to do the same. Results are also same, but with a slight difference. Numpy gives
@@ -85,7 +85,7 @@ basically the answers will be interchanged. Note that, **row = x** and **column

 We can find these parameters using a mask image.
@code{.py}
-min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(imgray,mask = mask)
+min_val, max_val, min_loc, max_loc = cv.minMaxLoc(imgray,mask = mask)
@endcode

 8. Mean Color or Mean Intensity
@@ -94,7 +94,7 @@ min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(imgray,mask = mask)
 Here, we can find the average color of an object. Or it can be average intensity of the object in
 grayscale mode. We again use the same mask to do it.
@code{.py}
-mean_val = cv2.mean(im,mask = mask)
+mean_val = cv.mean(im,mask = mask)
@endcode

 9. Extreme Points
@@ -6,7 +6,7 @@ Goal

 -   Understand what contours are.
 -   Learn to find contours, draw contours etc
-   You will see these functions : **cv2.findContours()**, **cv2.drawContours()**
+-   You will see these functions : **cv.findContours()**, **cv.drawContours()**

 What are contours?
 ------------------
@@ -24,14 +24,14 @@ detection and recognition.
 Let's see how to find contours of a binary image:
@code{.py}
 import numpy as np
-import cv2
+import cv2 as cv

-im = cv2.imread('test.jpg')
-imgray = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)
-ret, thresh = cv2.threshold(imgray, 127, 255, 0)
-im2, contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
+im = cv.imread('test.jpg')
+imgray = cv.cvtColor(im, cv.COLOR_BGR2GRAY)
+ret, thresh = cv.threshold(imgray, 127, 255, 0)
+im2, contours, hierarchy = cv.findContours(thresh, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
@endcode
-See, there are three arguments in **cv2.findContours()** function, first one is source image, second
+See, there are three arguments in **cv.findContours()** function, first one is source image, second
 is contour retrieval mode, third is contour approximation method. And it outputs a modified image, the contours and
 hierarchy. contours is a Python list of all the contours in the image. Each individual contour is a
 Numpy array of (x,y) coordinates of boundary points of the object.
@@ -42,7 +42,7 @@ the values given to them in code sample will work fine for all images.
 How to draw the contours?
 -------------------------

-To draw the contours, cv2.drawContours function is used. It can also be used to draw any shape
+To draw the contours, cv.drawContours function is used. It can also be used to draw any shape
 provided you have its boundary points. Its first argument is source image, second argument is the
 contours which should be passed as a Python list, third argument is index of contours (useful when
 drawing individual contour. To draw all contours, pass -1) and remaining arguments are color,
@@ -50,16 +50,16 @@ thickness etc.

 * To draw all the contours in an image:
@code{.py}
-cv2.drawContours(img, contours, -1, (0,255,0), 3)
+cv.drawContours(img, contours, -1, (0,255,0), 3)
@endcode
 * To draw an individual contour, say 4th contour:
@code{.py}
-cv2.drawContours(img, contours, 3, (0,255,0), 3)
+cv.drawContours(img, contours, 3, (0,255,0), 3)
@endcode
 * But most of the time, below method will be useful:
@code{.py}
 cnt = contours[4]
-cv2.drawContours(img, [cnt], 0, (0,255,0), 3)
+cv.drawContours(img, [cnt], 0, (0,255,0), 3)
@endcode

@note Last two methods are same, but when you go forward, you will see last one is more useful.
@@ -67,21 +67,21 @@ cv2.drawContours(img, [cnt], 0, (0,255,0), 3)
 Contour Approximation Method
 ============================

-This is the third argument in cv2.findContours function. What does it denote actually?
+This is the third argument in cv.findContours function. What does it denote actually?

 Above, we told that contours are the boundaries of a shape with same intensity. It stores the (x,y)
 coordinates of the boundary of a shape. But does it store all the coordinates ? That is specified by
 this contour approximation method.

-If you pass cv2.CHAIN_APPROX_NONE, all the boundary points are stored. But actually do we need all
+If you pass cv.CHAIN_APPROX_NONE, all the boundary points are stored. But actually do we need all
 the points? For eg, you found the contour of a straight line. Do you need all the points on the line
 to represent that line? No, we need just two end points of that line. This is what
-cv2.CHAIN_APPROX_SIMPLE does. It removes all redundant points and compresses the contour, thereby
+cv.CHAIN_APPROX_SIMPLE does. It removes all redundant points and compresses the contour, thereby
 saving memory.

 Below image of a rectangle demonstrate this technique. Just draw a circle on all the coordinates in
-the contour array (drawn in blue color). First image shows points I got with cv2.CHAIN_APPROX_NONE
-(734 points) and second image shows the one with cv2.CHAIN_APPROX_SIMPLE (only 4 points). See, how
+the contour array (drawn in blue color). First image shows points I got with cv.CHAIN_APPROX_NONE
+(734 points) and second image shows the one with cv.CHAIN_APPROX_SIMPLE (only 4 points). See, how
 much memory it saves!!!

 ![image](images/none.jpg)
@@ -10,9 +10,9 @@ Theory
 ------

 In the last few articles on contours, we have worked with several functions related to contours
-provided by OpenCV. But when we found the contours in image using **cv2.findContours()** function,
-we have passed an argument, **Contour Retrieval Mode**. We usually passed **cv2.RETR_LIST** or
-**cv2.RETR_TREE** and it worked nice. But what does it actually mean ?
+provided by OpenCV. But when we found the contours in image using **cv.findContours()** function,
+we have passed an argument, **Contour Retrieval Mode**. We usually passed **cv.RETR_LIST** or
+**cv.RETR_TREE** and it worked nice. But what does it actually mean ?

 Also, in the output, we got three arrays, first is the image, second is our contours, and one more
 output which we named as **hierarchy** (Please checkout the codes in previous articles). But we
@@ -23,7 +23,7 @@ That is what we are going to deal in this article.

 ### What is Hierarchy?

-Normally we use the **cv2.findContours()** function to detect objects in an image, right ? Sometimes
+Normally we use the **cv.findContours()** function to detect objects in an image, right ? Sometimes
 objects are in different locations. But in some cases, some shapes are inside other shapes. Just
 like nested figures. In this case, we call outer one as **parent** and inner one as **child**. This
 way, contours in an image has some relationship to each other. And we can specify how one contour is
@@ -82,8 +82,8 @@ contour-3a. For contour-3a, it is contour-3 and so on.
@note If there is no child or parent, that field is taken as -1

 So now we know about the hierarchy style used in OpenCV, we can check into Contour Retrieval Modes
-in OpenCV with the help of same image given above. ie what do flags like cv2.RETR_LIST,
-cv2.RETR_TREE, cv2.RETR_CCOMP, cv2.RETR_EXTERNAL etc mean?
+in OpenCV with the help of same image given above. ie what do flags like cv.RETR_LIST,
+cv.RETR_TREE, cv.RETR_CCOMP, cv.RETR_EXTERNAL etc mean?

 Contour Retrieval Mode
 ----------------------
@@ -185,7 +185,7 @@ array([[[ 3, -1,  1, -1],
 And this is the final guy, Mr.Perfect. It retrieves all the contours and creates a full family
 hierarchy list. **It even tells, who is the grandpa, father, son, grandson and even beyond... :)**.

-For examle, I took above image, rewrite the code for cv2.RETR_TREE, reorder the contours as per the
+For examle, I took above image, rewrite the code for cv.RETR_TREE, reorder the contours as per the
 result given by OpenCV and analyze it. Again, red letters give the contour number and green letters
 give the hierarchy order.

@@ -17,11 +17,11 @@ Theory and Code
 We saw what is convex hull in second chapter about contours. Any deviation of the object from this
 hull can be considered as convexity defect.

-OpenCV comes with a ready-made function to find this, **cv2.convexityDefects()**. A basic function
+OpenCV comes with a ready-made function to find this, **cv.convexityDefects()**. A basic function
 call would look like below:
@code{.py}
-hull = cv2.convexHull(cnt,returnPoints = False)
-defects = cv2.convexityDefects(cnt,hull)
+hull = cv.convexHull(cnt,returnPoints = False)
+defects = cv.convexityDefects(cnt,hull)
@endcode

@note Remember we have to pass returnPoints = False while finding convex hull, in order to find
@@ -33,29 +33,29 @@ line joining start point and end point, then draw a circle at the farthest point
 three values returned are indices of cnt. So we have to bring those values from cnt.

@code{.py}
-import cv2
+import cv2 as cv
 import numpy as np

-img = cv2.imread('star.jpg')
-img_gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
-ret,thresh = cv2.threshold(img_gray, 127, 255,0)
-im2,contours,hierarchy = cv2.findContours(thresh,2,1)
+img = cv.imread('star.jpg')
+img_gray = cv.cvtColor(img,cv.COLOR_BGR2GRAY)
+ret,thresh = cv.threshold(img_gray, 127, 255,0)
+im2,contours,hierarchy = cv.findContours(thresh,2,1)
 cnt = contours[0]

-hull = cv2.convexHull(cnt,returnPoints = False)
-defects = cv2.convexityDefects(cnt,hull)
+hull = cv.convexHull(cnt,returnPoints = False)
+defects = cv.convexityDefects(cnt,hull)

 for i in range(defects.shape[0]):
    s,e,f,d = defects[i,0]
    start = tuple(cnt[s][0])
    end = tuple(cnt[e][0])
    far = tuple(cnt[f][0])
-    cv2.line(img,start,end,[0,255,0],2)
-    cv2.circle(img,far,5,[0,0,255],-1)
+    cv.line(img,start,end,[0,255,0],2)
+    cv.circle(img,far,5,[0,0,255],-1)

-cv2.imshow('img',img)
-cv2.waitKey(0)
-cv2.destroyAllWindows()
+cv.imshow('img',img)
+cv.waitKey(0)
+cv.destroyAllWindows()
@endcode
 And see the result:

@@ -69,7 +69,7 @@ if point is on the contour.

 For example, we can check the point (50,50) as follows:
@code{.py}
-dist = cv2.pointPolygonTest(cnt,(50,50),True)
+dist = cv.pointPolygonTest(cnt,(50,50),True)
@endcode
 In the function, third argument is measureDist. If it is True, it finds the signed distance. If
 False, it finds whether the point is inside or outside or on the contour (it returns +1, -1, 0
@@ -80,25 +80,25 @@ time consuming process. So, making it False gives about 2-3X speedup.

 ### 3. Match Shapes

-OpenCV comes with a function **cv2.matchShapes()** which enables us to compare two shapes, or two
+OpenCV comes with a function **cv.matchShapes()** which enables us to compare two shapes, or two
 contours and returns a metric showing the similarity. The lower the result, the better match it is.
 It is calculated based on the hu-moment values. Different measurement methods are explained in the
 docs.
@code{.py}
-import cv2
+import cv2 as cv
 import numpy as np

-img1 = cv2.imread('star.jpg',0)
-img2 = cv2.imread('star2.jpg',0)
+img1 = cv.imread('star.jpg',0)
+img2 = cv.imread('star2.jpg',0)

-ret, thresh = cv2.threshold(img1, 127, 255,0)
-ret, thresh2 = cv2.threshold(img2, 127, 255,0)
-im2,contours,hierarchy = cv2.findContours(thresh,2,1)
+ret, thresh = cv.threshold(img1, 127, 255,0)
+ret, thresh2 = cv.threshold(img2, 127, 255,0)
+im2,contours,hierarchy = cv.findContours(thresh,2,1)
 cnt1 = contours[0]
-im2,contours,hierarchy = cv2.findContours(thresh2,2,1)
+im2,contours,hierarchy = cv.findContours(thresh2,2,1)
 cnt2 = contours[0]

-ret = cv2.matchShapes(cnt1,cnt2,1,0.0)
+ret = cv.matchShapes(cnt1,cnt2,1,0.0)
 print( ret )
@endcode
 I tried matching shapes with different shapes given below:
@@ -115,7 +115,7 @@ See, even image rotation doesn't affect much on this comparison.

@sa [Hu-Moments](http://en.wikipedia.org/wiki/Image_moment#Rotation_invariant_moments) are seven
 moments invariant to translation, rotation and scale. Seventh one is skew-invariant. Those values
-can be found using **cv2.HuMoments()** function.
+can be found using **cv.HuMoments()** function.

 Additional Resources
 ====================
@@ -123,10 +123,10 @@ Additional Resources
 Exercises
 ---------

-#  Check the documentation for **cv2.pointPolygonTest()**, you can find a nice image in Red and
+-#  Check the documentation for **cv.pointPolygonTest()**, you can find a nice image in Red and
    Blue color. It represents the distance from all pixels to the white curve on it. All pixels
    inside curve is blue depending on the distance. Similarly outside points are red. Contour edges
    are marked with White. So problem is simple. Write a code to create such a representation of
    distance.
-#  Compare images of digits or letters using **cv2.matchShapes()**. ( That would be a simple step
+-#  Compare images of digits or letters using **cv.matchShapes()**. ( That would be a simple step
    towards OCR )