● 텍스트 변경(크기, 색)

import mediapipe as mp

import time

import numpy as np

import random

mp_hands = mp.solutions.hands

mp_drawing = mp.solutions.drawing_utils

hands = mp_hands.Hands(

    max_num_hands=2,

    min_detection_confidence=0.7,

    min_tracking_confidence=0.7

)

cap = cv2.VideoCapture(0)

# 원 크기와 상태 변수

circle_radius = 10

circle_growing = False

start_time = None

exploded = False

shake_offset = (0, 0)

def is_hands_facing_each_other(hand1, hand2, img_width, threshold=100):

    # 손바닥 중심으로 x좌표 계산 (landmark 0이 손목, 9, 5 등 손바닥 위치 고려 가능)

    def palm_center(hand):

        x_vals = [lm.x for lm in hand.landmark]

        cx = int(np.mean(x_vals) * img_width)

        return cx

    cx1 = palm_center(hand1)

    cx2 = palm_center(hand2)

    # 두 손이 서로 마주보고 있는 조건:

    # 손 위치가 서로 가까이(x축 차이가 threshold 이하), 그리고 x 좌표가 서로 반대쪽(한쪽은 왼쪽, 다른쪽은 오른쪽)

    distance = abs(cx1 - cx2)

    facing = (distance < threshold) and (cx1 < cx2)

    return facing, (cx1 + cx2)//2

def apply_shake(frame, intensity=10):

    h, w = frame.shape[:2]

    dx = random.randint(-intensity, intensity)

    dy = random.randint(-intensity, intensity)

    M = np.float32([[1, 0, dx], [0, 1, dy]])

    shaken = cv2.warpAffine(frame, M, (w, h))

    return shaken, (dx, dy)

