Update app.py

app.py

@@ -1,211 +1,151 @@
-import cv2 
+import cv2
 import numpy as np
-import time
-
-class CameraAnalyzer:
-    def __init__(self, camera_source=0):
-        # Kamera başlatma
-        self.cap = cv2.VideoCapture(camera_source)
-        if not self.cap.isOpened():
-            raise ValueError("Kamera açılamadı!")
-            
-        # Çözünürlük ayarları (isteğe bağlı, performans için düşürülebilir)
-        self.cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
-        self.cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
+import gradio as gr
 
-        # Durum değişkenleri
+class CameraAnalyzerState:
+    def __init__(self):
         self.accumulated_frame = None
         self.frame_count = 0
-        self.is_calibrating = False
-        self.mode = "LIVE" # LIVE, DARK_CALIB, FLAT_CALIB, SPN_VIEW
-        
-        # Tespit edilen hatalı piksellerin listesi (koordinat olarak)
-        self.hot_pixels = []  # Karanlıkta parlayanlar
-        self.dead_pixels = [] # Aydınlıkta sönenler
-        
-        # SPN analizi için matrisler
-        self.spn_pattern = None
-
-    def capture_frame(self):
-        ret, frame = self.cap.read()
-        if not ret:
-            return None
-        return frame
-
-    def process_calibration(self, frame, mode):
-        """
-        Kalibrasyon sırasında kareleri toplar ve ortalamasını alır.
-        Bu yöntem rastgele gürültüyü (random noise) azaltarak
-        sabit gürültüyü (FPN/SPN) ortaya çıkarır.
-        """
-        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY).astype(np.float32)
-        
-        if self.accumulated_frame is None:
-            self.accumulated_frame = gray
+        self.mode = "LIVE"  # LIVE, DARK_CALIB, FLAT_CALIB, SPN_VIEW
+        self.hot_pixels = []
+        self.dead_pixels = []
+        self.msg = "Hazır. Canlı mod."
+
+    def reset(self):
+        self.accumulated_frame = None
+        self.frame_count = 0
+        self.mode = "LIVE"
+        self.msg = "Sıfırlandı."
+
+# Global state (Tek kullanıcı demo için. Çoklu kullanıcı için gr.State kullanılmalı ama basitlik adına global tutuyoruz)
+analyzer = CameraAnalyzerState()
+
+def process_frame(frame):
+    global analyzer
+    
+    if frame is None:
+        return None
+
+    # Görüntüyü çevir (Mirror effect)
+    frame = cv2.flip(frame, 1)
+    display_frame = frame.copy()
+    
+    # Griye çevir (işlemler için)
+    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY).astype(np.float32)
+
+    # --- DURUM YÖNETİMİ ---
+    if analyzer.mode == "DARK_CALIB" or analyzer.mode == "FLAT_CALIB":
+        if analyzer.accumulated_frame is None:
+            analyzer.accumulated_frame = gray
         else:
-            # Hareketli ortalama (Running Average)
-            cv2.accumulateWeighted(gray, self.accumulated_frame, 0.1)
-        
-        self.frame_count += 1
-        return cv2.convertScaleAbs(self.accumulated_frame)
-
-    def analyze_dark_frame(self, avg_frame, threshold=20):
-        """
-        Karanlık çerçeve analizi:
-        Simsiyah olması gereken yerde parlayan pikselleri (Hot Pixels) bulur.
-        """
-        # Eşik değerinin üzerindeki pikselleri bul
-        _, thresh = cv2.threshold(avg_frame, threshold, 255, cv2.THRESH_BINARY)
-        coordinates = cv2.findNonZero(thresh)
+            cv2.accumulateWeighted(gray, analyzer.accumulated_frame, 0.1)
         
