Spaces:
Sleeping
Sleeping
File size: 3,873 Bytes
f195b31 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 |
import cv2
import numpy as np
import tempfile
import os
from moviepy.video.io.VideoFileClip import VideoFileClip
def detect_watermark_image(image, watermark_text="WATERMARK", threshold=0.7):
"""Detect if an image contains a DCT-domain watermark.
Args:
image: Input image
watermark_text: The text to look for
threshold: Detection sensitivity threshold
Returns:
tuple: (detected (bool), highlighted_image)
"""
# Ensure image dimensions are divisible by 8 for DCT
h, w = image.shape[:2]
h_new = (h // 8) * 8
w_new = (w // 8) * 8
image = cv2.resize(image, (w_new, h_new))
# Convert to YCrCb and extract Y channel
ycrcb_image = cv2.cvtColor(image, cv2.COLOR_BGR2YCrCb)
y_channel, cr, cb = cv2.split(ycrcb_image)
# Apply DCT
dct_y = cv2.dct(np.float32(y_channel))
# Create known pattern for detection (systematic approach)
h_blocks, w_blocks = dct_y.shape[0] // 8, dct_y.shape[1] // 8
detection_score = 0
max_location = None
highlighted_image = image.copy()
# Search for watermark pattern in blocks
for y_block in range(h_blocks):
for x_block in range(w_blocks):
# Extract block
block = dct_y[y_block*8:(y_block+1)*8, x_block*8:(x_block+1)*8]
# Calculate variance to detect unusual patterns
block_variance = np.var(block)
# Check for anomalies in mid-frequency coefficients
mid_freq_mean = np.mean(np.abs(block[2:6, 2:6]))
# Simple detection heuristic
if mid_freq_mean > 2.0 and block_variance > 100:
detection_score += 1
max_location = (x_block*8, y_block*8)
detected = detection_score > (h_blocks * w_blocks * 0.01) # Detect if >1% of blocks show watermark characteristics
# Highlight detected region if found
if detected and max_location:
x, y = max_location
font = cv2.FONT_HERSHEY_SIMPLEX
text_size = cv2.getTextSize(watermark_text, font, 0.5, 1)[0]
cv2.putText(highlighted_image, "WATERMARK DETECTED", (x, y + text_size[1]),
font, 0.5, (0, 0, 255), 1, cv2.LINE_AA)
cv2.rectangle(highlighted_image, (x, y), (x + 64, y + 64), (0, 0, 255), 2)
return detected, highlighted_image
def detect_watermark_video(video_path, watermark_text="WATERMARK"):
"""Detect and highlight watermarks in a video file.
Args:
video_path (str): Path to the video file
watermark_text (str): The watermark text to detect
Returns:
tuple: (detection_result (bool), output_video_path)
"""
try:
# Process the video
video = VideoFileClip(video_path)
# Track detection across frames
frame_count = 0
detected_frames = 0
def process_frame(frame):
nonlocal frame_count, detected_frames
frame_count += 1
detected, highlighted_frame = detect_watermark_image(frame, watermark_text)
if detected:
detected_frames += 1
return highlighted_frame
processed_video = video.fl_image(process_frame)
# Save the result to a temporary file
temp_fd, output_path = tempfile.mkstemp(suffix=".mp4")
os.close(temp_fd) # Close the file descriptor properly
processed_video.write_videofile(output_path, codec='libx264')
# Determine if watermark is detected in the video
detection_result = detected_frames > (frame_count * 0.1) # >10% of frames have watermark
return detection_result, output_path
except Exception as e:
print(f"Error detecting watermark in video: {e}")
return False, None
|