175 lines
6.6 KiB
Python
175 lines
6.6 KiB
Python
"""Compare Shriinivas pie chart source graphs against Geometry Script translations."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import importlib.util
|
|
import json
|
|
import math
|
|
import sys
|
|
from pathlib import Path
|
|
from typing import Any
|
|
|
|
import bpy
|
|
|
|
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
TRANSLATION = ROOT / "examples" / "geometry_script" / "shriinivas_piechart.py"
|
|
|
|
|
|
def _load_translation() -> None:
|
|
spec = importlib.util.spec_from_file_location("vg_piechart_translation", TRANSLATION)
|
|
if spec is None or spec.loader is None:
|
|
raise RuntimeError(f"Could not load translation script: {TRANSLATION}")
|
|
module = importlib.util.module_from_spec(spec)
|
|
sys.modules[spec.name] = module
|
|
spec.loader.exec_module(module)
|
|
|
|
|
|
def _socket_by_name(sockets: Any, name: str):
|
|
for socket in sockets:
|
|
if socket.name == name:
|
|
return socket
|
|
raise KeyError(name)
|
|
|
|
|
|
def _new_geometry_group(name: str) -> bpy.types.GeometryNodeTree:
|
|
if name in bpy.data.node_groups:
|
|
bpy.data.node_groups.remove(bpy.data.node_groups[name])
|
|
group = bpy.data.node_groups.new(name, "GeometryNodeTree")
|
|
group.is_modifier = True
|
|
group.interface.new_socket(name="Geometry", in_out="INPUT", socket_type="NodeSocketGeometry")
|
|
group.interface.new_socket(name="Geometry", in_out="OUTPUT", socket_type="NodeSocketGeometry")
|
|
return group
|
|
|
|
|
|
def _set_inputs(group_node: bpy.types.GeometryNode, values: dict[str, object]) -> None:
|
|
lower_values = {name.lower(): value for name, value in values.items()}
|
|
for socket in group_node.inputs:
|
|
if socket.name in values:
|
|
socket.default_value = values[socket.name]
|
|
elif socket.name.lower() in lower_values:
|
|
socket.default_value = lower_values[socket.name.lower()]
|
|
|
|
|
|
def _build_segment_wrapper(name: str, group: bpy.types.GeometryNodeTree, inputs: dict[str, object]):
|
|
wrapper = _new_geometry_group(name)
|
|
nodes = wrapper.nodes
|
|
links = wrapper.links
|
|
group_node = nodes.new("GeometryNodeGroup")
|
|
group_node.node_tree = group
|
|
_set_inputs(group_node, inputs)
|
|
group_output = nodes.new("NodeGroupOutput")
|
|
links.new(_socket_by_name(group_node.outputs, "Curve"), _socket_by_name(group_output.inputs, "Geometry"))
|
|
return wrapper
|
|
|
|
|
|
def _build_chart_wrapper(name: str, group: bpy.types.GeometryNodeTree, inputs: dict[str, object]):
|
|
wrapper = _new_geometry_group(name)
|
|
nodes = wrapper.nodes
|
|
links = wrapper.links
|
|
group_input = nodes.new("NodeGroupInput")
|
|
group_node = nodes.new("GeometryNodeGroup")
|
|
group_node.node_tree = group
|
|
_set_inputs(group_node, inputs)
|
|
group_output = nodes.new("NodeGroupOutput")
|
|
if any(socket.name == "Geometry" for socket in group_node.inputs):
|
|
links.new(_socket_by_name(group_input.outputs, "Geometry"), _socket_by_name(group_node.inputs, "Geometry"))
|
|
links.new(_socket_by_name(group_node.outputs, "Geometry"), _socket_by_name(group_output.inputs, "Geometry"))
|
|
return wrapper
|
|
|
|
|
|
def _evaluated_vertices(group: bpy.types.GeometryNodeTree) -> list[tuple[float, float, float]]:
|
|
mesh = bpy.data.meshes.new(group.name + " Input Mesh")
|
|
obj = bpy.data.objects.new(group.name + " Object", mesh)
|
|
bpy.context.collection.objects.link(obj)
|
|
modifier = obj.modifiers.new(group.name + " Modifier", "NODES")
|
|
modifier.node_group = group
|
|
depsgraph = bpy.context.evaluated_depsgraph_get()
|
|
evaluated = obj.evaluated_get(depsgraph)
|
|
evaluated_mesh = evaluated.to_mesh()
|
|
try:
|
|
return [tuple(vertex.co) for vertex in evaluated_mesh.vertices]
|
|
finally:
|
|
evaluated.to_mesh_clear()
|
|
|
|
|
|
def _bounds(vertices: list[tuple[float, float, float]]) -> dict[str, list[float]]:
|
|
return {
|
|
"min": [min(vertex[i] for vertex in vertices) for i in range(3)],
|
|
"max": [max(vertex[i] for vertex in vertices) for i in range(3)],
|
|
}
|
|
|
|
|
|
def _compare(case: str, source_vertices, translated_vertices) -> dict[str, object]:
|
|
if len(source_vertices) != len(translated_vertices):
|
|
return {
|
|
"case": case,
|
|
"ok": False,
|
|
"reason": "vertex_count_mismatch",
|
|
"source_vertex_count": len(source_vertices),
|
|
"translated_vertex_count": len(translated_vertices),
|
|
"source_bounds": _bounds(source_vertices) if source_vertices else None,
|
|
"translated_bounds": _bounds(translated_vertices) if translated_vertices else None,
|
|
}
|
|
max_delta = 0.0
|
|
for source, translated in zip(sorted(source_vertices), sorted(translated_vertices)):
|
|
max_delta = max(max_delta, math.dist(source, translated))
|
|
return {
|
|
"case": case,
|
|
"ok": max_delta <= 1e-6,
|
|
"source_vertex_count": len(source_vertices),
|
|
"translated_vertex_count": len(translated_vertices),
|
|
"max_sorted_vertex_delta": max_delta,
|
|
"source_bounds": _bounds(source_vertices),
|
|
"translated_bounds": _bounds(translated_vertices),
|
|
}
|
|
|
|
|
|
def main() -> int:
|
|
_load_translation()
|
|
text_material = bpy.data.materials.get("Text Material") or bpy.data.materials.new("Text Material")
|
|
mat1 = bpy.data.materials.get("Material 1") or bpy.data.materials.new("Material 1")
|
|
mat2 = bpy.data.materials.get("Material 2") or bpy.data.materials.new("Material 2")
|
|
mat3 = bpy.data.materials.get("Material 3") or bpy.data.materials.new("Material 3")
|
|
|
|
segment_inputs = {
|
|
"Start": 0.35,
|
|
"Value": 0.8,
|
|
"Total": 2.4,
|
|
"Shift": 0.2,
|
|
"Segment Material": mat1,
|
|
"Text Material": text_material,
|
|
}
|
|
chart_inputs = {
|
|
"A": 0.8,
|
|
"A Shift": 0.2,
|
|
"A Material": mat1,
|
|
"B": 1.1,
|
|
"B Shift": 0.05,
|
|
"B Material": mat2,
|
|
"C": 0.5,
|
|
"C Shift": 0.0,
|
|
"C Material": mat3,
|
|
"Text Material": text_material,
|
|
}
|
|
|
|
cases = [
|
|
(
|
|
"segment",
|
|
_build_segment_wrapper("VG Verify Source Pie Segment", bpy.data.node_groups["NodeGroup"], segment_inputs),
|
|
_build_segment_wrapper("VG Verify Translated Pie Segment", bpy.data.node_groups["VG Pie Segment"], segment_inputs),
|
|
),
|
|
(
|
|
"chart",
|
|
_build_chart_wrapper("VG Verify Source Pie Chart", bpy.data.node_groups["Pie Chart"], chart_inputs),
|
|
_build_chart_wrapper("VG Verify Translated Pie Chart", bpy.data.node_groups["VG Pie Chart"], chart_inputs),
|
|
),
|
|
]
|
|
results = [_compare(case, _evaluated_vertices(source), _evaluated_vertices(translated)) for case, source, translated in cases]
|
|
ok = all(result["ok"] for result in results)
|
|
print("VG_PIECHART_TRANSLATION_BEHAVIOR " + json.dumps({"ok": ok, "results": results}, sort_keys=True))
|
|
return 0 if ok else 1
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main())
|