492 lines
26 KiB
Python
492 lines
26 KiB
Python
#!/usr/bin/env python3
|
|
"""Exercise camera defaults/errors and single-frame/movie agreement (CPU builds)."""
|
|
import os
|
|
from pathlib import Path
|
|
import struct
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import zlib
|
|
|
|
|
|
def fits_max(path):
|
|
"""Largest positive sample in the renderer's three-plane float FITS."""
|
|
data = path.read_bytes()
|
|
cards, offset = [], 0
|
|
while True:
|
|
block = data[offset:offset + 2880]
|
|
assert len(block) == 2880, f'truncated FITS header: {path}'
|
|
offset += 2880
|
|
cards.extend(block[i:i + 80] for i in range(0, 2880, 80))
|
|
if any(card.startswith(b'END') for card in cards[-36:]):
|
|
break
|
|
values = {}
|
|
for card in cards:
|
|
if card[8:10] == b'= ':
|
|
values[card[:8].decode().strip()] = card[10:30].decode().strip()
|
|
shape = tuple(int(values[f'NAXIS{axis}']) for axis in (1, 2, 3))
|
|
count = shape[0] * shape[1] * shape[2]
|
|
payload = data[offset:offset + count * 4]
|
|
assert len(payload) == count * 4, f'truncated FITS payload: {path}'
|
|
return max(struct.unpack(f'>{count}f', payload))
|
|
|
|
BUILD = Path(sys.argv[1] if len(sys.argv) > 1 else 'build/Release').resolve()
|
|
TESTDIR = Path(sys.argv[2]).resolve() if len(sys.argv) > 2 else BUILD
|
|
ENV = dict(os.environ, OMP_NUM_THREADS='4')
|
|
FITSDIFF = Path(__file__).resolve().parent.parent / 'scripts' / 'fits_floatdiff.py'
|
|
PATH_MAX = os.pathconf('/', 'PC_PATH_MAX')
|
|
|
|
|
|
def run(binary, *args, ok=True, env=ENV):
|
|
result = subprocess.run([str(binary), *map(str, args)], env=env,
|
|
capture_output=True, text=True)
|
|
if (result.returncode == 0) != ok:
|
|
raise AssertionError(f'{binary.name} {args}: {result.returncode}\n{result.stderr}')
|
|
return result
|
|
|
|
|
|
def png_payload(path, dimensions):
|
|
data = path.read_bytes()
|
|
assert data[:8] == b'\x89PNG\r\n\x1a\n'
|
|
offset, compressed = 8, bytearray()
|
|
while offset < len(data):
|
|
count, kind = struct.unpack_from('>I4s', data, offset)
|
|
payload = data[offset + 8:offset + 8 + count]
|
|
if kind == b'IHDR':
|
|
assert struct.unpack_from('>II', payload) == dimensions
|
|
if kind == b'IDAT':
|
|
compressed.extend(payload)
|
|
offset += count + 12
|
|
return zlib.decompress(compressed)
|
|
|
|
|
|
def ppm_payload(path, dimensions):
|
|
data = path.read_bytes()
|
|
assert data[:2] == b'P6'
|
|
fields, index = [], 2
|
|
while len(fields) < 3:
|
|
while data[index:index + 1].isspace():
|
|
index += 1
|
|
if data[index:index + 1] == b'#':
|
|
while data[index:index + 1] not in (b'\n', b''):
|
|
index += 1
|
|
continue
|
|
start = index
|
|
while not data[index:index + 1].isspace():
|
|
index += 1
|
|
fields.append(int(data[start:index]))
|
|
index += 1
|
|
assert (fields[0], fields[1]) == dimensions, (fields, dimensions)
|
|
return data[index:index + fields[0] * fields[1] * 3]
|
|
|
|
|
|
def image_payload(path, dimensions=(64, 48), allow_black=False):
|
|
data = path.read_bytes()
|
|
raw = ppm_payload(path, dimensions) if data[:2] == b'P6' else png_payload(path, dimensions)
|
|
assert raw, f'missing image data: {path}'
|
|
assert allow_black or any(raw), f'empty image: {path}'
|
|
return raw
|
|
|
|
|
|
# Version 3 wire layout. The first 100 bytes are the v2 provenance; the v3
|
|
# adaptive policy appends 9 doubles and a u32 (76 bytes) so the provenance
|
|
# block ends at 176. Each frame header is 48 bytes, so vertex payload starts at
|
|
# 224. A v3 vertex keeps the 84-byte v2 record and appends three u64 cost
|
|
# counters; a triangle stays 32 bytes. The CRC covers only the vertex+triangle
|
|
# payload, never the header.
|
|
MAP_PROVENANCE_END = 176
|
|
MAP_FRAME_HEADER_START = MAP_PROVENANCE_END
|
|
MAP_VERTEX_START = MAP_PROVENANCE_END + 48
|
|
MAP_VERTEX_SIZE = 84 + 24
|
|
MAP_TRIANGLE_SIZE = 32
|
|
|
|
|
|
def map_vertices(path):
|
|
data = path.read_bytes()
|
|
assert data[:8] == b'GRLENS\x01\x00'
|
|
assert struct.unpack_from('<I', data, 8)[0] == 3, 'expected v3 lens map'
|
|
assert struct.unpack_from('<Q', data, 32)[0] == 1 # frame_count
|
|
vertices, triangles = struct.unpack_from('<QQ', data, MAP_FRAME_HEADER_START + 24)
|
|
offset = MAP_VERTEX_START
|
|
values = []
|
|
for _ in range(vertices):
|
|
values.append(struct.unpack_from('<9dIIIQQQ', data, offset))
|
|
offset += MAP_VERTEX_SIZE
|
|
return values, data[offset:offset + triangles * MAP_TRIANGLE_SIZE]
|
|
|
|
|
|
with tempfile.TemporaryDirectory(prefix='gr-camera-cli-', dir='/tmp/opencode') as directory:
|
|
tmp = Path(directory)
|
|
for backend in ('minkowski', 'schwarzschild'):
|
|
binary = BUILD / f'{backend}_sky'
|
|
help_text = run(binary, '--help').stdout
|
|
ext = 'png' if '.png' in help_text else 'ppm'
|
|
hdr_available = any(line.startswith(' --hdr-output ')
|
|
for line in help_text.splitlines())
|
|
for option in ('--observer-time', '--observer-position', '--observer-velocity', '--camera-roll-deg'):
|
|
assert option in help_text
|
|
assert '--tone-map' in help_text and '--tone-map-p' in help_text
|
|
assert '--sensor-bloom-limit' in help_text
|
|
assert '--sensor-bloom-transfer' in help_text
|
|
assert '--dark-threshold' in help_text
|
|
assert '--observer-inward-speed' not in help_text
|
|
assert '_mesh.' in help_text, help_text
|
|
# The synthetic grid is calibrated for the renderer's default exposure.
|
|
# Using it (rather than the former 0.1) keeps the soft-clip default from
|
|
# saturating the whole frame, so the image comparisons below stay
|
|
# discriminating and the mesh overlay remains visible.
|
|
common = ['--catalog', 'assets/sky_grid_5deg.csv', '--width', 64,
|
|
'--height', 48, '--fov-deg', 80, '--exposure', 1e-3,
|
|
'--coarse-cell-pixels', 8, '--refine-max-level', 0, '--psf-relative-tail', 1e-4]
|
|
|
|
def render(name, *options):
|
|
path = tmp / f'{backend}_{name}.{ext}'
|
|
run(binary, *common, '--output', path, *options)
|
|
return image_payload(path)
|
|
|
|
# CPU fast-mode CLI smoke test: the FFTW resolve must run and report its
|
|
# one-time setup line.
|
|
if backend == 'minkowski':
|
|
fast_path = tmp / f'minkowski_fast.{ext}'
|
|
fast = run(binary, *common, '--fast-mode', '--fast-supersample', 2,
|
|
'--output', fast_path)
|
|
assert 'Fast FFTW:' in fast.stdout, fast.stdout
|
|
assert image_payload(fast_path)
|
|
|
|
# Equivalent independently specified and inferred camera geometry.
|
|
inferred = render('position', '--observer-position', -30, 0, 0)
|
|
explicit = render('explicit', '--observer-position', -30, 0, 0,
|
|
'--look-ra-deg', 0, '--look-dec-deg', 0)
|
|
angled = render('angle', '--look-ra-deg', 0, '--look-dec-deg', 0)
|
|
assert inferred == explicit == angled
|
|
pole = render('pole', '--observer-position', 0, 0, 30)
|
|
assert pole == render('pole_explicit', '--observer-position', 0, 0, 30,
|
|
'--look-ra-deg', 0, '--look-dec-deg', -90)
|
|
default = render('default')
|
|
# Stationary backends are time-translation invariant; the event time
|
|
# must nevertheless survive in lens-map metadata, including negatives.
|
|
for time in (0, 12.5, -12.5):
|
|
timed_map = tmp / f'{backend}_time_{time}.grlens'
|
|
assert default == render('timed', '--observer-time', time,
|
|
'--lens-map-output', timed_map)
|
|
saved_time, proper_time = struct.unpack_from(
|
|
'<dd', timed_map.read_bytes(), MAP_FRAME_HEADER_START + 8)
|
|
assert saved_time == time and proper_time == 0
|
|
pos = (0, 0, 0) if backend == 'minkowski' else (0, 0, 30)
|
|
assert default == render('default_explicit', '--observer-position', *pos,
|
|
'--look-ra-deg', 90, '--look-dec-deg', -90)
|
|
assert render('radius', '--observer-radius', 40) == render(
|
|
'radius_explicit', '--observer-radius', 40, '--look-ra-deg', 90,
|
|
'--look-dec-deg', -90)
|
|
for partial, value, ra, dec in [('--look-ra-deg', 37, 37, -90),
|
|
('--look-dec-deg', -23, 90, -23)]:
|
|
assert render('partial', partial, value) == render(
|
|
'complete', '--look-ra-deg', ra, '--look-dec-deg', dec)
|
|
|
|
# Tone-map selection: the default must equal explicit softclip p=2, the
|
|
# hardness must be adjustable, and legacy Reinhard must remain available
|
|
# while producing a visibly different image.
|
|
softclip2 = render('tonemap_softclip2', '--tone-map', 'softclip',
|
|
'--tone-map-p', 2)
|
|
assert softclip2 == default
|
|
assert softclip2 == render('tonemap_softclip', '--tone-map', 'softclip')
|
|
assert render('tonemap_p1', '--tone-map', 'softclip', '--tone-map-p', 1)
|
|
assert render('tonemap_reinhard', '--tone-map', 'reinhard') != softclip2
|
|
|
|
# --draw-mesh must leave the primary image untouched and only add a
|
|
# mesh-overlay sibling.
|
|
baseline = render('mesh_base')
|
|
mesh_output = tmp / f'{backend}_mesh_overlay.{ext}'
|
|
mesh_run = run(binary, *common, '--draw-mesh', '--output', mesh_output)
|
|
assert image_payload(mesh_output) == baseline
|
|
mesh_sibling = tmp / f'{backend}_mesh_overlay_mesh.{ext}'
|
|
assert mesh_sibling.exists(), mesh_run.stderr
|
|
assert image_payload(mesh_sibling) != baseline
|
|
assert not (tmp / f'{backend}_mesh_overlay_mesh_mesh.{ext}').exists()
|
|
|
|
# Only the final filename extension is replaced, dots in directories are
|
|
# not touched.
|
|
dotted_dir = tmp / 'dir.v1'
|
|
dotted_dir.mkdir(exist_ok=True)
|
|
dotted_output = dotted_dir / f'{backend}_image.final.{ext}'
|
|
run(binary, *common, '--draw-mesh', '--output', dotted_output)
|
|
assert dotted_output.exists()
|
|
dotted_mesh = dotted_dir / f'{backend}_image.final_mesh.{ext}'
|
|
assert dotted_mesh.exists(), dotted_output
|
|
assert not (dotted_dir / f'{backend}_image.final.{ext}_mesh.{ext}').exists()
|
|
assert image_payload(dotted_output) == baseline
|
|
|
|
# A mesh sibling that overflows PATH_MAX must fail before catalog or
|
|
# spacetime initialization.
|
|
target = PATH_MAX - 3
|
|
long_name = f'{backend}_image.{ext}'
|
|
long_path = '/' + 'd' * (target - len(long_name) - 2) + '/' + long_name
|
|
assert len(long_path) == target
|
|
assert target + len('_mesh') > PATH_MAX
|
|
too_long = run(binary, *common, '--draw-mesh', '--catalog',
|
|
tmp / 'missing_catalog.csv', '--output', long_path,
|
|
ok=False)
|
|
assert 'Mesh overlay output path is too long' in too_long.stderr, too_long.stderr
|
|
assert 'Blackbody backend' not in (too_long.stdout + too_long.stderr), too_long.stderr
|
|
assert 'PSF cache ready' not in (too_long.stdout + too_long.stderr)
|
|
|
|
errors = [
|
|
(['--observer-time'], None),
|
|
(['--observer-time', ''], None),
|
|
(['--observer-time', 'bad'], None),
|
|
(['--observer-time', 'nan'], None),
|
|
(['--observer-time', 'inf'], None),
|
|
(['--observer-time', '-inf'], None),
|
|
(['--observer-track', 'missing.csv', '--observer-time', 0], 'cannot be combined'),
|
|
(['--frames-dir', tmp, '--observer-time', 0], 'cannot be combined'),
|
|
(['--lens-map-input', 'missing.grlens', '--observer-time', 0], 'cannot be combined'),
|
|
(['--observer-position', 1, 2], None),
|
|
(['--observer-position', 1, 2, 'nan'], None),
|
|
(['--observer-velocity', 0, 0, 'inf'], None),
|
|
(['--look-ra-deg', 'nan'], None),
|
|
(['--look-dec-deg', 'inf'], None),
|
|
(['--observer-radius', 'nan'], None),
|
|
(['--observer-radius', 0], None),
|
|
(['--camera-roll-deg', 'nan'], None),
|
|
(['--observer-position', 0, 0, 0], 'Cannot infer'),
|
|
(['--observer-position', 3, 4, 5, '--observer-radius', 30], 'mutually exclusive'),
|
|
(['--observer-velocity', 10, 0, 0], 'not timelike'),
|
|
(['--observer-inward-speed', 0], None),
|
|
(['--observer-track', 'missing.csv', '--observer-velocity', 0, 0, 0], 'cannot be combined'),
|
|
(['--frames-dir', tmp, '--look-ra-deg', 0], 'cannot be combined'),
|
|
(['--lens-map-input', 'missing.grlens', '--camera-roll-deg', 0], 'cannot be combined'),
|
|
(['--tone-map', 'unknown'], None),
|
|
(['--tone-map'], None),
|
|
(['--tone-map-p'], None),
|
|
(['--tone-map-p', 0], None),
|
|
(['--tone-map-p', 0.5], None),
|
|
(['--tone-map-p', 'nan'], None),
|
|
(['--tone-map-p', 'inf'], None),
|
|
(['--tone-map', 'reinhard', '--tone-map-p', 2], 'applies only'),
|
|
(['--sensor-bloom-limit', 1], 'specified together'),
|
|
(['--sensor-bloom-transfer', 0.5], 'specified together'),
|
|
(['--sensor-bloom-limit', 0], None),
|
|
(['--sensor-bloom-limit', -1], None),
|
|
(['--sensor-bloom-limit', 'nan'], None),
|
|
(['--sensor-bloom-limit', 'inf'], None),
|
|
(['--sensor-bloom-limit', 1, '--sensor-bloom-transfer', -0.1], None),
|
|
(['--sensor-bloom-limit', 1, '--sensor-bloom-transfer', 1], None),
|
|
(['--sensor-bloom-limit', 1, '--sensor-bloom-transfer', 1.5], None),
|
|
(['--sensor-bloom-limit', 1, '--sensor-bloom-transfer', 'nan'], None),
|
|
(['--sensor-bloom-limit', 1, '--sensor-bloom-transfer', 'inf'], None),
|
|
(['--dark-threshold', 'nan'], None),
|
|
(['--dark-threshold', 'inf'], None),
|
|
(['--dark-threshold', 0], None),
|
|
(['--dark-threshold', -1], None),
|
|
]
|
|
if backend == 'schwarzschild':
|
|
errors += [(['--observer-position', 1.75, 0, 0], 'not timelike')]
|
|
render('inside', '--observer-position', 1.75, 0, 0,
|
|
'--observer-velocity', -0.5, 0, 0, '--look-ra-deg', 0, '--look-dec-deg', 0)
|
|
# A camera inside the old r=1.5 capture cutoff is a normal target.
|
|
render('inside_cutoff', '--observer-position', 1.5, 0, 0,
|
|
'--observer-velocity', -0.5, 0, 0, '--look-ra-deg', 0, '--look-dec-deg', 0)
|
|
# The camera-relative dark threshold is configurable.
|
|
render('dark_threshold_10', '--dark-threshold', 10)
|
|
for options, message in errors:
|
|
missing_catalog = tmp / 'should_not_be_created.csv'
|
|
result = run(binary, '--catalog', missing_catalog, *options, ok=False)
|
|
if message:
|
|
assert message in result.stderr, result.stderr
|
|
assert not missing_catalog.exists(), result.stderr
|
|
assert 'PSF cache ready' not in (result.stdout + result.stderr)
|
|
|
|
track = tmp / f'{backend}.csv'
|
|
run(TESTDIR / f'test_observer_{backend}', track)
|
|
single_map, movie_map = tmp / 'single.grlens', tmp / 'movie.grlens'
|
|
single = render('moving', '--observer-position', 3, -4, 5,
|
|
'--observer-velocity', 0.2, -0.1, 0.3,
|
|
'--look-ra-deg', 37, '--look-dec-deg', -23,
|
|
'--camera-roll-deg', 19, '--lens-map-output', single_map)
|
|
run(binary, *common, '--observer-track', track, '--frames-dir', tmp,
|
|
'--frames-prefix', backend, '--duration', 0, '--fps', 1,
|
|
'--lens-map-output', movie_map)
|
|
movie = image_payload(tmp / f'{backend}_000000.{ext}')
|
|
assert single == movie, f'{backend}: single/movie image mismatch'
|
|
a, ta = map_vertices(single_map)
|
|
b, tb = map_vertices(movie_map)
|
|
assert len(a) == len(b) and ta == tb
|
|
max_error = 0
|
|
for x, y in zip(a, b):
|
|
# Indices 9..11 are end_id/outcome/reason; indices 12..14 are the
|
|
# per-vertex integration cost counters, which are not physical ray
|
|
# provenance and may differ between the single and movie schedulers.
|
|
assert x[9:12] == y[9:12], 'ray endpoint provenance mismatch'
|
|
max_error = max(max_error, *(abs(v - w) for v, w in zip(x[:9], y[:9])))
|
|
assert max_error < 1e-9, max_error
|
|
|
|
# Movie frames keep the clean primary image and gain correctly named
|
|
# mesh siblings; never "frame_000000.png_mesh.png".
|
|
movie_mesh_dir = tmp / f'{backend}_movie_mesh'
|
|
movie_mesh_dir.mkdir()
|
|
run(binary, *common, '--observer-track', track, '--frames-dir',
|
|
movie_mesh_dir, '--frames-prefix', 'frame', '--duration', 0,
|
|
'--fps', 1, '--draw-mesh')
|
|
assert image_payload(movie_mesh_dir / f'frame_000000.{ext}') == movie
|
|
assert (movie_mesh_dir / f'frame_000000_mesh.{ext}').exists()
|
|
assert not (movie_mesh_dir / f'frame_000000.{ext}_mesh.{ext}').exists()
|
|
|
|
# A map import must still work without evaluating a camera/metric, and
|
|
# must follow the same clean-main plus mesh-sibling rule.
|
|
assert single == render('import', '--lens-map-input', single_map)
|
|
# A structurally valid v2 map with an explicit metric failure must not
|
|
# bypass the live-tracing publication gate. Recompute the payload CRC
|
|
# so this tests completion semantics rather than corruption detection.
|
|
incomplete_map = tmp / f'{backend}_incomplete.grlens'
|
|
payload = bytearray(single_map.read_bytes())
|
|
struct.pack_into('<II', payload, MAP_VERTEX_START + 76, 3, 5) # INCOMPLETE / INVALID_METRIC
|
|
struct.pack_into('<I', payload, len(payload)-4,
|
|
zlib.crc32(payload[MAP_VERTEX_START:-4]))
|
|
incomplete_map.write_bytes(payload)
|
|
refused = tmp / f'{backend}_refused.{ext}'
|
|
failure = run(binary, *common, '--lens-map-input', incomplete_map,
|
|
'--output', refused, ok=False)
|
|
assert 'Incomplete render refused' in failure.stderr
|
|
assert not refused.exists()
|
|
diagnostic = run(binary, *common, '--lens-map-input', incomplete_map,
|
|
'--allow-incomplete', '--output', refused)
|
|
assert 'publishing incomplete render' in diagnostic.stderr
|
|
assert refused.exists()
|
|
imported_mesh = tmp / f'{backend}_import_mesh.{ext}'
|
|
run(binary, *common, '--lens-map-input', single_map, '--draw-mesh',
|
|
'--output', imported_mesh)
|
|
assert image_payload(imported_mesh) == single
|
|
assert (tmp / f'{backend}_import_mesh_mesh.{ext}').exists()
|
|
|
|
if hdr_available:
|
|
# The clean HDR FITS payload and primary image are bit-identical
|
|
# with and without --draw-mesh; only the mesh sibling differs.
|
|
hdr_output = tmp / f'{backend}_hdr.{ext}'
|
|
hdr_mesh_output = tmp / f'{backend}_hdr_mesh.{ext}'
|
|
run(binary, *common, '--hdr-output', '--output', hdr_output)
|
|
run(binary, *common, '--hdr-output', '--draw-mesh', '--output',
|
|
hdr_mesh_output)
|
|
base_fits = tmp / f'{backend}_hdr_HDR.fits'
|
|
mesh_fits = tmp / f'{backend}_hdr_mesh_HDR.fits'
|
|
assert base_fits.exists() and mesh_fits.exists()
|
|
diff = subprocess.run([sys.executable, str(FITSDIFF), str(base_fits),
|
|
str(mesh_fits)], capture_output=True, text=True)
|
|
assert diff.returncode == 0, diff.stdout + diff.stderr
|
|
assert 'mismatches=0 max_abs=0 max_rel=0' in diff.stdout, diff.stdout
|
|
assert image_payload(hdr_output) == baseline
|
|
assert image_payload(hdr_mesh_output) == baseline
|
|
assert image_payload(tmp / f'{backend}_hdr_mesh_mesh.{ext}') != baseline
|
|
|
|
# Sensor-bloom integration runs in every build. With linear HDR the
|
|
# response limit is derived from the rendered peak; without it the
|
|
# fixture's calibrated exposure puts the display shoulder near 1.0,
|
|
# which is guaranteed to saturate this scene, so the default ENABLE_HDR=0
|
|
# suite still exercises the output-pipeline hook. The limit is placed
|
|
# well below the peak so the clamped region falls in the tone map's
|
|
# sensitive range and the display comparison stays discriminating.
|
|
if hdr_available:
|
|
base_peak = fits_max(base_fits)
|
|
assert base_peak > 0.0
|
|
bloom_limit = base_peak / 100.0
|
|
else:
|
|
bloom_limit = 1.0
|
|
hdr_args = ['--hdr-output'] if hdr_available else []
|
|
bloom_output = tmp / f'{backend}_bloom.{ext}'
|
|
bloom_run = run(binary, *common, *hdr_args,
|
|
'--sensor-bloom-limit', bloom_limit,
|
|
'--sensor-bloom-transfer', 0.5,
|
|
'--output', bloom_output)
|
|
assert image_payload(bloom_output) != baseline
|
|
assert 'Sensor bloom:' in bloom_run.stdout, bloom_run.stdout
|
|
report = bloom_run.stdout.split('Sensor bloom:', 1)[1].splitlines()[0]
|
|
fields = dict(token.split('=', 1) for token in report.split() if '=' in token)
|
|
assert int(fields['saturated']) > 0, report
|
|
assert int(fields['iterations'].split('/')[0]) >= 1, report
|
|
assert float(fields['peak']) >= bloom_limit, report
|
|
if hdr_available:
|
|
# The raw FITS is written before the model runs, so it stays
|
|
# byte-identical to the baseline even though the display changes.
|
|
bloom_fits = tmp / f'{backend}_bloom_HDR.fits'
|
|
assert bloom_fits.exists(), bloom_run.stderr
|
|
diff = subprocess.run([sys.executable, str(FITSDIFF), str(base_fits),
|
|
str(bloom_fits)], capture_output=True, text=True)
|
|
assert diff.returncode == 0, diff.stdout + diff.stderr
|
|
assert 'mismatches=0 max_abs=0 max_rel=0' in diff.stdout, diff.stdout
|
|
|
|
# The mesh overlay is drawn on the already-bloomed frame, so the primary
|
|
# image is unchanged by --draw-mesh and the diagnostic lines do not feed
|
|
# back into the overflow model.
|
|
bloom_mesh_output = tmp / f'{backend}_bloom_mesh.{ext}'
|
|
run(binary, *common, *hdr_args, '--sensor-bloom-limit', bloom_limit,
|
|
'--sensor-bloom-transfer', 0.5, '--draw-mesh',
|
|
'--output', bloom_mesh_output)
|
|
assert image_payload(bloom_mesh_output) == image_payload(bloom_output)
|
|
bloom_mesh_sibling = tmp / f'{backend}_bloom_mesh_mesh.{ext}'
|
|
assert bloom_mesh_sibling.exists()
|
|
assert image_payload(bloom_mesh_sibling) != image_payload(bloom_output)
|
|
if hdr_available:
|
|
bloom_mesh_fits = tmp / f'{backend}_bloom_mesh_HDR.fits'
|
|
diff = subprocess.run([sys.executable, str(FITSDIFF), str(base_fits),
|
|
str(bloom_mesh_fits)], capture_output=True, text=True)
|
|
assert diff.returncode == 0, diff.stdout + diff.stderr
|
|
assert 'mismatches=0 max_abs=0 max_rel=0' in diff.stdout, diff.stdout
|
|
|
|
if backend == 'schwarzschild':
|
|
# Two inward-looking free-fall samples at r=6.2696 and r=3.1593.
|
|
# At 16:9 the latter frame finishes in generation 0, while the
|
|
# former still needs refinement. Finishing the empty batch used
|
|
# to abort the whole movie in generation 1.
|
|
mixed = Path(__file__).parent / 'fixtures/schwarzschild_mixed_refinement.csv'
|
|
parallel_map = tmp / 'mixed-parallel.grlens'
|
|
result = run(binary, *common, '--height', 36, '--fov-deg', 60,
|
|
'--refine-max-level', 3, '--observer-track', mixed,
|
|
'--movie-track-samples', '--frames-dir', tmp,
|
|
'--frames-prefix', 'mixed', '--verbose',
|
|
'--lens-map-output', parallel_map)
|
|
assert 'Ray trace generation 1: frame 0 added' in result.stdout
|
|
assert 'Ray trace generation 0: frame 1 added' not in result.stdout
|
|
for frame in range(2):
|
|
image_payload(tmp / f'mixed_{frame:06d}.{ext}',
|
|
dimensions=(64, 36), allow_black=True)
|
|
# Thread scheduling must preserve endpoints, frame/sample IDs and
|
|
# the resulting adaptive mesh across the entire slab sweep.
|
|
for threads in (1, 16):
|
|
comparison_map = tmp / f'mixed-{threads}-threads.grlens'
|
|
run(binary, *common, '--height', 36, '--fov-deg', 60,
|
|
'--refine-max-level', 3, '--observer-track', mixed,
|
|
'--movie-track-samples', '--frames-dir', tmp,
|
|
'--frames-prefix', f'mixed-{threads}-threads',
|
|
'--lens-map-output', comparison_map,
|
|
env=dict(ENV, OMP_NUM_THREADS=str(threads)))
|
|
assert parallel_map.read_bytes() == comparison_map.read_bytes(), \
|
|
f'movie lens map changed with {threads} threads'
|
|
print('schwarzschild: movie lens map identical with 1, 4 and 16 threads', flush=True)
|
|
print(f'{backend}: CLI checks passed; single/movie image identical, map max error {max_error:.3g}', flush=True)
|
|
|
|
# In the moving bubble, (t, x) -> (t+T, x+v_s*T) preserves the
|
|
# metric and physical ray endpoints. This detects a stale t=0 in either
|
|
# camera metric evaluation or ray initialization, not just map metadata.
|
|
alc = BUILD / 'alcubierre_sky'
|
|
if alc.exists():
|
|
reference = None
|
|
for time in (0, 12.5, -12.5):
|
|
path = tmp / f'alcubierre_time_{time}.grlens'
|
|
run(alc, *common, '--alcubierre-vs', 0.3,
|
|
'--alcubierre-radius', 1, '--observer-time', time,
|
|
'--observer-position', 0.3 * time, 0, 0,
|
|
'--observer-velocity', 0.3, 0, 0,
|
|
'--look-ra-deg', 0, '--look-dec-deg', 0,
|
|
'--lens-map-output', path, '--output', tmp / 'alcubierre.png')
|
|
assert struct.unpack_from('<d', path.read_bytes(),
|
|
MAP_FRAME_HEADER_START + 8)[0] == time
|
|
vertices, triangles = map_vertices(path)
|
|
if reference is None:
|
|
reference = vertices, triangles
|
|
continue
|
|
expected, expected_triangles = reference
|
|
assert len(vertices) == len(expected) and triangles == expected_triangles
|
|
for actual, baseline in zip(vertices, expected):
|
|
assert actual[9:12] == baseline[9:12]
|
|
assert max(abs(a - b) for a, b in zip(actual[:9], baseline[:9])) < 1e-8
|
|
print('alcubierre: nonzero camera-time translation checks passed', flush=True)
|