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 | class ContactSheetGenerator:
"""Generates a composite grid of all AOVs (layers) for a single image frame."""
def __init__(
self,
config: ContactSheetConfig,
reader: Optional[ImageReader] = None,
layers: Optional[list[str]] = None,
layer_map: Optional[dict[str, LayerMapEntry]] = None,
) -> None:
"""Initialize generator.
Args:
config: Contact sheet layout configuration
reader: Optional reader instance to reuse across frames
layers: Optional layer list to reuse across frames
"""
self.config = config
self.reader = reader
self.layers = layers
self.layer_map = layer_map
if layer_map is not None:
logger.debug("Contact sheet layer map cached at init.")
def composite_layers(self, frame_path: Path) -> oiio.ImageBuf:
"""Composite all layers of a frame into a grid.
Args:
frame_path: Path to the image file (e.g. EXR)
Returns:
ImageBuf containing the composited grid
"""
reader = self.reader or ImageReaderFactory.create_reader(
frame_path, image_cache=get_shared_image_cache()
)
layers = self.layers or reader.get_layers(frame_path)
layer_map = self.layer_map
if layer_map is None and hasattr(reader, "get_layer_map"):
try:
layer_map = reader.get_layer_map(frame_path)
self.layer_map = layer_map
except Exception as e:
logger.debug(f"Failed to precompute layer map for {frame_path}: {e}")
if not layers:
# Fallback to just reading the image if no layers detected
return oiio.ImageBuf(str(frame_path))
subimage_buffers = self._build_subimage_buffers(reader, frame_path, layers, layer_map)
# We'll calculate thumb_h based on the first layer's aspect ratio
first_buf = self._resolve_layer_buf(
reader,
frame_path,
layers[0],
layer_map,
subimage_buffers,
)
spec = first_buf.spec()
h, w = spec.height, spec.width
layout = self._compute_layout(len(layers), w, h)
thumb_w = layout["thumb_w"]
thumb_h = layout["thumb_h"]
cell_w = layout["cell_w"]
cell_h = layout["cell_h"]
canvas_w = layout["canvas_w"]
canvas_h = layout["canvas_h"]
label_gap = layout["label_gap"]
padding = layout["padding"]
cols = layout["cols"]
# Create canvas
canvas_spec = oiio.ImageSpec(canvas_w, canvas_h, 3, oiio.FLOAT)
canvas = oiio.ImageBuf(canvas_spec)
oiio.ImageBufAlgo.fill(canvas, self.config.background_color)
# Process each layer
for i, layer_name in enumerate(layers):
row = i // cols
col = i % cols
x_offset = col * cell_w + padding
y_offset = row * cell_h + padding
try:
if layer_name == layers[0]:
layer_buf = first_buf
else:
layer_buf = self._resolve_layer_buf(
reader,
frame_path,
layer_name,
layer_map,
subimage_buffers,
)
if layer_buf.spec().width == thumb_w and layer_buf.spec().height == thumb_h:
scaled_buf = layer_buf
else:
scaled_buf = self._scale_to_thumbnail(layer_buf, thumb_w, thumb_h)
# Paste onto canvas
oiio.ImageBufAlgo.paste(canvas, x_offset, y_offset, 0, 0, scaled_buf)
# Add label
if self.config.show_labels:
label_x = x_offset
label_y = (
y_offset
+ thumb_h
+ label_gap
+ self.config.font_size
- max(2, int(self.config.font_size * 0.2))
)
oiio.ImageBufAlgo.render_text(
canvas,
label_x,
label_y,
layer_name,
fontsize=self.config.font_size,
textcolor=(1, 1, 1, 1),
)
except Exception as e:
logger.error(f"Failed to process layer {layer_name} for contact sheet: {e}")
return canvas
def _compute_layout(self, num_layers: int, source_w: int, source_h: int) -> dict[str, int]:
cols = self.config.columns
rows = (num_layers + cols - 1) // cols
padding = self.config.padding
thumb_w, thumb_h = self.config.resolve_layer_size(source_w, source_h)
label_gap, label_h = self._compute_label_metrics()
cell_w = thumb_w + (padding * 2)
cell_h = thumb_h + (padding * 2) + label_h
canvas_w = cell_w * cols
canvas_h = cell_h * rows
return {
"cols": cols,
"rows": rows,
"padding": padding,
"thumb_w": thumb_w,
"thumb_h": thumb_h,
"cell_w": cell_w,
"cell_h": cell_h,
"canvas_w": canvas_w,
"canvas_h": canvas_h,
"label_gap": label_gap,
"label_h": label_h,
}
def _compute_label_metrics(self) -> tuple[int, int]:
if not self.config.show_labels:
return 0, 0
label_gap = max(4, int(self.config.font_size * 0.01))
label_h = label_gap + int(self.config.font_size * 1.4)
return label_gap, label_h
def _build_subimage_buffers(
self,
reader: ImageReader,
frame_path: Path,
layers: list[str],
layer_map: Optional[dict[str, LayerMapEntry]],
) -> dict[int, oiio.ImageBuf]:
if not layer_map or not layers:
return {}
subimage_indices = set()
for layer_name in layers:
entry = layer_map.get(layer_name)
if entry is not None and entry.subimage_index is not None:
subimage_indices.add(entry.subimage_index)
subimage_buffers: dict[int, oiio.ImageBuf] = {}
for subimage_index in subimage_indices:
try:
if hasattr(reader, "read_subimagebuf"):
subimage_buffers[subimage_index] = reader.read_subimagebuf(
frame_path, subimage_index
)
else:
subimage_buffers[subimage_index] = oiio.ImageBuf(
str(frame_path), subimage_index, 0
)
except Exception as e:
logger.debug(f"Failed to cache subimage {subimage_index} for {frame_path}: {e}")
return {}
return subimage_buffers
def _resolve_layer_buf(
self,
reader: ImageReader,
frame_path: Path,
layer_name: str,
layer_map: Optional[dict[str, LayerMapEntry]],
subimage_buffers: dict[int, oiio.ImageBuf],
) -> oiio.ImageBuf:
if layer_map and subimage_buffers:
entry = layer_map.get(layer_name)
if entry is not None:
base_buf = subimage_buffers.get(entry.subimage_index)
if base_buf is not None:
if entry.channel_indices:
try:
return oiio.ImageBufAlgo.channels(base_buf, entry.channel_indices)
except Exception as e:
logger.debug(
f"Failed to slice channels for {layer_name} in {frame_path}: {e}"
)
else:
return base_buf
return reader.read_imagebuf(frame_path, layer=layer_name, layer_map=layer_map)
def _scale_to_thumbnail(self, buf: oiio.ImageBuf, width: int, height: int) -> oiio.ImageBuf:
"""Scale ImageBuf to thumbnail dimensions and return ImageBuf."""
return ImageScaler.scale_buf(buf, width=width, height=height)
|