Datasets:

aoiandroid
/

android-times-articles

import os
import sys
import json
import sqlite3
import argparse
import subprocess
import logging
from pathlib import Path
import numpy as np
from PIL import Image, ImageFilter

# Reconfigure stdout/stderr to utf-8 to avoid encoding issues on Windows
sys.stdout.reconfigure(encoding='utf-8')
sys.stderr.reconfigure(encoding='utf-8')

# Logging setup
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger("quality_gate_broll")

def validate_image_asset(img_path, min_width=500, min_height=300):
    """
    Perform deep validation of a B-roll image file.
    Checks: file existence, PIL verification, resolution, aspect ratio, blankness, and watermarks.
    Returns: (bool, str) -> (is_valid, reason)
    """
    path = Path(img_path)
    if not path.exists():
        return False, "File does not exist"
        
    # Check minimum file size (e.g. 5KB)
    try:
        size = path.stat().st_size
        if size < 5120:
            return False, f"File size is too small ({size} bytes). Likely a corrupt download or placeholder."
    except Exception as e:
        return False, f"Failed to get file stats: {e}"

    # 1. PIL opening and integrity check
    try:
        with Image.open(path) as img:
            img.verify() # verify integrity of the file container
    except Exception as e:
        return False, f"Image container is corrupted or invalid: {e}"

    # Re-open because verify() makes the file handle unusable
    try:
        with Image.open(path) as img:
            w, h = img.size
            
            # 2. Resolution check
            if w < min_width or h < min_height:
                return False, f"Resolution too low ({w}x{h}). Minimum required is {min_width}x{min_height}."
                
            # 3. Aspect Ratio check
            aspect = w / h
            # Normal landscape should be around 1.33 to 1.78. 
            # Reject vertical portrait (aspect < 0.75) and extreme panoramas (aspect > 2.5)
            if aspect < 0.75:
                return False, f"Asset is vertical / portrait (aspect ratio: {aspect:.2f}). 16:9 crop will lose context."
            if aspect > 2.5:
                return False, f"Asset is too wide / panoramic (aspect ratio: {aspect:.2f}). 16:9 crop will look extremely stretched or cropped."

            # 4. Blank screen / Solid color check
            # Convert to grayscale to simplify calculation
            gray_img = img.convert("L")
            arr = np.array(gray_img, dtype=np.float32)
            std_dev = np.std(arr)
            # A standard deviation < 5.0 indicates almost zero contrast (solid color / blank / broken download)
            if std_dev < 5.0:
                return False, f"Blank or solid color image detected (standard deviation: {std_dev:.2f})."

            # 5. Watermark / logo detection
            detected = detect_watermarks(img_path)
            if detected:
                return False, f"Watermark or logo pattern detected in regions: {detected}."

    except Exception as e:
        return False, f"Unexpected error during visual analysis: {e}"

    return True, "Pass"

def detect_watermarks(img_path):
    """
    Scan the corners and central-right/bottom-center of the image and return a list of regions that contain watermarks.
    """
    path = Path(img_path)
    if not path.exists():
        return []
        
    # Check if the filename contains stock/news keywords for adaptive thresholding
    path_lower = str(path).lower()
    is_stock_source = any(x in path_lower for x in ["getty", "alamy", "stock", "shutter", "anadolu", "reuters", "exclusive", "refinery"])
    
    try:
        with Image.open(path) as img:
            w, h = img.size
            gray_img = img.convert("L")
            arr = np.array(gray_img, dtype=np.float32)
            
            diff_x = np.abs(arr[:, 1:] - arr[:, :-1])
            diff_y = np.abs(arr[1:, :] - arr[:-1, :])
            edges = np.zeros_like(arr)
            edges[:, :-1] += diff_x
            edges[:-1, :] += diff_y
            
            cw = int(w * 0.15)
            ch = int(h * 0.15)
            cw = max(cw, 10)
            ch = max(ch, 10)
            
            regions = {
                "top_left": (0, 0, cw, ch),
                "top_right": (w-cw, 0, w, ch),
                "bottom_left": (0, h-ch, cw, h),
                "bottom_right": (w-cw, h-ch, w, h),
                "center_right": (int(w * 0.55), int(h * 0.45), int(w * 0.98), int(h * 0.80)),
                "bottom_center": (int(w * 0.20), int(h * 0.82), int(w * 0.80), h),
                "center": (int(w * 0.30), int(h * 0.30), int(w * 0.70), int(h * 0.70))
            }
            
            detected = []
            for name, (x1, y1, x2, y2) in regions.items():
                region = edges[y1:y2, x1:x2]
                if region.size == 0:
                    continue
                mean_edge = np.mean(region)
                max_edge = np.max(region)
                
                # Corner heuristics (normally low texture, so strict threshold)
                if name in ["top_left", "top_right", "bottom_left", "bottom_right"]:
                    if mean_edge > 15.0 and max_edge > 150.0:
                        detected.append(name)
                # Central/Bottom heuristics (higher natural texture, adaptive check to avoid false positives)
                else:
                    if is_stock_source:
                        high_contrast_pixels = np.sum(region > 120.0)
                        # Detect even if the mean edge is diluted in a large region, as long as strong local edges exist
                        if (mean_edge > 5.0 and max_edge > 80.0 and high_contrast_pixels > 15) or (high_contrast_pixels > 40):
                            detected.append(name)
                    else:
                        if mean_edge > 20.0 and max_edge > 200.0:
                            high_contrast_pixels = np.sum(region > 200.0)
                            if high_contrast_pixels > 30:
                                detected.append(name)
            return detected
    except Exception as e:
        logger.error(f"Error checking watermarks for {img_path}: {e}")
        return []

