app.py

# app.py

import gradio as gr
from utils import WatermarkProcessor
import json
import tempfile
import os
from datetime import datetime
import cv2
from PIL import Image
import numpy as np

class WatermarkGUI:
    def __init__(self):
        self.processor = WatermarkProcessor()
        self.create_interface()

    def process_watermark(self, image, watermark_text, author, purpose, opacity):
        """Process watermark with metadata"""
        if image is None or watermark_text.strip() == "":
            return None, "Please provide both image and watermark text"
            
        metadata = {
            "author": author,
            "purpose": purpose,
            "opacity": opacity
        }
        
        # Save temporary image
        temp_path = tempfile.mktemp(suffix='.png')
        Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2RGB)).save(temp_path)
        
        # Add watermark
        result_path, message = self.processor.encode(temp_path, watermark_text, metadata)
        
        if "Error" in message:
            return None, message
            
        # Generate quality report
        quality_report = self.processor.analyze_quality(temp_path, result_path)
        quality_data = json.loads(quality_report)
        
        # Create formatted report
        report = f"""
### Watermark Quality Report
- Quality Score: {quality_data['quality_score']}%
- PSNR: {quality_data['psnr']} dB
- Histogram Similarity: {quality_data['histogram_similarity'] * 100:.2f}%
- Modified Pixels: {quality_data['modified_pixels']:,}

### Metadata
- Author: {author}
- Purpose: {purpose}
- Timestamp: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
        """
        
        os.remove(temp_path)
        return cv2.imread(result_path), report

    def detect_watermark(self, image):
        """Detect and extract watermark"""
        if image is None:
            return "Please provide an image"
            
        # Save temporary image
        temp_path = tempfile.mktemp(suffix='.png')
        Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2RGB)).save(temp_path)
        
        # Extract watermark
        result = self.processor.decode(temp_path)
        os.remove(temp_path)
        
        try:
            # Parse JSON result
            data = json.loads(result)
            report = f"""
### Extracted Watermark
Text: {data['text']}

### Metadata
- Timestamp: {data['timestamp']}
- Author: {data['metadata'].get('author', 'N/A')}
- Purpose: {data['metadata'].get('purpose', 'N/A')}
            """
            return report
        except:
            return result

    def create_interface(self):
        """Create Gradio interface"""
        with gr.Blocks(css="footer {visibility: hidden}") as self.interface:
            gr.HTML("""<a href="https://visitorbadge.io/status?path=https%3A%2F%2Fgunship999-SecureWatermark.hf.space"> <img src="https://api.visitorbadge.io/api/visitors?path=https%3A%2F%2Fgunship999-SecureWatermark.hf.space&countColor=%23263759" /> </a>""")
            
            gr.Markdown("""# Enhanced Image Watermarking System
                       
### Welcome to Secure Watermark - Advanced Image Protection System

🔒 **Key Features:**
- **Dual Watermarking Technology**: Supports both steganography and PNG metadata
- **Secure Encryption**: Military-grade encryption for watermark data
- **Quality Assurance**: Real-time quality analysis and reporting
- **Metadata Support**: Track authorship, purpose, and timestamps
- **Integrity Verification**: Hash-based image tampering detection

💡 **Perfect for:**
- Copyright Protection
- Digital Asset Management
- Document Authentication
- Creative Work Protection

Try our system by uploading an image and adding your watermark below!
            """)
            
            with gr.Tabs():
                # Add Watermark Tab
                with gr.Tab("Add Watermark"):
                    with gr.Row():
                        with gr.Column():
                            input_image = gr.Image(label="Input Image", type="numpy")
                            watermark_text = gr.Textbox(label="Watermark Text")
                            author = gr.Textbox(label="Author", placeholder="Enter author name")
                            purpose = gr.Textbox(label="Purpose", placeholder="Enter watermark purpose")
                            opacity = gr.Slider(minimum=0.1, maximum=1.0, value=0.3, 
                                             label="Watermark Opacity")
                            
                            with gr.Row():
                                process_btn = gr.Button("Add Watermark", variant="primary")
                                
                        with gr.Column():
                            result_image = gr.Image(label="Watermarked Image")
                            quality_report = gr.Markdown(label="Quality Report")
                
                # Detect Watermark Tab
                with gr.Tab("Detect Watermark"):
                    with gr.Row():
                        detect_image = gr.Image(label="Input Image", type="numpy")
                        detect_result = gr.Markdown(label="Detected Watermark")
                    detect_btn = gr.Button("Detect Watermark")
            
            # Event handlers            
            process_btn.click(
                fn=self.process_watermark,
                inputs=[input_image, watermark_text, author, purpose, opacity],
                outputs=[result_image, quality_report]
            )
            
            detect_btn.click(
                fn=self.detect_watermark,
                inputs=[detect_image],
                outputs=detect_result
            )

    def launch(self, *args, **kwargs):
        """Launch the interface"""
        self.interface.launch(*args, **kwargs)

if __name__ == "__main__":
    app = WatermarkGUI()
    app.launch()