Upload clip_coordinates.py

clip_coordinates.py

@@ -0,0 +1,150 @@
+"""Batch-clamp four-point detection coordinates; dry-run unless --apply is set.
+
+Example:
+  python clip_coordinates.py --apply
+Default bounds: x in [0,447], y in [0,415] for a 448x416 image.
+Use --max-x 448 --max-y 416 only if your format uses continuous image-edge coordinates.
+"""
+import argparse
+import hashlib
+import json
+import math
+import os
+from pathlib import Path
+import re
+import shutil
+import tempfile
+from datetime import datetime
+
+
+def transform(data, path, max_x, max_y):
+    output = []
+    changed_rows = changed_values = upper = negative = rows = 0
+    for number, line in enumerate(data.splitlines(keepends=True), 1):
+        # Preserve a UTF-8 BOM, whitespace, line endings, class ID and confidence.
+        prefix = b'\xef\xbb\xbf' if number == 1 and line.startswith(b'\xef\xbb\xbf') else b''
+        body = line[len(prefix):]
+        tokens = list(re.finditer(rb'\S+', body))
+        if not tokens:
+            output.append(line)
+            continue
+        if len(tokens) != 10:
+            raise ValueError(f'{path}:{number}: expected 10 fields, got {len(tokens)}')
+        rows += 1
+        replacements = []
+        for i, token in enumerate(tokens[:8]):
+            value = float(token.group())
+            if not math.isfinite(value):
+                raise ValueError(f'{path}:{number}: non-finite coordinate')
+            limit = max_x if i % 2 == 0 else max_y
+            clipped = min(limit, max(0, value))
+            if clipped != value:
+                # Retain fixed-point precision of the original coordinate.
+                raw = token.group().decode('ascii')
+                precision = len(raw.split('.')[1]) if '.' in raw and 'e' not in raw.lower() else 6
+                replacements.append((token.start(), token.end(), f'{clipped:.{precision}f}'.encode('ascii')))
+                upper += value > limit
+                negative += value < 0
+        if replacements:
+            changed_rows += 1
+            changed_values += len(replacements)
+            for start, end, replacement in reversed(replacements):
+                body = body[:start] + replacement + body[end:]
+        output.append(prefix + body)
+    return b''.join(output), dict(rows=rows, changed_rows=changed_rows,
+                                  changed_values=changed_values,
+                                  upper_coordinates=upper, negative_coordinates=negative)
+
+
+def atomic_write(path, data):
+    fd, name = tempfile.mkstemp(prefix='.clip-', suffix='.tmp', dir=path.parent)
+    try:
+        with os.fdopen(fd, 'wb') as stream:
+            stream.write(data)
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.replace(name, path)
+    finally:
+        if os.path.exists(name):
+            os.unlink(name)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--root', type=Path, default=Path(r'D:\寅家验收\Perception'))
+    parser.add_argument('--max-x', type=float, default=447)
+    parser.add_argument('--max-y', type=float, default=415)
+    parser.add_argument('--apply', action='store_true')
+    parser.add_argument('--backup-dir', type=Path)
+    parser.add_argument('--report', type=Path)
+    args = parser.parse_args()
+    if not all(math.isfinite(v) and v > 0 for v in (args.max_x, args.max_y)):
+        parser.error('Bounds must be positive and finite')
+    root = args.root.resolve(strict=True)
+    directories = [root / name for name in ('Vehicle_A', 'Vehicle_B')]
+    if not all(p.is_dir() for p in directories):
+        parser.error('Both Vehicle_A and Vehicle_B directories are required')
+    plan = []
+    stats = {}
+    # Validate EVERY file before modifying any source file.
+    for directory in directories:
+        totals = dict(files=0, rows=0, changed_files=0, changed_rows=0,
+                      changed_values=0, upper_coordinates=0, negative_coordinates=0)
+        paths = []
+        for parent, _, names in os.walk(directory):
+            paths.extend(Path(parent) / name for name in names if name.lower().endswith('.txt'))
+        for index, path in enumerate(sorted(paths), 1):
+            if index % 2000 == 0:
+                print(f'Checking {directory.name}: {index}/{len(paths)} TXT files', flush=True)
+            resolved = path.resolve(strict=True)
+            if not resolved.is_relative_to(directory.resolve()):
+                raise ValueError(f'File resolves outside intended directory: {path}')
+            original = path.read_bytes()
+            updated, counts = transform(original, path, args.max_x, args.max_y)
+            totals['files'] += 1
+            for key, value in counts.items():
+                totals[key] += value
+            if original != updated:
+                totals['changed_files'] += 1
+                plan.append((path, original, updated, counts))
+        stats[directory.name] = totals
+        print(f'Checked {directory.name}: {totals}', flush=True)
+    report = dict(mode='apply' if args.apply else 'dry-run', root=str(root),
+                  bounds=dict(x=[0, args.max_x], y=[0, args.max_y]), statistics=stats)
+    if args.apply and plan:
+        backup = (args.backup_dir or Path(__file__).resolve().parent / 'coordinate_backups' /
+                  datetime.now().strftime('%Y%m%d_%H%M%S_%f')).resolve()
+        if backup.is_relative_to(root):
+            raise ValueError('Backup directory must be outside the source root')
+        backup.mkdir(parents=True, exist_ok=False)
+        # Back up ALL affected files before the first overwrite.
+        for path, original, _, _ in plan:
+            if path.read_bytes() != original:
+                raise RuntimeError(f'Source changed during preflight: {path}')
+            dest = backup / path.relative_to(root)
+            dest.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(path, dest)
+            if dest.read_bytes() != original:
+                raise RuntimeError(f'Backup verification failed: {path}')
+        print(f'Backed up {len(plan)} files to {backup}', flush=True)
+        report['backup_directory'] = str(backup)
+        report['modified_files'] = []
+        for path, original, updated, counts in plan:
+            if path.read_bytes() != original:
+                raise RuntimeError(f'Source changed before overwrite: {path}')
+            atomic_write(path, updated)
+            actual = path.read_bytes()
+            if actual != updated or transform(actual, path, args.max_x, args.max_y)[1]['changed_values']:
+                raise RuntimeError(f'Post-write verification failed: {path}')
+            report['modified_files'].append(dict(path=str(path), **counts,
+                original_sha256=hashlib.sha256(original).hexdigest(),
+                clipped_sha256=hashlib.sha256(updated).hexdigest()))
+        report['verification'] = 'All modified files match expected bytes and have in-range coordinates.'
+    if args.report:
+        args.report.parent.mkdir(parents=True, exist_ok=True)
+        args.report.write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding='utf-8')
+    print(json.dumps({k: v for k, v in report.items() if k != 'modified_files'}, ensure_ascii=False, indent=2))
+
+
+if __name__ == '__main__':
+    main()