while True:

    success, frame = cap.read()

    if not success:

        break

    frame = cv2.flip(frame, 1)

    img_h, img_w = frame.shape[:2]

    image_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

    result = hands.process(image_rgb)

    if result.multi_hand_landmarks and len(result.multi_hand_landmarks) == 2:

        hand1, hand2 = result.multi_hand_landmarks

        facing, center_x = is_hands_facing_each_other(hand1, hand2, img_w)

        # 손 랜드마크 그리기

        for hand_landmarks in result.multi_hand_landmarks:

            mp_drawing.draw_landmarks(frame, hand_landmarks, mp_hands.HAND_CONNECTIONS)

        if facing:

            if not circle_growing:

                start_time = time.time()

                circle_growing = True

                circle_radius = 10

                exploded = False

        else:

            circle_growing = False

            start_time = None

            circle_radius = 10

            exploded = False

    else:

        circle_growing = False

        start_time = None

        circle_radius = 10

        exploded = False

    # 원 크기 점진적 증가 처리 (0.5초마다 1.5배씩 증가)

    if circle_growing and start_time:

        elapsed = time.time() - start_time

        if elapsed > 0.5:

            factor = 1.5 ** int((elapsed - 0.5) // 0.5)

            circle_radius = int(10 * factor)

    # 원 크기가 너무 커지면 폭발 효과 + 화면 흔들림

    if circle_radius > 150 and not exploded:

        exploded = True

        explosion_start = time.time()

    # 화면 흔들림과 폭발 이펙트

    if exploded:

        frame, shake_offset = apply_shake(frame, intensity=20)

        # 폭발 이펙트 - 랜덤 위치에 작은 원 그리기

        for _ in range(50):

            x = random.randint(0, img_w)

            y = random.randint(0, img_h)

            r = random.randint(5, 15)

            color = (random.randint(150, 255), random.randint(0, 50), random.randint(0, 50))

            cv2.circle(frame, (x, y), r, color, -1)

        # 폭발 지속시간 1.5초

        if time.time() - explosion_start > 1.5:

            circle_growing = False

            start_time = None

            circle_radius = 10

            exploded = False

            shake_offset = (0, 0)

    else:

        # 원 그리기 (두 손이 마주보고 있을 때만)

        if circle_growing and start_time:

            center_y = img_h // 2

            cv2.circle(frame, (center_x + shake_offset[0], center_y + shake_offset[1]), circle_radius, (255, 0, 0), -1)

    cv2.imshow("Hand Interaction", frame)

    if cv2.waitKey(1) & 0xFF == 27:  # ESC

        break

cap.release()

cv2.destroyAllWindows()

import mediapipe as mp

import math

mp_hands = mp.solutions.hands

mp_drawing = mp.solutions.drawing_utils

hands = mp_hands.Hands(

static_image_mode=False,

max_num_hands=2,

min_detection_confidence=0.7,

min_tracking_confidence=0.5

)

def calculate_angle(a, b, c):

ba = (a[0]-b[0], a[1]-b[1])

bc = (c[0]-b[0], c[1]-b[1])

dot_product = ba[0]*bc[0] + ba[1]*bc[1]

mag_ba = math.sqrt(ba[0]**2 + ba[1]**2)

mag_bc = math.sqrt(bc[0]**2 + bc[1]**2)

if mag_ba * mag_bc == 0:

return 0

cos_angle = dot_product / (mag_ba * mag_bc)

cos_angle = max(min(cos_angle, 1), -1)

angle = math.acos(cos_angle)

return math.degrees(angle)

is_back_of_hand_facing(hand_landmarks, h):

thumb_mcp_y = hand_landmarks.landmark[2].y * h

pinky_mcp_y = hand_landmarks.landmark[17].y * h

return pinky_mcp_y < thumb_mcp_y

def is_finger_open_angle(hand_landmarks, tip_id, pip_id, mcp_id, w, h):

tip = hand_landmarks.landmark[tip_id]

pip = hand_landmarks.landmark[pip_id]

mcp = hand_landmarks.landmark[mcp_id]

tip_c = (tip.x w, tip.y h)

pip_c = (pip.x w, pip.y h)

mcp_c = (mcp.x w, mcp.y h)

angle = calculate_angle(tip_c, pip_c, mcp_c)

return angle > 160

def get_finger_states(hand_landmarks, w, h):

back_of_hand_facing = is_back_of_hand_facing(hand_landmarks, h)

if not back_of_hand_facing:

return None

fingers = []

fingers.append(is_finger_open_angle(hand_landmarks, 4, 3, 2, w, h)) # 엄지

fingers.append(is_finger_open_angle(hand_landmarks, 8, 6, 5, w, h)) # 검지

fingers.append(is_finger_open_angle(hand_landmarks, 12, 10, 9, w, h)) # 중지

fingers.append(is_finger_open_angle(hand_landmarks, 16, 14, 13, w, h))# 약지

fingers.append(is_finger_open_angle(hand_landmarks, 20, 18, 17, w, h))# 새끼

return fingers

def detect_hand_gesture(fingers):

if fingers == [False, False, False, False, False]:

return "Rock"

elif fingers == [False, True, True, False, False]:

return "Scissors"

elif all(fingers):

return "Paper"

else:

return "Unknown"

def main():

cap = cv2.VideoCapture(0)

while True:

success, frame = cap.read()

if not success:

break

frame = cv2.flip(frame, 1)

h, w, _ = frame.shape

image_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

result = hands.process(image_rgb)

if result.multi_hand_landmarks:

for hand_landmarks in result.multi_hand_landmarks:

mp_drawing.draw_landmarks(frame, hand_landmarks, mp_hands.HAND_CONNECTIONS)

fingers = get_finger_states(hand_landmarks, w, h)

if fingers is not None:

gesture = detect_hand_gesture(fingers)

cv2.putText(frame, f"Gesture: {gesture}", (10, 50),

cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 0), 2)

cv2.imshow("Rock Paper Scissors Gesture (Back of Hand)", frame)

if cv2.waitKey(1) & 0xFF == 27:

break

cap.release()

cv2.destroyAllWindows()

if name == "__main__":

main()

import mediapipe as mp

import random

import math

# MediaPipe 설정

mp_face = mp.solutions.face_mesh

face_mesh = mp_face.FaceMesh(max_num_faces=1)

# 초기화

width, height = 640, 480

score = 0

