| """The brain-to-hand contract: a translucent red square over the source and a |
| translucent blue one over the destination square or the tray, drawn on each image. |
| |
| Squares are projected from the board plane with a pinhole camera model. In sim the |
| camera pose comes from MuJoCo; on the real robot the same function takes the |
| calibrated pose (board homography for fixed cameras, forward kinematics plus |
| hand-eye calibration for the wrist). Drawn over everything, including the arm. |
| """ |
| from __future__ import annotations |
|
|
| from dataclasses import dataclass |
|
|
| import numpy as np |
| from PIL import Image, ImageDraw |
|
|
| NEAR = 0.01 |
|
|
|
|
| @dataclass |
| class Camera: |
| pos: np.ndarray |
| rot: np.ndarray |
| fovy_deg: float |
| width: int |
| height: int |
|
|
|
|
| def _clip_near(poly_cam: np.ndarray) -> np.ndarray: |
| """Sutherland-Hodgman clip of a camera-frame polygon against z <= -NEAR.""" |
| out = [] |
| n = len(poly_cam) |
| for i in range(n): |
| a, b = poly_cam[i], poly_cam[(i + 1) % n] |
| ina, inb = a[2] <= -NEAR, b[2] <= -NEAR |
| if ina: |
| out.append(a) |
| if ina != inb: |
| t = (-NEAR - a[2]) / (b[2] - a[2]) |
| out.append(a + t * (b - a)) |
| return np.array(out) |
|
|
|
|
| def project(cam: Camera, points_world: np.ndarray) -> np.ndarray | None: |
| """Pixel coordinates of a world polygon, after near-plane clipping.""" |
| local = (np.asarray(points_world) - cam.pos) @ cam.rot |
| local = _clip_near(local) |
| if len(local) < 3: |
| return None |
| f = cam.height / 2 / np.tan(np.radians(cam.fovy_deg) / 2) |
| u = cam.width / 2 + f * local[:, 0] / -local[:, 2] |
| v = cam.height / 2 - f * local[:, 1] / -local[:, 2] |
| return np.stack([u, v], 1) |
|
|
|
|
| @dataclass |
| class Jitter: |
| """Per-camera error in where the square is drawn, in the board plane.""" |
| shift: np.ndarray |
| angle: float |
| scale: float |
|
|
| @staticmethod |
| def sample(rng, cfg) -> "Jitter": |
| o = cfg["overlay"] |
| r = o["jitter_mm"] / 1000 * np.sqrt(rng.uniform()) |
| a = rng.uniform(0, 2 * np.pi) |
| return Jitter(np.array([r * np.cos(a), r * np.sin(a), 0.0]), |
| np.radians(rng.uniform(-o["jitter_rot_deg"], o["jitter_rot_deg"])), |
| 1 + rng.uniform(-o["jitter_scale"], o["jitter_scale"])) |
|
|
| def apply(self, poly: np.ndarray, extra_shift=None) -> np.ndarray: |
| c = poly.mean(0) |
| cs, sn = np.cos(self.angle), np.sin(self.angle) |
| rel = (poly - c) * [self.scale, self.scale, 1] |
| rel = np.stack([cs * rel[:, 0] - sn * rel[:, 1], sn * rel[:, 0] + cs * rel[:, 1], rel[:, 2]], 1) |
| shift = self.shift if extra_shift is None else self.shift + extra_shift |
| return c + rel + shift |
|
|
|
|
| def draw(image: np.ndarray, cam: Camera, polygons, alpha: float, outline: int = 0) -> np.ndarray: |
| """Composite filled translucent polygons [(world_poly, rgb), ...] onto an RGB image, |
| with an opaque edge `outline` pixels wide if given (makes small squares stand out).""" |
| base = Image.fromarray(image).convert("RGBA") |
| layer = Image.new("RGBA", base.size, (0, 0, 0, 0)) |
| pen = ImageDraw.Draw(layer) |
| for poly, rgb in polygons: |
| px = project(cam, poly) |
| if px is None: |
| continue |
| pts = [tuple(p) for p in px] |
| pen.polygon(pts, fill=(*rgb, int(round(alpha * 255)))) |
| if outline: |
| pen.line(pts + [pts[0]], fill=(*rgb, 255), width=outline, joint="curve") |
| return np.asarray(Image.alpha_composite(base, layer).convert("RGB")) |
|
|
