#!/usr/bin/env python3 from __future__ import annotations import json import os from pathlib import Path import numpy as np import trimesh CASE_SPEC = { "case_id": "quant-cli-openscad-parametric-task-01-ubuntu", "token": "EWQSCAD01", "title": "compact controller heat sink with straight external airflow channels", "objective": ( "Maximize externally exposed geometric surface area per material volume. " "This is a geometry-only proxy, not a thermal simulation." ), "metric_kind": "external_surface_per_volume", "metric_description": ( "(single connected exterior-shell area minus the base contact area) / material volume" ), "envelope_min_mm": [0.0, 0.0, 0.0], "envelope_max_mm": [80.0, 50.0, 28.0], "min_bbox_mm": [76.0, 46.0, 24.0], "min_volume_mm3": 14500.0, "max_volume_mm3": 54000.0, "base_thickness_mm": 4.0, "min_contact_area_mm2": 3800.0, "min_contact_span_mm": [76.0, 46.0], "min_fin_thickness_mm": 1.5, "min_fin_gap_mm": 3.0, "min_fin_count": 6, "max_fin_count": 16, "min_fin_run_mm": 44.0, "min_fin_top_z_mm": 24.0, "baseline_metrics": { "bbox_mm": [80.0, 50.0, 14.64], "volume_mm3": 48107.264, "external_surface_area_mm2": 7478.688, "external_surface_per_volume": 0.15545860, }, "reference_metrics": { "bbox_mm": [80.0, 50.0, 28.0], "volume_mm3": 36644.8, "external_surface_area_mm2": 30225.6, "external_surface_per_volume": 0.82482644, }, } DESKTOP = Path(os.environ.get("ENGIWORLD_EVAL_DIR") or os.environ.get("OUTPUT_ROOT") or "/home/user/Desktop") TOL = 0.15 def clamp(value, low=0.0, high=1.0): return max(low, min(high, float(value))) def as_mesh(obj): if isinstance(obj, trimesh.Scene): meshes = [g for g in obj.geometry.values() if isinstance(g, trimesh.Trimesh)] if not meshes: raise ValueError("scene has no mesh geometry") return trimesh.util.concatenate(meshes) return obj def load_stl(path: Path): if not path.is_file() or path.stat().st_size < 500: raise ValueError("optimized.stl missing or too small") mesh = as_mesh(trimesh.load_mesh(str(path), file_type="stl", process=True)) if mesh.vertices is None or len(mesh.vertices) < 8 or len(mesh.faces) < 12: raise ValueError("optimized.stl has too little mesh geometry") return mesh def connected_shell_count(mesh): """Count edge-connected surface shells without depending on scipy.""" faces = np.asarray(mesh.faces, dtype=np.int64) parent = np.arange(len(faces), dtype=np.int64) def find(item): while parent[item] != item: parent[item] = parent[parent[item]] item = parent[item] return int(item) def union(a, b): ra, rb = find(int(a)), find(int(b)) if ra != rb: parent[rb] = ra edge_owner = {} for face_index, face in enumerate(faces): a, b, c = (int(x) for x in face) for edge in ((a, b), (b, c), (c, a)): key = tuple(sorted(edge)) if key in edge_owner: union(face_index, edge_owner[key]) else: edge_owner[key] = face_index return len({find(index) for index in range(len(faces))}) def projected_xy_area(triangles): if len(triangles) == 0: return 0.0 edge_a = triangles[:, 1, :2] - triangles[:, 0, :2] edge_b = triangles[:, 2, :2] - triangles[:, 0, :2] return float(0.5 * np.abs(edge_a[:, 0] * edge_b[:, 1] - edge_a[:, 1] * edge_b[:, 0]).sum()) def projected_area(triangles, axes): if len(triangles) == 0: return 0.0 points = triangles[:, :, axes] edge_a = points[:, 1] - points[:, 0] edge_b = points[:, 2] - points[:, 0] return float(0.5 * np.abs(edge_a[:, 0] * edge_b[:, 1] - edge_a[:, 1] * edge_b[:, 0]).sum()) def base_contact_metrics(mesh): triangles = np.asarray(mesh.triangles, dtype=float) bounds = np.asarray(mesh.bounds, dtype=float) min_z = float(bounds[0][2]) bottom_mask = np.max(np.abs(triangles[:, :, 2] - min_z), axis=1) <= TOL bottom = triangles[bottom_mask] if len(bottom) == 0: return { "base_contact_area_mm2": 0.0, "base_contact_span_mm": [0.0, 0.0], "base_x_edge_wall_area_mm2": 0.0, "base_y_edge_wall_area_mm2": 0.0, } xy = bottom[:, :, :2].reshape((-1, 2)) spans = np.max(xy, axis=0) - np.min(xy, axis=0) base_top = min_z + CASE_SPEC["base_thickness_mm"] + TOL near_base = np.max(triangles[:, :, 2], axis=1) <= base_top at_x_edge = ( (np.max(np.abs(triangles[:, :, 0] - bounds[0][0]), axis=1) <= TOL) | (np.max(np.abs(triangles[:, :, 0] - bounds[1][0]), axis=1) <= TOL) ) at_y_edge = ( (np.max(np.abs(triangles[:, :, 1] - bounds[0][1]), axis=1) <= TOL) | (np.max(np.abs(triangles[:, :, 1] - bounds[1][1]), axis=1) <= TOL) ) return { "base_contact_area_mm2": round(projected_xy_area(bottom), 4), "base_contact_span_mm": [round(float(x), 4) for x in spans], "base_x_edge_wall_area_mm2": round(projected_area(triangles[near_base & at_x_edge], [1, 2]), 4), "base_y_edge_wall_area_mm2": round(projected_area(triangles[near_base & at_y_edge], [0, 2]), 4), } def straight_fin_metrics(mesh): """Measure paired, long Y-facing sides of straight fins above the base.""" triangles = np.asarray(mesh.triangles, dtype=float) normals = np.asarray(mesh.face_normals, dtype=float) planes = {} for tri, normal in zip(triangles, normals): if abs(float(normal[0])) < 0.98 or np.ptp(tri[:, 0]) > TOL: continue y_span = float(np.ptp(tri[:, 1])) z_span = float(np.ptp(tri[:, 2])) if y_span < CASE_SPEC["min_fin_run_mm"] - TOL or z_span < 18.0: continue x = round(float(np.mean(tri[:, 0])), 3) entry = planes.setdefault(x, {"area_yz": 0.0, "y_min": 1e9, "y_max": -1e9, "z_min": 1e9, "z_max": -1e9}) edge_a = tri[1, 1:] - tri[0, 1:] edge_b = tri[2, 1:] - tri[0, 1:] entry["area_yz"] += 0.5 * abs(float(edge_a[0] * edge_b[1] - edge_a[1] * edge_b[0])) entry["y_min"] = min(entry["y_min"], float(np.min(tri[:, 1]))) entry["y_max"] = max(entry["y_max"], float(np.max(tri[:, 1]))) entry["z_min"] = min(entry["z_min"], float(np.min(tri[:, 2]))) entry["z_max"] = max(entry["z_max"], float(np.max(tri[:, 2]))) valid_planes = [] for x, data in planes.items(): if ( data["area_yz"] >= 700.0 and data["y_max"] - data["y_min"] >= CASE_SPEC["min_fin_run_mm"] - TOL and data["z_min"] <= CASE_SPEC["base_thickness_mm"] + TOL and data["z_max"] >= CASE_SPEC["min_fin_top_z_mm"] - TOL ): valid_planes.append(x) valid_planes.sort() thicknesses = [] gaps = [] if len(valid_planes) % 2 == 0: thicknesses = [valid_planes[i + 1] - valid_planes[i] for i in range(0, len(valid_planes), 2)] gaps = [valid_planes[i + 2] - valid_planes[i + 1] for i in range(0, len(valid_planes) - 2, 2)] return { "fin_count": len(thicknesses), "fin_thicknesses_mm": [round(float(x), 4) for x in thicknesses], "fin_gaps_mm": [round(float(x), 4) for x in gaps], "fin_side_plane_count": len(valid_planes), } def metrics(mesh): bounds = np.asarray(mesh.bounds, dtype=float) dims = bounds[1] - bounds[0] volume = float(mesh.volume) contact = base_contact_metrics(mesh) external_area = float(mesh.area) - contact["base_contact_area_mm2"] result = { "bounds_min_mm": [round(float(x), 4) for x in bounds[0]], "bounds_max_mm": [round(float(x), 4) for x in bounds[1]], "bbox_mm": [round(float(x), 4) for x in dims], "volume_mm3": round(volume, 4), "exterior_shell_area_mm2": round(float(mesh.area), 4), "external_surface_area_mm2": round(external_area, 4), "external_surface_per_volume": round(external_area / max(volume, 1e-9), 8), "watertight": bool(mesh.is_watertight), "winding_consistent": bool(mesh.is_winding_consistent), "connected_shell_count": connected_shell_count(mesh), } result.update(contact) result.update(straight_fin_metrics(mesh)) return result def design_summary_errors(): path = DESKTOP / "design_summary.json" if not path.is_file(): return ["design_summary:missing"] try: data = json.loads(path.read_text(encoding="utf-8")) except Exception as exc: return [f"design_summary:unreadable:{exc}"] errors = [] if data.get("case_id") != CASE_SPEC["case_id"]: errors.append("design_summary:case_id_mismatch") if data.get("token") != CASE_SPEC["token"]: errors.append("design_summary:token_mismatch") if not isinstance(data.get("design"), str) or not data["design"].strip(): errors.append("design_summary:missing_design_text") return errors def score_from_metrics(m): eff = m["external_surface_per_volume"] baseline = CASE_SPEC["baseline_metrics"]["external_surface_per_volume"] reference = CASE_SPEC["reference_metrics"]["external_surface_per_volume"] raw = (eff - baseline) / max(reference - baseline, 1e-9) volume_factor = clamp( (CASE_SPEC["max_volume_mm3"] - m["volume_mm3"]) / max(CASE_SPEC["max_volume_mm3"] - CASE_SPEC["reference_metrics"]["volume_mm3"], 1.0), 0.0, 1.10, ) height_factor = clamp(m["bbox_mm"][2] / CASE_SPEC["envelope_max_mm"][2], 0.75, 1.0) score = clamp(0.88 * raw + 0.08 * volume_factor + 0.04 * height_factor) return { "metric_kind": CASE_SPEC["metric_kind"], "metric_value": round(eff, 8), "raw_efficiency_score": round(clamp(raw), 6), "volume_factor": round(volume_factor, 6), "height_factor": round(height_factor, 6), "score": round(score, 6), } def hard_errors(m): errors = [] for axis, (got, minimum) in enumerate(zip(m["bounds_min_mm"], CASE_SPEC["envelope_min_mm"])): if got < minimum - TOL: errors.append(f"bounds_min_axis_{axis}:below_envelope:{got}<{minimum}") if abs(m["bounds_min_mm"][2] - CASE_SPEC["envelope_min_mm"][2]) > TOL: errors.append( f"base_contact_z:must_be_{CASE_SPEC['envelope_min_mm'][2]}:got_{m['bounds_min_mm'][2]}" ) for axis, (got, maximum) in enumerate(zip(m["bounds_max_mm"], CASE_SPEC["envelope_max_mm"])): if got > maximum + TOL: errors.append(f"bounds_max_axis_{axis}:too_large:{got}>{maximum}") for axis, (got, minimum) in enumerate(zip(m["bbox_mm"], CASE_SPEC["min_bbox_mm"])): if got < minimum - TOL: errors.append(f"bbox_axis_{axis}:too_small:{got}<{minimum}") if not (CASE_SPEC["min_volume_mm3"] <= m["volume_mm3"] <= CASE_SPEC["max_volume_mm3"]): errors.append(f"volume:outside_range:{m['volume_mm3']}") if not m["watertight"] or not m["winding_consistent"] or m["volume_mm3"] <= 0: errors.append("solid:must_be_watertight_positive_and_winding_consistent") if m["connected_shell_count"] != 1: errors.append(f"solid:must_have_one_connected_exterior_shell:got_{m['connected_shell_count']}") if m["base_contact_area_mm2"] < CASE_SPEC["min_contact_area_mm2"]: errors.append(f"base_contact_area:too_small:{m['base_contact_area_mm2']}") for axis, (got, minimum) in enumerate(zip(m["base_contact_span_mm"], CASE_SPEC["min_contact_span_mm"])): if got < minimum - TOL: errors.append(f"base_contact_span_axis_{axis}:too_small:{got}<{minimum}") min_x_walls = 2.0 * CASE_SPEC["min_contact_span_mm"][1] * CASE_SPEC["base_thickness_mm"] min_y_walls = 2.0 * CASE_SPEC["min_contact_span_mm"][0] * CASE_SPEC["base_thickness_mm"] if m["base_x_edge_wall_area_mm2"] < min_x_walls - 1.0: errors.append(f"base_thickness:x_edge_walls_too_small:{m['base_x_edge_wall_area_mm2']}") if m["base_y_edge_wall_area_mm2"] < min_y_walls - 1.0: errors.append(f"base_thickness:y_edge_walls_too_small:{m['base_y_edge_wall_area_mm2']}") if not (CASE_SPEC["min_fin_count"] <= m["fin_count"] <= CASE_SPEC["max_fin_count"]): errors.append(f"fin_count:outside_range:{m['fin_count']}") if any(value < CASE_SPEC["min_fin_thickness_mm"] - TOL for value in m["fin_thicknesses_mm"]): errors.append(f"fin_thickness:below_{CASE_SPEC['min_fin_thickness_mm']}_mm") if any(value < CASE_SPEC["min_fin_gap_mm"] - TOL for value in m["fin_gaps_mm"]): errors.append(f"fin_gap:below_{CASE_SPEC['min_fin_gap_mm']}_mm") if m["external_surface_area_mm2"] <= 0 or m["external_surface_per_volume"] <= 0: errors.append("external_surface_metric:non_positive") return errors def write_result(result): for name in ("score.json", "quant_metrics.json"): try: (DESKTOP / name).write_text(json.dumps(result, indent=2, sort_keys=True) + "\n", encoding="utf-8") except Exception: pass print("True" if result.get("valid") else "False") def main(): try: m = metrics(load_stl(DESKTOP / "optimized.stl")) errors = design_summary_errors() + hard_errors(m) score_bits = score_from_metrics(m) result = { "case_id": CASE_SPEC["case_id"], "valid": not errors, "score": 0.0 if errors else score_bits["score"], "errors": errors, "metrics": m | score_bits, "baseline_metrics": CASE_SPEC["baseline_metrics"], "reference_metrics": CASE_SPEC["reference_metrics"], } except Exception as exc: result = {"case_id": CASE_SPEC["case_id"], "valid": False, "score": 0.0, "errors": [str(exc)], "metrics": {}} write_result(result) if __name__ == "__main__": main()