| """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} |
|
|
| |
| 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}") |
|
|
| |
| 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: |
| |
| 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 = [] |
|
|
| |
| 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)}") |
|
|
| |
| 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}") |
|
|
| |
| nodes = ann.get("nodes", []) |
| h_ok, h_errs = validate_acyclic_hierarchy(nodes) |
| errors.extend(h_errs) |
|
|
| |
| c_ok, c_errs = validate_coordinates(nodes, actual_w, actual_h) |
| errors.extend(c_errs) |
|
|
| |
| 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, |
| } |
|
|
| |
| 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).") |
|
|
