Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

11.2 KB
Raw Blame
"""Run with Blender's Python against an installed extension and the real local compiler."""
import argparse
import hashlib
import importlib
import json
from pathlib import Path
import sys

import addon_utils
import bpy
import bmesh
from mathutils import Vector

parser = argparse.ArgumentParser()
parser.add_argument("--module", default="bl_ext.aetheris_test.aetheris_cad")
parser.add_argument("--source-addon", type=Path)
parser.add_argument("--compiler", type=Path)
parser.add_argument("--output", required=True, type=Path)
parser.add_argument("--repo", required=True, type=Path)
parser.add_argument("--phase", choices=("create", "reopen"), default="create")
args = parser.parse_args(sys.argv[sys.argv.index("--") + 1:])
out = args.output.resolve()
out.mkdir(parents=True, exist_ok=True)
if args.source_addon:
    sys.path.insert(0, str(args.source_addon.resolve()))
addon_utils.enable(args.module, default_set=True, persistent=True)
addon = importlib.import_module(args.module)
if args.compiler:
    bpy.context.preferences.addons[args.module].preferences.executable_path = str(args.compiler.resolve())
state = addon.state


def select(root):
    for obj in bpy.context.selected_objects:
        obj.select_set(False)
    root.select_set(True)
    bpy.context.view_layer.objects.active = root


def build(root, **kwargs):
    select(root)
    result = bpy.ops.aetheris.build(**kwargs)
    assert result == {"FINISHED"}, root.aetheris.diagnostics.as_string() if root.aetheris.diagnostics else root.aetheris.status
    return state.body_of(root)


def dimensions(root):
    body = state.body_of(root)
    xs = [v.co.x for v in body.data.vertices]
    ys = [v.co.y for v in body.data.vertices]
    zs = [v.co.z for v in body.data.vertices]
    return [max(xs) - min(xs), max(ys) - min(ys), max(zs) - min(zs)]


def expect_dimensions(root, values):
    for actual, expected in zip(dimensions(root), values):
        # Blender stores float32 mesh positions; compare physical metres, including unit scale.
        assert abs(actual - expected) * bpy.context.scene.unit_settings.scale_length < 1e-7, (actual, expected)


def replace(text, source):
    text.clear()
    text.write(source)


def export(root, filename):
    select(root)
    path = out / filename
    assert bpy.ops.aetheris.export_step(filepath=str(path)) == {"FINISHED"}
    return path


if args.phase == "reopen":
    root = bpy.data.objects["CAD Plate"]
    select(root)
    accepted = root.aetheris.accepted_hash
    assert state.current_hash(root) == accepted
    assert state.accepted_step(root).startswith("ISO-10303-21;")
    expect_dimensions(root, [.1, .05, .008])
    material = state.body_of(root).data.materials[0]
    build(root)
    assert state.body_of(root).data.materials[0] == material
    assert abs(root.location.x - .025) < 1e-8
    assert abs(state.body_of(root).location.x - .003) < 1e-8
    packed = bpy.data.objects["Packed Plate"]
    assert len(packed.aetheris.resources) == 1
    build(packed)
    expect_dimensions(packed, [.04, .03, .012])
    export(root, "reopened.step")
    export(packed, "reopened-packed.step")
    (out / "reopen.json").write_text(json.dumps({"success": True, "saved_source": True, "saved_dependencies": True,
        "compiler_override": bool(args.compiler), "dimensions": dimensions(root)}, indent=2))
    print("AETHERIS_BLENDER_REOPEN_OK")
