from typing import Dict, Any, List, Optional from OCC.Core.BRepBuilderAPI import BRepBuilderAPI_MakeFace from OCC.Core.BRepGProp import brepgprop from OCC.Core.GProp import GProp_GProps from OCC.Core.gp import gp_Dir, gp_Pln, gp_Pnt from OCC.Core.TopAbs import TopAbs_FACE from OCC.Core.TopExp import TopExp_Explorer from OCC.Core.TopoDS import TopoDS_Face, topods from core.mold_generator import MoldCavityGenerator from core.aluminum_foam_mold import AluminumFoamMoldGenerator from core.parting_candidate_generator import PartingCandidateGenerator from core.parting_scheme_scorer import PartingSchemeScorer from utils.logger import get_logger logger = get_logger(__name__) class MultiSchemeMoldPlanner: """针对单个产品生成最多三套候选分模方案并排序。""" def __init__(self): self.candidate_generator = PartingCandidateGenerator() self.scheme_scorer = PartingSchemeScorer() self.mold_generator = MoldCavityGenerator(shrinkage_rate=0.005) self.aluminum_foam_generator = AluminumFoamMoldGenerator( shrinkage_rate=0.015, draft_angle=3.0, ) def generate_plan( self, shape: Any, material: Dict[str, Any], is_foam_material: bool = False, max_schemes: int = 3, process_params: Optional[Dict[str, Any]] = None, ) -> Dict[str, Any]: generator = self.aluminum_foam_generator if is_foam_material else self.mold_generator generator.set_material(material["name"]) self._apply_process_params(generator, material, process_params) analysis = generator._analyze_product_geometry(shape) analysis["axis_normal_stats"] = self._collect_axis_normal_stats(generator, shape) candidates = self.candidate_generator.generate_candidates( analysis=analysis, is_foam_material=is_foam_material, max_candidates=max_schemes, ) schemes = [] for candidate in candidates: for offset_variant in self._build_offset_variants(candidate, is_foam_material): try: scheme = self._build_scheme( generator=generator, shape=shape, analysis=analysis, candidate=offset_variant, is_foam_material=is_foam_material, ) if scheme is not None: schemes.append(scheme) except Exception as exc: logger.warning(f"候选方案 {offset_variant.get('scheme_id')} 生成失败: {exc}") if not schemes: raise ValueError("未能生成任何可用分模方案") scored_schemes = self.scheme_scorer.score_schemes(schemes)[:max_schemes] export_shapes = {} for idx, scheme in enumerate(scored_schemes, start=1): scheme["raw_scheme_id"] = scheme.get("scheme_id") scheme["scheme_id"] = f"scheme_{idx}" if scheme.get("cavity_data", {}).get("metadata") is not None: scheme["cavity_data"]["metadata"]["scheme_id"] = scheme["scheme_id"] scheme["cavity_data"]["metadata"]["process_parameters"] = dict(process_params or {}) export_shapes[scheme["scheme_id"]] = scheme.pop("_export_shapes", {}) best_scheme = scored_schemes[0] return { "best_scheme_id": best_scheme["scheme_id"], "candidate_schemes": scored_schemes, "_export_shapes": export_shapes, "global_summary": { "scheme_count": len(scored_schemes), "recommended_reason": best_scheme.get("summary", ""), }, } def _build_scheme( self, generator: Any, shape: Any, analysis: Dict[str, Any], candidate: Dict[str, Any], is_foam_material: bool, ) -> Optional[Dict[str, Any]]: parting_surface = self._build_parting_surface( generator, analysis, candidate["direction"], shape, candidate.get("offset_ratio", 0.0), candidate.get("opening_span_mm"), ) parting_line = generator.optimize_parting_line( generator._calculate_parting_line(shape, parting_surface) ) parting_direction = candidate["direction"] side_action_result = generator.side_action_designer.analyze_and_design( shape=shape, parting_direction=parting_direction, mold_size=generator._calculate_mold_size(analysis), parting_surface=parting_surface, ) undercut_regions = generator._build_undercut_regions( side_action_result.get("undercut_analysis", {}) ) mold_structure = self._determine_mold_structure(analysis, undercut_regions) scaled_shape = generator._apply_shrinkage_compensation(shape) drafted_shape = generator._apply_draft_angles(scaled_shape, parting_surface) cavity, core = generator._split_cavity_core(drafted_shape, parting_surface) cavity_result = { "cavity": cavity, "core": core, "parting_surface": parting_surface, "parting_line": parting_line, "analysis": analysis, "undercut_regions": undercut_regions, "side_actions": side_action_result, } if is_foam_material: cavity_result["mold_block"] = generator._generate_mold_block(cavity, analysis) cavity_result["parting_surfaces"] = { "primary_surface": parting_surface, "primary_line": parting_line, "primary_direction": parting_direction, "method": candidate["method"], "offset_ratio": candidate.get("offset_ratio", 0.0), } cavity_result["material"] = generator.foam_material cavity_result["shrinkage_applied"] = generator.shrinkage_rate cavity_result["draft_angle_applied"] = generator.draft_angle cavity_data = generator.generate_detailed_cavity_json(cavity_result) key_info = generator.generate_cavity_key_info(cavity_result) cavity_data.setdefault("metadata", {}) cavity_data["metadata"]["scheme_id"] = candidate["scheme_id"] cavity_data["metadata"]["scheme_method"] = candidate["method"] cavity_data["metadata"]["scheme_axis"] = candidate["axis"] cavity_data["metadata"]["scheme_reason"] = candidate["reason"] cavity_data["metadata"]["scheme_offset_ratio"] = candidate.get("offset_ratio", 0.0) cavity_data["metadata"]["scheme_offset_label"] = candidate.get("offset_label", "中面") cavity_data["metadata"]["mold_structure_type"] = mold_structure["mold_structure_type"] cavity_data["metadata"]["core_required"] = mold_structure["core_required"] cavity_data["metadata"]["structure_decision_reason"] = mold_structure["decision_reason"] return { "scheme_id": candidate["scheme_id"], "method": candidate["method"], "axis": candidate["axis"], "title": candidate["title"], "reason": candidate["reason"], "priority_score": candidate.get("priority_score"), "normal_alignment_score": candidate.get("normal_alignment_score"), "offset_ratio": candidate.get("offset_ratio", 0.0), "offset_label": candidate.get("offset_label", "中面"), "mold_structure_type": mold_structure["mold_structure_type"], "core_required": mold_structure["core_required"], "decision_reason": mold_structure["decision_reason"], "parting": { "axis": candidate["axis"], "direction": parting_direction, "line": parting_line, "surface": cavity_data.get("parting_surface", {}), }, "undercut_regions": undercut_regions, "side_actions": side_action_result, "cavity_data": cavity_data, "key_info": key_info, "_export_shapes": { "cavity": cavity, "core": core, "parting_surface": parting_surface, }, } @staticmethod def _apply_process_params(generator: Any, material: Dict[str, Any], process_params: Optional[Dict[str, Any]]): params = process_params or {} draft_angle = float(params.get("draft_angle", getattr(generator, "draft_angle", 2.0))) shrinkage_rate = float(params.get("shrinkage_rate", material.get("shrinkage", 0.005) * 100.0)) / 100.0 parting_precision = float(params.get("parting_precision", getattr(generator, "parting_line_tolerance", 0.1))) cavity_match = float(params.get("cavity_match", getattr(generator, "cavity_match_rate", 95.0))) generator.draft_angle = draft_angle generator.shrinkage_rate = shrinkage_rate generator.parting_line_tolerance = parting_precision generator.cavity_match_rate = cavity_match def _build_parting_surface( self, generator: Any, analysis: Dict[str, Any], direction_vector: List[float], shape: Any, offset_ratio: float = 0.0, opening_span_mm: Optional[float] = None, ) -> Any: center = analysis.get("bounding_box", {}).get("center", [0, 0, 0]) dims = analysis.get("bounding_box", {}).get("dimensions", [100, 100, 100]) span = max(dims) * 1.5 + 30 opening_span = opening_span_mm or max(dims) offset_distance = float(opening_span) * float(offset_ratio) origin = [ center[0] + direction_vector[0] * offset_distance, center[1] + direction_vector[1] * offset_distance, center[2] + direction_vector[2] * offset_distance, ] plane = gp_Pln( gp_Pnt(origin[0], origin[1], origin[2]), gp_Dir(direction_vector[0], direction_vector[1], direction_vector[2]), ) parting_surface = BRepBuilderAPI_MakeFace( plane, -span, span, -span, span, ).Face() return generator.extend_parting_surface(parting_surface, shape, extension=30.0) def _build_offset_variants( self, candidate: Dict[str, Any], is_foam_material: bool, ) -> List[Dict[str, Any]]: opening_span = float(candidate.get("opening_span_mm", 0.0)) if opening_span <= 0: return [dict(candidate)] ratios = [0.0, -0.12, 0.12] if is_foam_material and candidate.get("axis") == "Z": ratios = [0.0, -0.08, 0.08] variants = [] for ratio in ratios: variant = dict(candidate) label = "中面" id_label = "center" if ratio < 0: label = "偏下" if candidate.get("axis") == "Z" else "负向偏移" id_label = "neg" elif ratio > 0: label = "偏上" if candidate.get("axis") == "Z" else "正向偏移" id_label = "pos" variant["scheme_id"] = f"{candidate.get('axis', 'A').lower()}_{id_label}_{abs(ratio):.2f}" variant["offset_ratio"] = ratio variant["offset_label"] = label variant["reason"] = f"{candidate.get('reason', '')}，分型面位置: {label}" variants.append(variant) return variants def _collect_axis_normal_stats(self, generator: Any, shape: Any) -> Dict[str, float]: """按坐标轴统计面法向分布强度，用于候选方向排序。""" stats = {"X": 0.0, "Y": 0.0, "Z": 0.0} explorer = TopExp_Explorer(shape, TopAbs_FACE) while explorer.More(): face = topods.Face(explorer.Current()) explorer.Next() try: normal = generator._get_face_normal(face) if normal is None: continue props = GProp_GProps() brepgprop.SurfaceProperties(face, props) area = max(float(props.Mass()), 1.0) stats["X"] += abs(float(normal.X())) * area stats["Y"] += abs(float(normal.Y())) * area stats["Z"] += abs(float(normal.Z())) * area except Exception as exc: logger.debug(f"统计面法向失败: {exc}") total = stats["X"] + stats["Y"] + stats["Z"] if total <= 0: return {"X": 33.3, "Y": 33.3, "Z": 33.4} return { axis: round(value / total * 100, 2) for axis, value in stats.items() } @staticmethod def _determine_mold_structure(analysis: Dict[str, Any], undercut_regions: List[Dict[str, Any]]) -> Dict[str, Any]: """ 判定是否需要独立模芯。 规则为工程启发式： - 实心度高 + 平均厚度占比高 + 无明显倒扣：倾向两板半腔（无独立凸芯） - 否则：采用型腔+模芯结构 """ dims = analysis.get("bounding_box", {}).get("dimensions", [0.0, 0.0, 0.0]) valid_dims = [float(d) for d in dims if float(d) > 1e-6] min_dim = min(valid_dims) if valid_dims else 1.0 bbox_volume = 1.0 for dim in valid_dims[:3]: bbox_volume *= dim if bbox_volume <= 0: bbox_volume = 1.0 volume = float(analysis.get("volume", 0.0)) surface_area = float(analysis.get("surface_area", 0.0)) solid_ratio = max(0.0, min(volume / bbox_volume, 1.0)) avg_wall = (2.0 * volume / surface_area) if surface_area > 1e-6 else min_dim wall_ratio = max(0.0, min(avg_wall / max(min_dim, 1e-6), 1.0)) undercut_count = len(undercut_regions or []) core_required = not (solid_ratio > 0.62 and wall_ratio > 0.38 and undercut_count == 0) mold_structure_type = "cavity_core" if core_required else "two_half_cavity" decision_reason = ( f"solid_ratio={solid_ratio:.2f}, wall_ratio={wall_ratio:.2f}, " f"undercut_count={undercut_count}" ) return { "core_required": core_required, "mold_structure_type": mold_structure_type, "decision_reason": decision_reason, }