app.py

import gradio as gr
import cv2
import numpy as np
from datetime import datetime
import random

def temel_filtreler(image, filter_type):
    """Temel görüntü filtrelerini uygular"""
    if filter_type == "Gri Tonlama":
        return cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    elif filter_type == "Sepya":
        sepia_filter = np.array([
            [0.272, 0.534, 0.131],
            [0.349, 0.686, 0.168],
            [0.393, 0.769, 0.189]
        ])
        return cv2.transform(image, sepia_filter)
    elif filter_type == "Röntgen":
        # Geliştirilmiş röntgen efekti
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        inverted = cv2.bitwise_not(gray)
        # Kontrastı artır
        clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8,8))
        enhanced = clahe.apply(inverted)
        # Keskinleştir
        kernel = np.array([[-1,-1,-1], [-1,9,-1], [-1,-1,-1]])
        sharpened = cv2.filter2D(enhanced, -1, kernel)
        return cv2.cvtColor(sharpened, cv2.COLOR_GRAY2BGR)
    elif filter_type == "Bulanıklaştır":
        return cv2.GaussianBlur(image, (15, 15), 0)

def klasik_filtreler(image, filter_type):
    """Klasik görüntü filtreleri"""
    if filter_type == "Karakalem Efekti":
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        inverted = cv2.bitwise_not(gray)
        blurred = cv2.GaussianBlur(inverted, (21, 21), 0)
        sketch = cv2.divide(gray, cv2.subtract(255, blurred), scale=256)
        return cv2.cvtColor(sketch, cv2.COLOR_GRAY2BGR)
    
    elif filter_type == "Keskinleştir":
        kernel = np.array([[-1,-1,-1], [-1,9,-1], [-1,-1,-1]])
        return cv2.filter2D(image, -1, kernel)
    
    elif filter_type == "Kabartma":
        kernel = np.array([[0,-1,-1], [1,0,-1], [1,1,0]])
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        emboss = cv2.filter2D(gray, -1, kernel) + 128
        return cv2.cvtColor(emboss, cv2.COLOR_GRAY2BGR)
    
    elif filter_type == "Kenar Algılama":
        edges = cv2.Canny(image, 100, 200)
        return cv2.cvtColor(edges, cv2.COLOR_GRAY2BGR)

def yaratici_filtreler(image, filter_type):
    """Yaratıcı ve sıradışı görüntü filtreleri"""
    if filter_type == "Piksel Sanatı":
        h, w = image.shape[:2]
        piksel_size = 20
        small = cv2.resize(image, (w//piksel_size, h//piksel_size))
        return cv2.resize(small, (w, h), interpolation=cv2.INTER_NEAREST)
    
    elif filter_type == "Mozaik Efekti":
        h, w = image.shape[:2]
        mozaik_size = 30
        for i in range(0, h, mozaik_size):
            for j in range(0, w, mozaik_size):
                roi = image[i:i+mozaik_size, j:j+mozaik_size]
                if roi.size > 0:
                    color = np.mean(roi, axis=(0,1))
                    image[i:i+mozaik_size, j:j+mozaik_size] = color
        return image
    
    elif filter_type == "Gökkuşağı":
        hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
        h, w = image.shape[:2]
        for i in range(h):
            hsv[i, :, 0] = (hsv[i, :, 0] + i % 180).astype(np.uint8)
        return cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
    
    elif filter_type == "Gece Görüşü":
        green_image = image.copy()
        green_image[:,:,0] = 0  # Blue channel
        green_image[:,:,2] = 0  # Red channel
        return cv2.addWeighted(green_image, 1.5, np.zeros(image.shape, image.dtype), 0, -50)

def ozel_efektler(image, filter_type):
    """Özel efektler uygular"""
    if filter_type == "Matrix Efekti":
        green_matrix = np.zeros_like(image)
        green_matrix[:,:,1] = image[:,:,1]  # Sadece yeşil kanal
        random_brightness = np.random.randint(0, 255, size=image.shape[:2])
        green_matrix[:,:,1] = np.minimum(green_matrix[:,:,1] + random_brightness, 255)
        return green_matrix
    
    elif filter_type == "Dalga Efekti":
        rows, cols = image.shape[:2]
        img_output = np.zeros(image.shape, dtype=image.dtype)
        
        for i in range(rows):
            for j in range(cols):
                offset_x = int(25.0 * np.sin(2 * 3.14 * i / 180))
                offset_y = int(25.0 * np.cos(2 * 3.14 * j / 180))
                if i+offset_x < rows and j+offset_y < cols:
                    img_output[i,j] = image[(i+offset_x)%rows,(j+offset_y)%cols]
                else:
                    img_output[i,j] = 0
        return img_output
    
    elif filter_type == "Zaman Damgası":
        output = image.copy()
        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        font = cv2.FONT_HERSHEY_SIMPLEX
        cv2.putText(output, timestamp, (10, 30), font, 1, (255, 255, 255), 2)
        return output
    
    elif filter_type == "Glitch Efekti":
        glitch = image.copy()
        h, w = image.shape[:2]
        for _ in range(10):
            x1 = random.randint(0, w-50)
            y1 = random.randint(0, h-50)
            x2 = random.randint(x1, min(x1+50, w))
            y2 = random.randint(y1, min(y1+50, h))
            glitch[y1:y2, x1:x2] = np.roll(glitch[y1:y2, x1:x2], 
                                          random.randint(-20, 20), 
                                          axis=random.randint(0, 1))
        return glitch

def sanatsal_filtreler(image, filter_type):
    """Sanatsal görüntü filtrelerini uygular"""
    if filter_type == "Pop Art":
        img_small = cv2.resize(image, None, fx=0.5, fy=0.5)
        img_color = cv2.resize(img_small, (image.shape[1], image.shape[0]))
        for _ in range(2):
            img_color = cv2.bilateralFilter(img_color, 9, 300, 300)
        hsv = cv2.cvtColor(img_color, cv2.COLOR_BGR2HSV)
        hsv[:,:,1] = hsv[:,:,1]*1.5
        return cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
    
    elif filter_type == "Yağlı Boya":
        ret = np.float32(image.copy())
        ret = cv2.bilateralFilter(ret, 9, 75, 75)
        ret = cv2.detailEnhance(ret, sigma_s=15, sigma_r=0.15)
        ret = cv2.edgePreservingFilter(ret, flags=1, sigma_s=60, sigma_r=0.4)
        return np.uint8(ret)
    
    elif filter_type == "Çizgi Film":
        # Geliştirilmiş çizgi film efekti
        color = image.copy()
        gray = cv2.cvtColor(color, cv2.COLOR_BGR2GRAY)
        gray = cv2.medianBlur(gray, 5)
        edges = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 9, 9)
        color = cv2.bilateralFilter(color, 9, 300, 300)
        cartoon = cv2.bitwise_and(color, color, mask=edges)
        # Renk doygunluğunu artır
        hsv = cv2.cvtColor(cartoon, cv2.COLOR_BGR2HSV)
        hsv[:,:,1] = hsv[:,:,1]*1.4  # Doygunluk artışı
        return cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)