else:
    # Only this factory-startup test scene is modified.
    for obj in list(bpy.data.objects):
        bpy.data.objects.remove(obj, do_unlink=True)
    assert bpy.ops.aetheris.new_part() == {"FINISHED"}
    root = bpy.context.active_object
    root.name = "CAD Plate"
    body = build(root)
    expect_dimensions(root, [.08, .05, .008])
    identity = body.as_pointer()
    source = root.aetheris.source.as_string()
    material = bpy.data.materials.new("Qualification brass")
    material.diffuse_color = (.55, .28, .07, 1)
    material.use_nodes = True
    shader = material.node_tree.nodes["Principled BSDF"]
    shader.inputs["Base Color"].default_value = material.diffuse_color
    shader.inputs["Metallic"].default_value = .7
    shader.inputs["Roughness"].default_value = .3
    body.data.materials.clear()
    body.data.materials.append(material)
    root.location = (.025, -.025, .005)
    root.rotation_euler.z = .15
    body.location.x = .003
    transform = body.matrix_basis.copy()
    replace(root.aetheris.source, source.replace("80mm", "100mm"))
    body = build(root)
    assert body.as_pointer() == identity
    assert body.matrix_basis == transform
    assert body.data.materials[0] == material
    expect_dimensions(root, [.1, .05, .008])
    good = root.aetheris.source.as_string()
    accepted_mesh = state.mesh_hash(body.data)
    accepted_step = state.accepted_step(root)
    replace(root.aetheris.source, good.replace("diameter: 8mm", "diameter: -8mm"))
    assert bpy.ops.aetheris.build() == {"CANCELLED"}
    assert state.mesh_hash(body.data) == accepted_mesh
    assert root.aetheris.step.as_string() == accepted_step
    assert root.aetheris.diagnostics.as_string()
    try:
        state.accepted_step(root)
        raise AssertionError("A stale source exported STEP")
    except addon.BuildError:
        pass
    replace(root.aetheris.source, good)
    build(root)
    # Native mesh editing remains independent of exact CAD.
    assert bpy.ops.aetheris.mesh_copy() == {"FINISHED"}
    copy = bpy.context.active_object
    assert copy.data != body.data and copy.parent is None
    editable = bmesh.new()
    try:
        editable.from_mesh(copy.data)
        assert all(edge.is_manifold for edge in editable.edges), "Mesh copy has open display seams"
        volume_mm3 = abs(editable.calc_volume()) * 1e9
        import math
        assert abs(volume_mm3 - (100 * 50 * 8 - math.pi * 4 * 4 * 8)) < 5, volume_mm3
    finally:
        editable.free()
    copy.data.vertices[0].co.x += .001
    copy.hide_render = True
    copy.hide_set(True)
    select(root)
    body.data.vertices[0].co.x += .001
    assert bpy.ops.aetheris.build() == {"CANCELLED"}
    assert "vertex edits" in root.aetheris.status
    build(root, replace_edited=True)
    assert not state.mesh_edited(root)
    assert copy.data != body.data
    assert state.body_of(root).data.materials[0] == material
    export(root, "plate.step")
    # Build from packed dependencies, then take the original files away before reopening.
    external = out / "original-project"
    external.mkdir(exist_ok=True)
    fixture_dir = args.repo / "fixtures/Regression/BlenderAddon"
    for name in ("packed-plate.firmament", "parameters.firmament"):
        (external / name).write_bytes((fixture_dir / name).read_bytes())
    assert bpy.ops.aetheris.import_source(filepath=str(external / "packed-plate.firmament")) == {"FINISHED"}
    packed = bpy.context.active_object
    packed.name = "Packed Plate"
    assert bpy.ops.aetheris.build() == {"CANCELLED"}
    assert state.body_of(packed) is None
    assert bpy.ops.aetheris.add_resource(filepath=str(external / "parameters.firmament")) == {"FINISHED"}
    build(packed)
    expect_dimensions(packed, [.04, .03, .008])
    replace(packed.aetheris.resources[0].text, "Static Depth: Length = 12mm\n")
    build(packed)
    expect_dimensions(packed, [.04, .03, .012])
    packed.location = (-.055, .035, .005)
    # Source edits during an asynchronous compiler job cannot replace accepted geometry.
    select(root)
    files, main = state.project_files(root)
    job = addon.BuildJob(addon.executable(bpy.context), files, main)
    replace(root.aetheris.source, good.replace("100mm", "110mm"))
    try:
        import time
        while job.poll() is None:
            time.sleep(.02)
        mesh, step = job.result()
        try:
            state.install_result(root, mesh, step, job.digest, bpy.context.scene)
            raise AssertionError("A stale asynchronous result replaced the accepted part")
        except addon.BuildError as error:
            assert "Source changed" in str(error)
    finally:
        job.close()
    replace(root.aetheris.source, good)
    expect_dimensions(root, [.1, .05, .008])
    # Different Blender unit scales still represent the same millimetre geometry.
    bpy.context.scene.unit_settings.scale_length = .001
    body = build(root)
    expect_dimensions(root, [100, 50, 8])
    bpy.context.scene.unit_settings.scale_length = 1
    body = build(root)
    expect_dimensions(root, [.1, .05, .008])
    export(root, "plate.step")
    # A real Blender render of the compiler's geometry, alongside a native Blender floor.
    scene = bpy.context.scene
    scene.render.engine = "BLENDER_EEVEE"
    scene.render.resolution_x, scene.render.resolution_y = 1200, 800
    scene.render.resolution_percentage = 100
    scene.world = bpy.data.worlds.new("CAD studio")
    scene.world.use_nodes = True
    scene.world.node_tree.nodes["Background"].inputs[0].default_value = (.14, .17, .22, 1)
    scene.world.node_tree.nodes["Background"].inputs[1].default_value = .4
    floor_mesh = bpy.data.meshes.new("Blender floor")
    floor_mesh.from_pydata([(-1,-1,0), (1,-1,0), (1,1,0), (-1,1,0)], [], [(0,1,2,3)])
    floor = bpy.data.objects.new("Native Blender floor", floor_mesh)
    scene.collection.objects.link(floor)
    floor_material = bpy.data.materials.new("Studio floor")
    floor_material.diffuse_color = (.07, .09, .12, 1)
    floor_material.use_nodes = True
    floor_material.node_tree.nodes["Principled BSDF"].inputs["Base Color"].default_value = floor_material.diffuse_color
    floor_mesh.materials.append(floor_material)
    camera_data = bpy.data.cameras.new("CAD camera")
    camera = bpy.data.objects.new("CAD camera", camera_data)
    scene.collection.objects.link(camera)
    camera.location = (.19, -.23, .21)
    camera.rotation_euler = (Vector((0,0,.005)) - camera.location).to_track_quat("-Z", "Y").to_euler()
    camera_data.lens = 50
    camera_data.clip_start = .001
    scene.camera = camera
    for name, location, energy, size in [("Key", (.1,-.1,.2), 2, .15), ("Fill", (-.12,.05,.15), 1, .12)]:
        light = bpy.data.lights.new(name, "AREA")
        light.energy, light.shape, light.size = energy, "DISK", size
        obj = bpy.data.objects.new(name, light)
        scene.collection.objects.link(obj)
        obj.location = location
        obj.rotation_euler = (-obj.location).to_track_quat("-Z", "Y").to_euler()
    select(root)
    bpy.context.view_layer.update()
    scene.render.filepath = str(out / "cad-in-blender.png")
    bpy.ops.render.render(write_still=True)
    bpy.ops.wm.save_as_mainfile(filepath=str(out / "qualified.blend"))
    for path in external.iterdir():
        if path.suffix != ".unavailable":
            path.replace(path.with_suffix(path.suffix + ".unavailable"))
    (out / "create.json").write_text(json.dumps({"success": True, "module": args.module, "compiler_override": bool(args.compiler),
        "revision": root.aetheris.revision, "dimensions": dimensions(root), "triangles": len(body.data.polygons),
        "identity_preserved": True, "material_preserved": True, "placement_preserved": True, "failed_build_retained": True,
        "stale_result_refused": True, "mesh_copy_independent": True, "unit_scale_qualified": True,
        "packed_dependency": True, "original_dependency_removed": True,
        "step_sha256": hashlib.sha256((out / "plate.step").read_bytes()).hexdigest()}, indent=2))
    print("AETHERIS_BLENDER_CREATE_OK")