Upload folder using huggingface_hub

README.md

@@ -1,10 +1,10 @@
 ---
 title: Forensic
-emoji: 🏆
-colorFrom: gray
-colorTo: gray
+emoji: 👀
+colorFrom: blue
+colorTo: blue
 sdk: gradio
-sdk_version: 5.25.0
+sdk_version: 4.38.1
 app_file: app.py
 pinned: false
 ---

app.py

@@ -0,0 +1,103 @@
+import gradio as gr
+from image import add_and_detect_watermark_image
+from video import add_and_detect_watermark_video
+from detect import detect_watermark_image, detect_watermark_video
+
+# Image Interface
+image_inputs = [
+    gr.Image(type="numpy", label="Upload Image"),
+    gr.Textbox(label="Watermark Text")
+]
+
+image_outputs = [
+    gr.Image(type="numpy", label="Watermarked Image"),
+    gr.Image(type="numpy", label="Watermark Highlight"),
+    gr.File(label="Download Watermarked Image"),
+    gr.File(label="Download Watermark Highlight")
+]
+
+def process_image(image, text):
+    watermarked_image, highlight, watermarked_image_path, highlight_path = add_and_detect_watermark_image(image, text)
+    return watermarked_image, highlight, watermarked_image_path, highlight_path
+
+image_interface = gr.Interface(
+    fn=process_image,
+    inputs=image_inputs,
+    outputs=image_outputs,
+    title="Image Watermark Application",
+    description="Upload an image and add a watermark text. Detect watermark and highlight its position."
+)
+
+# Video Interface
+video_inputs = [
+    gr.Video(label="Upload Video"),
+    gr.Textbox(label="Watermark Text")
+]
+
+video_outputs = [
+    gr.Video(label="Watermarked Video"),
+    gr.Video(label="Watermark Highlight"),
+    gr.File(label="Download Watermarked Video"),
+    gr.File(label="Download Watermark Highlight")
+]
+
+def process_video(video, text):
+    watermarked_video_path, highlight_video_path, _, _ = add_and_detect_watermark_video(video, text)
+    return watermarked_video_path, highlight_video_path, watermarked_video_path, highlight_video_path
+
+video_interface = gr.Interface(
+    fn=process_video,
+    inputs=video_inputs,
+    outputs=video_outputs,
+    title="Video Watermark Application",
+    description="Upload a video and add a watermark text. Detect watermark and highlight its position."
+)
+
+# Forensic Watermark Detection Interface
+detect_inputs = [
+    gr.Image(type="numpy", label="Upload Image")
+]
+
+detect_outputs = [
+    gr.Image(type="numpy", label="Watermark Detection Result")
+]
+
+detect_interface = gr.Interface(
+    fn=detect_watermark_image,
+    inputs=detect_inputs,
+    outputs=detect_outputs,
+    title="Forensic Watermark Detection",
+    description="Upload an image to detect forensic watermarks."
+)
+
+# Video Detection Interface
+video_detect_inputs = [
+    gr.Video(label="Upload Video")
+]
+
+video_detect_outputs = [
+    gr.Video(label="Watermark Detection Result")
+]
+
+def detect_video(video):
+    detected_video_path = detect_watermark_video(video)
+    return detected_video_path
+
+video_detect_interface = gr.Interface(
+    fn=detect_video,
+    inputs=video_detect_inputs,
+    outputs=video_detect_outputs,
+    title="Video Watermark Detection",
+    description="Upload a video to detect forensic watermarks."
+)
+
+# Combine interfaces in tabs
+app = gr.TabbedInterface(
+    interface_list=[image_interface, video_interface, detect_interface, video_detect_interface],
+    tab_names=["Image", "Video", "Detect", "Video Detect"]
+)
+
+if __name__ == "__main__":
+    app.launch(
+        share=True
+    )

detect.py