def atmosferik_filtreler(image, filter_type):
    """Atmosferik filtreler"""
    if filter_type == "Sonbahar":
        # Geliştirilmiş sonbahar efekti
        autumn_filter = np.array([
            [0.393, 0.769, 0.189],
            [0.349, 0.686, 0.168],
            [0.272, 0.534, 0.131]
        ])
        autumn = cv2.transform(image, autumn_filter)
        # Renk sıcaklığını artır
        hsv = cv2.cvtColor(autumn, cv2.COLOR_BGR2HSV)
        hsv[:,:,0] = hsv[:,:,0]*0.8  # Turuncu/sarı tonlara kay
        hsv[:,:,1] = hsv[:,:,1]*1.2  # Doygunluğu artır
        return cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
    
    elif filter_type == "Nostalji":
        # Geliştirilmiş nostalji efekti
        # Kontrastı azalt ve sarımsı ton ekle
        image = cv2.convertScaleAbs(image, alpha=0.9, beta=10)
        sepia = cv2.transform(image, np.array([
            [0.393, 0.769, 0.189],
            [0.349, 0.686, 0.168],
            [0.272, 0.534, 0.131]
        ]))
        # Köşelerde karartma efekti
        h, w = image.shape[:2]
        kernel = np.zeros((h, w))
        center = (h//2, w//2)
        for i in range(h):
            for j in range(w):
                dist = np.sqrt((i-center[0])**2 + (j-center[1])**2)
                kernel[i,j] = 1 - min(1, dist/(np.sqrt(h**2 + w**2)/2))
        kernel = np.dstack([kernel]*3)
        return cv2.multiply(sepia, kernel).astype(np.uint8)
    
    elif filter_type == "Parlaklık Artır":
        # Geliştirilmiş parlaklık artırma
        hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
        # Parlaklığı artır
        hsv[:,:,2] = cv2.convertScaleAbs(hsv[:,:,2], alpha=1.2, beta=30)
        # Kontrastı da hafifçe artır
        return cv2.convertScaleAbs(cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR), alpha=1.1, beta=0)

def goruntu_isleme(image, filter_type):
    """Ana görüntü işleme fonksiyonu"""
    if image is None:
        return None
    
    image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
    
    # Filtre kategorilerine göre işlem
    temel_filtreler_listesi = ["Gri Tonlama", "Sepya", "Röntgen", "Bulanıklaştır"]
    klasik_filtreler_listesi = ["Karakalem Efekti", "Keskinleştir", "Kabartma", "Kenar Algılama"]
    yaratici_filtreler_listesi = ["Piksel Sanatı", "Mozaik Efekti", "Gökkuşağı", "Gece Görüşü"]
    ozel_efektler_listesi = ["Matrix Efekti", "Dalga Efekti", "Zaman Damgası", "Glitch Efekti"]
    sanatsal_filtreler_listesi = ["Pop Art", "Yağlı Boya", "Çizgi Film"]
    atmosferik_filtreler_listesi = ["Sonbahar", "Nostalji", "Parlaklık Artır"]
    
    if filter_type in temel_filtreler_listesi:
        output = temel_filtreler(image, filter_type)
    elif filter_type in klasik_filtreler_listesi:
        output = klasik_filtreler(image, filter_type)
    elif filter_type in yaratici_filtreler_listesi:
        output = yaratici_filtreler(image, filter_type)
    elif filter_type in ozel_efektler_listesi:
        output = ozel_efektler(image, filter_type)
    elif filter_type in sanatsal_filtreler_listesi:
        output = sanatsal_filtreler(image, filter_type)
    elif filter_type in atmosferik_filtreler_listesi:
        output = atmosferik_filtreler(image, filter_type)
    else:
        output = image
        
    return cv2.cvtColor(output, cv2.COLOR_BGR2RGB) if len(output.shape) == 3 else output



