File size: 4,872 Bytes
9ffd3e8 fad6045 | 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 | """How a cheap webcam renders the scene: auto-exposure, white balance, exposure, gamma, contrast,
saturation, vignetting, blur, sensor noise and JPEG compression (UVC webcams stream
MJPEG). Parameters are drawn per camera per episode from [webcam] in
phase2_config.toml; the noise is drawn per frame. Auto-exposure sets one gain per
episode from the first frame (mean brightness to a drawn target), as a webcam settles
on a scene; the exposure jitter then over- or under-exposes around it. Applied to the rendered image
before the red and blue squares, which are drawn on the captured frame. The policy
evaluation in simulation uses the same code, so it sees what training saw.
"""
from __future__ import annotations
import io
from dataclasses import dataclass
import numpy as np
from PIL import Image, ImageFilter
LUMA = np.array([0.299, 0.587, 0.114], np.float32)
@dataclass
class WebcamLook:
white_balance: np.ndarray # per-channel gain
exposure: float
gamma: float
contrast: float
saturation: float
vignette: float
blur_px: float
noise: float
jpeg_quality: int
target: float = 0.45 # auto-exposure target mean brightness
gain: float | None = None # set from the first frame
_vignette_mask: np.ndarray | None = None
@classmethod
def sample(cls, rng: np.random.Generator, cfg: dict) -> "WebcamLook":
c = cfg["webcam"]
u = lambda key: float(rng.uniform(*c[key]))
return cls(white_balance=(1 + rng.uniform(-c["white_balance"], c["white_balance"], 3)).astype(np.float32),
exposure=u("exposure"), gamma=u("gamma"), contrast=u("contrast"), saturation=u("saturation"),
vignette=u("vignette"), blur_px=u("blur_px"), noise=u("noise"),
jpeg_quality=int(rng.integers(c["jpeg_quality"][0], c["jpeg_quality"][1] + 1)),
target=u("auto_exposure_target"))
def describe(self) -> dict:
return dict(white_balance=[round(float(x), 3) for x in self.white_balance], exposure=round(self.exposure, 3),
auto_gain=None if self.gain is None else round(self.gain, 3),
gamma=round(self.gamma, 3), blur_px=round(self.blur_px, 2), noise=round(self.noise, 4),
jpeg_quality=self.jpeg_quality)
def apply(self, image: np.ndarray, rng: np.random.Generator) -> np.ndarray:
h, w = image.shape[:2]
x = image.astype(np.float32) / 255
if self.gain is None:
self.gain = float(np.clip(self.target / max(float((x @ LUMA).mean()), 1e-3), 0.6, 3.5))
x = np.clip(x * (self.white_balance * (self.gain * self.exposure)), 0, 1) ** self.gamma
mean = float(x.mean())
x = (x - mean) * self.contrast + mean
grey = (x @ LUMA)[..., None]
x = grey + (x - grey) * self.saturation
if self.vignette > 0:
if self._vignette_mask is None:
yy, xx = np.ogrid[:h, :w]
r2 = ((xx - w / 2) / (w / 2)) ** 2 + ((yy - h / 2) / (h / 2)) ** 2
self._vignette_mask = (1 - self.vignette * np.clip(r2 / 2, 0, 1)).astype(np.float32)[..., None]
x *= self._vignette_mask
if self.noise > 0:
x += rng.standard_normal(x.shape, dtype=np.float32) * self.noise
img = Image.fromarray((np.clip(x, 0, 1) * 255 + 0.5).astype(np.uint8))
if self.blur_px > 0.05:
img = img.filter(ImageFilter.GaussianBlur(self.blur_px))
buf = io.BytesIO()
img.save(buf, "JPEG", quality=self.jpeg_quality)
buf.seek(0)
return np.asarray(Image.open(buf).convert("RGB"))
def training_look(image: np.ndarray, crf: int = 30, pix_fmt: str = "yuv420p") -> np.ndarray:
"""The frame as the policy saw it in training: one pass through the dataset's video
codec (H.264; LeRobot's default is 4:2:0 chroma at CRF 30, [dataset] video_crf and
video_pix_fmt override it). Chroma subsampling washes out the small red and blue
squares, and a policy trained on decoded video looks for them in that form, so every
live frame (sim test or real camera) goes through the same round trip before the
policy sees it."""
import av
buf = io.BytesIO()
with av.open(buf, "w", format="mp4") as container:
stream = container.add_stream("libx264", rate=30)
stream.width, stream.height = image.shape[1], image.shape[0]
stream.pix_fmt = pix_fmt
stream.options = {"crf": str(crf), "g": "2", "threads": "1"}
for packet in stream.encode(av.VideoFrame.from_ndarray(np.ascontiguousarray(image), format="rgb24")):
container.mux(packet)
for packet in stream.encode():
container.mux(packet)
buf.seek(0)
with av.open(buf) as container:
return next(container.decode(video=0)).to_ndarray(format="rgb24")
|