def generate_watermark_mask(img_path, output_mask_path, detected_corners=None):
    """
    Generate a binary mask where detected watermark pixels are white (255) and dilated.
    """
    path = Path(img_path)
    if not path.exists():
        return False
        
    if detected_corners is None:
        detected_corners = detect_watermarks(img_path)
        
    if not detected_corners:
        # Create empty mask if no corners detected
        try:
            with Image.open(path) as img:
                mask = Image.new("L", img.size, color=0)
                mask.save(output_mask_path, "JPEG")
                return True
        except Exception as e:
            logger.error(f"Failed to create empty mask: {e}")
            return False
            
    try:
        with Image.open(path) as img:
            w, h = img.size
            gray_img = img.convert("L")
            arr = np.array(gray_img, dtype=np.float32)
            
            # Recompute edges to find watermark pixels
            diff_x = np.abs(arr[:, 1:] - arr[:, :-1])
            diff_y = np.abs(arr[1:, :] - arr[:-1, :])
            edges = np.zeros_like(arr)
            edges[:, :-1] += diff_x
            edges[:-1, :] += diff_y
            
            # Create a base black mask
            mask_arr = np.zeros((h, w), dtype=np.uint8)
            
            cw = int(w * 0.15)
            ch = int(h * 0.15)
            cw = max(cw, 10)
            ch = max(ch, 10)
            
            regions = {
                "top_left": (0, 0, cw, ch),
                "top_right": (w-cw, 0, w, ch),
                "bottom_left": (0, h-ch, cw, h),
                "bottom_right": (w-cw, h-ch, w, h),
                "center_right": (int(w * 0.55), int(h * 0.45), int(w * 0.98), int(h * 0.80)),
                "bottom_center": (int(w * 0.20), int(h * 0.82), int(w * 0.80), h),
                "center": (int(w * 0.30), int(h * 0.30), int(w * 0.70), int(h * 0.70))
            }
            
            for name in detected_corners:
                if name not in regions:
                    continue
                x1, y1, x2, y2 = regions[name]
                # In the region, pixels with edge strength > 15 are likely watermark strokes
                region_edges = edges[y1:y2, x1:x2]
                mask_region = np.zeros_like(region_edges, dtype=np.uint8)
                mask_region[region_edges > 15.0] = 255
                mask_arr[y1:y2, x1:x2] = mask_region
                
            mask_img = Image.fromarray(mask_arr)
            
            # Dilate the mask using PIL's MaxFilter to cover surrounding pixels of the watermark text/logo
            dilated_mask = mask_img.filter(ImageFilter.MaxFilter(size=9))
            
            # Save mask
            dilated_mask.save(output_mask_path, "JPEG")
            return True
            
    except Exception as e:
        logger.error(f"Error generating mask for {img_path}: {e}")
        return False