@@ -0,0 +1,68 @@
+import cv2
+import numpy as np
+import random
+import tempfile
+from moviepy.video.io.VideoFileClip import VideoFileClip
+
+def detect_watermark_image(image):
+    ycrcb_image = cv2.cvtColor(image, cv2.COLOR_BGR2YCrCb)
+    y_channel, _, _ = cv2.split(ycrcb_image)
+    dct_y = cv2.dct(np.float32(y_channel))
+    
+    # Detecting the watermark
+    watermark = np.zeros_like(dct_y)
+    rows, cols = dct_y.shape
+    font = cv2.FONT_HERSHEY_SIMPLEX
+    text = "WATERMARK"
+    text_size = cv2.getTextSize(text, font, 0.5, 1)[0]
+    text_x = np.random.randint(0, cols - text_size[0])
+    text_y = np.random.randint(text_size[1], rows)
+    watermark = cv2.putText(watermark, text, (text_x, text_y), font, 0.5, (0, 0, 255), 1, cv2.LINE_AA)
+    
+    detected_image = cv2.idct(dct_y + watermark)
+    detected_image = np.uint8(np.clip(detected_image, 0, 255))
+    
+    return detected_image
+
+def detect_watermark_video(video_path):
+    """Detect and highlight watermarks in a video file.
+    
+    Args:
+        video_path (str): Path to the video file
+        
+    Returns:
+        str: Path to the video with detected watermarks
+    """
+    def process_frame(frame):
+        ycrcb_image = cv2.cvtColor(frame, cv2.COLOR_BGR2YCrCb)
+        y_channel, _, _ = cv2.split(ycrcb_image)
+        dct_y = cv2.dct(np.float32(y_channel))
+        
+        # Detecting the watermark
+        watermark = np.zeros_like(dct_y)
+        rows, cols = dct_y.shape
+        font = cv2.FONT_HERSHEY_SIMPLEX
+        text = "WATERMARK"
+        text_size = cv2.getTextSize(text, font, 0.5, 1)[0]
+        text_x = np.random.randint(0, cols - text_size[0])
+        text_y = np.random.randint(text_size[1], rows)
+        watermark = cv2.putText(watermark, text, (text_x, text_y), font, 0.5, (0, 0, 255), 1, cv2.LINE_AA)
+        
+        detected_frame = cv2.idct(dct_y + watermark)
+        detected_frame = np.uint8(np.clip(detected_frame, 0, 255))
+        
+        # Reconstruct the image with detected watermark
+        ycrcb_image[:, :, 0] = detected_frame
+        output_frame = cv2.cvtColor(ycrcb_image, cv2.COLOR_YCrCb2BGR)
+        
+        return output_frame
+    
+    # Process the video
+    video = moviepy.VideoFileClip(video_path)
+    processed_video = video.fl_image(process_frame)
+    
+    # Save the result to a temporary file
+    _, output_path = tempfile.mkstemp(suffix=".mp4")
+    processed_video.write_videofile(output_path, codec='libx264')
+    
+    return output_path

image.py

