Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import cv2 | |
| import numpy as np | |
| from datetime import datetime | |
| import random | |
| def basic_filter(image, filter_type): | |
| """Apply basic image filters""" | |
| if filter_type == "Gray Toning": | |
| return cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) | |
| elif filter_type == "Sepia": | |
| 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 == "Voyeur": | |
| # Improved X-ray effect | |
| gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) | |
| inverted = cv2.bitwise_not(gray) | |
| # Increase contrast | |
| clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8,8)) | |
| enhanced = clahe.apply(inverted) | |
| # Sharpen | |
| 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 classic_filter(image, filter_type): | |
| """Classical display filters""" | |
| if filter_type == "Karakalem Effect": | |
| 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 == "Sharpen": | |
| kernel = np.array([[-1,-1,-1], [-1,9,-1], [-1,-1,-1]]) | |
| return cv2.filter2D(image, -1, kernel) | |
| elif filter_type == "Embossing": | |
| 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 == "Edge Detection": | |
| edges = cv2.Canny(image, 100, 200) | |
| return cv2.cvtColor(edges, cv2.COLOR_GRAY2BGR) | |
| def createer_filter(image, filter_type): | |
| """Creative and unusual image filters""" | |
| if filter_type == "Pixel Art": | |
| 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 == "Mosaic Effect": | |
| 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 == "Rainbow": | |
| 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 == "Night Vision": | |
| 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 special_effects(image, filter_type): | |
| """Apply special effects""" | |
| if filter_type == "Matrix Effect": | |
| green_matrix = np.zeros_like(image) | |
| green_matrix[:,:,1] = image[:,:,1] # Only green channel | |
| 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 == "Wave Effect": | |
| 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 == "Time Stamp": | |
| 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 Effect": | |
| 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 artistic_filter(image, filter_type): | |
| """Apply artistic image filters""" | |
| 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 == "Oil Paint": | |
| 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 == "Cartoon Film": | |
| # Improved cartoon effect | |
| 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) | |
| # Increase color saturation | |
| hsv = cv2.cvtColor(cartoon, cv2.COLOR_BGR2HSV) | |
| hsv[:,:,1] = hsv[:,:,1]*1.4 # Increase in saturation | |
| return cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR) | |
| def atmospheric_filter(image, filter_type): | |
| """Atmospheric Filters""" | |
| if filter_type == "Autumn": | |
| # Improved autumn effect | |
| 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) | |
| # Increase color temperature | |
| hsv = cv2.cvtColor(autumn, cv2.COLOR_BGR2HSV) | |
| hsv[:,:,0] = hsv[:,:,0]*0.8 # Orange/yellow tones | |
| hsv[:,:,1] = hsv[:,:,1]*1.2 # Increase saturation | |
| return cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR) | |
| elif filter_type == "Nostalgia": | |
| # Improved nostalgia effect | |
| # Reduce contrast and add yellowish tone | |
| 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] | |
| ])) | |
| # Dimming effect in corners | |
| 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 == "Increase Brightness": | |
| # Improved brightness enhancement | |
| hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV) | |
| # Increase brightness | |
| hsv[:,:,2] = cv2.convertScaleAbs(hsv[:,:,2], alpha=1.2, beta=30) | |
| # Increase the contrast slightly | |
| return cv2.convertScaleAbs(cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR), alpha=1.1, beta=0) | |
| def goruntu_isleme(image, filter_type): | |
| """Function of main image processing""" | |
| if image is None: | |
| return None | |
| image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR) | |
| # Process by filter categories | |
| basic_filter_listesi = ["Grey Toning", "Sepia", "Röntgen", "Frain"] | |
| Classic_filters_listesi = ["Caracalem Effect", "Cutify", "Emovation", "Blank Detection"] | |
| creative_filters_listesi = ["Pixel Art", "Mosaic Effect", "Rainbow", "Night Vision"] | |
| ozel_efektler_listesi = ["Matrix Effect", "Window", "Time Stamp," "Glitch Effect"] | |
| artistic_filters_listesi = ["Pop Art", "Oil Paint", "Cartoon"] | |
| atmospheric_filters_list = ["Autumn", "Nostalgia", "Increasing Shiny"] | |
| if filter_type in basic_filter_list: | |
| output = basic_filter(image, filter_type) | |
| elif filter_type in classic_filter_list: | |
| output = classic_filters(image, filter_type) | |
| elif filter_type's creation_filter_list: | |
| output = createer_filters(image, filter_type) | |
| elif filter_type in special_efektler_list: | |
| output = special_efekts(image, filter_type) | |
| elif filter_type in artistic_filters_list: | |
| output = artistic_filters (image, filter_type) | |
| elif filter_type in atmospheric_filters_list: | |
| output = atmospheric_filters(image, filter_type) | |
| else: | |
| output = image | |
| return cv2.cvtColor(output, cv2.COLOR_BGR2RGB) if len(output.shape) == 3 else output | |
| # Gradio interface | |
| with gr.Blocks(theme=gr.themes.Monochrome()) as app: | |
| gr.Markdown("# 🎨 Super and Unusual Image Filtering Studio") | |
| gr.Markdown("### 🌈 Add magical touches to your photos!") | |
| with gr.Row(): | |
| with gr.Column(): | |
| image_input = gr.Image(type="numpy", label="📸 Upload Photos") | |
| with gr.Accordion("ℹ️ Filter Categories", open=True): | |
| filter_type = gr.Radio( | |
| [ | |
| # Basic Filters | |
| "Grey Toning", "Sepia", "Röntgen", "Frain", | |
| #classic_filters_list | |
| "Karakalem Effect," "Cutify", "Emovation", "Bens Perception," | |
| # Creative Filters | |
| "Picles Art," "Mosaic Effect," "Rainbow," "Night Vision," | |
| # Special Effects | |
| "Matrix Effect," "Window Effect", "Time Stamp," "Glitch Effect," | |
| # Artistic Filters | |
| "Pop Art", "Oil Paint", "Cartoon", | |
| #Atmospheric Filters | |
| "Autumn", "Nostalgia", "Increasing Shiny"# Basic Filters | |
| "Grey Toning", "Sepia", "Röntgen", "Frain", | |
| #classic_filters_list | |
| "Karakalem Effect," "Cutify", "Emovation", "Bens Perception," | |
| # Creative Filters | |
| "Picles Art," "Mosaic Effect," "Rainbow," "Night Vision," | |
| # Special Effects | |
| "Matrix Effect," "Window Effect", "Time Stamp," "Glitch Effect," | |
| # Artistic Filters | |
| "Pop Art", "Oil Paint", "Cartoon", | |
| #Atmospheric Filters | |
| "Autumn", "Nostalgia", "Increase of Shiny" | |
| ], | |
| label="🎭 Select Filter", | |
| info="Choose the magic effect you want" | |
| ) | |
| submit_button = gr.Button("✨ Apply Filter", variant="primary") | |
| with gr.Column(): | |
| image_output = gr.Image(label="🖼️ Filtered Photo") | |
| with gr.Accordion("📝 Filter Descriptions", open=False): | |
| gr.Markdown(""" | |
| ### 🎨 Filter Categories and Effects | |
| #### 📊 Basic Filters | |
| - **Grey Toning**: Turns the image into a classic style in black and white tones | |
| - **Sepia**: Adds warm brown tones that give the photo an old photo vibe | |
| - **Cennant**: Acronyce scanning effect by adding reverse lighting to the image | |
| - **Speaking": It reduces details by creating a soft blur in the image. | |
| #### Classic Filters List | |
| - **Karakalem Effect**: It makes the image look like a charcoal drawing | |
| - **Cutify**: Declare the details in the image | |
| - **Emboss**: Adds embossing and depth effect to the image | |
| - **Bulk Detection: Emphasizes edge lines in the image | |
| #### s Creative Filters | |
| - **Picsel Art***: Dividing the image into small frames in retro pixel style | |
| - **Mosaic Effect**: Divids the photo into small pieces of mosaics | |
| - **Rainbow**: Adds colored rainbow effects to the image | |
| - **Night Vision***: Simulates the night vision device effect | |
| #### s Special Effects | |
| - **Matrix Effect**: Matrix movie effect | |
| - **Ware Effect**: Adds a water wave-like twisted degradation to the image, creating a feeling of ripple | |
| - **Time Stamp***: Adds the date and time of taking the photo on it gives a nostalgic atmosphere | |
| - **Glitch Effect***: Adding digital distortions, adds a retro style error effect to the photo | |
| #### s Artistic Filters | |
| - **Pop Art**: With vivid and contrasted colors, Andy Warhol-style creates iconic pop-art effect | |
| - **Oil Paint***: Simulates brush strokes, giving the image the appearance of oil painting | |
| - **Texture Effect***: Adding surface texture to the image gives a touching depth and a vial of artwork | |
| """) | |
| submit_button.click( | |
| goruntu_isleme, | |
| inputs=[image_input, filter_type], | |
| outputs=image_output | |
| ) | |
| app.launch(share=True) | |