feat: done

.gitignore

@@ -0,0 +1 @@
+/music

README.md

@@ -1,12 +1,42 @@
 ---
-title: Visual Music App
-emoji: 📉
-colorFrom: gray
-colorTo: yellow
+title: El Hareketiyle Müzik Kontrol
+emoji: 🎵
+colorFrom: purple
+colorTo: blue
 sdk: gradio
-sdk_version: 6.5.1
+sdk_version: "4.0.0"
 app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🎵 El Hareketiyle Müzik Kontrol
+
+Kamera ile el hareketlerinizi algılayarak müzik kontrol edin!
+
+## 🎯 El Hareketleri
+
+| Hareket | Eylem |
+|---------|-------|
+| ✋ Avuç aç (4-5 parmak) | **DURDUR** |
+| ☝️ Sadece işaret parmağı | **OYNAT** |
+| 👋 Eli hızla savur | **SONRAKİ** |
+
+## 🎶 Mevcut Şarkılar
+- 🎵 GOT Main Theme
+- 🎵 Hedwig's Theme
+- 🎵 The Shire
+
+## 🚀 Kullanım
+1. "▶️ Müziği Başlat" butonuna tıklayın
+2. Kameranızı açın
+3. El hareketlerinizle müziği kontrol edin!
+
+## 💡 İpuçları
+- Elinizi kameraya yakın tutun
+- İyi aydınlatma sağlayın
+- Parmakları net gösterin
+
+## 🛠️ Teknolojiler
+- **Gradio** - Web arayüzü
+- **MediaPipe** - El algılama
+- **OpenCV** - Görüntü işleme

app.py