target_score = 15

# 아이템 리스트 (사과 + 함정)

objects = [

{"type": "apple", "pos": [random.randint(100, 500), 0], "speed": 5},

{"type": "bad", "pos": [random.randint(100, 500), -200], "speed": 5}

]

apple_radius = 20

# 충돌 판정

def is_collision(obj_pos, mouth_pos):

ox, oy = obj_pos

mx, my = mouth_pos

distance = math.hypot(ox - mx, oy - my)

return distance < apple_radius + 20

# 웹캠

cap = cv2.VideoCapture(0)

while True:

ret, frame = cap.read()

if not ret:

break

frame = cv2.flip(frame, 1)

h, w, _ = frame.shape

rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

result = face_mesh.process(rgb)

mouth_pos = None

if result.multi_face_landmarks:

for face_landmarks in result.multi_face_landmarks:

lm = face_landmarks.landmark[13]

mx, my = int(lm.x w), int(lm.y h)

mouth_pos = (mx, my)

cv2.circle(frame, mouth_pos, 8, (255, 0, 0), -1)

# 오브젝트 이동 및 처리

for obj in objects:

obj["pos"][1] += int(obj["speed"])

# 충돌 감지

if mouth_pos and is_collision(obj["pos"], mouth_pos):

if obj["type"] == "apple":

score += 1

else:

score -= 1

# 오브젝트 초기화

obj["pos"] = [random.randint(50, w - 50), 0]

obj["speed"] += 0.2

# 바닥까지 떨어진 경우: 위치만 초기화

if obj["pos"][1] > h:

obj["pos"] = [random.randint(50, w - 50), 0]

obj["speed"] += 0.1

# 그리기

color = (0, 0, 255) if obj["type"] == "apple" else (0, 255, 255)

cv2.circle(frame, tuple(obj["pos"]), apple_radius, color, -1)

# 점수 표시

cv2.putText(frame, f'Score: {score}', (10, 30),

cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)

# 승리 조건

if score >= target_score:

cv2.putText(frame, 'You Win! 🎉', (150, 250),

cv2.FONT_HERSHEY_SIMPLEX, 1.5, (0, 255, 0), 4)

cv2.imshow("Catch Game", frame)

cv2.waitKey(2000)

break

# 화면 출력

cv2.imshow("Catch Game", frame)

if cv2.waitKey(1) & 0xFF == 27:

break

cap.release()

cv2.destroyAllWindows()

코드 :

import cv2
import mediapipe as mp
import math

mp_pose = mp.solutions.pose
pose = mp_pose.Pose(min_detection_confidence=0.7, min_tracking_confidence=0.7)
mp_drawing = mp.solutions.drawing_utils

WIDTH, HEIGHT = 640, 480

cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, WIDTH)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, HEIGHT)

def calculate_angle(a, b, c):
    ang = math.degrees(
        math.atan2(c[1] - b[1], c[0] - b[0]) -
        math.atan2(a[1] - b[1], a[0] - b[0])
    )
    ang = abs(ang)
    if ang > 180:
        ang = 360 - ang
    return ang