def remove_watermark_with_lama(img_path, output_path=None):
    """
    Detect, mask, and inpaint watermark/logo out of the image using LaMa.
    Then re-validate the result.
    Returns: (bool, str) -> (success, reason)
    """
    path = Path(img_path)
    if not path.exists():
        return False, "File does not exist"
        
    if output_path is None:
        output_path = img_path
        
    detected_corners = detect_watermarks(img_path)
    if not detected_corners:
        return True, "No watermark detected"
        
    logger.info(f"Watermark detected in corners {detected_corners} of {path.name}. Initiating removal...")
    
    # Paths for temporary mask and temporary output
    temp_mask_path = path.parent / f".temp_mask_{path.stem}.jpg"
    temp_out_path = path.parent / f".temp_out_{path.stem}.jpg"
    
    try:
        # 1. Generate mask
        if not generate_watermark_mask(path, temp_mask_path, detected_corners):
            return False, "Failed to generate watermark mask"
            
        # 2. Run LaMa inpainting
        lama_script = r"C:\Roaming\.agents\skills\lama-inpainting\lama_inpaint.py"
        if not os.path.exists(lama_script):
            return False, f"LaMa script not found at {lama_script}"
            
        cmd = [
            sys.executable,
            lama_script,
            "--image", str(path),
            "--mask", str(temp_mask_path),
            "--output", str(temp_out_path),
            "--device", "cpu"
        ]
        
        logger.info(f"Running LaMa inpainting: {' '.join(cmd)}")
        res = subprocess.run(cmd, capture_output=True, text=True, timeout=90)
        
        if res.returncode != 0:
            return False, f"LaMa inpainting script failed: {res.stderr.strip()}"
            
        if not temp_out_path.exists():
            return False, "LaMa script returned 0 but output file was not created"
            
        # 3. Re-validate the output image
        ok, reason = validate_image_asset(temp_out_path)
        if not ok:
            # If it failed because of watermark again, it means the removal failed or was incomplete
            return False, f"Watermark removal validation failed: {reason}"
            
        # 4. Overwrite/Save to target destination
        out_path = Path(output_path)
        if out_path.exists():
            out_path.unlink()
        temp_out_path.rename(out_path)
        
        logger.info(f"Watermark successfully removed and verified for {path.name}")
        return True, "Pass"
        
    except subprocess.TimeoutExpired:
        return False, "LaMa inpainting execution timed out"
    except Exception as e:
        logger.error(f"Unexpected error during watermark removal: {e}")
        return False, f"Unexpected error during removal: {e}"
    finally:
        # Cleanup temp files
        if temp_mask_path.exists():
            temp_mask_path.unlink(missing_ok=True)
        if temp_out_path.exists():
            temp_out_path.unlink(missing_ok=True)

def validate_video_asset(video_path):
    """
    Perform validation of a B-roll video file (Ken-Burns clip).
    Checks: file existence, size, and container integrity using ffprobe.
    Returns: (bool, str) -> (is_valid, reason)
    """
    path = Path(video_path)
    if not path.exists():
        return False, "File does not exist"
        
    try:
        size = path.stat().st_size
        if size < 10240: # 10KB minimum
            return False, f"File size is too small ({size} bytes). Likely a failed render."
    except Exception as e:
        return False, f"Failed to get file stats: {e}"

    # Use ffprobe to verify video integrity
    ffprobe = os.environ.get("VIDEO_AGENT_FFPROBE", "ffprobe")
    cmd = [
        ffprobe, "-v", "error",
        "-show_entries", "format=duration,size:stream=codec_type",
        "-of", "json",
        str(path)
    ]
    try:
        res = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
        if res.returncode != 0:
            return False, f"ffprobe container validation failed: {res.stderr.strip()}"
            
        data = json.loads(res.stdout)
        
        # Check duration
        duration_str = data.get("format", {}).get("duration")
        if not duration_str:
            return False, "No duration found in video container metadata"
        duration = float(duration_str)
        if duration <= 0:
            return False, f"Invalid video duration: {duration}s"
            
        # Check for video stream
        streams = data.get("streams", [])
        has_video_stream = any(s.get("codec_type") == "video" for s in streams)
        if not has_video_stream:
            return False, "No video stream found in the container"
            
    except subprocess.TimeoutExpired:
        return False, "ffprobe container validation timed out"
    except Exception as e:
        return False, f"Failed to validate video container via ffprobe: {e}"
        
    return True, "Pass"

