File size: 11,164 Bytes
3726258
 
3f3fbe2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3726258
3f3fbe2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
"""Deterministic layout solver: one box per class from per-class size priors (``class_size_priors.json``).
Used for k = 5 scenes, for never-co-occurring cliques and as the fallback of the language-model planner.
"""
from __future__ import annotations

import json
import math
from dataclasses import dataclass
from pathlib import Path
from typing import Dict, List, Optional, Sequence, Tuple

import numpy as np

DEFAULT_PRIORS_PATH = Path(__file__).resolve().parent / "class_size_priors.json"

DEFAULT_PRIOR: Dict[str, float] = {
    "rel_area_p25": 0.03, "rel_area_p50": 0.08, "rel_area_p75": 0.18,
    "aspect_median": 1.0,
}

VEHICLES = {"bicycle", "car", "motorcycle", "bus", "train", "truck", "boat"}
FURNITURE = {"bench", "chair", "couch", "bed", "dining table", "toilet"}
ANIMALS = {"bird", "cat", "dog", "horse", "sheep", "cow", "elephant", "bear",
           "zebra", "giraffe"}
PEOPLE = {"person"}
GROUND_CONTACT_CLASSES = VEHICLES | FURNITURE | ANIMALS | PEOPLE


@dataclass
class SolverConfig:
    img_size: int = 1024
    margin: int = 24
    min_short_side: int = 96
    min_rel_area: float = 0.02
    max_rel_area: float = 0.30
    max_iou: float = 0.02
    min_center_dist_frac: float = 0.25
    max_attempts: int = 2000
    shrink_factor: float = 0.85
    max_shrink_rounds: int = 12
    ground_contact_lower_frac: float = 0.60
    area_sigma_scale: float = 1.0
    area_scale: float = 1.0
    aspect_sigma: float = 0.15
    min_aspect: float = 0.33
    max_aspect: float = 3.0


def load_size_priors(path: Path = DEFAULT_PRIORS_PATH) -> Dict[str, Dict[str, float]]:
    with open(path) as f:
        d = json.load(f)
    return d.get("classes", d)


def box_iou(a: Sequence[float], b: Sequence[float]) -> float:
    ix1, iy1 = max(a[0], b[0]), max(a[1], b[1])
    ix2, iy2 = min(a[2], b[2]), min(a[3], b[3])
    iw, ih = max(0.0, ix2 - ix1), max(0.0, iy2 - iy1)
    inter = iw * ih
    if inter <= 0:
        return 0.0
    ua = (a[2] - a[0]) * (a[3] - a[1]) + (b[2] - b[0]) * (b[3] - b[1]) - inter
    return inter / ua if ua > 0 else 0.0


def _center(b: Sequence[float]) -> Tuple[float, float]:
    return (b[0] + b[2]) / 2.0, (b[1] + b[3]) / 2.0


def _diag(b: Sequence[float]) -> float:
    return math.hypot(b[2] - b[0], b[3] - b[1])


def pair_ok(a: Sequence[float], b: Sequence[float], cfg: SolverConfig) -> bool:
    if box_iou(a, b) > cfg.max_iou:
        return False
    ca, cb = _center(a), _center(b)
    dist = math.hypot(ca[0] - cb[0], ca[1] - cb[1])
    return dist >= cfg.min_center_dist_frac * min(_diag(a), _diag(b))


def _apply_size_floors(w: float, h: float, cfg: SolverConfig) -> Tuple[float, float]:
    """Short side >= min_short_side, area <= max_rel_area, inside the canvas."""
    canvas = float(cfg.img_size)
    max_side = canvas - 2 * cfg.margin
    if min(w, h) < cfg.min_short_side:
        if w <= h:
            w = float(cfg.min_short_side)
        else:
            h = float(cfg.min_short_side)
    cap = cfg.max_rel_area * canvas * canvas
    if w * h > cap:
        s = math.sqrt(cap / (w * h))
        w, h = max(w * s, cfg.min_short_side), max(h * s, cfg.min_short_side)
    w, h = min(w, max_side), min(h, max_side)
    return w, h


