241 lines
10 KiB
Python
241 lines
10 KiB
Python
"""Tests de Slice Wrap en arrière-plan (sans installer l'add-on).
|
||
|
||
"C:\\Program Files\\Blender Foundation\\Blender 5.2\\blender.exe" -b -P tests/run_tests.py -- [dossier_sortie] [--head]
|
||
- rapide (~40 s) : sphère trouée et bruitée → nom / numérotation / collection / Regenerate, Envelope fermée,
|
||
Wrap + Freeze (réparation), Despike (global, filtré, refus groupe absent, Protect Detail), Analyze.
|
||
- --head : chaîne complète sur la tête brute Pixal3D (11,8 M faces, ~2 min) + rendus de contrôle.
|
||
Termine par « RESULTAT : TOUT OK » ou la liste des échecs ; code de retour 0 si tout est bon, 1 sinon
|
||
(convention de la chaîne a2m : `tests/run_tests.py`, lancé avant chaque release).
|
||
"""
|
||
import importlib
|
||
import math
|
||
import os
|
||
import sys
|
||
import time
|
||
|
||
import bmesh
|
||
import bpy
|
||
import numpy as np
|
||
from mathutils import Vector
|
||
|
||
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||
sys.path.insert(0, os.path.dirname(ROOT))
|
||
for k in [k for k in sys.modules if k.startswith(os.path.basename(ROOT))]:
|
||
del sys.modules[k]
|
||
mod = importlib.import_module(os.path.basename(ROOT))
|
||
ARGS = sys.argv[sys.argv.index("--") + 1:] if "--" in sys.argv else []
|
||
OUT = next((a for a in ARGS if not a.startswith("--")), ROOT)
|
||
HEAD = r"C:\Users\a-mma\Desktop\CharacterDesign\Work3D\refs\head\3D\head_raw_pixal3d_front_s56.glb"
|
||
|
||
bpy.ops.wm.read_factory_settings(use_empty=True)
|
||
mod.register()
|
||
sc = bpy.context.scene
|
||
s = sc.slice_wrap
|
||
fails = []
|
||
|
||
|
||
def check(name, cond, msg=""):
|
||
print(("OK " if cond else "FAIL ") + f"{name} : {msg}")
|
||
if not cond:
|
||
fails.append(name)
|
||
|
||
|
||
def sel(o):
|
||
for x in bpy.context.selected_objects:
|
||
x.select_set(False)
|
||
o.hide_set(False)
|
||
o.select_set(True)
|
||
bpy.context.view_layer.objects.active = o
|
||
|
||
|
||
def topo(o):
|
||
bm = bmesh.new()
|
||
bm.from_mesh(o.data)
|
||
seen, pieces = set(), 0
|
||
for v in bm.verts:
|
||
if v in seen:
|
||
continue
|
||
pieces += 1
|
||
st = [v]
|
||
seen.add(v)
|
||
while st:
|
||
x = st.pop()
|
||
for e in x.link_edges:
|
||
w = e.other_vert(x)
|
||
if w not in seen:
|
||
seen.add(w)
|
||
st.append(w)
|
||
r = dict(faces=len(bm.faces), boundary=sum(e.is_boundary for e in bm.edges),
|
||
nonmanifold=sum(not e.is_manifold for e in bm.edges), pieces=pieces)
|
||
bm.free()
|
||
return r
|
||
|
||
|
||
def safe(op, **kw):
|
||
try:
|
||
return op(**kw)
|
||
except RuntimeError:
|
||
return {"CANCELLED"}
|
||
|
||
|
||
# ----------------------------------------------------------------------------- source : sphère trouée + bruit
|
||
bpy.ops.mesh.primitive_ico_sphere_add(subdivisions=5, radius=1.0)
|
||
src = bpy.context.active_object
|
||
src.name = "Tete"
|
||
bm = bmesh.new()
|
||
bm.from_mesh(src.data)
|
||
bmesh.ops.delete(bm, geom=[f for f in bm.faces if f.calc_center_median().z > 0.85
|
||
or abs(f.calc_center_median().x - 0.6) < 0.05], context="FACES") # trous
|
||
rng = np.random.default_rng(0)
|
||
for v in bm.verts:
|
||
v.co *= 1.0 + 0.004 * rng.standard_normal() # bruit
|
||
bm.to_mesh(src.data)
|
||
bm.free()
|
||
check("source trouée", topo(src)["boundary"] > 0, str(topo(src)))
|
||
|
||
# ----------------------------------------------------------------------------- nom / collection / Regenerate
|
||
s.pitch_rel = 1.5 # voxel grossier : test rapide (le défaut 0,6 % → ~100 k faces ×16)
|
||
pre = bpy.data.collections.new("SliceWrapCollection")
|
||
sc.collection.children.link(pre)
|
||
keep = bpy.data.objects.new("DejaLa", None)
|
||
pre.objects.link(keep)
|
||
sel(src)
|
||
t = time.time()
|
||
r1 = bpy.ops.slice_wrap.envelope()
|
||
e1 = bpy.context.active_object
|
||
check("envelope", r1 == {"FINISHED"}, f"{e1.name} en {time.time() - t:.1f} s")
|
||
check("nom suffixe", e1.name == "Tete_slicewrapped", e1.name)
|
||
tp = topo(e1)
|
||
check("enveloppe fermée", tp["boundary"] == 0 and tp["nonmanifold"] == 0 and tp["pieces"] == 1, str(tp))
|
||
check("source cachée", src.hide_get())
|
||
sel(src)
|
||
bpy.ops.slice_wrap.envelope()
|
||
e2 = bpy.context.active_object
|
||
check("numérotation", e2.name == "Tete_slicewrapped.001" and e1.name in bpy.data.objects, e2.name)
|
||
check("collection réutilisée", [c.name for c in e1.users_collection] == ["SliceWrapCollection"]
|
||
and "DejaLa" in pre.objects and len([c for c in bpy.data.collections if c.name.startswith("SliceWrapCollection")]) == 1)
|
||
nb = len(e2.data.polygons)
|
||
s.pitch_rel = 1.0
|
||
sel(e2)
|
||
r = bpy.ops.slice_wrap.regenerate()
|
||
check("regenerate sur place", r == {"FINISHED"} and bpy.context.active_object == e2 and len(e2.data.polygons) != nb,
|
||
f"{nb} → {len(e2.data.polygons)} faces")
|
||
s.pitch_rel = 1.5
|
||
s.use_collection = False
|
||
s.name_suffix = ""
|
||
sel(src)
|
||
bpy.ops.slice_wrap.envelope()
|
||
e4 = bpy.context.active_object
|
||
check("suffixe vide sans écraser la source", e4.name == "Tete.001" and src.name == "Tete"
|
||
and [c.name for c in e4.users_collection] == ["Scene Collection"], e4.name)
|
||
s.use_collection = True
|
||
s.name_suffix = "_slicewrapped"
|
||
|
||
# ----------------------------------------------------------------------------- objet sélectionné / annulation
|
||
check("plus de réglage Target", "target" not in s.bl_rna.properties)
|
||
check("opérateurs longs : propriété modal", "modal_run" in bpy.ops.slice_wrap.run.get_rna_type().properties)
|
||
sel(src)
|
||
src.select_set(False)
|
||
check("rien de sélectionné → Slice Wrap grisé", not bpy.ops.slice_wrap.run.poll())
|
||
sel(src)
|
||
check("objet sélectionné → Slice Wrap actif", bpy.ops.slice_wrap.run.poll())
|
||
n_obj, n_me, n_col = len(bpy.data.objects), len(bpy.data.meshes), len(bpy.data.collections)
|
||
g = mod.step_run(src) # chaîne complète pour compter les tranches, puis on la supprime
|
||
total = 0
|
||
try:
|
||
while True:
|
||
next(g)
|
||
total += 1
|
||
except StopIteration as e:
|
||
mod._remove_object(e.value[0])
|
||
sel(src)
|
||
check("chaîne découpée en tranches", total > 20, f"{total} tranches")
|
||
for stop in (3, total // 2, total): # annulation (Échap) : enveloppe, projection, juste avant le Reshape final
|
||
g = mod.step_run(src)
|
||
steps = 0
|
||
try:
|
||
for _ in range(stop):
|
||
next(g)
|
||
steps += 1
|
||
except StopIteration:
|
||
pass
|
||
g.close()
|
||
check(f"annulation après {steps} tranches : rien de créé",
|
||
(len(bpy.data.objects), len(bpy.data.meshes)) == (n_obj, n_me) and len(bpy.data.collections) == n_col,
|
||
f"objets {len(bpy.data.objects)}/{n_obj}, maillages {len(bpy.data.meshes)}/{n_me}")
|
||
sel(src)
|
||
|
||
# ----------------------------------------------------------------------------- Wrap + Freeze
|
||
sel(e1)
|
||
r = bpy.ops.slice_wrap.wrap_setup()
|
||
check("wrap setup", r == {"FINISHED"} and [m.type for m in e1.modifiers] == ["MULTIRES", "SHRINKWRAP"],
|
||
str([m.type for m in e1.modifiers]))
|
||
r = bpy.ops.slice_wrap.freeze()
|
||
check("freeze", r == {"FINISHED"} and [m.type for m in e1.modifiers] == ["MULTIRES"], str([m.type for m in e1.modifiers]))
|
||
check("regenerate refusé si wrappé", safe(bpy.ops.slice_wrap.regenerate) == {"CANCELLED"})
|
||
|
||
# ----------------------------------------------------------------------------- Despike
|
||
co0 = [v.co.copy() for v in e1.data.vertices]
|
||
g = mod.step_despike(e1)
|
||
next(g), next(g), next(g)
|
||
g.close()
|
||
check("despike annulé : maillage intact", [m.type for m in e1.modifiers] == ["MULTIRES"]
|
||
and all((v.co - c).length == 0 for v, c in zip(e1.data.vertices, co0))
|
||
and not any(o.name.endswith("_tmp") for o in bpy.data.objects))
|
||
vg = e1.vertex_groups.new(name="Zone")
|
||
vg.add([v.index for v in e1.data.vertices if v.co.z < 0], 1.0, "REPLACE")
|
||
e1.slice_wrap_despike_groups.add().group = "Zone"
|
||
r = bpy.ops.slice_wrap.despike()
|
||
check("despike filtré", r == {"FINISHED"})
|
||
e1.slice_wrap_despike_groups.clear()
|
||
e1.slice_wrap_despike_groups.add().group = "Absent"
|
||
check("despike refus groupe absent", safe(bpy.ops.slice_wrap.despike) == {"CANCELLED"})
|
||
e1.slice_wrap_despike_groups.clear()
|
||
s.despike_protect = True
|
||
check("despike global + Protect Detail", bpy.ops.slice_wrap.despike() == {"FINISHED"})
|
||
s.despike_protect = False
|
||
|
||
# ----------------------------------------------------------------------------- Analyze
|
||
r = bpy.ops.slice_wrap.analyze()
|
||
me = e1.data
|
||
check("analyze", r == {"FINISHED"} and {"sw_detail", "sw_shape", "sw_flow"} <= {a.name for a in me.attributes}
|
||
and {"SW_Detail_Color", "SW_Shape_Color"} <= {c.name for c in me.color_attributes}
|
||
and {"SW_Detail", "SW_Fold", "SW_Bulge"} <= {g.name for g in e1.vertex_groups})
|
||
check("pas de collision couleur / groupe", not ({c.name for c in me.color_attributes} & {g.name for g in e1.vertex_groups}))
|
||
r = bpy.ops.slice_wrap.show(mode="SW_Detail_Color")
|
||
check("show", r == {"FINISHED"} and me.color_attributes.render_color_index == me.color_attributes.active_color_index)
|
||
|
||
# ----------------------------------------------------------------------------- tête réelle (optionnel)
|
||
if "--head" in ARGS and os.path.isfile(HEAD):
|
||
bpy.ops.import_scene.gltf(filepath=HEAD)
|
||
coque = bpy.context.selected_objects[0]
|
||
coque.name = "Coque"
|
||
sel(coque)
|
||
t = time.time()
|
||
r = bpy.ops.slice_wrap.run()
|
||
env = bpy.context.active_object
|
||
check("tête : chaîne complète", r == {"FINISHED"} and [m.type for m in env.modifiers] == ["MULTIRES"],
|
||
f"{env.name}, base {len(env.data.polygons)} faces, {time.time() - t:.0f} s")
|
||
bpy.ops.slice_wrap.analyze()
|
||
sc.render.engine = "BLENDER_WORKBENCH"
|
||
sc.render.resolution_x = sc.render.resolution_y = 800
|
||
sc.display.shading.light = "MATCAP"
|
||
cam = bpy.data.objects.new("CAM", bpy.data.cameras.new("CAM"))
|
||
sc.collection.objects.link(cam)
|
||
sc.camera = cam
|
||
cam.data.type = "ORTHO"
|
||
for o in sc.objects:
|
||
if o.type == "MESH":
|
||
o.hide_render = o != env
|
||
for tag, loc, rot, scl in (("face", (0, -2, 0), (90, 0, 0), 0.75), ("cote", (2, 0.05, 0.08), (90, 0, 90), 0.45)):
|
||
cam.location = Vector(loc)
|
||
cam.rotation_euler = tuple(math.radians(a) for a in rot)
|
||
cam.data.ortho_scale = scl
|
||
sc.render.filepath = os.path.join(OUT, f"slice_wrap_head_{tag}.png")
|
||
bpy.ops.render.render(write_still=True)
|
||
print("IMAGE", sc.render.filepath)
|
||
|
||
mod.unregister()
|
||
print("RESULTAT :", "TOUT OK" if not fails else "ECHECS " + ", ".join(fails))
|
||
sys.exit(1 if fails else 0) # code de retour lu par « a2m validate --tests » et « a2m release »
|