| """Coordinate transformations and crop geometry for contextual screen perception dataset.""" |
| from __future__ import annotations |
|
|
| import math |
| from typing import Dict, List, Tuple, Union |
| from PIL import Image |
|
|
|
|
| class CropTransform: |
| """Manages coordinate transformations between source screenshot pixels and crop pixels.""" |
|
|
| def __init__( |
| self, |
| source_origin: Tuple[float, float], |
| padding: Tuple[float, float] = (0.0, 0.0), |
| scale: Tuple[float, float] = (1.0, 1.0), |
| crop_box_in_source: Tuple[float, float, float, float] = None, |
| crop_image_size: Tuple[int, int] = None, |
| ): |
| """ |
| source_origin: (x0, y0) in source screenshot pixels |
| padding: (px, py) applied before scaling / cropping |
| scale: (sx, sy) scaling factors (crop_pixels / unscaled_crop_pixels) |
| crop_box_in_source: (x0, y0, x1, y1) in source pixels |
| crop_image_size: (width, height) of the resulting crop image |
| """ |
| self.x0, self.y0 = float(source_origin[0]), float(source_origin[1]) |
| self.px, self.py = float(padding[0]), float(padding[1]) |
| self.sx, self.sy = float(scale[0]), float(scale[1]) |
| if self.sx <= 0 or self.sy <= 0: |
| raise ValueError(f"Scales must be positive, got ({self.sx}, {self.sy})") |
| self.crop_box_in_source = crop_box_in_source |
| self.crop_image_size = crop_image_size |
|
|
| def to_source_point(self, crop_x: float, crop_y: float) -> Tuple[float, float]: |
| """Convert crop coordinate to source screenshot pixels.""" |
| src_x = self.x0 + (crop_x - self.px) / self.sx |
| src_y = self.y0 + (crop_y - self.py) / self.sy |
| return (src_x, src_y) |
|
|
| def to_crop_point(self, src_x: float, src_y: float) -> Tuple[float, float]: |
| """Convert source screenshot pixel coordinate to crop coordinate.""" |
| crop_x = (src_x - self.x0) * self.sx + self.px |
| crop_y = (src_y - self.y0) * self.sy + self.py |
| return (crop_x, crop_y) |
|
|
| def to_source_box(self, crop_box: List[float]) -> List[float]: |
| """Convert [left, top, right, bottom] in crop pixels to source screenshot pixels.""" |
| if len(crop_box) != 4: |
| raise ValueError("Bounding box must have 4 coordinates") |
| l, t, r, b = crop_box |
| x1, y1 = self.to_source_point(l, t) |
| x2, y2 = self.to_source_point(r, b) |
| return [min(x1, x2), min(y1, y2), max(x1, x2), max(y1, y2)] |
|
|
| def to_crop_box(self, source_box: List[float]) -> List[float]: |
| """Convert [left, top, right, bottom] in source screenshot pixels to crop pixels.""" |
| if len(source_box) != 4: |
| raise ValueError("Bounding box must have 4 coordinates") |
| l, t, r, b = source_box |
| x1, y1 = self.to_crop_point(l, t) |
| x2, y2 = self.to_crop_point(r, b) |
| return [min(x1, x2), min(y1, y2), max(x1, x2), max(y1, y2)] |
|
|
| def to_dict(self) -> Dict[str, Union[float, List[float], List[int]]]: |
| return { |
| "source_origin": [self.x0, self.y0], |
| "padding": [self.px, self.py], |
| "scale": [self.sx, self.sy], |
| "crop_box_in_source": list(self.crop_box_in_source) if self.crop_box_in_source else None, |
| "crop_image_size": list(self.crop_image_size) if self.crop_image_size else None, |
| } |
|
|
| @classmethod |
| def from_dict(cls, data: dict) -> CropTransform: |
| return cls( |
| source_origin=tuple(data["source_origin"]), |
| padding=tuple(data["padding"]), |
| scale=tuple(data["scale"]), |
| crop_box_in_source=tuple(data["crop_box_in_source"]) if data.get("crop_box_in_source") else None, |
| crop_image_size=tuple(data["crop_image_size"]) if data.get("crop_image_size") else None, |
| ) |
|
|
|
|
| def validate_box(box: List[float], max_w: float, max_h: float, min_dim: float = 1.0) -> bool: |
| """Validate that box has valid coordinates within image bounds.""" |
| if not isinstance(box, (list, tuple)) or len(box) != 4: |
| return False |
| if any(isinstance(v, bool) or not isinstance(v, (int, float)) or not math.isfinite(v) for v in box): |
| return False |
| l, t, r, b = box |
| if l >= r or t >= b: |
| return False |
| if r - l < min_dim or b - t < min_dim: |
| return False |
| if l < -5 or t < -5 or r > max_w + 5 or b > max_h + 5: |
| |
| return False |
| return True |
|
|
|
|
| def clip_box(box: List[float], max_w: float, max_h: float) -> List[float]: |
| """Clips box to image boundaries [0, 0, max_w, max_h].""" |
| l, t, r, b = box |
| return [ |
| max(0.0, min(float(max_w), float(l))), |
| max(0.0, min(float(max_h), float(t))), |
| max(0.0, min(float(max_w), float(r))), |
| max(0.0, min(float(max_h), float(b))), |
| ] |
|
|
|
|
| def compute_iou(box_a: List[float], box_b: List[float]) -> float: |
| """Compute Intersection over Union between two boxes [l, t, r, b].""" |
| x1 = max(box_a[0], box_b[0]) |
| y1 = max(box_a[1], box_b[1]) |
| x2 = min(box_a[2], box_b[2]) |
| y2 = min(box_a[3], box_b[3]) |
| inter_area = max(0.0, x2 - x1) * max(0.0, y2 - y1) |
| if inter_area <= 0: |
| return 0.0 |
| area_a = (box_a[2] - box_a[0]) * (box_a[3] - box_a[1]) |
| area_b = (box_b[2] - box_b[0]) * (box_b[3] - box_b[1]) |
| union_area = area_a + area_b - inter_area |
| if union_area <= 0: |
| return 0.0 |
| return inter_area / union_area |
|
|
|
|
| def compute_containment(child_box: List[float], parent_box: List[float]) -> float: |
| """Fraction of child_box that is inside parent_box.""" |
| x1 = max(child_box[0], parent_box[0]) |
| y1 = max(child_box[1], parent_box[1]) |
| x2 = min(child_box[2], parent_box[2]) |
| y2 = min(child_box[3], parent_box[3]) |
| inter_area = max(0.0, x2 - x1) * max(0.0, y2 - y1) |
| child_area = (child_box[2] - child_box[0]) * (child_box[3] - child_box[1]) |
| if child_area <= 0: |
| return 0.0 |
| return inter_area / child_area |
|
|
|
|
| def extract_padded_crop( |
| image: Image.Image, |
| box: List[float], |
| pad_fraction: float = 0.05, |
| min_pad: int = 16, |
| ) -> Tuple[Image.Image, CropTransform]: |
| """ |
| Extract a padded crop from image. |
| Returns (cropped_pil_image, CropTransform). |
| """ |
| w, h = image.size |
| l, t, r, b = box |
| bw = r - l |
| bh = b - t |
|
|
| pad_x = max(min_pad, round(bw * pad_fraction)) |
| pad_y = max(min_pad, round(bh * pad_fraction)) |
|
|
| crop_l = max(0, int(round(l - pad_x))) |
| crop_t = max(0, int(round(t - pad_y))) |
| crop_r = min(w, int(round(r + pad_x))) |
| crop_b = min(h, int(round(b + pad_y))) |
|
|
| crop_im = image.crop((crop_l, crop_t, crop_r, crop_b)) |
| transform = CropTransform( |
| source_origin=(crop_l, crop_t), |
| padding=(0.0, 0.0), |
| scale=(1.0, 1.0), |
| crop_box_in_source=(crop_l, crop_t, crop_r, crop_b), |
| crop_image_size=crop_im.size, |
| ) |
| return crop_im, transform |
|
|