@@ -0,0 +1,346 @@
+"""
+El Hareketiyle Müzik Kontrol Uygulaması
+Gradio + MediaPipe + Audio Player
+
+Hugging Face Spaces için optimize edilmiş
+"""
+
+import gradio as gr
+import cv2
+import numpy as np
+from collections import deque
+import time
+import os
+from pathlib import Path
+
+# MediaPipe
+import mediapipe as mp
+
+mpHands = mp.solutions.hands
+mpDraw = mp.solutions.drawing_utils
+
+print("✓ MediaPipe yüklendi!")
+
+# Müzik dosyalarını bul
+MUSIC_DIR = Path(__file__).parent / "music"
+MUSIC_FILES = []
+
+if MUSIC_DIR.exists():
+    for ext in ['*.mp3', '*.wav', '*.ogg']:
+        MUSIC_FILES.extend(list(MUSIC_DIR.glob(ext)))
+    MUSIC_FILES = sorted(MUSIC_FILES)
+    print(f"✓ {len(MUSIC_FILES)} müzik dosyası bulundu!")
+else:
+    print("⚠ music/ klasörü bulunamadı")
+
+
+class MusicController:
+    """Müzik durumunu takip eden sınıf"""
+    def __init__(self):
+        self.current_index = 0
+        self.is_playing = False
+        self.music_files = MUSIC_FILES
+    
+    def get_current_track(self):
+        if self.music_files:
+            return str(self.music_files[self.current_index])
+        return None
+    
+    def get_current_name(self):
+        if self.music_files:
+            return self.music_files[self.current_index].stem
+        return "Müzik yok"
+    
+    def next_track(self):
+        if self.music_files:
+            self.current_index = (self.current_index + 1) % len(self.music_files)
+        return self.get_current_track(), self.get_current_name()
+    
+    def play(self):
+        self.is_playing = True
+    
+    def pause(self):
+        self.is_playing = False
+
+
+class HandGestureDetector:
+    """El hareketlerini algılayan sınıf"""
+    
+    def __init__(self):
+        self.hands = mpHands.Hands(
+            static_image_mode=False,
+            max_num_hands=1,
+            min_detection_confidence=0.7,
+            min_tracking_confidence=0.7
+        )
+        self.tipIds = [4, 8, 12, 16, 20]
+        self.position_history = deque(maxlen=10)
+        self.last_swipe_time = 0
+        self.last_gesture_time = 0
+    
+    def fingersUp(self, lmList):
+        """Hangi parmaklar yukarıda"""
+        fingers = []
+        if len(lmList) < 21:
+            return [0, 0, 0, 0, 0]
+        
+        # Başparmak
+        if lmList[self.tipIds[0]][1] < lmList[self.tipIds[0] - 1][1]:
+            fingers.append(1)
+        else:
+            fingers.append(0)
+        
+        # Diğer 4 parmak
+        for id in range(1, 5):
+            if lmList[self.tipIds[id]][2] < lmList[self.tipIds[id] - 2][2]:
+                fingers.append(1)
+            else:
+                fingers.append(0)
+        
+        return fingers
+    
+    def detect(self, frame):
+        """El algıla ve gesture döndür"""
+        if frame is None:
+            return None, None, "Kamera bekleniyor..."
+        
+        # BGR'ye çevir (Gradio RGB verir)
+        frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
+        frame = cv2.flip(frame, 1)  # Ayna
+        
+        imgRGB = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        results = self.hands.process(imgRGB)
+        
+        gesture = None
+        gesture_text = "👋 El gösterin"
+        current_time = time.time()
+        h, w = frame.shape[:2]
+        
+        if results.multi_hand_landmarks:
+            for handLms in results.multi_hand_landmarks:
+                # El çiz
+                mpDraw.draw_landmarks(frame, handLms, mpHands.HAND_CONNECTIONS)
+                
+                # Landmark listesi
+                lmList = []
+                for id, lm in enumerate(handLms.landmark):
+                    cx, cy = int(lm.x * w), int(lm.y * h)
+                    lmList.append([id, cx, cy])
+                
+                if len(lmList) >= 21:
+                    fingers = self.fingersUp(lmList)
+                    totalFingers = sum(fingers)
+                    wrist_x = lmList[0][1]
+                    
+                    # Swipe algılama
+                    self.position_history.append((wrist_x, current_time))
+                    
+                    if len(self.position_history) >= 6:
+                        positions = list(self.position_history)
+                        x_diff = positions[-1][0] - positions[0][0]
+                        time_diff = positions[-1][1] - positions[0][1]
+                        
+                        if time_diff < 0.35 and abs(x_diff) > 120:
+                            if current_time - self.last_swipe_time > 1.0:
+                                gesture = "swipe"
+                                self.last_swipe_time = current_time
+                                self.position_history.clear()
+                    
+                    # Gesture algılama
+                    if gesture is None and current_time - self.last_gesture_time > 0.5:
+                        if totalFingers >= 4:
+                            gesture = "palm"
+                            self.last_gesture_time = current_time
+                        elif fingers[1] == 1 and sum(fingers[2:]) == 0:
+                            gesture = "index"
+                            self.last_gesture_time = current_time
+                    
+                    # Görsel ve metin
+                    if gesture == "palm":
+                        cv2.putText(frame, "DURDUR", (50, 80),
+                                   cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 0, 255), 4)
+                        gesture_text = "✋ DURDUR"
+                    elif gesture == "index":
+                        cv2.putText(frame, "OYNAT", (50, 80),
+                                   cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 255, 0), 4)
+                        gesture_text = "☝️ OYNAT"
+                    elif gesture == "swipe":
+                        direction = ">>>" if x_diff > 0 else "<<<"
+                        cv2.putText(frame, f"SONRAKI {direction}", (50, 80),
+                                   cv2.FONT_HERSHEY_SIMPLEX, 1.5, (255, 165, 0), 3)
+                        gesture_text = "👋 SONRAKİ"
+                    else:
+                        gesture_text = f"🖐️ {totalFingers} parmak"
+                    
+                    # Debug
+                    cv2.putText(frame, f"Parmak: {totalFingers}", (10, h - 20),
+                               cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
+        
+        # BGR -> RGB (Gradio için)
+        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        
+        return frame, gesture, gesture_text
+
+
+# Global instances
+detector = HandGestureDetector()
+music_ctrl = MusicController()
+
+
+def process_frame(frame, current_audio):
+    """Gradio için frame işleme"""
+    processed_frame, gesture, gesture_text = detector.detect(frame)
+    
+    audio_file = current_audio
+    track_name = music_ctrl.get_current_name()
+    status = gesture_text
+    
+    # Gesture'a göre aksiyon
+    if gesture == "swipe":
+        audio_file, track_name = music_ctrl.next_track()
+        status = f"👋 SONRAKİ: {track_name}"
+    elif gesture == "palm":
+        music_ctrl.pause()
+        status = f"✋ DURAKLATILDI: {track_name}"
+    elif gesture == "index":
+        music_ctrl.play()
+        status = f"☝️ ÇALIYOR: {track_name}"
+    
+    return processed_frame, audio_file, f"🎵 {track_name}", status
+
+
+def start_music():
+    """İlk müziği başlat"""
+    track = music_ctrl.get_current_track()
+    name = music_ctrl.get_current_name()
+    music_ctrl.play()
+    return track, f"🎵 {name}", f"☝️ ÇALIYOR: {name}"
+
+
+def next_track():
+    """Sonraki şarkıya geç"""
+    track, name = music_ctrl.next_track()
+    return track, f"🎵 {name}"
+
+
+# Müzik listesi HTML
+def get_music_list_html():
+    if not MUSIC_FILES:
+        return "<p>Müzik dosyası bulunamadı</p>"
+    
+    html = "<div style='background:#1a1a2e; padding:10px; border-radius:10px;'>"
+    for i, f in enumerate(MUSIC_FILES):
+        icon = "▶️" if i == music_ctrl.current_index else "🎵"
+        html += f"<p style='color:white; margin:5px 0;'>{icon} {i+1}. {f.stem}</p>"
+    html += "</div>"
+    return html
+
+
+# Gradio arayüzü
+with gr.Blocks(
+    title="🎵 El Hareketiyle Müzik Kontrol",
+    theme=gr.themes.Soft(),
+    css="""
+    .music-info { 
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        padding: 15px;
+        border-radius: 10px;
+        color: white;
+        text-align: center;
+        font-size: 1.2em;
+    }
+    """
+) as demo:
+    
+    gr.Markdown("""
+    # 🎵 El Hareketiyle Müzik Kontrol
+    
+    Elinizi kameraya göstererek müzik kontrol edin!
+    """)
+    
+    # Mevcut audio state
+    current_audio = gr.State(value=music_ctrl.get_current_track())
+    
+    with gr.Row():
+        # Sol: Kamera
+        with gr.Column(scale=2):
+            gr.Markdown("### 📷 Kamera")
+            
+            webcam = gr.Image(
+                sources=["webcam"],
+                streaming=True,
+                label="Kamera Girişi",
+                height=400
+            )
+            
+            output_image = gr.Image(
+                label="🎯 El Algılama",
+                interactive=False,
+                height=400
+            )
+        
+        # Sağ: Kontroller ve Müzik
+        with gr.Column(scale=1):
+            gr.Markdown("### 🎹 El Hareketleri")
+            
+            gr.Markdown("""
+            | Hareket | Eylem |
+            |---------|-------|
+            | ✋ Avuç aç | **DURDUR** |
+            | ☝️ İşaret parmağı | **OYNAT** |
+            | 👋 El savur | **SONRAKİ** |
+            """)
+            
+            gr.Markdown("---")
+            gr.Markdown("### 🎵 Müzik Çalar")
+            
+            # Başlat butonu
+            start_btn = gr.Button("▶️ Müziği Başlat", variant="primary", size="lg")
+            next_btn = gr.Button("⏭️ Sonraki", size="lg")
+            
+            # Şarkı adı
+            track_name = gr.Markdown(
+                value=f"🎵 {music_ctrl.get_current_name()}",
+                elem_classes=["music-info"]
+            )
+            
+            # Audio player
+            audio_player = gr.Audio(
+                value=music_ctrl.get_current_track(),
+                label="🔊 Çalan Şarkı",
+                autoplay=False,
+                show_download_button=False
+            )
+            
+            # Durum
+            status = gr.Textbox(
+                label="📊 Durum",
+                value="▶️ Müziği başlatmak için butona tıklayın",
+                interactive=False
+            )
+            
+            gr.Markdown("---")
+            gr.Markdown("### 📋 Şarkı Listesi")
+            music_list = gr.HTML(value=get_music_list_html())
+    
+    # Event handlers
+    start_btn.click(
+        fn=start_music,
+        outputs=[audio_player, track_name, status]
+    )
+    
+    next_btn.click(
+        fn=next_track,
+        outputs=[audio_player, track_name]
+    )
+    
+    # Webcam stream
+    webcam.stream(
+        fn=process_frame,
+        inputs=[webcam, current_audio],
+        outputs=[output_image, audio_player, track_name, status]
+    )
+
+
+if __name__ == "__main__":
+    demo.launch()

app_sl.py

@@ -0,0 +1,272 @@
+"""
+El Hareketiyle Müzik Kontrol Uygulaması
+Streamlit + MediaPipe + Pygame
+"""
+
+import streamlit as st
+import cv2
+import numpy as np
+from pathlib import Path
+import pygame
+import time
+from hand_detector import HandGestureDetector
+
+# Sayfa ayarları
+st.set_page_config(
+    page_title="🎵 El Hareketiyle Müzik Kontrol",
+    page_icon="🎵",
+    layout="wide"
+)
+
+# CSS stilleri
+st.markdown("""
+<style>
+    .main-title {
+        text-align: center;
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        -webkit-background-clip: text;
+        -webkit-text-fill-color: transparent;
+        font-size: 3rem;
+        font-weight: bold;
+        margin-bottom: 1rem;
+    }
+    .gesture-card {
+        background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
+        border-radius: 15px;
+        padding: 20px;
+        margin: 10px 0;
+        text-align: center;
+    }
+    .status-playing {
+        background: linear-gradient(135deg, #11998e 0%, #38ef7d 100%);
+        color: white;
+        padding: 10px 20px;
+        border-radius: 25px;
+        font-weight: bold;
+    }
+    .status-paused {
+        background: linear-gradient(135deg, #ff416c 0%, #ff4b2b 100%);
+        color: white;
+        padding: 10px 20px;
+        border-radius: 25px;
+        font-weight: bold;
+    }
+    .music-list {
+        background: #1e1e2e;
+        border-radius: 10px;
+        padding: 15px;
+        color: white;
+    }
+    .current-song {
+        background: linear-gradient(90deg, #667eea, #764ba2);
+        padding: 10px;
+        border-radius: 8px;
+        margin: 5px 0;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+
+def init_pygame():
+    """Pygame mixer başlat"""
+    if not pygame.mixer.get_init():
+        pygame.mixer.init()
+
+
+def get_music_files():
+    """Müzik dosyalarını listele"""
+    music_dir = Path(__file__).parent / "music"
+    music_dir.mkdir(exist_ok=True)
+    
+    extensions = ['.mp3', '.wav', '.ogg']
+    music_files = []
+    
+    for ext in extensions:
+        music_files.extend(music_dir.glob(f"*{ext}"))
+    
+    return sorted(music_files)
+
+
+def init_session_state():
+    """Session state başlat"""
+    if 'is_playing' not in st.session_state:
+        st.session_state.is_playing = False
+    if 'current_track' not in st.session_state:
+        st.session_state.current_track = 0
+    if 'music_started' not in st.session_state:
+        st.session_state.music_started = False
+    if 'camera_active' not in st.session_state:
+        st.session_state.camera_active = False
+
+
+def play_music(filepath):
+    """Müzik çal"""
+    try:
+        pygame.mixer.music.load(str(filepath))
+        pygame.mixer.music.play()
+        return True
+    except Exception as e:
+        st.error(f"Müzik yüklenemedi: {e}")
+        return False
+
+
+def main():
+    st.markdown('<h1 class="main-title">🎵 El Hareketiyle Müzik Kontrol</h1>', unsafe_allow_html=True)
+    
+    init_pygame()
+    init_session_state()
+    
+    # Müzik dosyalarını al
+    music_files = get_music_files()
+    
+    # İki sütun: Sol taraf kamera, sağ taraf kontroller
+    col1, col2 = st.columns([2, 1])
+    
+    with col2:
+        st.markdown("### 🎹 Kontroller")
+        
+        # Hareket açıklamaları
+        st.markdown("""
+        <div class="gesture-card">
+            <h4>✋ Avuç Aç = DURDUR</h4>
+            <p>Elinizi açarak müziği durdurun</p>
+        </div>
+        """, unsafe_allow_html=True)
+        
+        st.markdown("""
+        <div class="gesture-card">
+            <h4>☝️ İşaret Parmağı = OYNAT</h4>
+            <p>İşaret parmağınızı kaldırarak çalın</p>
+        </div>
+        """, unsafe_allow_html=True)
+        
+        st.markdown("""
+        <div class="gesture-card">
+            <h4>👋 Savur = SONRAKİ</h4>
+            <p>Elinizi hızlıca sağa sola savurun</p>
+        </div>
+        """, unsafe_allow_html=True)
+        
+        st.markdown("---")
+        
+        # Müzik listesi
+        st.markdown("### 🎶 Müzik Listesi")
+        
+        if not music_files:
+            st.warning("⚠️ 'music' klasörüne müzik dosyası ekleyin!")
+            st.info("Desteklenen formatlar: .mp3, .wav, .ogg")
+        else:
+            for i, music in enumerate(music_files):
+                if i == st.session_state.current_track:
+                    st.markdown(f"""
+                    <div class="current-song">
+                        ▶️ {i+1}. {music.name}
+                    </div>
+                    """, unsafe_allow_html=True)
+                else:
+                    st.text(f"   {i+1}. {music.name}")
+        
+        st.markdown("---")
+        
+        # Durum göstergesi
+        if st.session_state.is_playing:
+            st.markdown('<p class="status-playing">🎵 Çalıyor...</p>', unsafe_allow_html=True)
+        else:
+            st.markdown('<p class="status-paused">⏸️ Duraklatıldı</p>', unsafe_allow_html=True)
+    
+    with col1:
+        st.markdown("### 📷 Kamera Görüntüsü")
+        
+        # Başlat/Durdur butonu
+        if not st.session_state.camera_active:
+            if st.button("🎬 Müzik Başlat & Kamera Aç", type="primary", use_container_width=True):
+                if music_files:
+                    st.session_state.camera_active = True
+                    st.session_state.music_started = True
+                    st.rerun()
+                else:
+                    st.error("Önce 'music' klasörüne müzik ekleyin!")
+        else:
+            if st.button("⏹️ Durdur & Kapat", type="secondary", use_container_width=True):
+                st.session_state.camera_active = False
+                st.session_state.is_playing = False
+                pygame.mixer.music.stop()
+                st.rerun()
+        
+        # Kamera frame placeholder
+        frame_placeholder = st.empty()
+        status_placeholder = st.empty()
+        
+        if st.session_state.camera_active and music_files:
+            # Kamerayı aç
+            cap = cv2.VideoCapture(0)
+            detector = HandGestureDetector()
+            
+            # İlk müziği başlat
+            if st.session_state.music_started:
+                if play_music(music_files[st.session_state.current_track]):
+                    st.session_state.is_playing = True
+                    st.session_state.music_started = False
+            
+            last_gesture = None
+            gesture_cooldown = 0.8
+            last_action_time = 0
+            
+            try:
+                while st.session_state.camera_active:
+                    ret, frame = cap.read()
+                    if not ret:
+                        st.error("Kamera okunamadı!")
+                        break
+                    
+                    frame = cv2.flip(frame, 1)  # Ayna görünümü
+                    gesture, annotated_frame = detector.detect_gesture(frame)
+                    
+                    current_time = time.time()
+                    
+                    # Hareket kontrolü (cooldown ile)
+                    if gesture and (current_time - last_action_time) > gesture_cooldown:
+                        if gesture == "palm" and st.session_state.is_playing:
+                            # Durdur
+                            pygame.mixer.music.pause()
+                            st.session_state.is_playing = False
+                            status_placeholder.info("⏸️ Müzik duraklatıldı")
+                            last_action_time = current_time
+                            
+                        elif gesture == "index" and not st.session_state.is_playing:
+                            # Devam et
+                            pygame.mixer.music.unpause()
+                            st.session_state.is_playing = True
+                            status_placeholder.success("▶️ Müzik devam ediyor")
+                            last_action_time = current_time
+                            
+                        elif gesture == "swipe":
+                            # Sonraki şarkı
+                            st.session_state.current_track = (st.session_state.current_track + 1) % len(music_files)
+                            play_music(music_files[st.session_state.current_track])
+                            st.session_state.is_playing = True
+                            status_placeholder.warning(f"⏭️ Sonraki: {music_files[st.session_state.current_track].name}")
+                            last_action_time = current_time
+                    
+                    # Frame'i RGB'ye çevir ve göster
+                    annotated_frame = cv2.cvtColor(annotated_frame, cv2.COLOR_BGR2RGB)
+                    frame_placeholder.image(annotated_frame, channels="RGB", use_container_width=True)
+                    
+                    # Müzik bitti mi kontrol et
+                    if not pygame.mixer.music.get_busy() and st.session_state.is_playing:
+                        # Otomatik sonraki şarkı
+                        st.session_state.current_track = (st.session_state.current_track + 1) % len(music_files)
+                        play_music(music_files[st.session_state.current_track])
+                    
+                    time.sleep(0.03)  # ~30 FPS
+                    
+            except Exception as e:
+                st.error(f"Hata: {e}")
+            finally:
+                cap.release()
+                detector.release()
+
+
+if __name__ == "__main__":
+    main()
+

hand_detector.py

@@ -0,0 +1,262 @@
+"""
+El Hareket Algılama Modülü
+MediaPipe Hands kullanarak el hareketlerini algılar
+
+Referans: https://medium.com/@odil.tokhirov/how-i-built-a-hand-gesture-recognition-model-in-python-part-1-db378cf196e6
+"""
+
+import cv2
+import numpy as np
+from collections import deque
+import time
+
+# MediaPipe import
+import mediapipe as mp
+
+# MediaPipe modüllerini al
+mpHands = mp.solutions.hands
+mpDraw = mp.solutions.drawing_utils
+
+print(f"✓ MediaPipe v{mp.__version__} yüklendi!")
+
+
+class HandGestureDetector:
+    """
+    El hareketlerini algılayan sınıf
+    
+    Kullanılan hareketler:
+    - palm: Avuç açık (4-5 parmak) -> Müzik durdur
+    - index: Sadece işaret parmağı -> Müzik başlat
+    - swipe: Hızlı yatay hareket -> Sonraki şarkı
+    """
+    
+    def __init__(self):
+        print("Hand detector başlatılıyor...")
+        
+        # MediaPipe Hands - basit konfigürasyon
+        self.hands = mpHands.Hands(
+            max_num_hands=1,
+            min_detection_confidence=0.7,
+            min_tracking_confidence=0.7
+        )
+        
+        # Parmak uç noktaları (landmark indeksleri)
+        # Thumb=4, Index=8, Middle=12, Ring=16, Pinky=20
+        self.tipIds = [4, 8, 12, 16, 20]
+        
+        # Swipe algılama
+        self.position_history = deque(maxlen=10)
+        self.last_swipe_time = 0
+        self.swipe_cooldown = 1.0
+        
+        # Gesture cooldown
+        self.last_gesture_time = 0
+        self.gesture_cooldown = 0.5
+        
+        print("✓ Hand detector hazır!")
+    
+    def findHands(self, frame, draw=True):
+        """El bul ve landmark'ları döndür"""
+        imgRGB = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        self.results = self.hands.process(imgRGB)
+        
+        if self.results.multi_hand_landmarks:
+            for handLms in self.results.multi_hand_landmarks:
+                if draw:
+                    mpDraw.draw_landmarks(frame, handLms, mpHands.HAND_CONNECTIONS)
+        
+        return frame
+    
+    def findPosition(self, frame, handNo=0):
+        """El landmark pozisyonlarını liste olarak döndür"""
+        lmList = []
+        
+        if self.results.multi_hand_landmarks:
+            if len(self.results.multi_hand_landmarks) > handNo:
+                myHand = self.results.multi_hand_landmarks[handNo]
+                h, w, c = frame.shape
+                
+                for id, lm in enumerate(myHand.landmark):
+                    cx, cy = int(lm.x * w), int(lm.y * h)
+                    lmList.append([id, cx, cy])
+        
+        return lmList
+    
+    def fingersUp(self, lmList):
+        """
+        Hangi parmakların yukarıda olduğunu döndür
+        Returns: [thumb, index, middle, ring, pinky]
+        """
+        fingers = []
+        
+        if len(lmList) < 21:
+            return [0, 0, 0, 0, 0]
+        
+        # Başparmak - x ekseni kontrolü
+        # Sağ el için: parmak ucu (4) < IP eklemi (3) ise açık
+        if lmList[self.tipIds[0]][1] < lmList[self.tipIds[0] - 1][1]:
+            fingers.append(1)
+        else:
+            fingers.append(0)
+        
+        # 4 parmak - y ekseni kontrolü
+        # Parmak ucu < PIP eklemi ise açık (y yukarı doğru küçülür)
+        for id in range(1, 5):
+            if lmList[self.tipIds[id]][2] < lmList[self.tipIds[id] - 2][2]:
+                fingers.append(1)
+            else:
+                fingers.append(0)
+        
+        return fingers
+    
+    def detect_gesture(self, frame):
+        """
+        Ana hareket algılama fonksiyonu
+        
+        Returns:
+            gesture: "palm", "index", "swipe" veya None
+            annotated_frame: İşaretlenmiş frame
+        """
+        # El bul
+        annotated_frame = self.findHands(frame.copy(), draw=True)
+        
+        # Pozisyonları al
+        lmList = self.findPosition(annotated_frame)
+        
+        gesture = None
+        current_time = time.time()
+        h, w = frame.shape[:2]
+        
+        if len(lmList) >= 21:
+            # Parmak durumları
+            fingers = self.fingersUp(lmList)
+            totalFingers = sum(fingers)
+            
+            # El merkezi (bilek pozisyonu - landmark 0)
+            wrist_x = lmList[0][1]
+            wrist_y = lmList[0][2]
+            
+            # ===== SWIPE ALGILAMA =====
+            self.position_history.append((wrist_x, current_time))
+            
+            if len(self.position_history) >= 6:
+                positions = list(self.position_history)
+                x_diff = positions[-1][0] - positions[0][0]
+                time_diff = positions[-1][1] - positions[0][1]
+                
+                # Hızlı yatay hareket = swipe
+                if time_diff < 0.35 and abs(x_diff) > 120:
+                    if current_time - self.last_swipe_time > self.swipe_cooldown:
+                        gesture = "swipe"
+                        self.last_swipe_time = current_time
+                        self.position_history.clear()
+                        
+                        direction = ">>>" if x_diff > 0 else "<<<"
+                        cv2.putText(annotated_frame, f"SONRAKI {direction}", (50, 80),
+                                   cv2.FONT_HERSHEY_SIMPLEX, 1.2, (0, 165, 255), 3)
+                        return gesture, annotated_frame
+            
+            # ===== GESTURE ALGILAMA =====
+            if current_time - self.last_gesture_time > self.gesture_cooldown:
+                
+                # AVUÇ AÇIK: 4 veya 5 parmak yukarıda
+                if totalFingers >= 4:
+                    gesture = "palm"
+                    self.last_gesture_time = current_time
+                    cv2.putText(annotated_frame, "DURDUR", (50, 80),
+                               cv2.FONT_HERSHEY_SIMPLEX, 1.5, (0, 0, 255), 3)
+                
+                # İŞARET PARMAĞI: Sadece işaret parmağı yukarıda
+                elif fingers == [0, 1, 0, 0, 0] or fingers == [1, 1, 0, 0, 0]:
+                    gesture = "index"
+                    self.last_gesture_time = current_time
+                    cv2.putText(annotated_frame, "OYNAT", (50, 80),
+                               cv2.FONT_HERSHEY_SIMPLEX, 1.5, (0, 255, 0), 3)
+            
+            # Debug bilgisi
+            cv2.putText(annotated_frame, f"Parmak: {totalFingers}", (10, h - 60),
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
+            
+            finger_str = f"B:{fingers[0]} I:{fingers[1]} O:{fingers[2]} Y:{fingers[3]} S:{fingers[4]}"
+            cv2.putText(annotated_frame, finger_str, (10, h - 30),
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.6, (200, 200, 200), 2)
+            
+            # El merkezi göster
+            cv2.circle(annotated_frame, (wrist_x, wrist_y), 10, (255, 0, 255), -1)
+            
+        else:
+            cv2.putText(annotated_frame, "El algilanmadi - Elinizi gosterin", (50, 50),
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.8, (100, 100, 255), 2)
+        
+        return gesture, annotated_frame
+    
+    def release(self):
+        """Kaynakları serbest bırak"""
+        self.hands.close()
+
+
+def test_detector():
+    """Test fonksiyonu"""
+    print("\n" + "="*50)
+    print("KAMERA AÇILIYOR...")
+    print("="*50)
+    
+    cap = cv2.VideoCapture(0)
+    
+    if not cap.isOpened():
+        print("HATA: Kamera açılamadı!")
+        return
+    
+    print("✓ Kamera açıldı!")
+    
+    detector = HandGestureDetector()
+    
+    print("\n" + "="*50)
+    print("EL HAREKETİ TEST MODU")
+    print("="*50)
+    print("Hareketler:")
+    print("  ✋ Avuç aç (4-5 parmak): DURDUR")
+    print("  ☝️  İşaret parmağı: OYNAT")
+    print("  👋 Eli hızla savur: SONRAKİ")
+    print("\nÇıkmak için 'q' tuşuna basın.")
+    print("="*50 + "\n")
+    
+    pTime = 0
+    
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            print("Frame okunamadı!")
+            break
+        
+        # Ayna görünümü
+        frame = cv2.flip(frame, 1)
+        
+        # Hareket algıla
+        gesture, annotated = detector.detect_gesture(frame)
+        
+        if gesture:
+            print(f">>> {gesture.upper()}")
+        
+        # FPS hesapla
+        cTime = time.time()
+        fps = 1 / (cTime - pTime) if (cTime - pTime) > 0 else 0
+        pTime = cTime
+        
+        cv2.putText(annotated, f"FPS: {int(fps)}", (10, 30),
+                   cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
+        
+        # Göster
+        cv2.imshow("El Hareketi Testi - 'q' ile cik", annotated)
+        
+        if cv2.waitKey(1) & 0xFF == ord('q'):
+            break
+    
+    cap.release()
+    detector.release()
+    cv2.destroyAllWindows()
+    print("\nTest sonlandırıldı.")
+
+
+if __name__ == "__main__":
+    test_detector()

requirements.txt

@@ -0,0 +1,15 @@
+# Gradio ile çalışan uygulama için gereksinimler
+gradio>=4.0.0
+opencv-python-headless>=4.8.0
+mediapipe>=0.10.0
+numpy<2.0
+
+
+# Streamlit ile çalışan uygulama için gereksinimler
+# streamlit>=1.28.0
+# opencv-python-headless>=4.8.0
+# mediapipe>=0.10.0
+# streamlit-webrtc>=0.45.0
+# av>=10.0.0
+# numpy<2.0
+