""" Comprehensive Empirical Verification and Stress-Testing Suite for Milestone 1 Diagram Assets Author: Challenger 1 (Milestone 1 - Diagram Asset Challenger) Target Assets: - docs/diagram-alur.fodg (LibreOffice Draw OASIS OpenDocument 1.3 XML) - docs/diagram-alur.svg (Vector SVG diagram) - docs/diagram-alur.png (4K UHD raster render) - scripts/export_diagram_png.py (Exporter pipeline) """ import sys import re import math import hashlib import time from pathlib import Path import xml.etree.ElementTree as ET from PIL import Image import numpy as np PROJECT_ROOT = Path(__file__).resolve().parent.parent DOCS_DIR = PROJECT_ROOT / "docs" FODG_PATH = DOCS_DIR / "diagram-alur.fodg" SVG_PATH = DOCS_DIR / "diagram-alur.svg" PNG_PATH = DOCS_DIR / "diagram-alur.png" EXPORTER_PATH = PROJECT_ROOT / "scripts" / "export_diagram_png.py" NAMESPACES = { "office": "urn:oasis:names:tc:opendocument:xmlns:office:1.0", "draw": "urn:oasis:names:tc:opendocument:xmlns:drawing:1.0", "style": "urn:oasis:names:tc:opendocument:xmlns:style:1.0", "text": "urn:oasis:names:tc:opendocument:xmlns:text:1.0", "svg": "urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0", "fo": "urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0", "table": "urn:oasis:names:tc:opendocument:xmlns:table:1.0", "xlink": "http://www.w3.org/1999/xlink", } def parse_dim_cm(val_str: str) -> float: if not val_str: return 0.0 val_str = val_str.strip() if val_str.endswith("cm"): return float(val_str[:-2]) elif val_str.endswith("mm"): return float(val_str[:-2]) / 10.0 elif val_str.endswith("in"): return float(val_str[:-2]) * 2.54 elif val_str.endswith("pt"): return float(val_str[:-2]) * 2.54 / 72.0 elif val_str.endswith("px"): return float(val_str[:-2]) * 2.54 / 96.0 try: return float(val_str) except ValueError: return 0.0 def test_fodg_integrity(): print("\n" + "="*60) print(">>> 1. FODG EMPIRICAL INTEGRITY & SCHEMA AUDIT") print("="*60) assert FODG_PATH.exists(), f"FODG file missing: {FODG_PATH}" fodg_size = FODG_PATH.stat().st_size print(f"FODG file size: {fodg_size} bytes") assert fodg_size > 1000, f"FODG file unusually small: {fodg_size} bytes" # XML Parse raw_content = FODG_PATH.read_text(encoding="utf-8") root = ET.fromstring(raw_content) print(f"FODG Root tag: {root.tag}") assert root.tag == f"{{{NAMESPACES['office']}}}document", f"Root tag mismatch: {root.tag}" # Attribute checks version = root.get(f"{{{NAMESPACES['office']}}}version") mimetype = root.get(f"{{{NAMESPACES['office']}}}mimetype") print(f"office:version: {version}") print(f"office:mimetype: {mimetype}") assert version == "1.3", f"Expected ODF version 1.3, got {version}" assert mimetype == "application/vnd.oasis.opendocument.graphics", f"Invalid mimetype: {mimetype}" # Automatic styles and page layout page_layouts = root.findall(f".//{{{NAMESPACES['style']}}}page-layout") print(f"Page layouts found: {len(page_layouts)}") assert len(page_layouts) >= 1, "Missing style:page-layout in FODG" page_prop = root.find(f".//{{{NAMESPACES['style']}}}page-layout-properties") assert page_prop is not None, "Missing style:page-layout-properties" page_w = page_prop.get(f"{{{NAMESPACES['fo']}}}page-width") page_h = page_prop.get(f"{{{NAMESPACES['fo']}}}page-height") orientation = page_prop.get(f"{{{NAMESPACES['style']}}}print-orientation") print(f"Page dimensions: width={page_w}, height={page_h}, orientation={orientation}") page_w_cm = parse_dim_cm(page_w) page_h_cm = parse_dim_cm(page_h) assert page_w_cm > 0 and page_h_cm > 0, "Invalid page dimensions in FODG" assert page_w_cm > page_h_cm, f"Expected landscape orientation (w > h), got w={page_w_cm}, h={page_h_cm}" # Shapes and Connectors draw_page = root.find(f".//{{{NAMESPACES['draw']}}}page") assert draw_page is not None, "Missing draw:page in FODG" custom_shapes = root.findall(f".//{{{NAMESPACES['draw']}}}custom-shape") connectors = root.findall(f".//{{{NAMESPACES['draw']}}}connector") styles = root.findall(f".//{{{NAMESPACES['style']}}}style") print(f"Total draw:custom-shape elements: {len(custom_shapes)}") print(f"Total draw:connector elements: {len(connectors)}") print(f"Total style:style elements: {len(styles)}") assert len(custom_shapes) >= 8, f"Expected at least 8 custom shapes (for 8 stages), got {len(custom_shapes)}" assert len(connectors) >= 7, f"Expected at least 7 connectors between stages, got {len(connectors)}" # Shape coordinate and bounding box bounds check shapes_info = [] for idx, shape in enumerate(custom_shapes): s_id = shape.get(f"{{{NAMESPACES['draw']}}}id") or shape.get(f"{{{NAMESPACES['draw']}}}name") or f"shape_{idx}" x_str = shape.get(f"{{{NAMESPACES['svg']}}}x") y_str = shape.get(f"{{{NAMESPACES['svg']}}}y") w_str = shape.get(f"{{{NAMESPACES['svg']}}}width") h_str = shape.get(f"{{{NAMESPACES['svg']}}}height") x = parse_dim_cm(x_str) y = parse_dim_cm(y_str) w = parse_dim_cm(w_str) h = parse_dim_cm(h_str) # Verify shape sits inside the page bounds (with 1.5cm safety margin) assert x >= 0, f"Shape {s_id} x coordinate < 0: {x}" assert y >= 0, f"Shape {s_id} y coordinate < 0: {y}" assert x + w <= page_w_cm + 1.0, f"Shape {s_id} exceeds page width: {x}+{w} > {page_w_cm}" assert y + h <= page_h_cm + 1.0, f"Shape {s_id} exceeds page height: {y}+{h} > {page_h_cm}" shapes_info.append({"id": s_id, "x": x, "y": y, "w": w, "h": h}) print(f"All {len(shapes_info)} shapes pass page boundary checks!") # Check stage text extraction all_text = " ".join([elem.text for elem in root.iter() if elem.text]) print(f"Total text characters in FODG: {len(all_text)}") required_keywords = [ "Video Archive", "FFmpeg", "SAM3", "Review", "Data Prep", "Master Dataset", "YOLO", "Live Counter", ] for kw in required_keywords: assert kw.lower() in all_text.lower(), f"Missing required keyword '{kw}' in FODG text content" print(f" [OK] FODG text includes keyword: '{kw}'") print("[PASS] FODG Schema, Namespace, Geometry, and Text Integrity Verified 100%") return True def test_svg_integrity(): print("\n" + "="*60) print(">>> 2. SVG EMPIRICAL INTEGRITY & VECTOR AUDIT") print("="*60) assert SVG_PATH.exists(), f"SVG file missing: {SVG_PATH}" svg_size = SVG_PATH.stat().st_size print(f"SVG file size: {svg_size} bytes") assert svg_size > 5000, f"SVG file too small: {svg_size} bytes" raw_svg = SVG_PATH.read_text(encoding="utf-8") root = ET.fromstring(raw_svg) # Strip namespace for clean tag matching ns = "{http://www.w3.org/2000/svg}" assert root.tag == f"{ns}svg" or root.tag == "svg", f"Root is not svg: {root.tag}" viewBox = root.get("viewBox") print(f"SVG viewBox: {viewBox}") assert viewBox == "0 0 1920 1080", f"Expected viewBox '0 0 1920 1080', got '{viewBox}'" # Extract all def IDs defs = root.find(f".//{ns}defs") assert defs is not None, "Missing section in SVG" def_ids = set() for child in defs.iter(): i = child.get("id") if i: def_ids.add(i) print(f"Total element IDs declared: {len(def_ids)} ({sorted(list(def_ids))})") assert len(def_ids) >= 10, f"Expected >= 10 def definitions (gradients, markers, filters), got {len(def_ids)}" # Audit all url(#id) references in SVG url_pattern = re.compile(r'url\(#([^)]+)\)') all_refs = url_pattern.findall(raw_svg) print(f"Total url(#...) references in SVG: {len(all_refs)}") missing_refs = set(all_refs) - def_ids print(f"Dangling/Missing url(#...) references: {missing_refs}") assert len(missing_refs) == 0, f"SVG contains broken url references: {missing_refs}" # Check Stage groups for stage_num in range(1, 9): stage_id = f"stage-{stage_num}" stage_elem = root.find(f".//*[@id='{stage_id}']") assert stage_elem is not None, f"Missing stage group with id='{stage_id}' in SVG" print(f" [OK] SVG Group found: #{stage_id}") # Check storage dock storage_dock = root.find(".//*[@id='storage-dock']") assert storage_dock is not None, "Missing #storage-dock in SVG" print(" [OK] SVG Group found: #storage-dock") # Check connectors connectors_group = root.find(".//*[@id='flow-connectors']") assert connectors_group is not None, "Missing #flow-connectors group in SVG" print(" [OK] SVG Group found: #flow-connectors") # Check connector path count connector_paths = connectors_group.findall(f".//{ns}path") + connectors_group.findall("path") print(f"Total connector paths in SVG: {len(connector_paths)}") assert len(connector_paths) == 8, f"Expected 8 connector paths, got {len(connector_paths)}" # Text extraction and verification text_elements = root.findall(f".//{ns}text") print(f"Total elements in SVG: {len(text_elements)}") assert len(text_elements) >= 30, f"Expected >= 30 text elements, got {len(text_elements)}" all_svg_text = " ".join([t.text for t in root.iter() if t.text]) print(f"Total text characters in SVG: {len(all_svg_text)}") pipeline_checks = [ ("Video Archive & CCTV", "Stage 1 Ingest"), ("FFmpeg Frame Extraction", "Stage 2 Slicing"), ("SAM3 Grounding Engine", "Stage 3 SAM3"), ("Review & Edit Canvas", "Stage 4 Canvas"), ("Data Prep & Triage", "Stage 5 Data Prep"), ("Master Dataset Freezing", "Stage 6 Freeze"), ("YOLO Retraining Engine", "Stage 7 YOLO"), ("Live Counter & Inference", "Stage 8 Live Counter"), ("app.db", "Storage SQLite"), ("06:00", "Working Day Cycle"), ("WHEP", "Streaming Protocol"), ("ByteTrack", "Tracker"), ("mAP", "Evaluation Metric") ] for term, label in pipeline_checks: assert term.lower() in all_svg_text.lower(), f"Missing required term '{term}' ({label}) in SVG text" print(f" [OK] Verified SVG semantic label: '{term}'") print("[PASS] SVG Structure, Defs Integrity, Groups, and Text Coverage Verified 100%") return True def test_png_integrity(): print("\n" + "="*60) print(">>> 3. PNG EMPIRICAL RASTER INTEGRITY & VISUAL AUDIT") print("="*60) assert PNG_PATH.exists(), f"PNG file missing: {PNG_PATH}" png_size = PNG_PATH.stat().st_size print(f"PNG file size: {png_size} bytes ({png_size/1024:.1f} KB)") # Check requirement size > 1MB assert png_size > 1_000_000, f"PNG file size must be > 1MB, got {png_size} bytes ({png_size/1024:.1f} KB)" print(f" [OK] PNG size > 1MB: {png_size} bytes > 1,000,000 bytes") with Image.open(PNG_PATH) as img: w, h = img.size mode = img.mode fmt = img.format print(f"Image Format: {fmt}") print(f"Image Dimensions: {w}x{h} px") print(f"Image Color Mode: {mode}") assert fmt == "PNG", f"Expected PNG format, got {fmt}" assert (w, h) == (3840, 2160), f"Expected dimensions (3840, 2160), got ({w}, {h})" assert mode == "RGB", f"Expected color mode RGB, got {mode}" # Statistical analysis of pixel data arr = np.array(img) assert arr.shape == (2160, 3840, 3), f"Unexpected array shape: {arr.shape}" mean_r, mean_g, mean_b = arr.mean(axis=(0, 1)) std_r, std_g, std_b = arr.std(axis=(0, 1)) min_r, min_g, min_b = arr.min(axis=(0, 1)) max_r, max_g, max_b = arr.max(axis=(0, 1)) print(f"Channel Means (R,G,B): ({mean_r:.2f}, {mean_g:.2f}, {mean_b:.2f})") print(f"Channel StdDev (R,G,B): ({std_r:.2f}, {std_g:.2f}, {std_b:.2f})") print(f"Channel Min (R,G,B): ({min_r}, {min_g}, {min_b})") print(f"Channel Max (R,G,B): ({max_r}, {max_g}, {max_b})") # Check for vibrant contrast (dark background ~8-15, highlights > 200) assert min_r <= 20 and min_g <= 20 and min_b <= 25, "Background not sufficiently dark" assert max_r >= 220 and max_g >= 220 and max_b >= 220, "Foreground highlights missing or washed out" assert std_r > 15 and std_g > 15 and std_b > 20, "Image has insufficient visual variance / flat render" # Unique colors check across full pixel space flat_pixels = arr.reshape(-1, 3) unique_colors = len(np.unique(flat_pixels, axis=0)) print(f"Full unique colors: {unique_colors:,}") assert unique_colors > 10000, f"Expected > 10,000 unique colors (anti-aliasing & gradients), got {unique_colors}" print("[PASS] PNG Dimensions (3840x2160), Mode (RGB), Size (>1MB), and Pixel Quality Verified 100%") return True def test_anti_ai_and_language_qc(): print("\n" + "="*60) print(">>> 4. ANTI-AI & TECHNICAL LANGUAGE QC AUDIT") print("="*60) # Extract all visible text nodes from FODG and SVG fodg_root = ET.fromstring(FODG_PATH.read_text(encoding="utf-8")) svg_root = ET.fromstring(SVG_PATH.read_text(encoding="utf-8")) fodg_texts = " \n ".join([t.text for t in fodg_root.iter() if t.text and t.text.strip()]) svg_texts = " \n ".join([t.text for t in svg_root.iter() if t.text and t.text.strip()]) forbidden_patterns = [ r"--", # Double hyphens r"delve", # AI cliche r"crucial", # AI cliche r"testament", # AI cliche r"beacon", # AI cliche r"furthermore", # AI filler r"in conclusion", # AI filler r"it is important", # AI filler ] for p in forbidden_patterns: match_fodg = re.findall(p, fodg_texts, re.IGNORECASE) match_svg = re.findall(p, svg_texts, re.IGNORECASE) assert len(match_fodg) == 0, f"Forbidden AI marker '{p}' found in FODG text: {match_fodg}" assert len(match_svg) == 0, f"Forbidden AI marker '{p}' found in SVG text: {match_svg}" print(f" [OK] Clean of AI marker pattern: '{p}'") print("[PASS] Anti-AI Phrasing and Text Cleanliness Verified 100%") return True def test_exporter_reproducibility(): print("\n" + "="*60) print(">>> 5. EXPORTER SCRIPT REPRODUCIBILITY & DETERMINISM") print("="*60) assert EXPORTER_PATH.exists(), f"Exporter script missing: {EXPORTER_PATH}" # Read current PNG hash initial_hash = hashlib.sha256(PNG_PATH.read_bytes()).hexdigest() print(f"Initial PNG SHA-256: {initial_hash}") # Import and test exporter import importlib.util spec = importlib.util.spec_from_file_location("exporter", EXPORTER_PATH) exporter = importlib.util.module_from_spec(spec) spec.loader.exec_module(exporter) t0 = time.perf_counter() import asyncio asyncio.run(exporter.export_svg_to_png(SVG_PATH, PNG_PATH, width=1920, height=1080, scale=2.0)) elapsed = time.perf_counter() - t0 print(f"Exporter execution time: {elapsed:.2f}s") new_hash = hashlib.sha256(PNG_PATH.read_bytes()).hexdigest() print(f"Re-exported PNG SHA-256: {new_hash}") assert initial_hash == new_hash, f"Hash mismatch after re-export! {initial_hash} vs {new_hash}" print("[PASS] Exporter Script is 100% Deterministic and Reproducible") return True def test_multiscale_and_clipping(): print("\n" + "="*60) print(">>> 6. MULTI-SCALE RENDERING & DOM CLIPPING AUDIT") print("="*60) import asyncio from playwright.async_api import async_playwright import io async def _async_audit(): svg_content = SVG_PATH.read_text(encoding="utf-8") scales = [1.0, 2.0, 3.0] async with async_playwright() as p: browser = await p.chromium.launch() # 1. Multi-scale test for scale in scales: page = await browser.new_page( viewport={"width": 1920, "height": 1080}, device_scale_factor=scale ) html_wrapper = f""" {svg_content} """ await page.set_content(html_wrapper) await page.wait_for_timeout(300) png_bytes = await page.screenshot(type="png") with Image.open(io.BytesIO(png_bytes)) as img: w, h = img.size exp_w, exp_h = int(1920 * scale), int(1080 * scale) assert (w, h) == (exp_w, exp_h), f"Scale {scale} failed: {w}x{h} != {exp_w}x{exp_h}" print(f" [OK] Scale {scale:.1f}x -> {w}x{h} px ({len(png_bytes)/1024:.1f} KB)") await page.close() # 2. Text clipping / bounding box check page = await browser.new_page( viewport={"width": 1920, "height": 1080}, device_scale_factor=2.0 ) await page.set_content(html_wrapper) await page.wait_for_timeout(300) issues = await page.evaluate("""() => { const issues = []; const svg = document.querySelector('svg'); const svgRect = svg.getBoundingClientRect(); const textNodes = document.querySelectorAll('text'); textNodes.forEach(t => { const rect = t.getBoundingClientRect(); if (rect.left < svgRect.left - 2 || rect.right > svgRect.right + 2 || rect.top < svgRect.top - 2 || rect.bottom > svgRect.bottom + 2) { issues.push({ type: 'CANVAS_OVERFLOW', text: t.textContent.trim() }); } }); return { totalTextElements: textNodes.length, issues: issues }; }""") await page.close() await browser.close() print(f"Total Text Nodes inspected for clipping: {issues['totalTextElements']}") assert len(issues['issues']) == 0, f"Detected text clipping issues: {issues['issues']}" print(" [OK] Zero text elements exceed SVG canvas boundaries!") asyncio.run(_async_audit()) print("[PASS] Multi-Scale & Layout Clipping Audit Passed 100%") return True def main(): print("="*70) print("CHALLENGER 1 (MILESTONE 1) — EMPIRICAL VERIFICATION HARNESS") print("="*70) t_start = time.perf_counter() test_fodg_integrity() test_svg_integrity() test_png_integrity() test_anti_ai_and_language_qc() test_exporter_reproducibility() test_multiscale_and_clipping() t_total = time.perf_counter() - t_start print("\n" + "="*70) print(f"ALL EMPIRICAL TESTS PASSED SUCCESSFULLY IN {t_total:.2f}s (100% PASS RATE)") print("="*70) if __name__ == "__main__": main()