-        detected = []
-        if coordinates is not None:
-            for coord in coordinates:
-                detected.append((coord[0][0], coord[0][1]))
-        return detected
-
-    def analyze_flat_frame(self, avg_frame, threshold=200):
-        """
-        Düz alan (beyaz) analizi:
-        Beyaz olması gereken yerde siyah kalan pikselleri (Dead Pixels) bulur.
-        """
-        # Eşik değerinin altındaki pikselleri bul (Beklenen çok parlak, gelen karanlık)
-        # Not: Threshold ortam ışığına göre ayarlanmalıdır.
-        _, thresh = cv2.threshold(avg_frame, threshold, 255, cv2.THRESH_BINARY_INV)
-        coordinates = cv2.findNonZero(thresh)
+        analyzer.frame_count += 1
         
-        detected = []
-        if coordinates is not None:
-            for coord in coordinates:
-                detected.append((coord[0][0], coord[0][1]))
-        return detected
-
-    def extract_spn(self, avg_frame):
-        """
-        Sensor Pattern Noise (SPN) Çıkarımı:
-        Basitleştirilmiş yöntem: Görüntüden, görüntünün yumuşatılmış halini çıkarırız.
-        Geriye kalan yüksek frekanslı detaylar sensör gürültüsü ve ince dokulardır.
-        """
-        # 1. Gürültüden arındırılmış (denoised) versiyonu oluştur (Gaussian Blur ile)
-        float_avg = avg_frame.astype(np.float32)
-        denoised = cv2.GaussianBlur(float_avg, (5, 5), 0)
-        
-        # 2. Orijinal ortalamadan yumuşatılmış hali çıkar (Geriye gürültü kalır)
-        noise_residue = float_avg - denoised
-        
-        # 3. Görselleştirme için normalize et (0-255 arasına çek ve kontrastı artır)
-        # SPN normalde çıplak gözle görülmez, bu yüzden güçlendiriyoruz.
-        spn_vis = cv2.normalize(noise_residue, None, 0, 255, cv2.NORM_MINMAX)
-        spn_vis = cv2.convertScaleAbs(spn_vis, alpha=5.0, beta=128) # Kontrast artır
-        
-        return spn_vis
-
-    def run(self):
-        print("--- KAMERA SENSÖR ANALİZİ ---")
-        print("'d': Karanlık Mod Kalibrasyonu (Lensi Kapatın)")
-        print("'f': Düz Alan Kalibrasyonu (Beyaz Bir Yere Tutun)")
-        print("'s': SPN (Sensör Gürültüsü) Görünümüne Geç")
-        print("'r': Reset / Canlı Mod")
-        print("'q': Çıkış")
-        
-        while True:
-            frame = self.capture_frame()
-            if frame is None:
-                break
-
-            display_frame = frame.copy()
-            h, w = frame.shape[:2]
-
-            # Tuş kontrolleri
-            key = cv2.waitKey(1) & 0xFF
+        # 30 kare toplandıysa analizi yap
+        if analyzer.frame_count > 30:
+            avg_frame = cv2.convertScaleAbs(analyzer.accumulated_frame)
             
-            if key == ord('d'): # Karanlık Kalibrasyon Başlat
-                self.mode = "DARK_CALIB"
-                self.accumulated_frame = None
-                self.frame_count = 0
-                self.hot_pixels = []
-                print("Karanlık kalibrasyon başladı. Lütfen lensi kapatın.")
-                
-            elif key == ord('f'): # Düz Alan Kalibrasyon Başlat
-                self.mode = "FLAT_CALIB"
-                self.accumulated_frame = None
-                self.frame_count = 0
-                self.dead_pixels = []
-                print("Düz alan kalibrasyonu başladı. Beyaz bir yüzeye tutun.")
+            if analyzer.mode == "DARK_CALIB":
+                # Hot Pixel Analizi
+                _, thresh = cv2.threshold(avg_frame, 25, 255, cv2.THRESH_BINARY)
+                coords = cv2.findNonZero(thresh)
+                analyzer.hot_pixels = [(p[0][0], p[0][1]) for p in coords] if coords is not None else []
+                analyzer.msg = f"Karanlık Kalibrasyon Bitti! {len(analyzer.hot_pixels)} sıcak piksel bulundu."
             
