#!/usr/bin/env python3 from __future__ import annotations import json import os import sys from pathlib import Path import numpy as np import trimesh CASE_SPEC = {'case_id': 'quant-cli-openscad-parametric-task-05-ubuntu', 'token': 'EWQSCAD05', 'title': 'low-profile ventilated battery shield', 'objective': 'Maximize surface density for a low-profile ventilated shield while penalizing unnecessary height.', 'metric_kind': 'low_profile_surface_density', 'metric_description': 'surface_area/volume with a low-height penalty; thin ventilated shields score higher than tall blocks', 'reference_design': 'thin base plate with perimeter rails and low slats', 'envelope_mm': [115.0, 75.0, 22.0], 'min_bbox_mm': [109.0, 69.0, 12.0], 'min_volume_mm3': 42000.0, 'max_volume_mm3': 76000.0, 'base_thickness_mm': 2.8, 'target_height_mm': 15.0, 'starter_block_size': [105.8, 61.5, 8.36], 'starter_block_center': [57.5, 37.5, 6.98], 'optimized_boxes': [{'name': 'front_rail', 'size': [115.0, 3.0, 12.0], 'center': [57.5, 1.5, 8.8]}, {'name': 'back_rail', 'size': [115.0, 3.0, 12.0], 'center': [57.5, 73.5, 8.8]}, {'name': 'left_rail', 'size': [3.0, 75.0, 12.0], 'center': [1.5, 37.5, 8.8]}, {'name': 'right_rail', 'size': [3.0, 75.0, 12.0], 'center': [113.5, 37.5, 8.8]}, {'name': 'vent_slat_1', 'size': [3.0, 68.0, 13.0], 'center': [15.0, 37.5, 9.3]}, {'name': 'vent_slat_2', 'size': [3.0, 68.0, 13.0], 'center': [27.142857142857142, 37.5, 9.3]}, {'name': 'vent_slat_3', 'size': [3.0, 68.0, 13.0], 'center': [39.285714285714285, 37.5, 9.3]}, {'name': 'vent_slat_4', 'size': [3.0, 68.0, 13.0], 'center': [51.42857142857143, 37.5, 9.3]}, {'name': 'vent_slat_5', 'size': [3.0, 68.0, 13.0], 'center': [63.57142857142857, 37.5, 9.3]}, {'name': 'vent_slat_6', 'size': [3.0, 68.0, 13.0], 'center': [75.71428571428571, 37.5, 9.3]}, {'name': 'vent_slat_7', 'size': [3.0, 68.0, 13.0], 'center': [87.85714285714286, 37.5, 9.3]}, {'name': 'vent_slat_8', 'size': [3.0, 68.0, 13.0], 'center': [100.0, 37.5, 9.3]}], 'hard_constraints': ['Produce the required open geometry output file rather than only reporting metrics.', 'Stay inside the stated bounding envelope and above the minimum useful spans.', 'Stay within the stated material-volume range.', 'Do not read ground_truth, edit eval.py, or fabricate score/metric files.'], 'invalid_conditions': ['Missing, unparsable, empty, or implausibly small STL geometry.', 'Bounding-box or volume hard-constraint violation.', 'Self-reported metrics without valid geometry.', 'Native project files used as the only deliverable.'], 'baseline_metrics': {'bbox_mm': [115.0, 75.0, 11.16], 'volume_mm3': 78546.012, 'surface_area_mm2': 34124.656, 'surface_per_volume': 0.43445434}, 'reference_metrics': {'bbox_mm': [115.0, 75.0, 15.8], 'volume_mm3': 58614.0, 'surface_area_mm2': 41914.0, 'surface_per_volume': 0.71508513}, 'reference_score': {'metric_kind': 'low_profile_surface_density', 'metric_value': 0.68648173, 'surface_per_volume': 0.71508513, 'raw_efficiency_score': 1.0, 'volume_factor': 1.0, 'height_factor': 0.885714, 'score': 0.995429}} CASE_SPEC.update( { "envelope_min_mm": [0.0, 0.0, 0.0], "grid_pitch_mm": 1.0, "contact_z_mm": 0.0, "vent_probe_z_mm": 10.0, "min_contact_coverage_ratio": 0.80, "min_contact_component_ratio": 0.95, "min_vent_open_ratio": 0.35, "min_slat_count": 4, "max_slat_count": 16, "min_slat_thickness_mm": 2.0, "min_slat_gap_mm": 3.0, } ) 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): 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): root_a, root_b = find(int(a)), find(int(b)) if root_a != root_b: parent[root_b] = root_a edge_owner = {} for face_index, face in enumerate(faces): a, b, c = (int(value) for value 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 vertical_hit_z(x, y, triangle): a, b, c = triangle v0 = c[:2] - a[:2] v1 = b[:2] - a[:2] v2 = np.asarray([x, y], dtype=float) - a[:2] denominator = v0[0] * v1[1] - v1[0] * v0[1] if abs(float(denominator)) < 1e-10: return None u = (v2[0] * v1[1] - v1[0] * v2[1]) / denominator v = (v0[0] * v2[1] - v2[0] * v0[1]) / denominator if u < -1e-9 or v < -1e-9 or u + v > 1.0 + 1e-9: return None return float(a[2] + u * (c[2] - a[2]) + v * (b[2] - a[2])) def point_is_solid(triangles, x, y, z): hits = [] for triangle in triangles: hit = vertical_hit_z(x, y, triangle) if hit is None or hit <= z + 1e-7: continue if all(abs(hit - previous) > 1e-6 for previous in hits): hits.append(hit) return len(hits) % 2 == 1 def raster_mask(mesh, z, planar_only=False): pitch = CASE_SPEC["grid_pitch_mm"] width, depth = CASE_SPEC["envelope_mm"][:2] xs = np.arange(0.5 * pitch, width, pitch) ys = np.arange(0.5 * pitch, depth, pitch) triangles = np.asarray(mesh.triangles, dtype=float) if planar_only: triangles = triangles[np.max(np.abs(triangles[:, :, 2] - z), axis=1) <= TOL] mask = np.zeros((len(ys), len(xs)), dtype=bool) for row, y in enumerate(ys): for column, x in enumerate(xs): if planar_only: mask[row, column] = any( (hit := vertical_hit_z(x, y, triangle)) is not None and abs(hit - z) <= TOL for triangle in triangles ) else: mask[row, column] = point_is_solid(triangles, x, y, z) return mask def component_sizes(mask): visited = np.zeros_like(mask, dtype=bool) sizes = [] rows, columns = mask.shape for row in range(rows): for column in range(columns): if not mask[row, column] or visited[row, column]: continue stack = [(row, column)] visited[row, column] = True size = 0 while stack: current_row, current_column = stack.pop() size += 1 for next_row, next_column in ( (current_row - 1, current_column), (current_row + 1, current_column), (current_row, current_column - 1), (current_row, current_column + 1), ): if ( 0 <= next_row < rows and 0 <= next_column < columns and mask[next_row, next_column] and not visited[next_row, next_column] ): visited[next_row, next_column] = True stack.append((next_row, next_column)) sizes.append(size) return sizes def line_runs(line): runs = [] start = None for index, occupied in enumerate(np.asarray(line, dtype=bool)): if occupied and start is None: start = index elif not occupied and start is not None: runs.append((start, index - 1)) start = None if start is not None: runs.append((start, len(line) - 1)) return runs def separated_feature_metrics(mask): pitch = CASE_SPEC["grid_pitch_mm"] candidates = [] for line in list(mask) + list(mask.T): runs = line_runs(line) if not runs: continue widths = [(end - start + 1) * pitch for start, end in runs] gaps = [(runs[index + 1][0] - runs[index][1] - 1) * pitch for index in range(len(runs) - 1)] candidates.append( { "count": len(runs), "min_width": min(widths), "min_gap": min(gaps, default=0.0), } ) best = max(candidates, key=lambda item: (item["count"], item["min_gap"], item["min_width"])) return best def functional_metrics(mesh): contact = raster_mask(mesh, CASE_SPEC["contact_z_mm"], planar_only=True) probe = raster_mask(mesh, CASE_SPEC["vent_probe_z_mm"]) contact_sizes = component_sizes(contact) features = separated_feature_metrics(probe) return { "contact_coverage_ratio": round(float(contact.mean()), 6), "largest_contact_component_ratio": round( max(contact_sizes, default=0) / max(int(contact.sum()), 1), 6 ), "vent_probe_z_mm": CASE_SPEC["vent_probe_z_mm"], "vent_slat_run_count": features["count"], "min_vent_slat_width_mm": round(features["min_width"], 4), "min_vent_clear_gap_mm": round(features["min_gap"], 4), "vent_probe_open_ratio": round(1.0 - float(probe.mean()), 6), } def metrics(mesh): bounds = np.asarray(mesh.bounds, dtype=float) dims = (bounds[1] - bounds[0]).tolist() volume = float(mesh.volume) area = float(mesh.area) 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), "surface_area_mm2": round(area, 4), "surface_per_volume": round(area / max(volume, 1e-9), 8), "watertight": bool(mesh.is_watertight), "winding_consistent": bool(mesh.is_winding_consistent), "is_volume": bool(mesh.is_volume), "connected_shell_count": connected_shell_count(mesh), } result.update(functional_metrics(mesh)) return result def metric_value(m): dims = m["bbox_mm"] vol = max(m["volume_mm3"], 1e-9) surface = m["surface_area_mm2"] kind = CASE_SPEC["metric_kind"] if kind == "surface_per_volume": return surface / vol if kind == "footprint_per_volume": return (dims[0] * dims[1]) / vol if kind == "span_height_per_volume": return (dims[0] * dims[2]) / vol if kind == "clearance_surface_mix": return 0.72 * (surface / vol) + 0.28 * ((dims[1] * dims[2]) / vol) if kind == "low_profile_surface_density": return (surface / vol) * clamp(1.0 - 0.35 * max(0.0, dims[2] - CASE_SPEC["target_height_mm"]) / max(CASE_SPEC["envelope_mm"][2] - CASE_SPEC["target_height_mm"], 1.0), 0.65, 1.05) raise ValueError("unknown metric_kind: " + str(kind)) 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 = metric_value(m) baseline = metric_value(CASE_SPEC["baseline_metrics"]) reference = metric_value(CASE_SPEC["reference_metrics"]) raw = (eff - baseline) / max(reference - baseline, 1e-9) vol = m["volume_mm3"] volume_factor = clamp((CASE_SPEC["max_volume_mm3"] - vol) / max(CASE_SPEC["max_volume_mm3"] - CASE_SPEC["reference_metrics"]["volume_mm3"], 1.0), 0.0, 1.10) height_factor = clamp( (CASE_SPEC["envelope_mm"][2] - m["bbox_mm"][2]) / max(CASE_SPEC["envelope_mm"][2] - CASE_SPEC["target_height_mm"], 1.0), 0.0, 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), "surface_per_volume": round(m["surface_area_mm2"] / max(m["volume_mm3"], 1e-9), 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 = [] dims = m["bbox_mm"] 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}") for axis, (got, maximum) in enumerate(zip(m["bounds_max_mm"], CASE_SPEC["envelope_mm"])): if got > maximum + TOL: errors.append(f"bounds_max_axis_{axis}:above_envelope:{got}>{maximum}") for i, (got, max_allowed) in enumerate(zip(dims, CASE_SPEC["envelope_mm"])): if got > max_allowed + TOL: errors.append(f"bbox_axis_{i}:too_large:{got}>{max_allowed}") for i, (got, min_allowed) in enumerate(zip(dims, CASE_SPEC["min_bbox_mm"])): if got < min_allowed - TOL: errors.append(f"bbox_axis_{i}:too_small:{got}<{min_allowed}") 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 not m["is_volume"]: errors.append("solid:must_be_watertight_positive_and_winding_consistent") if m["connected_shell_count"] != 1: errors.append(f"solid:must_have_one_edge_connected_shell:got_{m['connected_shell_count']}") if m["contact_coverage_ratio"] < CASE_SPEC["min_contact_coverage_ratio"]: errors.append(f"base_contact:coverage_too_low:{m['contact_coverage_ratio']}") if m["largest_contact_component_ratio"] < CASE_SPEC["min_contact_component_ratio"]: errors.append(f"base_contact:largest_component_too_small:{m['largest_contact_component_ratio']}") if not (CASE_SPEC["min_slat_count"] <= m["vent_slat_run_count"] <= CASE_SPEC["max_slat_count"]): errors.append(f"ventilation:slat_count_outside_range:{m['vent_slat_run_count']}") if m["min_vent_slat_width_mm"] < CASE_SPEC["min_slat_thickness_mm"]: errors.append(f"ventilation:slat_thickness_too_small:{m['min_vent_slat_width_mm']}") if m["min_vent_clear_gap_mm"] < CASE_SPEC["min_slat_gap_mm"]: errors.append(f"ventilation:clear_gap_too_small:{m['min_vent_clear_gap_mm']}") if m["vent_probe_open_ratio"] < CASE_SPEC["min_vent_open_ratio"]: errors.append(f"ventilation:open_ratio_too_low:{m['vent_probe_open_ratio']}") if m["surface_area_mm2"] <= 0 or m["surface_per_volume"] <= 0: errors.append("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(): errors = [] try: m = metrics(load_stl(DESKTOP / "optimized.stl")) errors.extend(design_summary_errors()) errors.extend(hard_errors(m)) score_bits = score_from_metrics(m) score = 0.0 if errors else score_bits["score"] result = { "case_id": CASE_SPEC["case_id"], "valid": not errors, "score": round(score, 6), "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()