cam.py

# organize imports
import cv2
import imutils
import numpy as np
from sklearn.metrics import pairwise
from keras.models import load_model
import tkinter as tk 
import time 

# global variables
bg = None


def run_avg(image, accumWeight):
    global bg
    # initialize the background
    if bg is None:
        bg = image.copy().astype("float")
        return

    # compute weighted average, accumulate it and update the background
    cv2.accumulateWeighted(image, bg, accumWeight)


def segment(image, threshold=25):
    global bg
    # find the absolute difference between background and current frame
    diff = cv2.absdiff(bg.astype("uint8"), image)

    # threshold the diff image so that we get the foreground
    thresholded = cv2.threshold(diff, threshold, 255, cv2.THRESH_BINARY)[1]

    # get the contours in the thresholded image
    (cnts, _) = cv2.findContours(thresholded.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

    # return None, if no contours detected
    if len(cnts) == 0:
        return
    else:
        # based on contour area, get the maximum contour which is the hand
        segmented = max(cnts, key=cv2.contourArea)
        return (thresholded, segmented)

def _load_weights():
    try:
        model = load_model("/home/saichandra/Desktop/Hand-Gestures-Recognition-master/hand_gesture_recognition.h5")
        # print(model.get_weights())
        # print(model.optimizer)
        return model
    except Exception as e:
        return None
    

li=[]
le=[]
def getPredictedClass(model):
    image = cv2.imread('Temp.png')
    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    gray_image = cv2.resize(gray_image, dsize=(100, 120))
    gray_image = gray_image.reshape(1, 100, 120, 1)

    prediction = model.predict(gray_image)

    predicted_class = np.argmax(prediction)
    if predicted_class == 0:
         print("Blank")
         return "Blank"
         time.sleep(100)
        
    elif predicted_class == 1:
        print("None")
        return "None"
        time.sleep(100)


    elif predicted_class == 2:
        li.append("Thumbs Up")
        print("Thumbs Up")
        return "Thumbs Up"
        time.sleep(100)
       
        

    elif predicted_class == 3:
        le.append("Thumbs Down")

        print("Thumbs Down")
        return "Thumbs Down"
        time.sleep(100)


    elif predicted_class == 4:
        print("None")
        return "None"

    elif predicted_class == 5:
        print("None")
        return "None"
        time.sleep(100)


if __name__ == "__main__":
    # initialize accumulated weight
    accumWeight = 0.5

    # get the reference to the webcam
    camera = cv2.VideoCapture(0)

    fps = int(camera.get(cv2.CAP_PROP_FPS))
    # region of interest (ROI) coordinates
    top, right, bottom, left = 10, 350, 225, 590
    # initialize num of frames
    num_frames = 0
    # calibration indicator
    calibrated = False
    model = _load_weights()
    k = 0
    # keep looping, until interrupted
    while (True):
        # get the current frame
        (grabbed, frame) = camera.read()

        # resize the frame
        frame = imutils.resize(frame, width=700)
        # flip the frame so that it is not the mirror view
        frame = cv2.flip(frame, 1)

        # clone the frame
        clone = frame.copy()

        # get the height and width of the frame
        (height, width) = frame.shape[:2]

        # get the ROI
        roi = frame[top:bottom, right:left]

        # convert the roi to grayscale and blur it
        gray = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY)
        gray = cv2.GaussianBlur(gray, (7, 7), 0)

        # to get the background, keep looking till a threshold is reached
        # so that our weighted average model gets calibrated
        if num_frames < 30:
            run_avg(gray, accumWeight)
            if num_frames == 1:
                print("[STATUS] please wait! calibrating...")
            elif num_frames == 29:
                print("[STATUS] calibration successfull...")
        else:
            # segment the hand region
            hand = segment(gray)

            # check whether hand region is segmented
            if hand is not None:
                # if yes, unpack the thresholded image and
                # segmented region
                (thresholded, segmented) = hand

                # draw the segmented region and display the frame
                cv2.drawContours(clone, [segmented + (right, top)], -1, (0, 0, 255))

                # count the number of fingers
                # fingers = count(thresholded, segmented)
                if k % (fps / 6) == 0:
                    cv2.imwrite('Temp.png', thresholded)
                    predictedClass = getPredictedClass(model)
                    cv2.putText(clone, str(predictedClass), (70, 45), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)

                # show the thresholded image
                cv2.imshow("Thesholded", thresholded)
        k = k + 1
        # draw the segmented hand
        cv2.rectangle(clone, (left, top), (right, bottom), (0, 255, 0), 2)

        # increment the number of frames
        num_frames += 1

        # display the frame with segmented hand
        cv2.imshow("Gesture Detection", clone)

        # observe the keypress by the user
        keypress = cv2.waitKey(1) & 0xFF

        # if the user pressed "q", then stop looping
        if keypress == ord("q"):
            x=len(li)
            print("Thumbs Up: ",x)
            y=len(le)
            print("Thumbs Down: ",y)
            if (x==0 and y==0):
                print("YOUR RESULT : "+"Not Responded")
            elif(x==y):
                print("YOUR RESULT: "+"Not Responded")
            elif(x==0 and y>x):
                li.append("Thumbs Up")
                print("YOUR RESULT : ",str(set(le)))
            elif(y==0 and x>y):
                le.append("Thumbs Down")
                print("YOUR RESULT : ",str(set(li)))
            elif(x>y):
                print("YOUR RESULT : ",str(set(li)))
            elif(y>x):
                print("YOUR RESULT : ",str(set(le)))

            break
        
    # free up memory
    camera.release()
    cv2.destroyAllWindows()