def scan_and_cleanup_broll_database(db_path, dry_run=False):
    """
    Scan the local SQLite DB, validate all registered B-roll video and source image assets,
    delete failed ones, and clean up database records.
    """
    if not os.path.exists(db_path):
        logger.error(f"Database {db_path} does not exist.")
        return {"error": "DB not found"}

    conn = sqlite3.connect(db_path)
    cursor = conn.cursor()
    
    try:
        cursor.execute("SELECT id, title, query, image_url, local_path FROM broll_assets")
        rows = cursor.fetchall()
    except Exception as e:
        logger.error(f"Failed to query database: {e}")
        conn.close()
        return {"error": str(e)}
        
    logger.info(f"Scanning {len(rows)} registered B-roll records...")
    
    scanned = 0
    passed = 0
    failed_video = 0
    failed_image = 0
    missing_files = 0
    deleted_records = []
    
    # We will track which images are associated with which videos to locate the source images.
    # The source images are typically in C:\ComfyUI\Broll\images with a name derived from URL hash and title.
    # The database local_path points to the video (.mp4).
    for row_id, title, query, url, local_path_str in rows:
        scanned += 1
        
        if not local_path_str:
            logger.warning(f"Record ID {row_id} has empty local_path. Removing record.")
            deleted_records.append(row_id)
            missing_files += 1
            continue
            
        video_path = Path(local_path_str)
        
        # Locate corresponding source image in ComfyUI\Broll\images
        # The filename of the video is [hash]_[title].mp4 and the image is [hash]_[title].jpg
        video_name = video_path.name
        img_name = video_name.replace(".mp4", ".jpg")
        img_path = Path(r"C:\ComfyUI\Broll\images") / img_name
        
        # 1. Check file existence
        if not video_path.exists():
            logger.warning(f"Video file missing: {video_path}. Removing record.")
            deleted_records.append(row_id)
            missing_files += 1
            # Clean up image if it exists
            if img_path.exists() and not dry_run:
                img_path.unlink()
            continue
            
        # 2. Validate Video
        vid_ok, vid_reason = validate_video_asset(video_path)
        if not vid_ok:
            logger.warning(f"Video {video_name} failed Quality Gate: {vid_reason}")
            failed_video += 1
            deleted_records.append(row_id)
            if not dry_run:
                video_path.unlink(missing_ok=True)
                if img_path.exists():
                    img_path.unlink(missing_ok=True)
            continue
            
        # 3. Validate Source Image (if exists)
        if img_path.exists():
            img_ok, img_reason = validate_image_asset(img_path)
            if not img_ok:
                # If failed because of watermark, try to remove it
                if "Watermark" in img_reason:
                    logger.info(f"Source image {img_name} has watermark. Attempting automatic removal...")
                    if not dry_run:
                        removed, remove_reason = remove_watermark_with_lama(img_path)
                        if removed:
                            # Re-generate video because the old video has the watermark
                            logger.info(f"Watermark removed from image. Regenerating video clip {video_name}...")
                            try:
                                from collect_broll_agent import generate_ken_burns_clip
                                # Delete old video
                                video_path.unlink(missing_ok=True)
                                if generate_ken_burns_clip(img_path, video_path):
                                    logger.info(f"Video regenerated successfully: {video_name}")
                                    img_ok = True
                                else:
                                    logger.error(f"Failed to regenerate video {video_name} from restored image")
                            except Exception as ex:
                                logger.error(f"Error during video regeneration: {ex}")
                        else:
                            logger.warning(f"Watermark removal failed for {img_name}: {remove_reason}")
                            
                if not img_ok:
                    logger.warning(f"Source image {img_name} failed Quality Gate: {img_reason}")
                    failed_image += 1
                    deleted_records.append(row_id)
                    if not dry_run:
                        video_path.unlink(missing_ok=True)
                        img_path.unlink(missing_ok=True)
                    continue
        else:
            # If the source image is missing but the video exists and is valid, we let it pass
            # because the video is already compiled and good to go.
            pass
            
        passed += 1

    # Apply database deletions
    if deleted_records and not dry_run:
        logger.info(f"Removing {len(deleted_records)} failed/missing records from database...")
        try:
            # SQLite supports up to 999 variables, chunk if needed
            for i in range(0, len(deleted_records), 500):
                chunk = deleted_records[i:i+500]
                cursor.execute(f"DELETE FROM broll_assets WHERE id IN ({','.join('?' for _ in chunk)})", chunk)
            conn.commit()
        except Exception as e:
            logger.error(f"Failed to delete records from DB: {e}")
            
    conn.close()
    
    summary = {
        "scanned": scanned,
        "passed": passed,
        "failed_video": failed_video,
        "failed_image": failed_image,
        "missing_files": missing_files,
        "deleted_records_count": len(deleted_records)
    }
    
    logger.info(f"Cleanup finished. Summary: {summary}")
    return summary

def main():
    parser = argparse.ArgumentParser(description="B-roll Quality Gate Scanner & Cleaner")
    parser.add_argument("--db-path", type=str, default=r"C:\ComfyUI\Articles\broll_assets.db", help="Path to SQLite DB")
    parser.add_argument("--cleanup", action="store_true", help="Perform database scanning and cleanup.")
    parser.add_argument("--dry-run", action="store_true", help="Scan only, do not delete files or DB records.")
    parser.add_argument("--image", type=str, help="Validate a single image file.")
    parser.add_argument("--remove-watermark", action="store_true", help="Remove watermark from single image (must specify --image)")
    parser.add_argument("--video", type=str, help="Validate a single video file.")
    args = parser.parse_args()

    if args.image:
        if args.remove_watermark:
            ok, reason = remove_watermark_with_lama(args.image)
            print(f"Watermark removal for {args.image}: {'PASS' if ok else 'FAIL'}")
            if not ok:
                print(f"Reason: {reason}")
            sys.exit(0 if ok else 1)
        else:
            ok, reason = validate_image_asset(args.image)
            print(f"Image validation for {args.image}: {'PASS' if ok else 'FAIL'}")
            if not ok:
                print(f"Reason: {reason}")
            sys.exit(0 if ok else 1)
        
    if args.video:
        ok, reason = validate_video_asset(args.video)
        print(f"Video validation for {args.video}: {'PASS' if ok else 'FAIL'}")
        if not ok:
            print(f"Reason: {reason}")
        sys.exit(0 if ok else 1)

    if args.cleanup:
        summary = scan_and_cleanup_broll_database(args.db_path, dry_run=args.dry_run)
        print("\n=== Cleanup Scan Report ===")
        print(json.dumps(summary, indent=4))
        sys.exit(0)

    parser.print_help()