-            elif key == ord('s'): # SPN Görünümü
-                if self.accumulated_frame is not None:
-                    self.mode = "SPN_VIEW"
-                else:
-                    print("Önce bir kalibrasyon (d veya f) yaparak veri toplayın.")
-
-            elif key == ord('r'): # Reset
-                self.mode = "LIVE"
-                self.accumulated_frame = None
-                
-            elif key == ord('q'): # Çıkış
-                break
-
-            # MODLARA GÖRE İŞLEMLER
-            if self.mode == "DARK_CALIB":
-                avg = self.process_calibration(frame, "dark")
-                
-                # Anlık analiz (örneğin 30 kare sonra analiz yap)
-                if self.frame_count > 30:
-                    self.hot_pixels = self.analyze_dark_frame(avg, threshold=15)
-                    cv2.putText(display_frame, "Analiz Tamamlandi!", (10, 60), 
-                               cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
-                    self.mode = "LIVE" # Otomatik olarak canlıya dön
-                
-                cv2.putText(display_frame, f"Karanlik Kalibrasyon: {self.frame_count}/30", (10, 30), 
-                           cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
-
-            elif self.mode == "FLAT_CALIB":
-                avg = self.process_calibration(frame, "flat")
-                
-                if self.frame_count > 30:
-                    # Ortalama parlaklığın %50'sinin altındakileri ölü kabul et
-                    mean_val = np.mean(avg)
-                    threshold = mean_val * 0.5 
-                    self.dead_pixels = self.analyze_flat_frame(avg, threshold=threshold)
-                    cv2.putText(display_frame, "Analiz Tamamlandi!", (10, 60), 
-                               cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
-                    self.mode = "LIVE"
-                
-                cv2.putText(display_frame, f"Duz Alan Kalibrasyon: {self.frame_count}/30", (10, 30), 
-                           cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 0, 0), 2)
-
-            elif self.mode == "SPN_VIEW":
-                # Birikmiş kareden SPN çıkar
-                if self.accumulated_frame is not None:
-                    avg_int = cv2.convertScaleAbs(self.accumulated_frame)
-                    spn_vis = self.extract_spn(avg_int)
-                    
-                    # SPN'i renkliye çevirip ekrana bas (gri tonlamalı)
-                    display_frame = cv2.cvtColor(spn_vis, cv2.COLOR_GRAY2BGR)
-                    cv2.putText(display_frame, "SPN (Sensor Pattern Noise) Gorunumu", (10, 30), 
-                               cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 255), 2)
+            elif analyzer.mode == "FLAT_CALIB":
+                # Dead Pixel Analizi
+                mean_val = np.mean(avg_frame)
+                threshold_val = mean_val * 0.6
+                _, thresh = cv2.threshold(avg_frame, threshold_val, 255, cv2.THRESH_BINARY_INV)
+                coords = cv2.findNonZero(thresh)
+                analyzer.dead_pixels = [(p[0][0], p[0][1]) for p in coords] if coords is not None else []
+                analyzer.msg = f"Düz Alan Kalibrasyonu Bitti! {len(analyzer.dead_pixels)} ölü piksel bulundu."
+            
+            # Analiz bitince Live moda dön ama verileri sakla
+            analyzer.mode = "LIVE"
+            analyzer.accumulated_frame = None
+            analyzer.frame_count = 0
+        else:
+            analyzer.msg = f"Kalibrasyon yapılıyor... {analyzer.frame_count}/30"
+
+    # --- GÖRSELLEŞTİRME ---
+    
+    # SPN Modu (Gürültü Görme)
+    if analyzer.mode == "SPN_VIEW":
+        # SPN için anlık kareyi yumuşatıp çıkarıyoruz (basitleştirilmiş anlık SPN)
+        # Gerçek SPN birikmiş kare ister ama webcam akışında anlık göstermek daha efektiftir
+        float_img = gray
+        denoised = cv2.GaussianBlur(float_img, (5, 5), 0)
+        residue = float_img - denoised
+        spn_vis = cv2.normalize(residue, None, 0, 255, cv2.NORM_MINMAX)
+        spn_vis = cv2.convertScaleAbs(spn_vis, alpha=5.0, beta=128)
+        display_frame = cv2.cvtColor(spn_vis, cv2.COLOR_GRAY2BGR)
+        cv2.putText(display_frame, "SPN MODU", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 255), 2)
+
+    # İşaretlemeler (Live Modda)
+    else:
+        # Hot Pixels (Kırmızı)
+        for x, y in analyzer.hot_pixels:
+            cv2.circle(display_frame, (x, y), 8, (255, 0, 0), 2) # Kırmızı (RGB'de Gradio BGR alabilir dikkat)
             