while True:
    ret, frame = cap.read()
    if not ret:
        break
    frame = cv2.flip(frame, 1)
    image_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

    results = pose.process(image_rgb)

    if results.pose_landmarks:
        mp_drawing.draw_landmarks(frame, results.pose_landmarks, mp_pose.POSE_CONNECTIONS)

        landmarks = results.pose_landmarks.landmark

        def get_coord(idx):
            return int(landmarks[idx].x * WIDTH), int(landmarks[idx].y * HEIGHT)

        left_shoulder = get_coord(mp_pose.PoseLandmark.LEFT_SHOULDER.value)
        right_shoulder = get_coord(mp_pose.PoseLandmark.RIGHT_SHOULDER.value)
        left_hip = get_coord(mp_pose.PoseLandmark.LEFT_HIP.value)
        left_knee = get_coord(mp_pose.PoseLandmark.LEFT_KNEE.value)

        hip_angle = calculate_angle(left_shoulder, left_hip, left_knee)

        messages = []
        if hip_angle < 160:
            messages.append("Your back is slouched!")

        # 어깨 불균형 강화 기준
        shoulder_y_diff = abs(left_shoulder[1] - right_shoulder[1])  # 수직 차이
        shoulder_x_diff = abs(left_shoulder[0] - right_shoulder[0])  # 수평 차이

        vertical_threshold = 15  # 수직 차이 임계값 (픽셀)
        horizontal_threshold = 100  # 수평 차이 임계값 (픽셀)

        if shoulder_y_diff > vertical_threshold or shoulder_x_diff > horizontal_threshold:
            messages.append("Your shoulders are uneven!")

        y0 = 50
        for i, msg in enumerate(messages):
            cv2.putText(frame, msg, (30, y0 + i*40), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,255), 3)

        cv2.putText(frame, f"Hip angle: {int(hip_angle)}", (30, HEIGHT - 90), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (255,255,255), 2)
        cv2.putText(frame, f"Shoulder Y diff: {int(shoulder_y_diff)} px", (30, HEIGHT - 60), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (255,255,255), 2)
        cv2.putText(frame, f"Shoulder X diff: {int(shoulder_x_diff)} px", (30, HEIGHT - 30), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (255,255,255), 2)

    cv2.imshow("Posture Correction", frame)
    if cv2.waitKey(1) & 0xFF == 27:
        break

cap.release()
cv2.destroyAllWindows()

코드 :

import cv2
import numpy as np

# 웹캠 열기
cap = cv2.VideoCapture(0)

# 해상도 설정 (1920x1080)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 1920)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 1080)

cv2.namedWindow("Wound Detection", cv2.WINDOW_NORMAL)

while True:
    ret, frame = cap.read()
    if not ret:
        break

    # HSV 변환
    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)

    # 붉은색 범위 조정 (더 진한 색만 탐지)
    lower_red1 = np.array([0, 100, 100])
    upper_red1 = np.array([5, 255, 255])
    lower_red2 = np.array([170, 100, 100])
    upper_red2 = np.array([180, 255, 255])

    mask1 = cv2.inRange(hsv, lower_red1, upper_red1)
    mask2 = cv2.inRange(hsv, lower_red2, upper_red2)
    mask = mask1 + mask2

    # 노이즈 제거
    kernel = np.ones((5, 5), np.uint8)
    mask_clean = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)
    mask_clean = cv2.morphologyEx(mask_clean, cv2.MORPH_CLOSE, kernel)

    # 윤곽선 검출
    contours, _ = cv2.findContours(mask_clean, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

    for cnt in contours:
        area = cv2.contourArea(cnt)
        if area > 800:  # 작은 노이즈 제거
            x, y, w, h = cv2.boundingRect(cnt)
            cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 0, 255), 2)
            cv2.putText(frame, "Possible Wound", (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)

    # 화면 출력
    cv2.imshow("Wound Detection", frame)
    cv2.imshow("Red Area Mask", mask_clean)

    # ESC 키로 종료
    if cv2.waitKey(1) & 0xFF == 27:
        break

# 종료 처리
cap.release()
cv2.destroyAllWindows()

import mediapipe as mp

import time

import random

mp_hands = mp.solutions.hands

mp_drawing = mp.solutions.drawing_utils

hands = mp_hands.Hands(max_num_hands=1, min_detection_confidence=0.7)

def is_finger_open(lm, tip, pip):

return lm[tip].y < lm[pip].y

def is_back_of_hand(lm):

# 손바닥/손등 판별: 엄지와 검지 중간 마디 z 좌표 평균

thumb_mcp_z = lm[2].z

index_mcp_z = lm[5].z

avg_z = (thumb_mcp_z + index_mcp_z) / 2

return avg_z > 0 # 양수면 손등, 음수면 손바닥

def is_thumb_open(lm, handedness):

back_of_hand = is_back_of_hand(lm)

if back_of_hand:

# 손등 방향일 때 엄지 인식 반전

if handedness == "Right":

return lm[4].x > lm[3].x

else:

return lm[4].x < lm[3].x

else:

# 손바닥 방향일 때 기존 로직

if handedness == "Right":

return lm[4].x < lm[3].x

else:

return lm[4].x > lm[3].x

def detect_gesture(hand_landmarks, handedness):

lm = hand_landmarks.landmark

thumb = is_thumb_open(lm, handedness)

index = is_finger_open(lm, 8, 6)

middle = is_finger_open(lm, 12, 10)

ring = is_finger_open(lm, 16, 14)

pinky = is_finger_open(lm, 20, 18)

# 바위: 모두 접음

if not thumb and not index and not middle and not ring and not pinky:

return "Rock"

# 보: 모두 핌

elif thumb and index and middle and ring and pinky:

return "Paper"

# 가위: 검지+중지 또는 엄지+검지 핌 (가위손)

elif (index and middle and not ring and not pinky) or (thumb and index and not middle and not ring and not pinky):

return "Scissors"

else:

return "Unknown"

def decide_winner(player, computer):

if player == computer:

return "Draw"

elif (player "Rock" and computer "Scissors") or \

(player "Scissors" and computer "Paper") or \

(player "Paper" and computer "Rock"):

return "You Win!"

else:

return "You Lose!"

cap = cv2.VideoCapture(0)

game_state = "ready"

count_start_time = 0

player_choice = ""

computer_choice = ""

result_text = ""

while True:

ret, frame = cap.read()

if not ret:

break

frame = cv2.flip(frame, 1) # 좌우 반전

image_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

result = hands.process(image_rgb)

h, w, _ = frame.shape

if game_state == "ready":

cv2.putText(frame, "Press 'Space' to Start", (50, 50),

cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 200, 200), 2)

