2024 AI메이커톤(광양고) by 이미숙

Face detection

gwangyang243 — 2024-08-24 08:40:55 UTC

Hands

gwangyang243 — 2024-08-24 08:41:07 UTC

Face detection

gwangyang243 — 2024-08-24 08:42:32 UTC

Hands

gwangyang243 — 2024-08-24 08:44:16 UTC

일정

gwangyang243 — 2024-08-24 08:47:07 UTC

8월 30일(금) 정보관 4층 AI실

2:50 ~ 3:10 등록 및 팀빌딩

3:20 ~ 5:00 mediapipe, face detection, hands 강의

5:00 ~ 5:30 저녁식사

5:30 ~ 7:30 모둠별 기획 및 제작

7:30 ~ 8:30 발표 및 갤러리워크, 시상

운영진

gwangyang243 — 2024-08-24 08:47:48 UTC

강사: 정보 이미숙

보조강사: 졸업생 김태선, 김철주

모둠별 산출물

gwangyang243 — 2024-08-24 08:54:26 UTC

1.기획PPT

목표 및 배경: 프로그램 기획의 목적과 배경 설명
프로그램 개요: 프로그램의 주요 내용 및 특성
프로그램 구현: 순서도 및 프로그램
성과 및 기대 효과: 프로그램 실행 후 예상되는 성과와 기대 효과

2.구현 프로그램

최약체둘

gwangyang230518 — 2024-08-30 06:19:30 UTC

team. code

2024-08-30 06:19:58 UTC

집가고싶다

2024-08-30 06:20:12 UTC

멋진 팀 이름

2024-08-30 06:20:13 UTC

혜지쌤의 아이들

2024-08-30 06:20:24 UTC

놈놈놈놈

2024-08-30 06:20:47 UTC

한태경 팀

2024-08-30 06:38:57 UTC

2024-08-30 09:11:03 UTC

2024-08-30 09:43:32 UTC

import cv2

import mediapipe as mp

mp_drawing = mp.solutions.drawing_utils

mp_hands = mp.solutions.hands

drawing = False

points = []

def recognize_gesture(hand_landmarks):

index_tip = hand_landmarks.landmark[mp_hands.HandLandmark.INDEX_FINGER_TIP]

thumb_tip = hand_landmarks.landmark[mp_hands.HandLandmark.THUMB_TIP]

if index_tip.y < thumb_tip.y:

return "Drawing"

else:

return "Not Drawing"

def main():

global drawing, points

cap = cv2.VideoCapture(0)

if not cap.isOpened():

print("웹캠을 열 수 없습니다.")

return

with mp_hands.Hands(

model_complexity=1,

min_detection_confidence=0.7,

min_tracking_confidence=0.7

) as hands:

while True:

success, image = cap.read()

if not success:

print("빈 카메라 프레임을 무시합니다.")

continue

image = cv2.flip(image, 1)

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

results = hands.process(image_rgb)

if results.multi_hand_landmarks:

for hand_landmarks in results.multi_hand_landmarks:

gesture = recognize_gesture(hand_landmarks)

index_tip = hand_landmarks.landmark[mp_hands.HandLandmark.INDEX_FINGER_TIP]

x, y = int(index_tip.x image.shape[1]), int(index_tip.y image.shape[0])

if gesture == "Drawing":

drawing = True

points.append((x, y))

else:

drawing = False

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

if drawing and len(points) > 1:

for i in range(1, len(points)):

cv2.line(image, points[i - 1], points[i], (0, 255, 0), 5)

cv2.imshow('Hand Gesture Drawing', image)

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

break

cap.release()

cv2.destroyAllWindows()

if name == "__main__":

main()

2024-08-30 10:00:33 UTC

신세계를 경험할수 있습니다

2024-08-30 10:00:54 UTC

카메라를 향해 손가락을 들어주세요

화이트보드

2024-08-30 10:13:39 UTC

화이트 보드

손 다 펴면 그려지고 주먹 쥐면 멈춤

enter 화이트보드 초기화

키보드 x 버튼 그리기 멈춤

키보드 s 버튼 화이트보드 저장

2024-08-30 10:16:16 UTC

AR 키보드

gwangyang230518 — 2024-08-30 10:17:33 UTC

import cv2
import mediapipe as mp
import numpy as np
from pynput.keyboard import Controller

# Initialize Mediapipe Hands and drawing utilities
mp_hands = mp.solutions.hands

# Initialize the keyboard controller
keyboard = Controller()

# Initialize webcam
cap = cv2.VideoCapture(0)

# Define the virtual keyboard layout for 'a' to 'z'
keys = list("abcdefghijklmnopqrstuvwxyz")
key_size = 50  # Size of each key
rows = 3  # Number of rows in the virtual keyboard
keys_per_row = 10  # Number of keys per row

# Calculate key positions
key_positions = []
for i in range(rows):
    row_keys = keys[i * keys_per_row: (i + 1) * keys_per_row]
    for j, key in enumerate(row_keys):
        x = 30 + j * (key_size + 10)
        y = 50 + i * (key_size + 10)
        key_positions.append((key, (x, y)))