-            # Canlı modda hatalı pikselleri işaretle
-            if self.mode == "LIVE":
-                # Hot Pixels (Kırmızı Daire)
-                for x, y in self.hot_pixels:
-                    cv2.circle(display_frame, (x, y), 5, (0, 0, 255), 1)
-                    # Daha belirgin olması için ok işareti de eklenebilir
-                
-                # Dead Pixels (Mavi Daire)
-                for x, y in self.dead_pixels:
-                    cv2.circle(display_frame, (x, y), 5, (255, 0, 0), 1)
-
-                info_text = f"Hot: {len(self.hot_pixels)} | Dead: {len(self.dead_pixels)}"
-                cv2.putText(display_frame, info_text, (10, h - 20), 
-                           cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 1)
-
-            cv2.imshow("Sensor Analiz", display_frame)
-
-        self.cap.release()
-        cv2.destroyAllWindows()
+        # Dead Pixels (Mavi)
+        for x, y in analyzer.dead_pixels:
+            cv2.circle(display_frame, (x, y), 8, (0, 0, 255), 2) # Mavi
+
+    # Bilgi mesajı
+    cv2.putText(display_frame, analyzer.msg, (10, display_frame.shape[0] - 20), 
+                cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
+
+    # OpenCV BGR formatından RGB formatına çevir (Gradio için)
+    return cv2.cvtColor(display_frame, cv2.COLOR_BGR2RGB)
+
+def set_mode_dark():
+    analyzer.mode = "DARK_CALIB"
+    analyzer.accumulated_frame = None
+    analyzer.frame_count = 0
+    analyzer.msg = "Lensi kapatin..."
+    return
+
+def set_mode_flat():
+    analyzer.mode = "FLAT_CALIB"
+    analyzer.accumulated_frame = None
+    analyzer.frame_count = 0
+    analyzer.msg = "Beyaz bir duvara tutun..."
+    return
+
+def set_mode_spn():
+    analyzer.mode = "SPN_VIEW"
+    analyzer.msg = "SPN Modu"
+    return
+
+def reset_all():
+    analyzer.reset()
+    return
+
+# --- ARAYÜZ ---
+with gr.Blocks() as demo:
+    gr.Markdown("# Kamera Dead Pixel & SPN Analizi")
+    gr.Markdown("Bu araç tarayıcı kameranızı kullanarak sensör analizi yapar.")
+    
+    with gr.Row():
+        start_dark = gr.Button("1. Karanlık Kalibrasyon (Hot Pixel)")
+        start_flat = gr.Button("2. Düz Alan Kalibrasyon (Dead Pixel)")
+        start_spn = gr.Button("3. SPN Modu (Gürültü)")
+        btn_reset = gr.Button("Sıfırla")
+
+    # Webcam Input (Streaming=True sürekli akış sağlar)
+    image_input = gr.Image(sources=["webcam"], streaming=True, label="Kamera")
+    image_output = gr.Image(label="Analiz Sonucu")
+
+    # Buton olayları
+    start_dark.click(fn=set_mode_dark, inputs=None, outputs=None)
+    start_flat.click(fn=set_mode_flat, inputs=None, outputs=None)
+    start_spn.click(fn=set_mode_spn, inputs=None, outputs=None)
+    btn_reset.click(fn=reset_all, inputs=None, outputs=None)
+
+    # Akış döngüsü
+    image_input.stream(fn=process_frame, inputs=image_input, outputs=image_output, time_limit=600)
 
 if __name__ == "__main__":
-    app = CameraAnalyzer()
-    app.run()
+    demo.launch()