elif game_state == "countdown":

elapsed = time.time() - count_start_time

remaining = max(0, 3 - int(elapsed))

if remaining > 0:

cv2.putText(frame, f"{remaining}", (w // 2 - 20, h // 2),

cv2.FONT_HERSHEY_DUPLEX, 3, (255, 0, 0), 5)

else:

game_state = "result"

if result.multi_hand_landmarks and result.multi_handedness:

hand = result.multi_hand_landmarks[0]

handedness_label = result.multi_handedness[0].classification[0].label

player_choice = detect_gesture(hand, handedness_label)

else:

player_choice = "Unknown"

computer_choice = random.choice(["Rock", "Paper", "Scissors"])

result_text = decide_winner(player_choice, computer_choice)

result_time = time.time()

elif game_state == "result":

cv2.putText(frame, f"You: {player_choice}", (50, 80),

cv2.FONT_HERSHEY_SIMPLEX, 1.2, (0, 255, 255), 2)

cv2.putText(frame, f"Computer: {computer_choice}", (50, 130),

cv2.FONT_HERSHEY_SIMPLEX, 1.2, (0, 255, 255), 2)

cv2.putText(frame, result_text, (50, 200),

cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 128, 255), 4)

if time.time() - result_time > 3:

game_state = "ready"

if result.multi_hand_landmarks:

for hand_landmarks in result.multi_hand_landmarks:

mp_drawing.draw_landmarks(frame, hand_landmarks, mp_hands.HAND_CONNECTIONS)

cv2.imshow("Rock Paper Scissors", frame)

key = cv2.waitKey(1) & 0xFF

if key == 27: # ESC

break

elif key 32 and game_state "ready": # Space

count_start_time = time.time()

game_state = "countdown"

player_choice = ""

computer_choice = ""

result_text = ""

cap.release()

cv2.destroyAllWindows()

import mediapipe as mp

import math

from pynput.mouse import Controller, Button

# Mediapipe 초기화

mp_hands = mp.solutions.hands

mp_drawing = mp.solutions.drawing_utils

hands = mp_hands.Hands()

# 마우스 컨트롤 초기화

mouse = Controller()

paper_holding = False  # Paper 유지 상태 변수

scissors_clicked = False

# 웹캠 열기

cap = cv2.VideoCapture(0)

