app.py

import os
import RPi.GPIO as GPIO
import time
import threading
from flask import Flask, render_template, Response, request
from flask_socketio import SocketIO
from datetime import datetime
import cv2
import numpy as np
import camera

# Flask 앱 설정
app = Flask(__name__)
socketio = SocketIO(app)

UPLOAD_FOLDER = 'static/images'
if not os.path.exists(UPLOAD_FOLDER):
    os.makedirs(UPLOAD_FOLDER)

# GPIO 핀 설정
TRIG = 20
ECHO = 16
LED_PINS = [6, 13, 19]

# GPIO 초기화
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.setup(TRIG, GPIO.OUT)
GPIO.setup(ECHO, GPIO.IN)
for pin in LED_PINS:
    GPIO.setup(pin, GPIO.OUT)

# 필터 이미지
filters = {
    "cat": cv2.imread("static/filters/cat.png", cv2.IMREAD_UNCHANGED),
    "bunny": cv2.imread("static/filters/bunny.png", cv2.IMREAD_UNCHANGED),
    "dog": cv2.imread("static/filters/dog.png", cv2.IMREAD_UNCHANGED),
    "angel": cv2.imread("static/filters/angel.png", cv2.IMREAD_UNCHANGED),
    "devil": cv2.imread("static/filters/devil.png", cv2.IMREAD_UNCHANGED),
}

# 얼굴 탐지기 초기화
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + "haarcascade_frontalface_default.xml")

# 전역 변수
selected_filter = None
countdown_active = False
led_blinking = False

# 초음파 센서 거리 측정
def measure_distance(trig, echo):
    time.sleep(0.2)
    GPIO.output(trig, GPIO.HIGH)
    time.sleep(0.00001)
    GPIO.output(trig, GPIO.LOW)

    while GPIO.input(echo) == 0:
        pulse_start = time.time()

    while GPIO.input(echo) == 1:
        pulse_end = time.time()

    pulse_duration = pulse_end - pulse_start
    distance = pulse_duration * 34300 / 2  # 거리 계산 (cm)
    return distance

# LED 깜빡임 함수
def blink_leds():
    global led_blinking
    led_blinking = True
    while led_blinking:
        for pin in LED_PINS:
            GPIO.output(pin, GPIO.HIGH)
        time.sleep(0.5)
        for pin in LED_PINS:
            GPIO.output(pin, GPIO.LOW)
        time.sleep(0.5)

# 카운트다운 및 LED 연동
def countdown_with_led():
    global countdown_active, led_blinking
    countdown_active = True
    threading.Thread(target=blink_leds, daemon=True).start()

    for i in range(10, 0, -1):
        print(f"카운트다운: {i}초 남음")
        socketio.emit('countdown', {'time': i})
        time.sleep(1)

    countdown_active = False
    led_blinking = False
    for pin in LED_PINS:
        GPIO.output(pin, GPIO.LOW)
    take_picture()

# 초음파 센서 감지 스레드
def sensor_monitor():
    global countdown_active
    while True:
        try:
            distance = measure_distance(TRIG, ECHO)
            if distance < 30:  # 30cm 이내에서 카운트다운 시작
                if not countdown_active:
                    threading.Thread(target=countdown_with_led, daemon=True).start()
        except Exception as e:
            print(f"초음파 센서 오류: {e}")
        time.sleep(0.5)

# 사진 촬영 함수
def take_picture():
    global selected_filter
    frame = camera.take_picture()

    if frame is None:
        print("사진 촬영 실패: 카메라 문제")
        return

    if selected_filter and selected_filter in filters:
        frame = apply_filter(frame, filters[selected_filter])

    filename = f"{UPLOAD_FOLDER}/{datetime.now().strftime('%Y%m%d_%H%M%S')}.jpg"
    success = cv2.imwrite(filename, frame)
    if success:
        print(f"사진 저장 성공: {filename}")
    else:
        print("사진 저장 실패")

# 필터 적용 함수
def apply_filter(frame, filter_image):
    gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    faces = face_cascade.detectMultiScale(gray_frame, scaleFactor=1.1, minNeighbors=5, minSize=(50, 50))

    for (x, y, w, h) in faces:
        filter_resized = cv2.resize(filter_image, (w, h))
        fw, fh = filter_resized.shape[1], filter_resized.shape[0]
        alpha_mask = filter_resized[:, :, 3] / 255.0

        fy = y - 30
        fy = max(fy, 0)
        if fy + fh > frame.shape[0]:
            fy = frame.shape[0] - fh

        for c in range(3):
            frame[fy:fy+fh, x:x+fw, c] = (
                alpha_mask * filter_resized[:, :, c] +
                (1 - alpha_mask) * frame[fy:fy+fh, x:x+fw, c]
            )
    return frame

# 실시간 비디오 스트리밍
def gen_frames():
    global selected_filter
    while True:
        frame = camera.take_picture()
        if frame is None:
            continue

        if selected_filter and selected_filter in filters:
            frame = apply_filter(frame, filters[selected_filter])

        ret, buffer = cv2.imencode('.jpg', frame, [cv2.IMWRITE_JPEG_QUALITY, 70])
        if not ret:
            continue
        yield (b'--frame\r\n'
               b'Content-Type: image/jpeg\r\n\r\n' + buffer.tobytes() + b'\r\n')

# Flask 라우트
@app.route('/')
def index():
    return render_template('index.html')

@app.route('/video_feed')
def video_feed():
    return Response(gen_frames(), mimetype='multipart/x-mixed-replace; boundary=frame')

@app.route('/set_filter', methods=['POST'])
def set_filter():
    global selected_filter
    data = request.get_json()
    selected_filter = data.get('filter')
    return "필터 설정 성공", 200

@app.route('/start_countdown')
def start_countdown():
    global countdown_active
    if not countdown_active:
        threading.Thread(target=countdown_with_led, daemon=True).start()
        return "카운트다운 시작!"
    return "이미 카운트다운 중입니다."

if __name__ == '__main__':
    camera.init(width=640, height=480)
    try:
        threading.Thread(target=sensor_monitor, daemon=True).start()
        socketio.run(app, host='0.0.0.0', port=5000)
    finally:
        camera.final()
        GPIO.cleanup()