def sample_target_sizes(labels: Sequence[str], priors: Dict[str, Dict[str, float]],
                        rng: np.random.Generator, cfg: SolverConfig
                        ) -> List[Tuple[float, float, float]]:
    """Per label: (w, h, target_rel_area) before any shrink round."""
    canvas = float(cfg.img_size)
    out = []
    for lbl in labels:
        p = priors.get(lbl, DEFAULT_PRIOR)
        p25 = max(float(p.get("rel_area_p25", DEFAULT_PRIOR["rel_area_p25"])), 1e-4)
        p50 = max(float(p.get("rel_area_p50", DEFAULT_PRIOR["rel_area_p50"])), 1e-4)
        p75 = max(float(p.get("rel_area_p75", DEFAULT_PRIOR["rel_area_p75"])), p25)
        sigma = cfg.area_sigma_scale * (math.log(p75) - math.log(p25)) / 1.349
        rel = math.exp(math.log(p50) + rng.normal(0.0, max(sigma, 1e-3)))
        rel = min(max(rel, p25), p75) * cfg.area_scale
        rel = min(max(rel, cfg.min_rel_area), cfg.max_rel_area)
        ar = float(p.get("aspect_median", 1.0)) * math.exp(rng.normal(0.0, cfg.aspect_sigma))
        ar = min(max(ar, cfg.min_aspect), cfg.max_aspect)
        area_px = rel * canvas * canvas
        w = math.sqrt(area_px * ar)
        h = math.sqrt(area_px / ar)
        w, h = _apply_size_floors(w, h, cfg)
        out.append((w, h, rel))
    return out


