graduation-project/identify.py

import time
from mem_top import mem_top
import cv2
import mediapipe as mp
import math
import util


# page_up_count = 0
# page_down_count = 0
# last_wrist_point = (0, 0)


class Identify:
    def __init__(self, v):
        self.result = 0
        self.position_x = 0
        self.position_y = 0
        self.image = []
        self.identify_results = []
        self.hand_points = []
        self.angle_list = []
        self.is_finger_straight = [False, False, False, False, False]
        self.is_identify = False
        self.last_control_flag = 0
        self.v = v
        self.page_up_count = 0
        self.page_down_count = 0
        self.last_wrist_point = (0, 0)

    def begin(self):
        capture = cv2.VideoCapture(0)
        # j = 1
        # count = 0
        # last_control_flag = 0
        # global control_flag, x, y
        while 1:
            ret, self.image = capture.read()
            # mp_drawing = mp.solutions.drawing_utils
            mp_holistic = mp.solutions.holistic
            holistic = mp_holistic.Holistic(static_image_mode=True)
            rgb_image = cv2.cvtColor(self.image, cv2.COLOR_BGR2RGB)
            self.identify_results = holistic.process(rgb_image)
            self.is_identify = False
            self.is_finger_straight[0] = False
            self.is_finger_straight[1] = False
            self.is_finger_straight[2] = False
            self.is_finger_straight[3] = False
            self.is_finger_straight[4] = False
            self.hand_points.clear()
            if self.identify_results.left_hand_landmarks:
                for hand_landmarks in self.identify_results.left_hand_landmarks.landmark:
                    h, w, c = self.image.shape
                    cx, cy = int(hand_landmarks.x * w), int(hand_landmarks.y * h)
                    self.hand_points.append((cx, cy))
                    self.is_identify = True
            # print(self.hand_points)
            self.judge_finger_straight()
            flag = self.judge_control()
            # x = position[0]
            # y = position[1]
            # cv2.namedWindow("Video")
            # cv2.imshow("Video", self.image)
            # if cv2.waitKey(1) & 0xFF == ord('q'):
            #     break
            # if flag == 2:
            #     control_flag = flag
            #     continue
            # if flag == 3:
            #     control_flag = flag
            #     continue
            # if not flag:
            #     control_flag = 0
            #     continue
            # if flag != self.last_control_flag:
            #     self.last_control_flag = flag
            #     count = 0
            #     print(str(flag) + " != " + str(self.last_control_flag))
            #     continue
            # else:
            #     if count < 4:
            #         count = count + 1
            #     if count < 3:
            #         self.v.value = 0
            #         control_flag = 0
            #         print("final_control_flag = " + str(control_flag))
            #         continue
            # print("count = " + str(count))
            control_flag = flag
            self.v.value = flag
            print("final_control_flag = " + str(control_flag))
        capture.release()
        cv2.destroyAllWindows()

    # def binary_picture(self, image):
    #     # 灰度图像
    #     gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    #     # 二值图像
    #     ret, binary = cv2.threshold(gray, 50, 255, cv2.THRESH_BINARY)
    #     return binary

    def hand_angle(self):
        '''
            获取对应手相关向量的二维角度,根据角度确定手势
        '''
        angle_list = []
        hand_ = self.hand_points
        # ---------------------------- thumb 大拇指角度
        angle_ = util.Util.vector_2d_angle(
            ((int(hand_[2][0]) - int(hand_[3][0])), (int(hand_[2][1]) - int(hand_[3][1]))),
            ((int(hand_[3][0]) - int(hand_[4][0])), (int(hand_[3][1]) - int(hand_[4][1])))
        )
        angle_list.append(angle_)
        # ---------------------------- index 食指角度
        angle_ = util.Util.vector_2d_angle(
            ((int(hand_[5][0]) - int(hand_[6][0])), (int(hand_[5][1]) - int(hand_[6][1]))),
            ((int(hand_[7][0]) - int(hand_[8][0])), (int(hand_[7][1]) - int(hand_[8][1])))
        )
        angle_list.append(angle_)
        # ---------------------------- middle 中指角度
        angle_ = util.Util.vector_2d_angle(
            ((int(hand_[9][0]) - int(hand_[10][0])), (int(hand_[9][1]) - int(hand_[10][1]))),
            ((int(hand_[11][0]) - int(hand_[12][0])), (int(hand_[11][1]) - int(hand_[12][1])))
        )
        angle_list.append(angle_)
        # ---------------------------- ring 无名指角度
        angle_ = util.Util.vector_2d_angle(
            ((int(hand_[13][0]) - int(hand_[14][0])), (int(hand_[13][1]) - int(hand_[14][1]))),
            ((int(hand_[15][0]) - int(hand_[16][0])), (int(hand_[15][1]) - int(hand_[16][1])))
        )
        angle_list.append(angle_)
        # ---------------------------- pink 小拇指角度
        angle_ = util.Util.vector_2d_angle(
            ((int(hand_[17][0]) - int(hand_[18][0])), (int(hand_[17][1]) - int(hand_[18][1]))),
            ((int(hand_[19][0]) - int(hand_[20][0])), (int(hand_[19][1]) - int(hand_[20][1])))
        )
        angle_list.append(angle_)
        self.angle_list = angle_list

    # def deal_with_one_image():
    #     results = holistic.process(image)
    #     hand_points = []
    #     if results.left_hand_landmarks:
    #         for hand_landmarks in results.left_hand_landmarks.landmark:
    #             h, w, c = image.shape
    #             cx, cy = int(hand_landmarks.x * w), int(hand_landmarks.y * h)
    #             hand_points.append((cx, cy))
    #     return hand_points
    def judge_finger_straight(self):
        if self.is_identify:
            self.hand_angle()
            for i in range(5):
                self.is_finger_straight[i] = util.Util.is_straight(self.angle_list[i])

    def judge_zero(self):
        return not self.is_finger_straight[1] and not self.is_finger_straight[2] and \
               not self.is_finger_straight[3] and not self.is_finger_straight[4]

    def judge_one(self):
        return self.is_finger_straight[1] and not self.is_finger_straight[2] and \
               not self.is_finger_straight[3] and not self.is_finger_straight[4]

    def judge_two(self):
        return self.is_finger_straight[1] and self.is_finger_straight[2] and \
               not self.is_finger_straight[3] and not self.is_finger_straight[4]

    def judge_three(self):
        return self.is_finger_straight[1] and self.is_finger_straight[2] and \
               self.is_finger_straight[3] and not self.is_finger_straight[4]

    def judge_four(self):
        return self.is_finger_straight[1] and self.is_finger_straight[2] and \
               self.is_finger_straight[3] and self.is_finger_straight[4]

    def judge_five(self):
        return self.is_finger_straight[1] and self.is_finger_straight[2] and \
               self.is_finger_straight[3] and self.is_finger_straight[4]

    # def judge_five(self):
    #     self.hand_angle()
    #     return util.Util.is_straight(self.angle_list[1]) and util.Util.is_straight(
    #         self.angle_list[2]) and util.Util.is_straight(self.angle_list[3]) and util.Util.is_straight(
    #         self.angle_list[4])

    # def judge_open(self):
    #     self.hand_angle()
    #     # angle_ = vector_2d_angle(
    #     #     ((int(points[0][0]) - int(points[5][0])), (int(points[0][1]) - int(points[5][1]))),
    #     #     ((int(points[5][0]) - int(points[8][0])), (int(points[5][1]) - int(points[8][1])))
    #     # )
    #     return not util.Util.is_straight(self.angle_list[1]) and util.Util.is_straight(
    #         self.angle_list[2]) and util.Util.is_straight(self.angle_list[3]) and util.Util.is_straight(
    #         self.angle_list[4])
    #
    # def judge_up(self):
    #     self.hand_angle()
    #     angle_ = util.Util.vector_2d_angle(
    #         ((int(self.hand_points[0][0]) - int(self.hand_points[5][0])),
    #          (int(self.hand_points[0][1]) - int(self.hand_points[5][1]))),
    #         ((int(self.hand_points[5][0]) - int(self.hand_points[8][0])),
    #          (int(self.hand_points[5][1]) - int(self.hand_points[8][1])))
    #     )
    #     return util.Util.is_straight(
    #         self.angle_list[1] and not util.Util.is_straight(self.angle_list[2]) and not util.Util.is_straight(
    #             self.angle_list[3]) and not util.Util.is_straight(self.angle_list[4])) and angle_ <= 40
    #
    # def judge_down(self):
    #     self.hand_angle()
    #     return util.Util.is_straight(self.angle_list[1]) and util.Util.is_straight(
    #         self.angle_list[2]) and not util.Util.is_straight(self.angle_list[3]) and not util.Util.is_straight(
    #         self.angle_list[4])
    #
    # def judge_end(self):
    #     self.hand_angle()
    #     return not util.Util.is_straight(self.angle_list[1]) and not util.Util.is_straight(
    #         self.angle_list[2]) and not util.Util.is_straight(self.angle_list[3]) and not util.Util.is_straight(
    #         self.angle_list[4])

    # def judge_one(self):
    #     self.hand_angle()
    #     return util.Util.is_straight(self.angle_list[1]) and not util.Util.is_straight(
    #         self.angle_list[2]) and not util.Util.is_straight(self.angle_list[3]) and not util.Util.is_straight(
    #         self.angle_list[4])

    def judge_page_up(self):
        if self.page_up_count == 0:
            if self.judge_five():
                self.last_wrist_point = self.hand_points[0]
                self.page_up_count += 1
            return False
        if self.judge_five() and self.hand_points[0][0] < self.last_wrist_point[0]:
            if self.hand_points[0][0] > self.last_wrist_point[0]:
                self.page_up_count = 0
                return False
            if self.page_up_count >= 2:
                self.page_up_count = 0
                self.last_wrist_point = (0, 0)
                return True
            self.page_up_count += 1
        self.last_wrist_point = self.hand_points[0]
        return False

    def judge_page_down(self):
        # global last_wrist_point
        # global page_down_count
        # print("page_down_count = " + str(page_down_count))
        # print("last_wrist_point = " + str(last_wrist_point))
        # print("points[0] = " + str(points[0]))
        if self.page_down_count == 0:
            if self.judge_five():
                self.last_wrist_point = self.hand_points[0]
                self.page_down_count += 1
            return False
        if self.judge_five() and self.hand_points[0][0] > self.last_wrist_point[0]:
            if self.hand_points[0][0] < self.last_wrist_point[0]:
                self.page_down_count = 0
                return False
            if self.page_down_count >= 2:
                self.page_down_count = 0
                self.last_wrist_point = (0, 0)
                return True
            self.page_down_count += 1
        self.last_wrist_point = self.hand_points[0]
        return False

    def judge_control(self):
        if self.is_identify:
            if self.judge_one():
                # print("open_ppt")
                return 1
            elif self.judge_page_up():
                # print("ppt_up")
                return 2
            elif self.judge_three():
                # print("ppt_down")
                return 3
            elif self.judge_zero():
                # print("ppt_end")
                return 4
            else:
                print("other")
        else:
            print("no_hand_points")
        return 0

#
# identify = Identify()
# identify.begin()