# Reverse key positions for display
def reverse_key_positions(positions):
    h, w, _ = image.shape
    return [(key, (w - x - key_size, y)) for key, (x, y) in positions]

# List of fingertip landmarks (only thumb and index finger)
fingertip_landmarks = [
    mp_hands.HandLandmark.THUMB_TIP,      # Thumb
    mp_hands.HandLandmark.INDEX_FINGER_TIP # Index Finger
]

# Initialize Mediapipe Hands solution
with mp_hands.Hands(
    model_complexity=0,
    min_detection_confidence=0.5,
    min_tracking_confidence=0.5) as hands:
    
    # Dictionary to track touch states and previous touch states
    key_touch_states = {key: False for key, _ in key_positions}
    prev_key_touch_states = {key: False for key, _ in key_positions}
    
    while cap.isOpened():
        success, image = cap.read()
        if not success:
            print("Ignoring empty camera frame.")
            break

        # Convert the image to RGB
        image.flags.writeable = False
        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
        results = hands.process(image)

        # Convert back to BGR for rendering
        image.flags.writeable = True
        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
        h, w, _ = image.shape

        # Create a transparent overlay for the keyboard
        overlay = np.zeros((h, w, 4), dtype=np.uint8)
        alpha = 170  # Transparency level (0-255, 255 is fully opaque)

        # Draw the virtual keyboard on the overlay
        reversed_key_positions = reverse_key_positions(key_positions)
        for key, pos in reversed_key_positions:
            x, y = pos
            color = (255, 255, 255)  # Default color is white
            if key_touch_states[key]:
                color = (0, 255, 0)  # Change color to green if the key is pressed
            cv2.rectangle(overlay, (x, y), (x + key_size, y + key_size), color, -1)
            cv2.putText(overlay, key, (x + 15, y + 45), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 2)

        # Add alpha channel to the overlay
        overlay = cv2.merge((overlay[:, :, :3], (overlay[:, :, 3] * alpha / 255).astype(np.uint8)))

        # Blend the overlay with the original image
        image = cv2.addWeighted(image, 1.0, overlay[:, :, :3], alpha / 255.0, 0)

        # Reset key touch states
        for key in key_touch_states.keys():
            key_touch_states[key] = False

        # If hand landmarks are detected
        if results.multi_hand_landmarks:
            for hand_landmarks in results.multi_hand_landmarks:
                # Get coordinates of thumb and index fingertip
                fingertip_coords = {}
                for fingertip in fingertip_landmarks:
                    fingertip_coords[fingertip] = hand_landmarks.landmark[fingertip]

                # Check distance between thumb and index finger
                def distance(pt1, pt2):
                    return np.sqrt((pt1.x - pt2.x)**2 + (pt1.y - pt2.y)**2 + (pt1.z - pt2.z)**2)

                # Define a threshold distance for the fingers to be considered close
                close_threshold = 0.05

                thumb_fingertip = fingertip_landmarks[0]
                index_fingertip = fingertip_landmarks[1]
                dist = distance(fingertip_coords[thumb_fingertip], fingertip_coords[index_fingertip])
                
                if dist < close_threshold:
                    # Mark the keys under the fingertips as touched
                    for key, pos in key_positions:
                        x, y = pos
                        thumb_pixel = (int(fingertip_coords[thumb_fingertip].x * w), int(fingertip_coords[thumb_fingertip].y * h))
                        index_pixel = (int(fingertip_coords[index_fingertip].x * w), int(fingertip_coords[index_fingertip].y * h))
                        
                        x_flipped = w - x - key_size

                        if (x_flipped <= thumb_pixel[0] <= x_flipped + key_size and y <= thumb_pixel[1] <= y + key_size) or \
                           (x_flipped <= index_pixel[0] <= x_flipped + key_size and y <= index_pixel[1] <= y + key_size):
                            key_touch_states[key] = True

        # Print key press event only if the key state has just been changed to pressed
        for key in key_touch_states.keys():
            if key_touch_states[key] and not prev_key_touch_states[key]:
                # Reverse key position for actual input
                actual_key_pos = {k: pos for k, pos in zip(keys, key_positions)}
                reversed_key_pos = reverse_key_positions(key_positions)
                for rev_key, rev_pos in reversed_key_pos:
                    if key == rev_key:
                        # Simulate key press using pynput
                        keyboard.press(key)
                        keyboard.release(key)
                        print(f"{key}",end='')
                        break

        # Update previous key touch states
        prev_key_touch_states = key_touch_states.copy()

        # Mirror the image and show it
        cv2.imshow('Virtual Keyboard', cv2.flip(image, 1))
        
        # Exit on 'Esc' key press
        if cv2.waitKey(5) & 0xFF == 27:
            break

# Release the capture device
cap.release()
cv2.destroyAllWindows()

2024-08-30 10:19:20 UTC

2024-08-30 10:22:38 UTC

2024-08-30 10:22:50 UTC