Update Chapter 2 4 5

Author: Diraw

Project 2 Finger Counter/FingerCounter.py

@@ -0,0 +1,97 @@
+# This script can only detect gestures of the right hand
+import cv2
+import time
+import os
+import HandTrackingModule as htm
+
+# Set the width and height of the camera, i.e., resolution
+wCam, hCam = 640, 480
+
+# Open the camera
+cap = cv2.VideoCapture(0)
+cap.set(3, wCam)  # Set camera width
+cap.set(4, hCam)  # Set camera height
+
+# Specify the path to the finger image folder
+folderPath = "E:\\Advance Computer Vision with Python\\main_en\\Project 2 Finger Counter\\FingerImages"
+myList = os.listdir(folderPath)  # Get a list of all file names in the folder
+print(myList)
+
+overlayList = []  # List to store finger images
+for imPath in myList:
+    # Read each finger image
+    image = cv2.imread(f"{folderPath}/{imPath}")
+    overlayList.append(image)  # Add image to the list
+
+print(len(overlayList))  # Output the number of images
+
+pTime = 0  # Initialize previous frame time
+
+# Create a hand detector object, set detection confidence to 0.75
+detector = htm.handDetector(detectionCon=0.75)
+
+# List of fingertip IDs
+tipIds = [4, 8, 12, 16, 20]
+
+while True:
+    success, img = cap.read()  # Read frame from camera
+    img = cv2.flip(img, 1)  # Horizontally flip the image
+    img = detector.findHands(img)  # Detect hands and draw hand keypoints
+    lmList = detector.findPosition(
+        img, draw=False
+    )  # Get list of hand keypoint positions
+
+    if len(lmList) != 0:
+        fingers = []
+
+        # Detect thumb (based on x-coordinates of thumb tip and second joint)
+        if lmList[tipIds[0]][1] < lmList[tipIds[0] - 1][1]:
+            # If following the source code, if lmList[tipIds[0]][1] > lmList[tipIds[0] - 1][1] determines the extension of the right thumb before flipping
+            # So if I choose img = cv2.flip(img, 1), then if lmList[tipIds[0]][1] > lmList[tipIds[0] - 1][1] determines the extension of the left thumb after horizontal flipping, to keep detecting the right hand, change greater than to less than
+            # Therefore, this script can only detect gestures of the right hand
+            fingers.append(1)  # 1 indicates the finger is extended
+        else:
+            fingers.append(0)  # 0 indicates the finger is bent
+
+        # Detect the other four fingers (based on y-coordinates of fingertip and finger root)
+        for id in range(1, 5):
+            if lmList[tipIds[id]][2] < lmList[tipIds[id] - 2][2]:
+                fingers.append(1)
+            else:
+                fingers.append(0)
+
+        totalFingers = fingers.count(1)  # Count the number of extended fingers
+        print(totalFingers)
+
+        # Select the image corresponding to the number of fingers and overlay it
+        h, w, c = overlayList[totalFingers - 1].shape
+        # totalFingers - 1 is because list indices start from 0, while totalFingers represents the number of fingers (starting from 1). So subtract 1 to correctly access the corresponding image in the list
+        # Therefore, put 0 at the end of the list, because at this time no fingers are extended, totalFingers is 0, subtracting 1 gets -1, which is the last one in the list
+        img[0:h, 0:w] = overlayList[
+            totalFingers - 1
+        ]  # Place the image of the corresponding number of fingers in the top-left corner of the camera image
+
+        # Draw a rectangle and display the number of fingers
+        cv2.rectangle(img, (20, 225), (170, 425), (0, 255, 0), cv2.FILLED)
+        cv2.putText(
+            img,
+            str(totalFingers),
+            (45, 375),
+            cv2.FONT_HERSHEY_PLAIN,
+            10,
+            (255, 0, 0),
+            25,
+        )
+
+    cTime = time.time()  # Get current frame time
+    fps = 1 / (cTime - pTime)  # Calculate frame rate
+    pTime = cTime  # Update previous frame time
+
+    # Display frame rate on the image
+    cv2.putText(
+        img, f"FPS: {int(fps)}", (400, 70), cv2.FONT_HERSHEY_PLAIN, 3, (255, 0, 0), 3
+    )
+
+    # Display the processed image
+    cv2.imshow("Image", img)
+    cv2.waitKey(1)  # Wait for a key press, 1 millisecond