def calculate_angle(a, b, c):

    """세 점을 이용해 각도를 계산하는 함수"""

    ab = [a[0] - b[0], a[1] - b[1]]

    bc = [c[0] - b[0], c[1] - b[1]]

    dot = ab[0] bc[0] + ab[1] bc[1]

    det = ab[0] bc[1] - ab[1] bc[0]

    angle = math.atan2(det, dot) * 180.0 / math.pi

    return abs(angle)

def detect_finger_open(landmarks, width, height):

    """손가락을 핀 상태로 인식하는 함수"""

    finger_tips = [4, 8, 12, 16, 20]

    finger_ips = [3, 7, 11, 15, 19]

    finger_names = ["Thumb", "Index", "Middle", "Ring", "Pinky"]

    open_fingers = []

    open_threshold = 160  # 각도가 160도 이상이면 핀 상태로 인식

    wrist = (landmarks[0].x width, landmarks[0].y height)

    for tip_idx, ip_idx, name in zip(finger_tips, finger_ips, finger_names):

        tip = (landmarks[tip_idx].x width, landmarks[tip_idx].y height)

        ip = (landmarks[ip_idx].x width, landmarks[ip_idx].y height)

        angle = calculate_angle(tip, ip, wrist)

        if angle > open_threshold:

            open_fingers.append(name)

    return open_fingers

def recognize_gesture(open_fingers):

    """가위, 바위, 보 제스처를 인식하는 함수"""

    if len(open_fingers) == 5:

        return "Paper"

    elif len(open_fingers) == 2 and "Index" in open_fingers and "Middle" in open_fingers:

        return "Scissors"

    elif len(open_fingers) == 0:

        return "Rock"

    return "just hand"

def perform_action(gesture):

    """제스처에 따른 마우스 동작 수행"""

    global paper_holding, scissors_clicked

    if gesture == "Paper":

        if not paper_holding:

            print("Paper 감지 → 더블클릭 + 눌림 유지")

            mouse.click(Button.left, 2)

            mouse.press(Button.left)

            paper_holding = True

        scissors_clicked = False

    else:

        if paper_holding:

            print("Paper 해제 → 버튼 놓기")

            mouse.release(Button.left)

            paper_holding = False

        if gesture == "Scissors":

            if not scissors_clicked:

                mouse.click(Button.left)

                scissors_clicked = True

        else:

            scissors_clicked = False

while True:

    success, frame = cap.read()

    if not success:

        break

    frame = cv2.flip(frame, 1)

    image_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

    result = hands.process(image_rgb)

    if result.multi_hand_landmarks:

        for hand_landmarks, handedness in zip(result.multi_hand_landmarks, result.multi_handedness):

            h, w, _ = frame.shape

            hand_label = handedness.classification[0].label

            open_fingers = detect_finger_open(hand_landmarks.landmark, w, h)

            gesture = recognize_gesture(open_fingers)

            perform_action(gesture)

            # 디버깅 텍스트만 표시 (랜드마크 표시 제거됨)

            color = (0, 255, 0) if hand_label == "Left" else (0, 0, 255)

            position = (50, 50) if hand_label == "Left" else (50, 100)

            cv2.putText(frame, f"{hand_label} Hand: {gesture}", position,

                        cv2.FONT_HERSHEY_SIMPLEX, 1, color, 2)

    cv2.imshow("Rock Paper Scissors Gesture Recognition", frame)

    if cv2.waitKey(1) & 0xFF == 27:  # ESC 키로 종료

        break

cap.release()

cv2.destroyAllWindows()

import mediapipe as mp

import numpy as np

mp_hands = mp.solutions.hands

mp_face_mesh = mp.solutions.face_mesh

hands = mp_hands.Hands()

face_mesh = mp_face_mesh.FaceMesh()

cap = cv2.VideoCapture(0)

def is_only_thumb_index_pinky_open(hand_landmarks):

lm = hand_landmarks.landmark

def y_open(tip, pip):

return lm[tip].y < lm[pip].y

def y_closed(tip, pip):

return lm[tip].y > lm[pip].y

thumb_open = lm[mp_hands.HandLandmark.THUMB_TIP].x < lm[mp_hands.HandLandmark.THUMB_IP].x