if __name__ == "__main__":
    main()

	import os
	import sys
	import json
	import sqlite3
	import argparse
	import subprocess
	import logging
	from pathlib import Path
	import numpy as np
	from PIL import Image, ImageFilter

	# Reconfigure stdout/stderr to utf-8 to avoid encoding issues on Windows
	sys.stdout.reconfigure(encoding='utf-8')
	sys.stderr.reconfigure(encoding='utf-8')

	# Logging setup
	logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
	logger = logging.getLogger("quality_gate_broll")

	def validate_image_asset(img_path, min_width=500, min_height=300):
	"""
	Perform deep validation of a B-roll image file.
	Checks: file existence, PIL verification, resolution, aspect ratio, blankness, and watermarks.
	Returns: (bool, str) -> (is_valid, reason)
	"""
	path = Path(img_path)
	if not path.exists():
	return False, "File does not exist"

	# Check minimum file size (e.g. 5KB)
	try:
	size = path.stat().st_size
	if size < 5120:
	return False, f"File size is too small ({size} bytes). Likely a corrupt download or placeholder."
	except Exception as e:
	return False, f"Failed to get file stats: {e}"

	# 1. PIL opening and integrity check
	try:
	with Image.open(path) as img:
	img.verify() # verify integrity of the file container
	except Exception as e:
	return False, f"Image container is corrupted or invalid: {e}"

	# Re-open because verify() makes the file handle unusable
	try:
	with Image.open(path) as img:
	w, h = img.size

	# 2. Resolution check
	if w < min_width or h < min_height:
	return False, f"Resolution too low ({w}x{h}). Minimum required is {min_width}x{min_height}."

	# 3. Aspect Ratio check
	aspect = w / h
	# Normal landscape should be around 1.33 to 1.78.
	# Reject vertical portrait (aspect < 0.75) and extreme panoramas (aspect > 2.5)
	if aspect < 0.75:
	return False, f"Asset is vertical / portrait (aspect ratio: {aspect:.2f}). 16:9 crop will lose context."
	if aspect > 2.5:
	return False, f"Asset is too wide / panoramic (aspect ratio: {aspect:.2f}). 16:9 crop will look extremely stretched or cropped."

	# 4. Blank screen / Solid color check
	# Convert to grayscale to simplify calculation
	gray_img = img.convert("L")
	arr = np.array(gray_img, dtype=np.float32)
	std_dev = np.std(arr)
	# A standard deviation < 5.0 indicates almost zero contrast (solid color / blank / broken download)
	if std_dev < 5.0:
	return False, f"Blank or solid color image detected (standard deviation: {std_dev:.2f})."

	# 5. Watermark / logo detection
	detected = detect_watermarks(img_path)
	if detected:
	return False, f"Watermark or logo pattern detected in regions: {detected}."

	except Exception as e:
	return False, f"Unexpected error during visual analysis: {e}"

	return True, "Pass"

	def detect_watermarks(img_path):
	"""
	Scan the corners and central-right/bottom-center of the image and return a list of regions that contain watermarks.
	"""
	path = Path(img_path)
	if not path.exists():
	return []

	# Check if the filename contains stock/news keywords for adaptive thresholding
	path_lower = str(path).lower()
	is_stock_source = any(x in path_lower for x in ["getty", "alamy", "stock", "shutter", "anadolu", "reuters", "exclusive", "refinery"])

	try:
	with Image.open(path) as img:
	w, h = img.size
	gray_img = img.convert("L")
	arr = np.array(gray_img, dtype=np.float32)

	diff_x = np.abs(arr[:, 1:] - arr[:, :-1])
	diff_y = np.abs(arr[1:, :] - arr[:-1, :])
	edges = np.zeros_like(arr)
	edges[:, :-1] += diff_x
	edges[:-1, :] += diff_y

	cw = int(w * 0.15)
	ch = int(h * 0.15)
	cw = max(cw, 10)
	ch = max(ch, 10)

	regions = {
	"top_left": (0, 0, cw, ch),
	"top_right": (w-cw, 0, w, ch),
	"bottom_left": (0, h-ch, cw, h),
	"bottom_right": (w-cw, h-ch, w, h),
	"center_right": (int(w * 0.55), int(h * 0.45), int(w * 0.98), int(h * 0.80)),
	"bottom_center": (int(w * 0.20), int(h * 0.82), int(w * 0.80), h),
	"center": (int(w * 0.30), int(h * 0.30), int(w * 0.70), int(h * 0.70))
	}

	detected = []
	for name, (x1, y1, x2, y2) in regions.items():
	region = edges[y1:y2, x1:x2]
	if region.size == 0:
	continue
	mean_edge = np.mean(region)
	max_edge = np.max(region)

	# Corner heuristics (normally low texture, so strict threshold)
	if name in ["top_left", "top_right", "bottom_left", "bottom_right"]:
	if mean_edge > 15.0 and max_edge > 150.0:
	detected.append(name)
	# Central/Bottom heuristics (higher natural texture, adaptive check to avoid false positives)
	else:
	if is_stock_source:
	high_contrast_pixels = np.sum(region > 120.0)
	# Detect even if the mean edge is diluted in a large region, as long as strong local edges exist
	if (mean_edge > 5.0 and max_edge > 80.0 and high_contrast_pixels > 15) or (high_contrast_pixels > 40):
	detected.append(name)
	else:
	if mean_edge > 20.0 and max_edge > 200.0:
	high_contrast_pixels = np.sum(region > 200.0)
	if high_contrast_pixels > 30:
	detected.append(name)
	return detected
	except Exception as e:
	logger.error(f"Error checking watermarks for {img_path}: {e}")
	return []

	def generate_watermark_mask(img_path, output_mask_path, detected_corners=None):
	"""
	Generate a binary mask where detected watermark pixels are white (255) and dilated.
	"""
	path = Path(img_path)
	if not path.exists():
	return False

	if detected_corners is None:
	detected_corners = detect_watermarks(img_path)

	if not detected_corners:
	# Create empty mask if no corners detected
	try:
	with Image.open(path) as img:
	mask = Image.new("L", img.size, color=0)
	mask.save(output_mask_path, "JPEG")
	return True
	except Exception as e:
	logger.error(f"Failed to create empty mask: {e}")
	return False

	try:
	with Image.open(path) as img:
	w, h = img.size
	gray_img = img.convert("L")
	arr = np.array(gray_img, dtype=np.float32)

	# Recompute edges to find watermark pixels
	diff_x = np.abs(arr[:, 1:] - arr[:, :-1])
	diff_y = np.abs(arr[1:, :] - arr[:-1, :])
	edges = np.zeros_like(arr)
	edges[:, :-1] += diff_x
	edges[:-1, :] += diff_y

	# Create a base black mask
	mask_arr = np.zeros((h, w), dtype=np.uint8)

	cw = int(w * 0.15)
	ch = int(h * 0.15)
	cw = max(cw, 10)
	ch = max(ch, 10)

	regions = {
	"top_left": (0, 0, cw, ch),
	"top_right": (w-cw, 0, w, ch),
	"bottom_left": (0, h-ch, cw, h),
	"bottom_right": (w-cw, h-ch, w, h),
	"center_right": (int(w * 0.55), int(h * 0.45), int(w * 0.98), int(h * 0.80)),
	"bottom_center": (int(w * 0.20), int(h * 0.82), int(w * 0.80), h),
	"center": (int(w * 0.30), int(h * 0.30), int(w * 0.70), int(h * 0.70))
	}

	for name in detected_corners:
	if name not in regions:
	continue
	x1, y1, x2, y2 = regions[name]
	# In the region, pixels with edge strength > 15 are likely watermark strokes
	region_edges = edges[y1:y2, x1:x2]
	mask_region = np.zeros_like(region_edges, dtype=np.uint8)
	mask_region[region_edges > 15.0] = 255
	mask_arr[y1:y2, x1:x2] = mask_region

	mask_img = Image.fromarray(mask_arr)

	# Dilate the mask using PIL's MaxFilter to cover surrounding pixels of the watermark text/logo
	dilated_mask = mask_img.filter(ImageFilter.MaxFilter(size=9))

	# Save mask
	dilated_mask.save(output_mask_path, "JPEG")
	return True

	except Exception as e:
	logger.error(f"Error generating mask for {img_path}: {e}")
	return False

	def remove_watermark_with_lama(img_path, output_path=None):
	"""
	Detect, mask, and inpaint watermark/logo out of the image using LaMa.
	Then re-validate the result.
	Returns: (bool, str) -> (success, reason)
	"""
	path = Path(img_path)
	if not path.exists():
	return False, "File does not exist"

	if output_path is None:
	output_path = img_path

	detected_corners = detect_watermarks(img_path)
	if not detected_corners:
	return True, "No watermark detected"

	logger.info(f"Watermark detected in corners {detected_corners} of {path.name}. Initiating removal...")

	# Paths for temporary mask and temporary output
	temp_mask_path = path.parent / f".temp_mask_{path.stem}.jpg"
	temp_out_path = path.parent / f".temp_out_{path.stem}.jpg"

	try:
	# 1. Generate mask
	if not generate_watermark_mask(path, temp_mask_path, detected_corners):
	return False, "Failed to generate watermark mask"

	# 2. Run LaMa inpainting
	lama_script = r"C:\Roaming\.agents\skills\lama-inpainting\lama_inpaint.py"
	if not os.path.exists(lama_script):
	return False, f"LaMa script not found at {lama_script}"

	cmd = [
	sys.executable,
	lama_script,
	"--image", str(path),
	"--mask", str(temp_mask_path),
	"--output", str(temp_out_path),
	"--device", "cpu"
	]

	logger.info(f"Running LaMa inpainting: {' '.join(cmd)}")
	res = subprocess.run(cmd, capture_output=True, text=True, timeout=90)

	if res.returncode != 0:
	return False, f"LaMa inpainting script failed: {res.stderr.strip()}"

	if not temp_out_path.exists():
	return False, "LaMa script returned 0 but output file was not created"

	# 3. Re-validate the output image
	ok, reason = validate_image_asset(temp_out_path)
	if not ok:
	# If it failed because of watermark again, it means the removal failed or was incomplete
	return False, f"Watermark removal validation failed: {reason}"

	# 4. Overwrite/Save to target destination
	out_path = Path(output_path)
	if out_path.exists():
	out_path.unlink()
	temp_out_path.rename(out_path)

	logger.info(f"Watermark successfully removed and verified for {path.name}")
	return True, "Pass"

	except subprocess.TimeoutExpired:
	return False, "LaMa inpainting execution timed out"
	except Exception as e:
	logger.error(f"Unexpected error during watermark removal: {e}")
	return False, f"Unexpected error during removal: {e}"
	finally:
	# Cleanup temp files
	if temp_mask_path.exists():
	temp_mask_path.unlink(missing_ok=True)
	if temp_out_path.exists():
	temp_out_path.unlink(missing_ok=True)

	def validate_video_asset(video_path):
	"""
	Perform validation of a B-roll video file (Ken-Burns clip).
	Checks: file existence, size, and container integrity using ffprobe.
	Returns: (bool, str) -> (is_valid, reason)
	"""
	path = Path(video_path)
	if not path.exists():
	return False, "File does not exist"

	try:
	size = path.stat().st_size
	if size < 10240: # 10KB minimum
	return False, f"File size is too small ({size} bytes). Likely a failed render."
	except Exception as e:
	return False, f"Failed to get file stats: {e}"

	# Use ffprobe to verify video integrity
	ffprobe = os.environ.get("VIDEO_AGENT_FFPROBE", "ffprobe")
	cmd = [
	ffprobe, "-v", "error",
	"-show_entries", "format=duration,size:stream=codec_type",
	"-of", "json",
	str(path)
	]
	try:
	res = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
	if res.returncode != 0:
	return False, f"ffprobe container validation failed: {res.stderr.strip()}"

	data = json.loads(res.stdout)

	# Check duration
	duration_str = data.get("format", {}).get("duration")
	if not duration_str:
	return False, "No duration found in video container metadata"
	duration = float(duration_str)
	if duration <= 0:
	return False, f"Invalid video duration: {duration}s"

	# Check for video stream
	streams = data.get("streams", [])
	has_video_stream = any(s.get("codec_type") == "video" for s in streams)
	if not has_video_stream:
	return False, "No video stream found in the container"

	except subprocess.TimeoutExpired:
	return False, "ffprobe container validation timed out"
	except Exception as e:
	return False, f"Failed to validate video container via ffprobe: {e}"

	return True, "Pass"

	def scan_and_cleanup_broll_database(db_path, dry_run=False):
	"""
	Scan the local SQLite DB, validate all registered B-roll video and source image assets,
	delete failed ones, and clean up database records.
	"""
	if not os.path.exists(db_path):
	logger.error(f"Database {db_path} does not exist.")
	return {"error": "DB not found"}

	conn = sqlite3.connect(db_path)
	cursor = conn.cursor()

	try:
	cursor.execute("SELECT id, title, query, image_url, local_path FROM broll_assets")
	rows = cursor.fetchall()
	except Exception as e:
	logger.error(f"Failed to query database: {e}")
	conn.close()
	return {"error": str(e)}

	logger.info(f"Scanning {len(rows)} registered B-roll records...")

	scanned = 0
	passed = 0
	failed_video = 0
	failed_image = 0
	missing_files = 0
	deleted_records = []

	# We will track which images are associated with which videos to locate the source images.
	# The source images are typically in C:\ComfyUI\Broll\images with a name derived from URL hash and title.
	# The database local_path points to the video (.mp4).
	for row_id, title, query, url, local_path_str in rows:
	scanned += 1

	if not local_path_str:
	logger.warning(f"Record ID {row_id} has empty local_path. Removing record.")
	deleted_records.append(row_id)
	missing_files += 1
	continue

	video_path = Path(local_path_str)

	# Locate corresponding source image in ComfyUI\Broll\images
	# The filename of the video is [hash]_[title].mp4 and the image is [hash]_[title].jpg
	video_name = video_path.name
	img_name = video_name.replace(".mp4", ".jpg")
	img_path = Path(r"C:\ComfyUI\Broll\images") / img_name

	# 1. Check file existence
	if not video_path.exists():
	logger.warning(f"Video file missing: {video_path}. Removing record.")
	deleted_records.append(row_id)
	missing_files += 1
	# Clean up image if it exists
	if img_path.exists() and not dry_run:
	img_path.unlink()
	continue

	# 2. Validate Video
	vid_ok, vid_reason = validate_video_asset(video_path)
	if not vid_ok:
	logger.warning(f"Video {video_name} failed Quality Gate: {vid_reason}")
	failed_video += 1
	deleted_records.append(row_id)
	if not dry_run:
	video_path.unlink(missing_ok=True)
	if img_path.exists():
	img_path.unlink(missing_ok=True)
	continue

	# 3. Validate Source Image (if exists)
	if img_path.exists():
	img_ok, img_reason = validate_image_asset(img_path)
	if not img_ok:
	# If failed because of watermark, try to remove it
	if "Watermark" in img_reason:
	logger.info(f"Source image {img_name} has watermark. Attempting automatic removal...")
	if not dry_run:
	removed, remove_reason = remove_watermark_with_lama(img_path)
	if removed:
	# Re-generate video because the old video has the watermark
	logger.info(f"Watermark removed from image. Regenerating video clip {video_name}...")
	try:
	from collect_broll_agent import generate_ken_burns_clip
	# Delete old video
	video_path.unlink(missing_ok=True)
	if generate_ken_burns_clip(img_path, video_path):
	logger.info(f"Video regenerated successfully: {video_name}")
	img_ok = True
	else:
	logger.error(f"Failed to regenerate video {video_name} from restored image")
	except Exception as ex:
	logger.error(f"Error during video regeneration: {ex}")
	else:
	logger.warning(f"Watermark removal failed for {img_name}: {remove_reason}")

	if not img_ok:
	logger.warning(f"Source image {img_name} failed Quality Gate: {img_reason}")
	failed_image += 1
	deleted_records.append(row_id)
	if not dry_run:
	video_path.unlink(missing_ok=True)
	img_path.unlink(missing_ok=True)
	continue
	else:
	# If the source image is missing but the video exists and is valid, we let it pass
	# because the video is already compiled and good to go.
	pass

	passed += 1

	# Apply database deletions
	if deleted_records and not dry_run:
	logger.info(f"Removing {len(deleted_records)} failed/missing records from database...")
	try:
	# SQLite supports up to 999 variables, chunk if needed
	for i in range(0, len(deleted_records), 500):
	chunk = deleted_records[i:i+500]
	cursor.execute(f"DELETE FROM broll_assets WHERE id IN ({','.join('?' for _ in chunk)})", chunk)
	conn.commit()
	except Exception as e:
	logger.error(f"Failed to delete records from DB: {e}")

	conn.close()

	summary = {
	"scanned": scanned,
	"passed": passed,
	"failed_video": failed_video,
	"failed_image": failed_image,
	"missing_files": missing_files,
	"deleted_records_count": len(deleted_records)
	}

	logger.info(f"Cleanup finished. Summary: {summary}")
	return summary

	def main():
	parser = argparse.ArgumentParser(description="B-roll Quality Gate Scanner & Cleaner")
	parser.add_argument("--db-path", type=str, default=r"C:\ComfyUI\Articles\broll_assets.db", help="Path to SQLite DB")
	parser.add_argument("--cleanup", action="store_true", help="Perform database scanning and cleanup.")
	parser.add_argument("--dry-run", action="store_true", help="Scan only, do not delete files or DB records.")
	parser.add_argument("--image", type=str, help="Validate a single image file.")
	parser.add_argument("--remove-watermark", action="store_true", help="Remove watermark from single image (must specify --image)")
	parser.add_argument("--video", type=str, help="Validate a single video file.")
	args = parser.parse_args()

	if args.image:
	if args.remove_watermark:
	ok, reason = remove_watermark_with_lama(args.image)
	print(f"Watermark removal for {args.image}: {'PASS' if ok else 'FAIL'}")
	if not ok:
	print(f"Reason: {reason}")
	sys.exit(0 if ok else 1)
	else:
	ok, reason = validate_image_asset(args.image)
	print(f"Image validation for {args.image}: {'PASS' if ok else 'FAIL'}")
	if not ok:
	print(f"Reason: {reason}")
	sys.exit(0 if ok else 1)

	if args.video:
	ok, reason = validate_video_asset(args.video)
	print(f"Video validation for {args.video}: {'PASS' if ok else 'FAIL'}")
	if not ok:
	print(f"Reason: {reason}")
	sys.exit(0 if ok else 1)

	if args.cleanup:
	summary = scan_and_cleanup_broll_database(args.db_path, dry_run=args.dry_run)
	print("\n=== Cleanup Scan Report ===")
	print(json.dumps(summary, indent=4))
	sys.exit(0)

	parser.print_help()

	if __name__ == "__main__":
	main()