Project 2 Finger Counter/FingerImages/1.png

@@ -0,0 +1,105 @@
+"""
+Hand Tracing Module
+By: Murtaza Hassan
+Youtube: http://www.youtube.com/c/MurtazasWorkshopRoboticsandAI
+Website: https://www.computervision.zone
+
+Modified by: Diraw
+Date: 20240812
+Description:
+1. Modified the initialization of the `Hands` object to use named parameters for better clarity and compatibility with the latest version of the mediapipe library. This change ensures that the parameters are correctly mapped to the expected arguments in the `Hands` class.
+2. Added a line to flip the image horizontally using `cv2.flip(img, 1)` to ensure the hand movements appear mirrored, which is more intuitive for user interaction
+"""
+
+import cv2
+import mediapipe as mp
+import time
+
+
+# Hand detector class
+class handDetector:
+    def __init__(self, mode=False, maxHands=2, detectionCon=0.5, trackCon=0.5):
+        # Initialize parameters
+        self.mode = mode  # Whether to use static mode
+        self.maxHands = maxHands  # Maximum number of hands to detect
+        self.detectionCon = detectionCon  # Detection confidence
+        self.trackCon = trackCon  # Tracking confidence
+
+        # Initialize MediaPipe hand model
+        self.mpHands = mp.solutions.hands
+        # self.hands = self.mpHands.Hands(
+        #     self.mode, self.maxHands, self.detectionCon, self.trackCon
+        # )
+        self.hands = self.mpHands.Hands(
+            static_image_mode=self.mode,
+            max_num_hands=self.maxHands,
+            min_detection_confidence=self.detectionCon,
+            min_tracking_confidence=self.trackCon,
+        )
+
+        # Initialize drawing tools
+        self.mpDraw = mp.solutions.drawing_utils
+
+    def findHands(self, img, draw=True):
+        # Convert the image to RGB
+        imgRGB = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+        # Process the image to detect hands
+        self.results = self.hands.process(imgRGB)
+
+        # If hands are detected
+        if self.results.multi_hand_landmarks:
+            for handLms in self.results.multi_hand_landmarks:
+                # Draw hand keypoints and connections
+                if draw:
+                    self.mpDraw.draw_landmarks(
+                        img, handLms, self.mpHands.HAND_CONNECTIONS
+                    )
+        return img
+
+    def findPosition(self, img, handNo=0, draw=True):
+        lmList = []  # Store hand keypoint positions
+        if self.results.multi_hand_landmarks:
+            myHand = self.results.multi_hand_landmarks[handNo]
+            for id, lm in enumerate(myHand.landmark):
+                # Get image dimensions
+                h, w, c = img.shape
+                # Calculate pixel position of keypoints
+                cx, cy = int(lm.x * w), int(lm.y * h)
+                lmList.append([id, cx, cy])
+                # Draw keypoints
+                if draw:
+                    cv2.circle(img, (cx, cy), 15, (255, 0, 255), cv2.FILLED)
+        return lmList
+
+
+# Main function
+def main():
+    pTime = 0  # Previous frame time
+    cTime = 0  # Current frame time
+    cap = cv2.VideoCapture(0)  # Open the camera
+    detector = handDetector()  # Create hand detector object
+
+    while True:
+        success, img = cap.read()  # Read camera frame
+        img = cv2.flip(img, 1)  # Horizontally flip the image
+        img = detector.findHands(img)  # Detect hands and draw
+        lmList = detector.findPosition(img)  # Get hand keypoint positions
+        if len(lmList) != 0:
+            print(lmList[4])  # Print coordinates of the thumb tip
+
+        cTime = time.time()  # Get current time
+        fps = 1 / (cTime - pTime)  # Calculate frame rate
+        pTime = cTime  # Update previous frame time
+
+        # Display frame rate on the image
+        cv2.putText(
+            img, str(int(fps)), (10, 70), cv2.FONT_HERSHEY_PLAIN, 3, (255, 0, 255), 3
+        )
+
+        # Display the image
+        cv2.imshow("Image", img)
+        cv2.waitKey(1)
+
+
+if __name__ == "__main__":
+    main()

Project 2 Finger Counter/FingerImages/2.png