@@ -0,0 +1,47 @@
+import cv2
+import numpy as np
+import random
+import tempfile
+from utils import resize_image, text_to_image
+
+def add_and_detect_watermark_image(image, watermark_text, num_watermarks=5):
+    watermark_positions = []
+
+    h, w, _ = image.shape
+    h_new = (h // 8) * 8
+    w_new = (w // 8) * 8
+    image_resized = cv2.resize(image, (w_new, h_new))
+    
+    ycrcb_image = cv2.cvtColor(image_resized, cv2.COLOR_BGR2YCrCb)
+    y_channel, cr_channel, cb_channel = cv2.split(ycrcb_image)
+    
+    dct_y = cv2.dct(np.float32(y_channel))
+    
+    rows, cols = dct_y.shape
+    font = cv2.FONT_HERSHEY_SIMPLEX
+    for _ in range(num_watermarks):
+        text_size = cv2.getTextSize(watermark_text, font, 0.5, 1)[0]
+        text_x = random.randint(0, cols - text_size[0])
+        text_y = random.randint(text_size[1], rows)
+        watermark = np.zeros_like(dct_y)
+        watermark = cv2.putText(watermark, watermark_text, (text_x, text_y), font, 0.5, (1, 1, 1), 1, cv2.LINE_AA)
+        dct_y += watermark * 0.01
+        watermark_positions.append((text_x, text_y, text_size[0], text_size[1]))
+    
+    idct_y = cv2.idct(dct_y)
+    
+    ycrcb_image[:, :, 0] = idct_y
+    watermarked_image = cv2.cvtColor(ycrcb_image, cv2.COLOR_YCrCb2BGR)
+    
+    watermark_highlight = watermarked_image.copy()
+    for (text_x, text_y, text_w, text_h) in watermark_positions:
+        cv2.putText(watermark_highlight, watermark_text, (text_x, text_y), font, 0.5, (0, 0, 255), 1, cv2.LINE_AA)
+        cv2.rectangle(watermark_highlight, (text_x, text_y - text_h), (text_x + text_w, text_y), (0, 0, 255), 2)
+
+    # Save watermarked image and highlight to temporary files
+    _, watermarked_image_path = tempfile.mkstemp(suffix=".png")
+    _, watermark_highlight_path = tempfile.mkstemp(suffix=".png")
+    cv2.imwrite(watermarked_image_path, watermarked_image)
+    cv2.imwrite(watermark_highlight_path, watermark_highlight)
+    
+    return watermarked_image, watermark_highlight, watermarked_image_path, watermark_highlight_path

requirements.txt

@@ -0,0 +1,4 @@
+gradio
+numpy
+opencv-python
+moviepy

utils.py

@@ -0,0 +1,15 @@
+import numpy as np
+import cv2
+
+def resize_image(img, shape):
+    return cv2.resize(img, (shape[1], shape[0]), interpolation=cv2.INTER_LINEAR)
+
+def text_to_image(text, img_shape, font=cv2.FONT_HERSHEY_SIMPLEX, font_scale=3, thickness=5):
+    text_size = cv2.getTextSize(text, font, font_scale, thickness)[0]
+    text_x = (img_shape[1] - text_size[0]) // 2
+    text_y = (img_shape[0] + text_size[1]) // 2
+
+    img_wm = np.zeros(img_shape, dtype=np.uint8)
+    cv2.putText(img_wm, text, (text_x, text_y), font, font_scale, (255, 255, 255), thickness)
+
+    return img_wm

video.py

@@ -0,0 +1,74 @@
+import cv2
+import numpy as np
+import random
+import tempfile
+import os
+from moviepy.video.io.VideoFileClip import VideoFileClip  # Updated import path
+
+def add_and_detect_watermark_video(video_path, watermark_text, num_watermarks=5):
+    def add_watermark_to_frame(frame):
+        watermark_positions = []
+
+        # Resize frame to be divisible by 8 (required for DCT)
+        h, w, _ = frame.shape
+        h_new = (h // 8) * 8
+        w_new = (w // 8) * 8
+        frame_resized = cv2.resize(frame, (w_new, h_new))
+        
+        # Convert to YCrCb color space and extract Y channel
+        ycrcb_image = cv2.cvtColor(frame_resized, cv2.COLOR_BGR2YCrCb)
+        y_channel, cr_channel, cb_channel = cv2.split(ycrcb_image)
+        
+        # Apply DCT to the Y channel
+        dct_y = cv2.dct(np.float32(y_channel))
+        
+        # Add watermark in the DCT domain
+        rows, cols = dct_y.shape
+        font = cv2.FONT_HERSHEY_SIMPLEX
+        for _ in range(num_watermarks):
+            text_size = cv2.getTextSize(watermark_text, font, 0.5, 1)[0]
+            text_x = random.randint(0, cols - text_size[0])
+            text_y = random.randint(text_size[1], rows)
+            watermark = np.zeros_like(dct_y)
+            watermark = cv2.putText(watermark, watermark_text, (text_x, text_y), font, 0.5, (1, 1, 1), 1, cv2.LINE_AA)
+            dct_y += watermark * 0.01
+            watermark_positions.append((text_x, text_y, text_size[0], text_size[1]))
+        
+        # Apply inverse DCT
+        idct_y = cv2.idct(dct_y)
+        
+        # Merge channels and convert back to BGR
+        ycrcb_image[:, :, 0] = idct_y
+        watermarked_frame = cv2.cvtColor(ycrcb_image, cv2.COLOR_YCrCb2BGR)
+        
+        # Highlight watermarks for visualization
+        watermark_highlight = watermarked_frame.copy()
+        for (text_x, text_y, text_w, text_h) in watermark_positions:
+            cv2.putText(watermark_highlight, watermark_text, (text_x, text_y), font, 0.5, (0, 0, 255), 1, cv2.LINE_AA)
+            cv2.rectangle(watermark_highlight, (text_x, text_y - text_h), (text_x + text_w, text_y), (0, 0, 255), 2)
+        
+        return watermarked_frame, watermark_highlight
+
+    try:
+        # Load video using MoviePy
+        video = VideoFileClip(video_path)
+        
+        # Apply watermark to each frame
+        video_with_watermark = video.fl_image(lambda frame: add_watermark_to_frame(frame)[0])
+        video_with_highlight = video.fl_image(lambda frame: add_watermark_to_frame(frame)[1])
+
+        # Create temporary files for output videos
+        temp_fd, watermarked_video_path = tempfile.mkstemp(suffix=".mp4")
+        temp_fd_highlight, highlight_video_path = tempfile.mkstemp(suffix=".mp4")
+        os.close(temp_fd)
+        os.close(temp_fd_highlight)
+        
+        # Write output videos
+        video_with_watermark.write_videofile(watermarked_video_path, codec='libx264')
+        video_with_highlight.write_videofile(highlight_video_path, codec='libx264')
+
+        return watermarked_video_path, highlight_video_path
+
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        return None, None