Merge pull request #1121 from Shantnu-singh/main

added hand detection using openCv

Author: sanjay-kv

Hand detection package/Hand_detection_module.py

@@ -0,0 +1,87 @@
+import cv2
+import time
+import mediapipe as mp
+
+# mode = False , maxHands = 2 , detectionCon = 0.5 , TrackCon = 0.5
+class HandDetection:
+    def __init__(self , min_detection_confidence = 0.5):
+        # self.mode = mode
+        # self.maxHand = maxHands
+        self.min_detection_confidence = min_detection_confidence
+        # self.TrackCon = TrackCon
+
+        self.mpHands = mp.solutions.hands
+        self.hands = self.mpHands.Hands( self.min_detection_confidence )
+        self.mpDraw = mp.solutions.drawing_utils
+
+
+    def findHand(self , frame , flag = True):
+        RGB_frame = cv2.cvtColor(frame , cv2.COLOR_BGR2RGB)
+        self.results = self.hands.process(RGB_frame)
+
+        # print(self.results.multi_hand_landmarks)
+
+        if self.results.multi_hand_landmarks:
+            for multihands in self.results.multi_hand_landmarks:
+                if flag:
+                    self.mpDraw.draw_landmarks(frame , multihands , self.mpHands.HAND_CONNECTIONS)
+
+        return frame
+    
+    def findPosition(self , frame , handno = 0 , draw = True):
+
+        lmList = []
+        
+        if self.results.multi_hand_landmarks:
+            myHand = self.results.multi_hand_landmarks[handno]
+
+            for id , lm in enumerate(myHand.landmark):
+                h , w , c = frame.shape
+                cx , cy = int(lm.x*w) , int(lm.y*h)
+                # print(id , cx , cy)
+                lmList.append([id , cx , cy])
+
+                if draw:
+        
+                    cv2.circle(frame , (cx , cy) , 7 , (255 , 0 , 9) , cv2.FILLED)
+
+        return lmList
+
+    
+def main():
+    pTime = 0
+    cTime = 0
+
+
+    cap = cv2.VideoCapture(0)
+    
+    detector = HandDetection()
+
+
+    while True:
+
+        rec , frame = cap.read()
+
+        frame = detector.findHand(frame)
+        lmlist = detector.findPosition(frame)
+        
+        if len(lmlist) != 0:
+            print(lmlist[4])
+        
+        cTime  =time.time()
+        Fps = 1/(cTime - pTime)
+        pTime = cTime
+
+        cv2.putText(frame , str(int(Fps)) , (10 , 40) , cv2.FONT_HERSHEY_COMPLEX , 1 , (0,255 , 0) , 2 )
+        
+
+    
+        cv2.imshow("webcam" , frame)
+        if cv2.waitKey(1) & 0xFF == ord("x"):
+         break
+
+    cap.release()
+    cv2.destroyAllWindows()
+
+if __name__ == "__main__":
+    main()

Hand detection package/Raw code module.py

@@ -0,0 +1,52 @@
+import mediapipe as mp
+import cv2
+import numpy as np
+import time
+
+mpHands = mp.solutions.hands
+hands = mpHands.Hands()
+mpDraw = mp.solutions.drawing_utils
+
+pTime = 0
+cTime = 0
+
+
+cap = cv2.VideoCapture(0)
+
+while True:
+
+    rec , frame = cap.read()
+    
+    gray_frame = cv2.cvtColor(frame , cv2.COLOR_BGR2RGB)
+    results = hands.process(gray_frame)
+
+    print(results.multi_hand_landmarks)
+
+    if results.multi_hand_landmarks:
+        for multihands in results.multi_hand_landmarks:
+            for id , lm in enumerate(multihands.landmark):
+                h , w , c = frame.shape
+                cx , cy = int(lm.x*w) , int(lm.y*h)
+                print(id , cx , cy)
+
+                if id == 4:
+                    cv2.circle(frame , (cx , cy) , 15 , (255 , 255 , 9) , cv2.FILLED)
+
+            mpDraw.draw_landmarks(frame , multihands , mpHands.HAND_CONNECTIONS)
+    
+    cTime  =time.time()
+    Fps = 1/(cTime - pTime)
+    pTime = cTime
+
+    cv2.putText(frame , str(int(Fps)) , (10 , 40) , cv2.FONT_HERSHEY_COMPLEX , 1 , (0,255 , 0) , 2 )
+        
+
+    
+    cv2.imshow("webcam" , frame)
+    if cv2.waitKey(1) & 0xFF == ord("x"):
+        break
+
+cap.release()
+cv2.destroyAllWindows()
+
+    

Hand detection package/__pycache__/Hand_detection_module.cpython-38.pyc

@@ -0,0 +1,61 @@
+# Hand Detection Module
+
+This project is a Python module that utilizes MediaPipe and OpenCV for real-time hand detection and landmark recognition using a webcam. The module detects hand landmarks and highlights specific points, such as the tip of the thumb, on the video feed.
+
+## Table of Contents
+- [Introduction](#introduction)
+- [Features](#features)
+- [Installation](#installation)
+- [Usage](#usage)
+- [How It Works](#how-it-works)
+- [Limitations](#limitations)
+## Introduction
+
+This hand detection module is designed for real-time detection and tracking of hand landmarks. It leverages MediaPipe's pre-trained hand detection model and OpenCV for video capture and processing.
+
+## Features
+
+- Real-time hand detection using a webcam.
+- Identification and marking of specific hand landmarks (e.g., thumb tip).
+- Display of the video feed with overlayed hand landmarks and frames per second (FPS).
+- Simple and efficient, with the ability to handle multiple hands.
+
+## Installation
+
+To use this module, ensure you have Python installed along with the required libraries:
+
+```bash
+pip install opencv-python
+pip install mediapipe
+```
+
+## Usage
+
+To run the hand detection module, execute the script:
+
+```bash
+python Hand_detection_module.py
+```
+
+The script will open your webcam and start detecting hand landmarks in real-time. Press 'x' to exit the application.
+
+## How It Works
+
+1. **Video Capture**: The script captures video from the default webcam using OpenCV.
+2. **Frame Processing**: Each frame is converted to RGB and processed by the MediaPipe Hands model to detect hand landmarks.
+3. **Landmark Detection**: The detected landmarks are identified and their coordinates are calculated.
+4. **Landmark Highlighting**: Specific landmarks (like the thumb tip) are highlighted on the video feed using colored circles.
+5. **FPS Calculation**: The script calculates and displays the frames per second (FPS) to monitor performance.
+
+### Key Sections of the Code
+
+- **Hand Landmark Detection**: The code uses `mp.solutions.hands` to detect hand landmarks and `mp.solutions.drawing_utils` to draw them on the video feed.
+- **Specific Landmark Highlighting**: The tip of the thumb (landmark ID 4) is highlighted with a filled circle.
+- **FPS Display**: The FPS is calculated based on the time difference between consecutive frames and displayed on the video feed.
+
+## Limitations
+
+- **Lighting Conditions**: The accuracy of hand detection can be affected by poor lighting conditions.
+- **Single Camera Source**: The script is designed to work with a single webcam source and may require modifications for other video inputs.
+- **Dependency on MediaPipe**: This module heavily relies on the MediaPipe library, so any updates or changes in MediaPipe might require adjustments to the code.
+