raptorreplica
a073f73f3a
Add rational atlas cells and bounded authenticated Original-detail retention with standalone synthetic regression checks. Rebuild Linux and Windows runtimes; validate all 5384 supplied frames and preserve three exact 1080p regression controls.
63 lines
2.4 KiB
Python
63 lines
2.4 KiB
Python
"""Synthetic-only scalar model of the proposed opt-in kernel; no game/art IO."""
|
|
import math
|
|
import struct
|
|
|
|
def f32(value):
|
|
return struct.unpack('<f', struct.pack('<f', value))[0]
|
|
|
|
def lanczos(value):
|
|
if value == 0:
|
|
return 1.0
|
|
if abs(value) >= 3:
|
|
return 0.0
|
|
value *= math.pi
|
|
return math.sin(value) / value * (math.sin(value / 3) / (value / 3))
|
|
|
|
def axis_weights(start, end, output):
|
|
start, end = float(start), float(end)
|
|
scale = max((end - start) / output, 1.0)
|
|
rows = []
|
|
for destination in range(output):
|
|
center = start + (destination + 0.5) * (end - start) / output
|
|
lower = max(math.floor(center - 3 * scale), math.floor(start))
|
|
upper = min(math.ceil(center + 3 * scale), math.ceil(end))
|
|
weights = []
|
|
for index in range(lower, upper):
|
|
overlap = max(0.0, min(index + 1, end) - max(index, start))
|
|
weight = lanczos((index + 0.5 - center) / scale) * overlap
|
|
if weight:
|
|
weights.append((index, weight))
|
|
total = sum(value for _, value in weights)
|
|
if not math.isfinite(total) or abs(total) <= 1e-12:
|
|
raise ValueError('invalid rational atlas filter weights')
|
|
rows.append([(index, f32(value / total)) for index, value in weights])
|
|
return rows
|
|
|
|
def sample_fractional(pixels, geometry):
|
|
left, top, right, bottom = geometry['bounds']
|
|
width, height = geometry['resident']
|
|
_, first_y, _, last_y = geometry['pixels']
|
|
x_weights = axis_weights(left, right, width)
|
|
y_weights = axis_weights(top, bottom, height)
|
|
horizontal = []
|
|
for source_y in range(first_y, last_y):
|
|
row = []
|
|
for weights in x_weights:
|
|
sample = [0.0] * 4
|
|
for source_x, weight in weights:
|
|
for channel in range(4):
|
|
sample[channel] = f32(sample[channel] + f32(pixels[source_y][source_x][channel] * weight))
|
|
row.append(sample)
|
|
horizontal.append(row)
|
|
result = []
|
|
for weights in y_weights:
|
|
row = []
|
|
for x in range(width):
|
|
sample = [0.0] * 4
|
|
for source_y, weight in weights:
|
|
for channel in range(4):
|
|
sample[channel] = f32(sample[channel] + f32(horizontal[source_y - first_y][x][channel] * weight))
|
|
row.append(tuple(math.floor(min(255, max(0, value)) + 0.5) for value in sample))
|
|
result.append(row)
|
|
return result
|