adds size and opacity sliders for the watermark image

app.py

@@ -1,5 +1,8 @@
 import gradio as gr
 import os
+import tempfile
+from PIL import Image
+import numpy as np
 
 css = """
 p {
@@ -58,11 +61,57 @@ w5 = os.path.join(os.path.dirname(__file__), "files/frog.jpg")
 w6 = os.path.join(os.path.dirname(__file__), "files/Human_generated.png")
 w7 = os.path.join(os.path.dirname(__file__), "files/hf-logo_transpng.png")
 
-def generate_image(original_image, watermark):
-    return gr.Image(original_image, watermark=watermark)
 
-def generate_video(original_video, watermark):
-    return gr.Video(original_video, watermark=watermark)
+def process_watermark(watermark_path, opacity, size, for_video=False):
+    """Process watermark image with opacity and size adjustments"""
+    if watermark_path is None:
+        return None
+    
+    # Load watermark image
+    if isinstance(watermark_path, str):
+        watermark = Image.open(watermark_path)
+    else:
+        watermark = Image.fromarray(watermark_path) if isinstance(watermark_path, np.ndarray) else watermark_path
+    
+    # Convert to RGBA if not already
+    if watermark.mode != 'RGBA':
+        watermark = watermark.convert('RGBA')
+    
+    # Resize watermark based on size parameter
+    original_size = watermark.size
+    new_size = (int(original_size[0] * size), int(original_size[1] * size))
+    watermark = watermark.resize(new_size, Image.Resampling.LANCZOS)
+    
+    # Applying Opacity
+    # Get the alpha channel and multiply by opacity
+    r, g, b, a = watermark.split()
+    a = a.point(lambda x: int(x * opacity))
+    watermark = Image.merge('RGBA', (r, g, b, a))
+    
+    # Return PIL Image for images, file path for videos
+    if for_video:
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.png')
+        watermark.save(temp_file.name, 'PNG')
+        temp_file.close()
+        return temp_file.name
+    else:
+        return watermark
+        
+def generate_image(original_image, watermark, opacity, size):
+    if original_image is None:
+        return None
+    processed_watermark = process_watermark(watermark, opacity, size, for_video=False)
+    # Convert original_image to PIL Image if it's a numpy array
+    if isinstance(original_image, np.ndarray):
+        original_image = Image.fromarray(original_image)
+    return gr.Image(original_image, watermark=processed_watermark)
+
+def generate_video(original_video, watermark, opacity, size):
+    if original_video is None:
+        return None
+    processed_watermark = process_watermark(watermark, opacity, size, for_video=True)
+    return gr.Video(original_video, watermark=processed_watermark)
+
 
 
 with gr.Blocks(css=css) as demo:
@@ -96,15 +145,72 @@ with gr.Blocks(css=css) as demo:
             gr.Markdown("**Inputs**: Image and watermark file")
         with gr.Column():
             gr.Markdown("**Output**: Watermarked image")
-        gr.Interface(generate_image, [gr.Image(), gr.Image(type='filepath', image_mode=None)], gr.Image(),
-                 examples=[[d, w7], [w4, w5], [c, w6],])
+
+        with gr.Row():
+            with gr.Column():
+                input_image = gr.Image(label="Original Image")
+                watermark_image = gr.Image(type='filepath', image_mode=None, label="Watermark Image")
+                with gr.Accordion("Watermark settings", open=False):
+                    opacity_slider = gr.Slider(minimum=0.0, maximum=1.0, value=1.0, step=0.1, label="Watermark Opacity")
+                    size_slider = gr.Slider(minimum=0.1, maximum=2.0, value=1.0, step=0.1, label="Watermark Size")
+                generate_btn = gr.Button("Generate Watermarked Image")
+            with gr.Column():
+                output_image = gr.Image(label="Watermarked Image")
+        
+        # Examples
+        gr.Examples(
+            examples=[
+                [d, w7, 1.0, 1.0],
+                [w4, w5, 0.7, 0.8],
+                [c, w6, 0.9, 1.2]
+            ],
+            inputs=[input_image, watermark_image, opacity_slider, size_slider],
+            outputs=output_image,
+            fn=generate_image,
+            cache_examples=False
+        )
+        
+        generate_btn.click(
+            fn=generate_image,
+            inputs=[input_image, watermark_image, opacity_slider, size_slider],
+            outputs=output_image
+        )        
+        
     with gr.Tab("Video Watermarking"):
         with gr.Column():
             gr.Markdown("**Inputs**: Video and watermark file")
         with gr.Column():
             gr.Markdown("**Output**: Watermarked video")
-        gr.Interface(generate_video, [gr.Video(), gr.Image(type='filepath', image_mode=None)], gr.Video(),
-                 examples=[[a, w1], [b, w2], [a, w3], [b, w4]])
+
+        with gr.Row():
+            with gr.Column():
+                input_video = gr.Video(label="Original Video")
+                watermark_video = gr.Image(type='filepath', image_mode=None, label="Watermark Image")
+                with gr.Accordion("Watermark settings", open=False):
+                    opacity_slider_video = gr.Slider(minimum=0.0, maximum=1.0, value=1.0, step=0.1, label="Watermark Opacity")
+                    size_slider_video = gr.Slider(minimum=0.1, maximum=2.0, value=1.0, step=0.1, label="Watermark Size")
+                generate_btn_video = gr.Button("Generate Watermarked Video")
+            with gr.Column():
+                output_video = gr.Video(label="Watermarked Video")
+        
+        # Examples
+        gr.Examples(
+            examples=[
+                [a, w1, 1.0, 1.0],
+                [b, w2, 0.8, 0.9],
+                [a, w3, 0.6, 1.5],
+                [b, w4, 0.7, 0.8]
+            ],
+            inputs=[input_video, watermark_video, opacity_slider_video, size_slider_video],
+            outputs=output_video,
+            fn=generate_video
+        )
+        
+        generate_btn_video.click(
+            fn=generate_video,
+            inputs=[input_video, watermark_video, opacity_slider_video, size_slider_video],
+            outputs=output_video
+        )
     
 if __name__ == "__main__":
     demo.launch()