File size: 5,925 Bytes
6452a62 | 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 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 | """Comprehensive validator for contextual screen perception annotations."""
from __future__ import annotations
import argparse
import hashlib
import json
from pathlib import Path
from typing import Dict, List, Tuple
import jsonschema
from PIL import Image
REPO_ROOT = Path(__file__).resolve().parents[3]
SCHEMA_FILE = REPO_ROOT / "screen_understanding/dataset/schema/annotation.schema.json"
def validate_acyclic_hierarchy(nodes: List[Dict]) -> Tuple[bool, List[str]]:
"""Verify that parent links form an acyclic tree with exactly one root."""
errors = []
node_ids = {n["id"] for n in nodes}
roots = [n for n in nodes if n.get("parent_id") is None]
if len(roots) != 1:
errors.append(f"Expected exactly 1 root node with parent_id=None, found {len(roots)}")
elif roots[0]["id"] != "n_0000":
errors.append(f"Root node must have id 'n_0000', got {roots[0]['id']}")
parent_map = {n["id"]: n.get("parent_id") for n in nodes}
# Check for nonexistent parents
for nid, pid in parent_map.items():
if pid is not None and pid not in node_ids:
errors.append(f"Node {nid} references nonexistent parent {pid}")
# Check for cycles
for nid in node_ids:
visited = set()
curr = nid
while curr is not None:
if curr in visited:
errors.append(f"Cycle detected in parent hierarchy containing node {curr}")
break
visited.add(curr)
curr = parent_map.get(curr)
return len(errors) == 0, errors
def validate_coordinates(nodes: List[Dict], width: int, height: int) -> Tuple[bool, List[str]]:
"""Ensure all bounding boxes have valid dimensions within image bounds."""
errors = []
for n in nodes:
nid = n["id"]
box = n.get("bbox")
if not isinstance(box, list) or len(box) != 4:
errors.append(f"Node {nid} has invalid bbox format: {box}")
continue
l, t, r, b = box
if l >= r:
errors.append(f"Node {nid} has left >= right: {box}")
if t >= b:
errors.append(f"Node {nid} has top >= bottom: {box}")
if l < 0 or t < 0 or r > width or b > height:
# Allow tolerance of up to 2 pixels for rounding
if l < -2 or t < -2 or r > width + 2 or b > height + 2:
errors.append(f"Node {nid} bbox is out of image bounds ([0, 0, {width}, {height}]): {box}")
return len(errors) == 0, errors
def validate_proposals_coverage(annotation: Dict, raw_proposals: Dict) -> Tuple[bool, List[str]]:
"""Ensure all raw proposals have a recorded disposition."""
errors = []
raw_list = raw_proposals.get("proposals", [])
raw_ids = {p["id"] for p in raw_list}
cov = annotation.get("coverage", {})
dispositions = cov.get("proposals_disposition", {})
missing_dispositions = raw_ids - set(dispositions.keys())
if missing_dispositions:
errors.append(f"{len(missing_dispositions)} proposals missing explicit disposition: {list(missing_dispositions)[:5]}...")
return len(errors) == 0, errors
def validate_annotation_file(
annotation_path: Path,
image_path: Path,
raw_proposals_path: Optional[Path] = None,
) -> Dict:
"""Validate annotation against schema, geometry, hierarchy, and image hash."""
schema = json.loads(SCHEMA_FILE.read_text())
ann = json.loads(annotation_path.read_text())
errors = []
warnings = []
# 1. JSON Schema validation
try:
jsonschema.validate(instance=ann, schema=schema)
except jsonschema.ValidationError as e:
errors.append(f"JSON Schema validation error: {e.message} at path {list(e.path)}")
# 2. Image hash and dimensions check
im = Image.open(image_path)
actual_w, actual_h = im.size
actual_hash = hashlib.sha256(image_path.read_bytes()).hexdigest()
rec_img = ann.get("image", {})
if rec_img.get("width") != actual_w or rec_img.get("height") != actual_h:
errors.append(f"Dimension mismatch: image is ({actual_w}, {actual_h}) vs recorded ({rec_img.get('width')}, {rec_img.get('height')})")
if rec_img.get("sha256") != actual_hash:
errors.append(f"SHA-256 mismatch for image: recorded {rec_img.get('sha256')} != actual {actual_hash}")
# 3. Hierarchy check
nodes = ann.get("nodes", [])
h_ok, h_errs = validate_acyclic_hierarchy(nodes)
errors.extend(h_errs)
# 4. Coordinate validity
c_ok, c_errs = validate_coordinates(nodes, actual_w, actual_h)
errors.extend(c_errs)
# 5. Proposal dispositions
if raw_proposals_path and raw_proposals_path.exists():
raw_p = json.loads(raw_proposals_path.read_text())
p_ok, p_errs = validate_proposals_coverage(ann, raw_p)
errors.extend(p_errs)
is_valid = len(errors) == 0
report = {
"valid": is_valid,
"screen_id": ann.get("screen_id"),
"node_count": len(nodes),
"errors": errors,
"warnings": warnings,
"schema_version": ann.get("schema_version"),
"timestamp": Path(annotation_path).stat().st_mtime,
}
# Save to validation.json alongside annotation
val_path = annotation_path.parent / "validation.json"
val_path.write_text(json.dumps(report, indent=2) + "\n")
return report
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--annotation", type=Path, required=True)
parser.add_argument("--image", type=Path, required=True)
parser.add_argument("--proposals", type=Path, default=None)
args = parser.parse_args()
rep = validate_annotation_file(args.annotation, args.image, args.proposals)
print(f"Validation result: {'PASSED' if rep['valid'] else 'FAILED'}")
if not rep["valid"]:
for e in rep["errors"]:
print(" - Error:", e)
else:
print(f"All checks passed ({rep['node_count']} nodes).")
|