index_open = y_open(mp_hands.HandLandmark.INDEX_FINGER_TIP, mp_hands.HandLandmark.INDEX_FINGER_PIP)

pinky_open = y_open(mp_hands.HandLandmark.PINKY_TIP, mp_hands.HandLandmark.PINKY_PIP)

middle_closed = y_closed(mp_hands.HandLandmark.MIDDLE_FINGER_TIP, mp_hands.HandLandmark.MIDDLE_FINGER_PIP)

ring_closed = y_closed(mp_hands.HandLandmark.RING_FINGER_TIP, mp_hands.HandLandmark.RING_FINGER_PIP)

return thumb_open and index_open and pinky_open and middle_closed and ring_closed

def get_eye_coordinates(face_landmarks, image_width, image_height):

left_eye_idx = [33, 133]

right_eye_idx = [362, 263]

left_eye = []

right_eye = []

for idx in left_eye_idx:

x = int(face_landmarks[idx].x * image_width)

y = int(face_landmarks[idx].y * image_height)

left_eye.append((x, y))

for idx in right_eye_idx:

x = int(face_landmarks[idx].x * image_width)

y = int(face_landmarks[idx].y * image_height)

right_eye.append((x, y))

return left_eye, right_eye

def draw_sunglasses(frame, left_eye, right_eye):

left_center = np.mean(left_eye, axis=0).astype(int)

right_center = np.mean(right_eye, axis=0).astype(int)

eye_distance = int(np.linalg.norm(left_center - right_center))

glass_width = eye_distance * 2

glass_height = eye_distance // 2

mid_x = (left_center[0] + right_center[0]) // 2

mid_y = (left_center[1] + right_center[1]) // 2