def _try_place(order: List[int], dims: List[Tuple[float, float]],
               labels: Sequence[str], rng: np.random.Generator,
               cfg: SolverConfig, attempt_budget: int
               ) -> Tuple[Optional[List[List[int]]], int]:
    """One placement pass. Returns (boxes in label order or None, attempts used)."""
    canvas = cfg.img_size
    placed: Dict[int, List[int]] = {}
    attempts = 0
    per_obj = max(1, attempt_budget // max(1, len(order)))
    for i in order:
        w, h = dims[i]
        wi, hi = int(math.floor(w)), int(math.floor(h))
        x_lo, x_hi = cfg.margin, canvas - cfg.margin - wi
        if labels[i] in GROUND_CONTACT_CLASSES:
            y2_lo = max(cfg.margin + hi,
                        int(round((1.0 - cfg.ground_contact_lower_frac) * canvas)))
            y2_hi = canvas - cfg.margin
            y_lo, y_hi = y2_lo - hi, y2_hi - hi
        else:
            y_lo, y_hi = cfg.margin, canvas - cfg.margin - hi
        if x_hi < x_lo or y_hi < y_lo:
            return None, attempts
        ok = False
        for _ in range(per_obj):
            attempts += 1
            x1 = int(rng.integers(x_lo, x_hi + 1))
            y1 = int(rng.integers(y_lo, y_hi + 1))
            cand = [x1, y1, x1 + wi, y1 + hi]
            if all(pair_ok(cand, b, cfg) for b in placed.values()):
                placed[i] = cand
                ok = True
                break
        if not ok:
            return None, attempts
    return [placed[i] for i in range(len(labels))], attempts


def solve_layout(labels: Sequence[str], priors: Dict[str, Dict[str, float]],
                 img_size: int = 1024, seed: int = 0,
                 cfg: Optional[SolverConfig] = None, area_scale: float = 1.0) -> Dict:
    """Return ``{layout_boxes, layout_source, layout_attempts, layout_shrink_rounds,
    target_rel_areas}``. ``layout_source`` is ``"solver"`` on success and
    ``"grid_fallback"`` only if every shrink round failed (not expected for
    <= 8 objects at the configured floors). ``layout_attempts`` counts solver
    placements, not LLM calls; Stage 1 renames it to ``solver_attempts``."""
    cfg = cfg or SolverConfig()
    if cfg.img_size != img_size or cfg.area_scale != area_scale:
        cfg = SolverConfig(**{**cfg.__dict__, "img_size": img_size,
                              "area_scale": float(area_scale)})
    rng = np.random.default_rng(int(seed))
    sizes = sample_target_sizes(labels, priors, rng, cfg)
    base_dims = [(w, h) for w, h, _ in sizes]
    areas = [w * h for w, h in base_dims]
    order = sorted(range(len(labels)), key=lambda i: -areas[i])

    total_attempts = 0
    for rnd in range(cfg.max_shrink_rounds + 1):
        s = cfg.shrink_factor ** rnd
        dims = [_apply_size_floors(w * s, h * s, cfg) for w, h in base_dims]
        boxes, used = _try_place(order, dims, labels, rng, cfg, cfg.max_attempts)
        total_attempts += used
        if boxes is not None:
            return {
                "layout_boxes": boxes,
                "layout_source": "solver",
                "layout_attempts": total_attempts,
                "layout_shrink_rounds": rnd,
                "target_rel_areas": [round(float(r), 5) for _, _, r in sizes],
            }
    from strangebench.scene_specs.select_scenes_and_layouts import _grid_fallback
    return {
        "layout_boxes": _grid_fallback(list(labels), img_size),
        "layout_source": "grid_fallback",
        "layout_attempts": total_attempts,
        "layout_shrink_rounds": cfg.max_shrink_rounds,
        "target_rel_areas": [round(float(r), 5) for _, _, r in sizes],
    }


def check_layout(boxes: Sequence[Sequence[int]], labels: Sequence[str],
                 cfg: Optional[SolverConfig] = None) -> List[str]:
    """Return a list of violated rules (empty = valid). Used by the tests and
    by the Stage 1 driver as a cheap assertion on solver output."""
    cfg = cfg or SolverConfig()
    canvas = cfg.img_size
    problems: List[str] = []
    for i, b in enumerate(boxes):
        x1, y1, x2, y2 = b
        if not (cfg.margin <= x1 < x2 <= canvas - cfg.margin
                and cfg.margin <= y1 < y2 <= canvas - cfg.margin):
            problems.append(f"{labels[i]}: outside margins {b}")
        if min(x2 - x1, y2 - y1) < cfg.min_short_side:
            problems.append(f"{labels[i]}: short side < {cfg.min_short_side}")
        rel = (x2 - x1) * (y2 - y1) / float(canvas * canvas)
        if rel > cfg.max_rel_area + 1e-6:
            problems.append(f"{labels[i]}: rel area {rel:.3f} > {cfg.max_rel_area}")
        if labels[i] in GROUND_CONTACT_CLASSES and \
                y2 < (1.0 - cfg.ground_contact_lower_frac) * canvas - 1:
            problems.append(f"{labels[i]}: ground-contact class floats (y2={y2})")
    for i in range(len(boxes)):
        for j in range(i + 1, len(boxes)):
            if not pair_ok(boxes[i], boxes[j], cfg):
                problems.append(f"{labels[i]} vs {labels[j]}: overlap/center rule")
    return problems


def shrink_anchor_box(box: Sequence[int], img_size: int = 1024,
                      max_rel_area: float = 0.02, min_short_side: int = 72,
                      margin: int = 24) -> Tuple[List[int], float]:
    """Shrink ``box`` around its center so its area is <= ``max_rel_area`` of
    the canvas while keeping the short side >= ``min_short_side``. The
    aspect ratio is preserved unless the short-side floor forces the long
    side down to keep the area cap. Returns (new_box, realized_rel_area)."""
    x1, y1, x2, y2 = (float(v) for v in box)
    w, h = x2 - x1, y2 - y1
    cx, cy = (x1 + x2) / 2.0, (y1 + y2) / 2.0
    cap = max_rel_area * img_size * img_size
    if w * h > cap:
        s = math.sqrt(cap / (w * h))
        w, h = w * s, h * s
        if min(w, h) < min_short_side:
            if w <= h:
                w = float(min_short_side)
                h = min(h, cap / w)
            else:
                h = float(min_short_side)
                w = min(w, cap / h)
    w, h = max(w, min(min_short_side, img_size - 2 * margin)), \
        max(h, min(min_short_side, img_size - 2 * margin))
    wi, hi = int(math.floor(w)), int(math.floor(h))
    nx1, ny1 = cx - wi / 2.0, cy - hi / 2.0
    nx1 = min(max(nx1, margin), img_size - margin - wi)
    ny1 = min(max(ny1, margin), img_size - margin - hi)
    x1i, y1i = int(round(nx1)), int(round(ny1))
    nb = [x1i, y1i, x1i + wi, y1i + hi]
    rel = (nb[2] - nb[0]) * (nb[3] - nb[1]) / float(img_size * img_size)
    return nb, rel


def rel_area_of_box(box: Sequence[float], img_size: int = 1024) -> float:
    return max(0.0, (box[2] - box[0])) * max(0.0, (box[3] - box[1])) / float(img_size * img_size)