Files
gods-eye-view/tools/blender/check_import.py
T

148 lines
7.6 KiB
Python

"""Synthetic CPU-only Blender import, projection and .blend round-trip check.
blender --background --factory-startup --disable-autoexec --threads 1
--python tools/blender/check_import.py -- fixture-directory
No renderer or GPU context is requested. All landmarks are synthetic empties.
"""
import importlib.util
import json
from pathlib import Path
import sys
import bpy
from bpy_extras.object_utils import world_to_camera_view
from mathutils import Vector
spec = importlib.util.spec_from_file_location("camera_import", Path(__file__).with_name("camera_import.py"))
importer = importlib.util.module_from_spec(spec)
spec.loader.exec_module(importer)
args = sys.argv[sys.argv.index("--") + 1:]
if len(args) != 1:
raise SystemExit("Expected one fixture directory")
directory = Path(args[0])
reference = json.loads((directory / "projection-reference.json").read_text())
original_names = set(bpy.data.scenes.keys())
original_settings = {scene.name: (scene.render.resolution_x, scene.render.resolution_y, scene.frame_end) for scene in bpy.data.scenes}
bpy.context.preferences.filepaths.file_preview_type = 'NONE'
def block(scene, name, center, size):
"""Tiny owned synthetic blockout, so the saved rig has an editable set."""
x, y, z = center
sx, sy, sz = [value / 2 for value in size]
vertices = [(x+dx*sx, y+dy*sy, z+dz*sz) for dx, dy, dz in [(-1,-1,-1),(1,-1,-1),(1,1,-1),(-1,1,-1),(-1,-1,1),(1,-1,1),(1,1,1),(-1,1,1)]]
faces = [(0,3,2,1),(4,5,6,7),(0,1,5,4),(1,2,6,5),(2,3,7,6),(3,0,4,7)]
mesh = bpy.data.meshes.new(name)
mesh.from_pydata(vertices, [], faces)
mesh.update()
obj = bpy.data.objects.new(name, mesh)
scene.collection.objects.link(obj)
cases = []
for case in reference["cases"]:
manifest = importer.read_manifest(directory / case["manifest"])
scene = importer.import_manifest(manifest)
# All validation occurs before bpy mutation.
malformed = json.loads(json.dumps(manifest))
malformed["frames"][-1]["basisColumns"][0] = [2, 0, 0]
names = set(bpy.data.scenes.keys())
objects = set(bpy.data.objects.keys())
try:
importer.import_manifest(malformed)
raise AssertionError("Malformed transform was accepted")
except ValueError:
assert set(bpy.data.scenes.keys()) == names
assert set(bpy.data.objects.keys()) == objects
for index, point in enumerate(case["checks"][0]["points"]):
landmark = bpy.data.objects.new(f"Synthetic landmark {index}", None)
landmark.location = point["position"]
scene.collection.objects.link(landmark)
block(scene, 'Synthetic ground, no map data', [0, 0, -1], [1400, 1400, 2])
for index in [0, 6, 9]:
sample = manifest['frames'][index]
point = case['checks'][index]['points'][0]['position']
direction = [(point[i]-sample['position'][i])/100 for i in range(3)]
distance = -sample['position'][2]/direction[2]
center = [sample['position'][i]+direction[i]*distance for i in range(2)] + [10]
block(scene, f'Synthetic block {index}', center, [24, 24, 20])
cases.append((case, manifest, scene.name))
# JSON may spell an integer-valued number as 1920.0. Blender RNA requires ints.
float_case = dict(reference['cases'][0], name='integer-valued JSON floats')
float_manifest = importer.read_manifest(directory / float_case['manifest'])
for key in ['width', 'height', 'frameEnd']:
float_manifest['timeline'][key] = float(float_manifest['timeline'][key])
for shot in float_manifest['shots']:
shot['frameStart'] = float(shot['frameStart'])
float_scene = importer.import_manifest(float_manifest)
cases.append((float_case, float_manifest, float_scene.name))
def check_all():
max_error = 0.0
projection_count = 0
for case, manifest, scene_name in cases:
scene = bpy.data.scenes[scene_name]
bpy.context.window.scene = scene
bpy.context.view_layer.update()
metadata = json.loads(scene["gev_source"])
assert metadata["sceneId"] == manifest["source"]["sceneId"]
assert json.loads(scene["gev_coordinates"]) == manifest["coordinates"]
assert json.loads(scene["gev_timeline"]) == manifest["timeline"]
assert scene.frame_start == 1 and scene.frame_end == len(manifest["frames"])
expected_rate = manifest["timeline"]["fps"]["numerator"] / manifest["timeline"]["fps"]["denominator"]
assert abs(scene.render.fps / scene.render.fps_base - expected_rate) < 2e-6
assert scene.unit_settings.scale_length == 1
assert scene.render.resolution_x == manifest["timeline"]["width"]
assert scene.render.resolution_y == manifest["timeline"]["height"]
cameras = {json.loads(obj["gev_shot"])["id"]: obj for obj in scene.objects if "gev_shot" in obj}
assert set(cameras) == {shot["id"] for shot in manifest["shots"]}
for shot in manifest["shots"]:
camera = cameras[shot["id"]]
assert json.loads(camera["gev_shot"]) == shot
expected_frames = [sample["frame"] for sample in manifest["frames"] if sample["shotId"] == shot["id"]]
curves = list(importer._camera_curves(camera))
assert len(curves) == 7, "Expected three location and four quaternion channels"
for curve in curves:
assert [key.co[0] for key in curve.keyframe_points] == expected_frames
assert all(key.interpolation == "LINEAR" for key in curve.keyframe_points)
for item in case["checks"]:
scene.frame_set(item["frame"])
active = scene.camera
camera = cameras[item["shotId"]]
assert active == camera, "Timeline marker selected the wrong camera"
assert camera.data.sensor_fit == "HORIZONTAL"
assert abs(camera.data.lens - manifest["camera"]["lensMm"]) < 1e-5
for point in item["points"]:
projected = world_to_camera_view(scene, camera, Vector(point["position"]))
assert projected.z > 0, (case['name'], item['frame'], 'landmark behind camera')
error = max(abs(projected.x - point["uv"][0]), abs(projected.y - point["uv"][1]))
max_error = max(error, max_error)
assert error < 2e-5, (case["name"], item["frame"], error)
projection_count += 1
for name in original_names:
scene = bpy.data.scenes[name]
assert (scene.render.resolution_x, scene.render.resolution_y, scene.frame_end) == original_settings[name]
return max_error, projection_count
before_error, count = check_all()
blend = directory / "synthetic-cameras.blend"
if blend.exists():
raise SystemExit("Synthetic output already exists; choose a fresh fixture directory")
bpy.context.window.scene = bpy.data.scenes[cases[0][2]]
bpy.context.scene.frame_set(1)
for area in bpy.context.screen.areas:
if area.type == 'VIEW_3D':
area.spaces.active.region_3d.view_perspective = 'CAMERA'
bpy.ops.wm.save_as_mainfile(filepath=str(blend.resolve()), check_existing=False)
assert blend.stat().st_size > 10000
bpy.ops.wm.open_mainfile(filepath=str(blend.resolve()), load_ui=False, use_scripts=False)
assert bpy.context.scene.name == cases[0][2], 'Demo must reopen on the blockout scene'
after_error, after_count = check_all()
assert after_count == count
receipt = {"state": "BLENDER_CAMERA_PROJECTION_OK", "blenderVersion": bpy.app.version_string, "cases": len(cases), "projectionsBeforeSave": count, "projectionsAfterReload": after_count, "maxUvError": max(before_error, after_error), "rendered": False, "gpuRequested": False, "blend": blend.name}
(directory / "blender-receipt.json").write_text(json.dumps(receipt, indent=2) + "\n")
print(json.dumps(receipt))