| import gradio as gr | |
| from src.utils.change_format import change_format | |
| from src.utils.remove_background import remove_background_from_url | |
| from src.utils.visualize_image import visualize_base64_image | |
| from src.utils.generate_image import generate_image | |
| from src.utils.apply_filter import apply_filter | |
| from src.utils.add_text import add_text_to_image | |
| from src.utils.watermark import add_watermark, remove_watermark | |
| from src.utils.describe import describe_image | |
| from src.utils.compress import compress_image | |
| import base64 | |
| from PIL import Image | |
| import io | |
| import requests | |
| def image_to_base64(image): | |
| if image is None: | |
| return None | |
| buffer = io.BytesIO() | |
| image.save(buffer, format="PNG") | |
| return base64.b64encode(buffer.getvalue()).decode() | |
| def base64_to_image(base64_str): | |
| if not base64_str: | |
| return None | |
| image_data = base64.b64decode(base64_str) | |
| return Image.open(io.BytesIO(image_data)) | |
| def url_to_base64(url): | |
| response = requests.get(url) | |
| return base64.b64encode(response.content).decode() | |
| def gradio_remove_background(image): | |
| if image is None: | |
| return None | |
| base64_img = image_to_base64(image) | |
| result = remove_background_from_url(f"data:image/png;base64,{base64_img}") | |
| return base64_to_image(result) | |
| def gradio_describe_image(image): | |
| if image is None: | |
| return "No image provided" | |
| base64_img = image_to_base64(image) | |
| return describe_image(base64_img) | |
| def gradio_change_format(image, format_type): | |
| if image is None: | |
| return None | |
| base64_img = image_to_base64(image) | |
| result = change_format(base64_img, format_type) | |
| return base64_to_image(result) | |
| def gradio_generate_image(prompt, width=512, height=512): | |
| result = generate_image(prompt, width, height) | |
| return base64_to_image(result) | |
| def gradio_apply_filter(image, filter_type): | |
| if image is None: | |
| return None | |
| base64_img = image_to_base64(image) | |
| result = apply_filter(base64_img, filter_type) | |
| return base64_to_image(result) | |
| def gradio_add_text(image, text, x=50, y=50, font_size=20, color="white"): | |
| if image is None: | |
| return None | |
| base64_img = image_to_base64(image) | |
| result = add_text_to_image(base64_img, text, x, y, font_size, color) | |
| return base64_to_image(result) | |
| def gradio_add_watermark(image, watermark_text, opacity=0.5): | |
| if image is None: | |
| return None | |
| base64_img = image_to_base64(image) | |
| result = add_watermark(base64_img, watermark_text, opacity) | |
| return base64_to_image(result) | |
| def gradio_remove_watermark(image): | |
| if image is None: | |
| return None | |
| base64_img = image_to_base64(image) | |
| result = remove_watermark(base64_img) | |
| return base64_to_image(result) | |
| def gradio_compress_image(image, quality=80): | |
| if image is None: | |
| return None | |
| base64_img = image_to_base64(image) | |
| result = compress_image(base64_img, quality) | |
| return base64_to_image(result) | |
| def create_gradio_interface(): | |
| with gr.Blocks(title="Image Processing Service", theme=gr.themes.Soft()) as demo: | |
| gr.Markdown("# 🖼️ Image Processing Service") | |
| gr.Markdown("Servicio completo de procesamiento de imágenes") | |
| with gr.Tabs(): | |
| with gr.Tab("🎨 Generate Image"): | |
| with gr.Row(): | |
| prompt_input = gr.Textbox(label="Prompt", placeholder="Describe the image you want to generate") | |
| with gr.Column(): | |
| width_input = gr.Slider(256, 1024, 512, label="Width") | |
| height_input = gr.Slider(256, 1024, 512, label="Height") | |
| generate_btn = gr.Button("Generate", variant="primary") | |
| generated_output = gr.Image(label="Generated Image") | |
| generate_btn.click( | |
| gradio_generate_image, | |
| [prompt_input, width_input, height_input], | |
| generated_output | |
| ) | |
| with gr.Tab("🔍 Describe Image"): | |
| with gr.Row(): | |
| describe_input = gr.Image(label="Upload Image", type="pil") | |
| description_output = gr.Textbox(label="Description", lines=4) | |
| describe_input.change(gradio_describe_image, describe_input, description_output) | |
| with gr.Tab("✂️ Remove Background"): | |
| with gr.Row(): | |
| bg_input = gr.Image(label="Upload Image", type="pil") | |
| bg_output = gr.Image(label="Background Removed") | |
| bg_input.change(gradio_remove_background, bg_input, bg_output) | |
| with gr.Tab("🎭 Apply Filters"): | |
| with gr.Row(): | |
| filter_input = gr.Image(label="Upload Image", type="pil") | |
| with gr.Column(): | |
| filter_type = gr.Dropdown( | |
| ["blur", "sharpen", "vintage", "black_white", "sepia"], | |
| label="Filter Type", | |
| value="blur" | |
| ) | |
| filter_output = gr.Image(label="Filtered Image") | |
| filter_input.change(gradio_apply_filter, [filter_input, filter_type], filter_output) | |
| filter_type.change(gradio_apply_filter, [filter_input, filter_type], filter_output) | |
| with gr.Tab("📝 Add Text"): | |
| with gr.Row(): | |
| text_input = gr.Image(label="Upload Image", type="pil") | |
| with gr.Column(): | |
| text_content = gr.Textbox(label="Text", placeholder="Enter text to add") | |
| with gr.Row(): | |
| text_x = gr.Number(label="X Position", value=50) | |
| text_y = gr.Number(label="Y Position", value=50) | |
| with gr.Row(): | |
| font_size = gr.Slider(10, 100, 20, label="Font Size") | |
| text_color = gr.ColorPicker(label="Color", value="#FFFFFF") | |
| text_output = gr.Image(label="Image with Text") | |
| inputs = [text_input, text_content, text_x, text_y, font_size, text_color] | |
| for inp in inputs: | |
| inp.change(gradio_add_text, inputs, text_output) | |
| with gr.Tab("💧 Watermark"): | |
| with gr.Tabs(): | |
| with gr.Tab("Add Watermark"): | |
| with gr.Row(): | |
| watermark_input = gr.Image(label="Upload Image", type="pil") | |
| with gr.Column(): | |
| watermark_text = gr.Textbox(label="Watermark Text") | |
| watermark_opacity = gr.Slider(0.1, 1.0, 0.5, label="Opacity") | |
| watermark_output = gr.Image(label="Watermarked Image") | |
| inputs = [watermark_input, watermark_text, watermark_opacity] | |
| for inp in inputs: | |
| inp.change(gradio_add_watermark, inputs, watermark_output) | |
| with gr.Tab("Remove Watermark"): | |
| with gr.Row(): | |
| unwatermark_input = gr.Image(label="Upload Image", type="pil") | |
| unwatermark_output = gr.Image(label="Watermark Removed") | |
| unwatermark_input.change(gradio_remove_watermark, unwatermark_input, unwatermark_output) | |
| with gr.Tab("🗜️ Compress"): | |
| with gr.Row(): | |
| compress_input = gr.Image(label="Upload Image", type="pil") | |
| with gr.Column(): | |
| quality_slider = gr.Slider(10, 100, 80, label="Quality %") | |
| compress_output = gr.Image(label="Compressed Image") | |
| compress_input.change(gradio_compress_image, [compress_input, quality_slider], compress_output) | |
| quality_slider.change(gradio_compress_image, [compress_input, quality_slider], compress_output) | |
| with gr.Tab("🔄 Change Format"): | |
| with gr.Row(): | |
| format_input = gr.Image(label="Upload Image", type="pil") | |
| with gr.Column(): | |
| format_type = gr.Dropdown( | |
| ["PNG", "JPEG", "WEBP", "BMP"], | |
| label="Output Format", | |
| value="PNG" | |
| ) | |
| format_output = gr.Image(label="Converted Image") | |
| format_input.change(gradio_change_format, [format_input, format_type], format_output) | |
| format_type.change(gradio_change_format, [format_input, format_type], format_output) | |
| gr.Markdown("---") | |
| gr.Markdown("💡 **Status**: Active | Procesamiento de imágenes en tiempo real") | |
| return demo | |
| if __name__ == "__main__": | |
| demo = create_gradio_interface() | |
| demo.launch( | |
| server_name="0.0.0.0", | |
| server_port=7860, | |
| share=True, | |
| show_error=True | |
| ) |