@@ -0,0 +1,92 @@
+import cv2
+import numpy as np
+import HandTrackingModule as htm
+import time
+import autopy
+
+##########################
+wCam, hCam = 640, 480
+frameR = 100  # Frame reduction
+smoothening = 7  # Smoothing factor
+#########################
+# The above are comments used to create visual separators in the code. They can help developers to more clearly separate different parts of the code, making it more readable. These lines themselves have no function, just to improve code readability
+
+pTime = 0
+plocX, plocY = 0, 0
+clocX, clocY = 0, 0
+
+cap = cv2.VideoCapture(0)
+cap.set(3, wCam)
+cap.set(4, hCam)
+detector = htm.handDetector(maxHands=1)
+wScr, hScr = autopy.screen.size()  # Get screen width and height
+# autopy.screen.size() returns the screen size in pixels
+# wScr is the screen width, hScr is the screen height
+# print(wScr, hScr)
+
+while True:
+    # 1. Detect hand landmarks
+    success, img = cap.read()
+    img = cv2.flip(img, 1)  # Horizontally flip the image
+    img = detector.findHands(img)
+    lmList, bbox = detector.findPosition(img)
+
+    # 2. Get positions of index and middle fingertips
+    if len(lmList) != 0:
+        x1, y1 = lmList[8][1:]
+        x2, y2 = lmList[12][1:]
+        # print(x1, y1, x2, y2)
+
+        # 3. Check which fingers are up
+        fingers = detector.fingersUp()
+        # print(fingers)
+        cv2.rectangle(
+            img, (frameR, frameR), (wCam - frameR, hCam - frameR), (255, 0, 255), 2
+        )
+
+        # 4. Only index finger up: Moving mode
+        if fingers[1] == 1 and fingers[2] == 0:
+            # 5. Convert coordinates
+            x3 = np.interp(x1, (frameR, wCam - frameR), (0, wScr))
+            y3 = np.interp(y1, (frameR, hCam - frameR), (0, hScr))
+            # np.interp() is a function for linear interpolation. Its basic usage: np.interp(x, xp, fp)
+            # Where x is the point to interpolate, xp is the range of input data points (known x values), fp is the range of output data points (known y values)
+            # Here, x1 and y1 are the positions of the finger in the camera image, (frameR, wCam - frameR) is the range of finger movement in the camera image, (0, wScr) and (0, hScr) are the screen coordinate ranges
+            # Through np.interp(), the program maps the finger position in the camera image to the screen coordinates, thus achieving the correspondence between finger movement and mouse cursor movement. This allows finger movement in the camera to control the mouse cursor on the screen
+
+            # 6. Smooth the values
+            clocX = plocX + (x3 - plocX) / smoothening
+            clocY = plocY + (y3 - plocY) / smoothening
+            # clocX and clocY are the current smoothed coordinates, plocX and plocY are the previous frame coordinates
+            # x3 and y3 are the target coordinates after interpolation in the current frame, smoothening is a smoothing factor to control the degree of smoothing
+            # Each update, the current position (clocX, clocY) moves a small part towards the target position (x3, y3), smoothening controls the step size of the movement, the larger the value, the slower and smoother the movement
+            # Smoothing makes the mouse pointer move a bit slower, but the purpose is to reduce jitter and make the movement smoother
+            # If you feel the movement is too slow, you can try reducing the value of smoothening, so the pointer will follow the finger movement faster
+
+            # 7. Move the mouse
+            # autopy.mouse.move(wScr - clocX, clocY)
+            # Use the above statement if not flipped
+            autopy.mouse.move(clocX, clocY)
+            cv2.circle(img, (x1, y1), 15, (255, 0, 255), cv2.FILLED)
+            plocX, plocY = clocX, clocY
+
+        # 8. Both index and middle fingers up: Clicking mode
+        if fingers[1] == 1 and fingers[2] == 1:
+            # 9. Calculate the distance between the two fingers
+            length, img, lineInfo = detector.findDistance(8, 12, img)
+            print(length)
+
+            # 10. If the distance is short, click the mouse
+            if length < 40:
+                cv2.circle(img, (lineInfo[4], lineInfo[5]), 15, (0, 255, 0), cv2.FILLED)
+                autopy.mouse.click()
+
+    # 11. Frame rate
+    cTime = time.time()
+    fps = 1 / (cTime - pTime)
+    pTime = cTime
+    cv2.putText(img, str(int(fps)), (20, 50), cv2.FONT_HERSHEY_PLAIN, 3, (255, 0, 0), 3)
+
+    # 12. Display
+    cv2.imshow("Image", img)
+    cv2.waitKey(1)