Change examples to import cv2 as cv

Seems to be more common

Author: sfe-SparkFro

examples/ex01_hello_opencv.py

@@ -1,5 +1,5 @@
 # Import OpenCV, just as you would in any other Python environment!
-import cv2
+import cv2 as cv
 
 # Standard OpenCV leverages the host operating system to access hardware, but we
 # don't have that luxury in MicroPython. Instead, drivers are provided for
@@ -26,30 +26,30 @@
 
 # OpenCV's drawing functions can be used to modify the image as well. For
 # example, we can draw a green ellipse at the center of the image
-img = cv2.ellipse(img, (160, 120), (100, 50), 0, 0, 360, (0, 255, 0), -1)
+img = cv.ellipse(img, (160, 120), (100, 50), 0, 0, 360, (0, 255, 0), -1)
 
 # Note - Most OpenCV functions return the resulting image. It's redundant for
 # the drawing functions and often ignored, but if you call those functions from
 # the REPL without assigning it to a variable, the entire array will be printed.
 # To avoid this, you can simply re-assign the image variable (for example,
-# `img = cv2.function(...)`)
+# `img = cv.function(...)`)
 
 # And the obligatory "Hello OpenCV" text! This time in red
-img = cv2.putText(img, "Hello OpenCV!", (50, 200), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
+img = cv.putText(img, "Hello OpenCV!", (50, 200), cv.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
 
-# Once we have an image ready to show, just call `cv2.imshow()`, almost like any
+# Once we have an image ready to show, just call `cv.imshow()`, almost like any
 # other Python environment! However, there is one important difference:
 # 
-# Standard OpenCV takes a window name string in `cv2.imshow()`, which is used
+# Standard OpenCV takes a window name string in `cv.imshow()`, which is used
 # to display the image in a window. We don't have windows in MicroPython, so
 # there is an API change where the first argument must be a display driver. Any
 # display driver can be used, as long as it implements an `imshow()` method that
 # takes a NumPy array as input
-cv2.imshow(display, img) # Can alternatively call `display.imshow(img)`
+cv.imshow(display, img) # Can alternatively call `display.imshow(img)`
 
-# Standard OpenCV requires a call to `cv2.waitKey()` to process events and
+# Standard OpenCV requires a call to `cv.waitKey()` to process events and
 # actually display the image. However the display driver shows the image
-# immediately, so it's not necessary to call `cv2.waitKey()` in MicroPython.
+# immediately, so it's not necessary to call `cv.waitKey()` in MicroPython.
 # But it is available, and behaves almost like any other Python environment! The
 # only difference is that it requires a key to be pressed in the REPL instead of
 # a window. It will wait for up to the specified number of milliseconds (0 for
@@ -58,7 +58,7 @@
 # Note - Some MicroPython IDEs (like Thonny) don't actually send any key presses
 # until you hit Enter on your keyboard
 print("Press any key to continue")
-key = cv2.waitKey(0) # Not necessary to display image, can remove if desired
+key = cv.waitKey(0) # Not necessary to display image, can remove if desired
 
 # Print the key pressed
 print("Key pressed:", chr(key))

examples/ex02_camera.py

@@ -1,13 +1,13 @@
 # Import OpenCV and hardware initialization module
-import cv2
+import cv2 as cv
 from cv2_hardware_init import *
 
 # Open a camera, similar to any other Python environment! In standard OpenCV,
-# you would use `cv2.VideoCapture(0)` or similar, and OpenCV would leverage the
+# you would use `cv.VideoCapture(0)` or similar, and OpenCV would leverage the
 # host operating system to open a camera object and return it as a
-# `cv2.VideoCapture` object. However, we don't have that luxury in MicroPython,
+# `cv.VideoCapture` object. However, we don't have that luxury in MicroPython,
 # so a camera driver is required instead. Any camera driver can be used, as long
-# as it implements the same methods as the standard OpenCV `cv2.VideoCapture`
+# as it implements the same methods as the standard OpenCV `cv.VideoCapture`
 # class, such as `open()`, `read()`, and `release()`
 camera.open()
 
@@ -27,10 +27,10 @@
         break
 
     # Display the frame
-    cv2.imshow(display, frame)
+    cv.imshow(display, frame)
 
     # Check for key presses
-    key = cv2.waitKey(1)
+    key = cv.waitKey(1)
 
     # If any key is pressed, exit the loop
     if key != -1:

examples/ex03_touch_screen.py

@@ -1,5 +1,5 @@
 # Import OpenCV and hardware initialization module
-import cv2
+import cv2 as cv
 from cv2_hardware_init import *
 
 # Import NumPy
@@ -9,7 +9,7 @@
 img = np.zeros((240, 320, 3), dtype=np.uint8)
 
 # Prompt the user to draw on the screen
-img = cv2.putText(img, "Touch to draw!", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
+img = cv.putText(img, "Touch to draw!", (10, 30), cv.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
 
 # Prompt the user to press a key to continue
 print("Press any key to continue")
@@ -42,13 +42,13 @@
 
     # Draw a line if touching
     if touching:
-        img = cv2.line(img, (x0, y0), (x1, y1), (255, 255, 255), 2)
+        img = cv.line(img, (x0, y0), (x1, y1), (255, 255, 255), 2)
 
     # Display the frame
     display.imshow(img)
 
     # Check for key presses
-    key = cv2.waitKey(1)
+    key = cv.waitKey(1)
 
     # If any key is pressed, exit the loop
     if key != -1:

examples/ex04_imread_imwrite.py

@@ -1,8 +1,8 @@
 # Import OpenCV and hardware initialization module
-import cv2
+import cv2 as cv
 from cv2_hardware_init import *
 
-# Call `cv2.imread()` to read an image from the MicroPython filesystem, just
+# Call `cv.imread()` to read an image from the MicroPython filesystem, just
 # like in any other Python environment! Make sure to copy the image to the
 # MicroPython filesystem first, and set the path to the image file as needed
 # 
@@ -11,35 +11,35 @@
 # 
 # Note - only BMP and PNG formats are currently supported in MicroPython OpenCV
 print("Loading image...")
-img = cv2.imread("test_images/sparkfun_logo.png")
+img = cv.imread("test_images/sparkfun_logo.png")
 
 # Show the image for 1 second
 # 
 # Note - If the image is larger or smaller than the display, the behavior will
 # depend on the display driver. For example, the default ST7789 display driver
 # will crop large images, and show small images in the top-left corner
-cv2.imshow(display, img)
+cv.imshow(display, img)
 
 # Prompt the user to press a key to continue
 print("Press any key to continue")
-key = cv2.waitKey(0)
+key = cv.waitKey(0)
 
-# Let's modify the image! Here we use `cv2.Canny()` to perform edge detection
+# Let's modify the image! Here we use `cv.Canny()` to perform edge detection
 # on the image, which is a common operation in computer vision
 print("Performing edge detection...")
-edges = cv2.Canny(img, 100, 200)
+edges = cv.Canny(img, 100, 200)
 
 # Display the modified image
-cv2.imshow(display, edges)
+cv.imshow(display, edges)
 
 # Now we'll save the modified image to the MicroPython filesystem using
-# `cv2.imwrite()`, just like in any other Python environment!
+# `cv.imwrite()`, just like in any other Python environment!
 # 
 # Again, SD cards are supported, just change the path to point to the SD card
 # 
 # Note - only BMP and PNG formats are currently supported in MicroPython OpenCV
 print("Saving modified image...")
-success = cv2.imwrite("test_images/sparkfun_logo_edges.png", edges)
+success = cv.imwrite("test_images/sparkfun_logo_edges.png", edges)
 
 # Check if the image was saved successfully
 if success:

examples/ex05_detect_sfe_logo.py

@@ -1,5 +1,5 @@
 # Import OpenCV
-import cv2
+import cv2 as cv
 from cv2_hardware_init import *
 from ulab import numpy as np
 import time
@@ -53,19 +53,19 @@
     # method to create a binary image. This means it will only detect a dark
     # logo on a light background (or vice versa), but you can modify this to
     # find specific colors or use other methods if desired
-    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
-    thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)
+    gray = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)
+    thresh = cv.threshold(gray, 0, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)
 
     # Find contours in the binary image, which represent the boundaries of
     # shapes. Contours are a powerful tool in OpenCV for shape analysis and
     # object detection
-    contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
+    contours, hierarchy = cv.findContours(thresh, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
 
     # It's possible that no contours were found, so first check if any were
     # found before proceeding
     if contours:
         # We'll compare the contours found in the image to the reference logo
-        # contour defined earlier. We will use the `cv2.matchShapes()` function
+        # contour defined earlier. We will use the `cv.matchShapes()` function
         # to compare the shapes to pick the best match, so we need to initialize
         # variables to keep track of the best match found so far
         best_contour = None
@@ -74,18 +74,18 @@
         # Loop through each contour found in the image to find the best match
         for i in range(len(contours)):
             # If the image is noisy, the binarized image may contain many tiny
-            # contours that are obviously not the logo. `cv2.matchShapes()` can
+            # contours that are obviously not the logo. `cv.matchShapes()` can
             # take some time, so we can be more efficient by skipping obviously
             # wrong contours. In this example, the logo we're looking for is
             # fairly complex, so we can skip contours that have too few points
             # since they will definitely be too simple to match the logo
             if len(contours[i]) < 20:
                 continue
 
-            # Now we call `cv2.matchShapes()` which returns a "similarity" score
+            # Now we call `cv.matchShapes()` which returns a "similarity" score
             # between the two shapes. The lower the score, the more similar the
             # shapes are
-            similarity = cv2.matchShapes(logo_contour, contours[i], cv2.CONTOURS_MATCH_I2, 0)
+            similarity = cv.matchShapes(logo_contour, contours[i], cv.CONTOURS_MATCH_I2, 0)
 
             # Check if this contour is a better match than the best so far
             if similarity < best_similarity:
@@ -100,23 +100,23 @@
         # higher threshold of 1.0
         if best_similarity < 1.0:
             # Now we'll draw the best contour found on the original image
-            frame = cv2.drawContours(frame, [best_contour], -1, (0, 0, 255), 2)
+            frame = cv.drawContours(frame, [best_contour], -1, (0, 0, 255), 2)
 
     # All processing is done! Calculate the frame rate and display it
     current_time = time.ticks_us()
     fps = 1000000 / (current_time - loop_time)
     loop_time = current_time
-    frame = cv2.putText(frame, f"FPS: {fps:.2f}", (40, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
+    frame = cv.putText(frame, f"FPS: {fps:.2f}", (40, 30), cv.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
 
     # Draw the reference logo contour in the top left corner of the frame
     frame[0:50, 0:40] = (0,0,0)
-    frame = cv2.drawContours(frame, [logo_contour], -1, (255, 255, 255), 1, offset=(2, 2))
+    frame = cv.drawContours(frame, [logo_contour], -1, (255, 255, 255), 1, offset=(2, 2))
 
     # Display the frame
-    cv2.imshow(display, frame)
+    cv.imshow(display, frame)
 
     # Check for key presses
-    key = cv2.waitKey(1)
+    key = cv.waitKey(1)
 
     # If any key is pressed, exit the loop
     if key != -1: