Datasets:
File size: 4,462 Bytes
e1ced61 | 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 | """Structured deterministic renderers — registry & dispatch (``docs/02`` §9, P6).
A renderer turns one structured :class:`~explicit_learning.sources.base.World`
into the four byte-addressed P6 assets (``rgba.png``, ``node_map.uint32.png``,
``render_manifest.json``, ``text_manifest.json``) by **drawing fresh from the
world**, never by editing an input raster. Each concrete renderer lives in its
own module with its train/held-out family pairs; this module is the registry.
Status (hand-off note for the next agent): the three renderer modules
(:mod:`plot`, :mod:`geometry`, :mod:`base`) are implemented and gate-clean
(byte-identical replay, node-map coverage, glyph linkage all pass on smoke
worlds), but the ``render`` CLI subcommand is **not yet wired** and there are
**no unit tests** under ``tests/unit/test_renderers.py`` yet — that, plus the
table renderer (optional), is the remaining P6 work. See
``docs/09_RENDER_VALIDATION.md`` for the non-visual verification method.
"""
from __future__ import annotations
from ..sources.base import World
from .base import (
GlyphRecord,
RenderedAssets,
Renderer,
RendererFamily,
RendererKind,
RenderError,
validate_rendered_assets,
)
from .clevr import CLEVR_FAMILIES, ClevrRenderer
from .clevr_blender import (
ClevrBlenderConfig,
ClevrBlenderResult,
blender_renderer_spec,
render_clevr_blender_assets,
render_clevr_blender_rgba,
)
from .geometry import GEOMETRY_FAMILIES, GeometryRenderer
from .node_map import coverage_verdict, decode_uint32_png, index_table, read_owners
from .plot import PLOT_FAMILIES, PlotRenderer
from .text_manifest import link_verdict
#: Train/held-out family registries, keyed by family name (``docs/02`` §9.3).
FAMILIES: dict[str, RendererFamily] = {
**PLOT_FAMILIES,
**GEOMETRY_FAMILIES,
**CLEVR_FAMILIES,
}
#: Concrete renderers, keyed by world kind.
RENDERERS: dict[RendererKind, Renderer] = {
"plot": PlotRenderer(),
"geometry": GeometryRenderer(),
"clevr": ClevrRenderer(),
}
def get_renderer(kind: RendererKind) -> Renderer:
"""The concrete renderer for a world ``kind`` (raises if none)."""
try:
return RENDERERS[kind]
except KeyError:
raise RenderError(f"no renderer for kind {kind!r}") from None
def family_for(renderer_id: str) -> RendererFamily:
"""Resolve a ``renderer_id`` (a family name) to its :class:`RendererFamily`."""
try:
return FAMILIES[renderer_id]
except KeyError:
raise RenderError(f"unknown renderer family: {renderer_id!r}") from None
def render(
world: World,
*,
renderer_id: str,
seed: int,
width: int,
height: int,
) -> RenderedAssets:
"""Render ``world`` under family ``renderer_id`` — the common §9.1 entrypoint.
The world's ``world_schema`` selects the renderer (``plot_world_v1`` → plot,
``geometry_world_v1`` → geometry); ``renderer_id`` selects the train/held-out
family. The two are independent: same world, different family ⇒ disjoint
assets (gate: "train/held-out assets disjoint").
"""
schema = world.get("world_schema", "")
if schema == "plot_world_v1":
renderer = RENDERERS["plot"]
elif schema == "geometry_world_v1":
renderer = RENDERERS["geometry"]
elif schema == "clevr_world_v1":
renderer = RENDERERS["clevr"]
else:
raise RenderError(f"no renderer for world_schema {schema!r}")
family = family_for(renderer_id)
if family.kind != renderer.kind:
raise RenderError(
f"renderer family {family.name!r} has kind {family.kind!r}, "
f"expected {renderer.kind!r} for {schema!r}"
)
return renderer.render(
world,
renderer_id=renderer_id,
seed=seed,
width=width,
height=height,
family=family,
)
__all__ = [
"FAMILIES",
"CLEVR_FAMILIES",
"ClevrRenderer",
"ClevrBlenderConfig",
"ClevrBlenderResult",
"GEOMETRY_FAMILIES",
"GlyphRecord",
"PLOT_FAMILIES",
"RENDERERS",
"RenderError",
"RenderedAssets",
"Renderer",
"RendererFamily",
"RendererKind",
"coverage_verdict",
"blender_renderer_spec",
"decode_uint32_png",
"family_for",
"get_renderer",
"index_table",
"link_verdict",
"read_owners",
"render",
"render_clevr_blender_assets",
"render_clevr_blender_rgba",
"validate_rendered_assets",
]
|