# Gradio arayüzü
with gr.Blocks(theme=gr.themes.Monochrome()) as app:
    gr.Markdown("# 🎨 Süper ve Sıradışı Görüntü Filtreleme Stüdyosu")
    gr.Markdown("### 🌈 Fotoğraflarınıza büyülü dokunuşlar ekleyin!")
    
    with gr.Row():
        with gr.Column():
            image_input = gr.Image(type="numpy", label="📸 Fotoğraf Yükle")
            with gr.Accordion("ℹ️ Filtre Kategorileri", open=True):
                filter_type = gr.Radio(
                    [
                        # Temel Filtreler
                        "Gri Tonlama", "Sepya", "Röntgen", "Bulanıklaştır",
                        #klasik_filtreler_listesi 
                        "Karakalem Efekti", "Keskinleştir", "Kabartma", "Kenar Algılama",                       
                        # Yaratıcı Filtreler
                        "Piksel Sanatı", "Mozaik Efekti", "Gökkuşağı", "Gece Görüşü",
                        # Özel Efektler
                        "Matrix Efekti", "Dalga Efekti", "Zaman Damgası", "Glitch Efekti",
                        # Sanatsal Filtreler
                        "Pop Art", "Yağlı Boya", "Çizgi Film",
                        #Atmosferik Filtreler
                        "Sonbahar", "Nostalji", "Parlaklık Artır"
                    ],
                    label="🎭 Filtre Seç",
                    info="İstediğiniz sihirli efekti seçin"
                )
            submit_button = gr.Button("✨ Filtreyi Uygula", variant="primary")
            
        with gr.Column():
            image_output = gr.Image(label="🖼️ Filtrelenmiş Fotoğraf")
    
    with gr.Accordion("📝 Filtre Açıklamaları", open=False):
        gr.Markdown("""
        ### 🎨 Filtre Kategorileri ve Efektler
        
        #### 📊 Temel Filtreler
        - **Gri Tonlama**: Görüntüyü siyah-beyaz tonlarında, klasik bir tarzda dönüştürür
        - **Sepya**: Fotoğrafa eski bir fotoğraf havası veren, sıcak kahverengi tonları ekler
        - **Röntgen**: Görüntüye ters ışıklandırma ekleyerek X-ray taraması etkisi oluşturur
        - **Bulanıklaştır**: Görüntüde yumuşak bir bulanıklık oluşturarak detayları azaltır.                

        ####🖼️ Klasik Filtreler Listesi
        - **Karakalem Efekti**: Görüntüyü karakalem çizimi gibi gösterir
        - **Keskinleştir**: Görüntüdeki detayları belirginleştirir
        - **Kabartma**: Görüntüye kabartma ve derinlik efekti ekler
        - **Kenar Algılama: Görüntüdeki kenar hatlarını vurgular          
        
        #### 🎮 Yaratıcı Filtreler
        - **Piksel Sanatı**: Görüntüyü retro piksel tarzında küçük karelere böler
        - **Mozaik Efekti**: Fotoğrafı küçük mozaik parçalarına böler böler
        - **Gökkuşağı**: Görüntüye renkli gökkuşağı efektleri ekler
        - **Gece Görüşü**: Gece görüş cihazı efektini simüle eder
        
        #### 🎬 Özel Efektler
        - **Matrix Efekti**: Matrix film efekti
        - **Dalga Efekti**: Görüntüye su dalgası benzeri kıvrımlı bir bozulma ekler, dalgalanma hissi yaratır
        - **Zaman Damgası**: Fotoğrafın üzerine çekildiği tarih ve saati ekleyerek nostaljik bir hava verir
        - **Glitch Efekti**: Dijital bozulmalar ekleyerek, fotoğrafa retro tarzda bir hata efekti katar
        
        #### 🎭 Sanatsal Filtreler
        - **Pop Art**: Canlı ve kontrastlı renklerle, Andy Warhol tarzı ikonik pop-art efekti oluşturur
        - **Yağlı Boya**: Fırça darbelerini simüle ederek görüntüye yağlı boya tablosu görünümü kazandırır
        - **Doku Efekti**: Görüntüye yüzey dokusu ekleyerek dokunsal bir derinlik ve sanat eseri havası verir
        """)
    
    submit_button.click(
        goruntu_isleme,
        inputs=[image_input, filter_type],
        outputs=image_output
    )

app.launch(share=True)