left_top = (mid_x - glass_width // 2, mid_y - glass_height // 2)

right_top = (mid_x, mid_y - glass_height // 2)

# 렌즈

cv2.rectangle(frame, left_top, (left_top[0] + glass_width // 2, left_top[1] + glass_height), (0, 0, 0), -1)

cv2.rectangle(frame, right_top, (right_top[0] + glass_width // 2, right_top[1] + glass_height), (0, 0, 0), -1)

# 브릿지

cv2.line(frame, (left_top[0] + glass_width // 2, mid_y), (right_top[0], mid_y), (0, 0, 0), 5)

while cap.isOpened():

ret, frame = cap.read()

if not ret:

break

frame = cv2.flip(frame, 1)

# MediaPipe 처리

frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

results_hands = hands.process(frame_rgb)

results_face = face_mesh.process(frame_rgb)

if results_hands.multi_hand_landmarks:

for hand_landmarks in results_hands.multi_hand_landmarks:

if is_only_thumb_index_pinky_open(hand_landmarks):

if results_face.multi_face_landmarks:

for face_landmarks in results_face.multi_face_landmarks:

left_eye, right_eye = get_eye_coordinates(face_landmarks.landmark, frame.shape[1], frame.shape[0])

draw_sunglasses(frame, left_eye, right_eye)

cv2.imshow('Frame', frame)

if cv2.waitKey(1) & 0xFF == ord('q'):

break

cap.release()

cv2.destroyAllWindows()

import mediapipe as mp

import math

# Mediapipe 초기화

mp_hands = mp.solutions.hands

mp_drawing = mp.solutions.drawing_utils

hands = mp_hands.Hands(

max_num_hands=1,

min_detection_confidence=0.7,

min_tracking_confidence=0.5

)

# 실험 상태 변수

experiment_started = False

selected_variable = None

adjusting = False

current_gesture = "None"

# 각도 계산 함수 (사용 안 하지만 참고용)

def calculate_angle(a, b, c):

ab = [a[0] - b[0], a[1] - b[1]]

bc = [c[0] - b[0], c[1] - b[1]]

dot = ab[0] bc[0] + ab[1] bc[1]

det = ab[0] bc[1] - ab[1] bc[0]

angle = math.atan2(det, dot) * 180.0 / math.pi

return abs(angle)

# 손가락 열림 감지

def detect_finger_open(landmarks, width, height):

finger_tips = [4, 8, 12, 16, 20]

finger_ips = [3, 7, 11, 15, 19]

finger_names = ["Thumb", "Index", "Middle", "Ring", "Pinky"]

open_fingers = []

open_threshold = 160 # 각도 기준 (180에 가까울수록 더 곧게 펴짐)

wrist = (landmarks[0].x width, landmarks[0].y height)

for tip_idx, ip_idx, name in zip(finger_tips, finger_ips, finger_names):

tip = (landmarks[tip_idx].x width, landmarks[tip_idx].y height)

ip = (landmarks[ip_idx].x width, landmarks[ip_idx].y height)

angle = calculate_angle(tip, ip, wrist)

if angle > open_threshold:

open_fingers.append(name)

return open_fingers

# 제스처 인식

def recognize_gesture(open_fingers, landmarks, width, height):

if len(open_fingers) == 5:

return "Start_Experiment"

elif len(open_fingers) == 0:

return "Stop_Experiment"

elif len(open_fingers) == 1 and "Index" in open_fingers:

return "Select"

# 엄지와 검지의 거리로 Pinch 감지

thumb_tip = landmarks[4]

index_tip = landmarks[8]

distance = math.hypot((thumb_tip.x - index_tip.x) * width,

(thumb_tip.y - index_tip.y) * height)

if distance < 40:

return "Pinch"

return "None"

# 제스처에 따른 동작 수행

def perform_action(gesture):

global experiment_started, selected_variable, adjusting

if gesture == "Start_Experiment":

if not experiment_started:

print("🧪 실험 시작!")

experiment_started = True

selected_variable = None

adjusting = False

elif gesture == "Stop_Experiment":

if experiment_started:

print("🛑 실험 종료! 데이터 저장 완료.")

experiment_started = False

selected_variable = None

adjusting = False

elif gesture == "Select" and experiment_started:

print("👉 변수 선택: 온도")

selected_variable = "온도"

adjusting = False

elif gesture == "Pinch" and selected_variable:

if not adjusting:

print(f"🤏 {selected_variable} 조절 시작")

adjusting = True

else:

print(f"⚙️ {selected_variable} 값 조정 중...")

elif gesture == "None":

if adjusting:

print("🔓 조절 종료")

adjusting = False

# 웹캠 실행

cap = cv2.VideoCapture(0)

while True:

success, frame = cap.read()

if not success:

break

frame = cv2.flip(frame, 1)

h, w, _ = frame.shape

image_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

result = hands.process(image_rgb)

if result.multi_hand_landmarks:

for hand_landmarks, handedness in zip(result.multi_hand_landmarks, result.multi_handedness):

mp_drawing.draw_landmarks(frame, hand_landmarks, mp_hands.HAND_CONNECTIONS)

open_fingers = detect_finger_open(hand_landmarks.landmark, w, h)

gesture = recognize_gesture(open_fingers, hand_landmarks.landmark, w, h)

if gesture != current_gesture:

current_gesture = gesture

perform_action(gesture)

# 화면에 현재 상태 시각화

cv2.putText(frame, f"Gesture: {gesture}", (10, 40),

cv2.FONT_HERSHEY_SIMPLEX, 1.2, (0, 255, 0), 3)

cv2.putText(frame, f"Experiment: {'ON' if experiment_started else 'OFF'}", (10, 80),

cv2.FONT_HERSHEY_SIMPLEX, 1.2, (255, 100, 0), 3)

if selected_variable:

cv2.putText(frame, f"Variable: {selected_variable}", (10, 120),

cv2.FONT_HERSHEY_SIMPLEX, 1.2, (100, 255, 255), 3)

if adjusting:

cv2.putText(frame, f"Adjusting: YES", (10, 160),

cv2.FONT_HERSHEY_SIMPLEX, 1.2, (0, 100, 255), 3)

else:

current_gesture = "None"

cv2.imshow("Smart Lab Assistant - Gesture Control", frame)

if cv2.waitKey(1) & 0xFF == 27: # ESC 키

break

cap.release()

cv2.destroyAllWindows()