""" 侧壁/倒扣面滑块机构检测与设计模块 功能： 1. 倒扣区域检测 - 识别无法直接脱模的侧壁凹槽 2. 滑块机构设计 - 侧向分型抽芯机构 3. 斜顶机构设计 - 内侧倒扣的斜顶脱模机构 4. 机构运动学分析 - 抽芯行程、脱模角度计算 倒扣检测原理： - 分型方向确定后，检查每个面的法向量 - 如果面的法向量与脱模方向的点积为负（面朝向脱模反方向） 且该面不在分型面上，则判定为倒扣面 - 根据倒扣面的位置（外侧/内侧）选择滑块或斜顶 滑块 vs 斜顶： - 滑块：外侧倒扣，沿导滑槽侧向运动 - 斜顶：内侧倒扣，沿斜导柱内侧运动 """ from typing import Dict, List, Any, Optional, Tuple import math import numpy as np from OCC.Core.TopoDS import TopoDS_Shape, TopoDS_Face from shared.utils.logger import get_logger logger = get_logger(__name__) class UndercutDetector: """倒扣区域检测器""" def detect_undercuts(self, shape: TopoDS_Shape, parting_direction: List[float], parting_surface: Optional[TopoDS_Face] = None) -> Dict[str, Any]: """ 检测产品中的倒扣区域 Args: shape: OCC 产品形状 parting_direction: 分型方向 [nx, ny, nz] parting_surface: 分型面（可选） Returns: { "undercut_faces": List[Dict], "slider_regions": List[Dict], "lifter_regions": List[Dict], "total_undercut_area": float, "requires_slider": bool, "requires_lifter": bool, "complexity": str } """ try: from OCC.Core.TopExp import TopExp_Explorer from OCC.Core.TopAbs import TopAbs_FACE from OCC.Core.TopoDS import TopoDS_Face, topods from OCC.Core.BRepAdaptor import BRepAdaptor_Surface from OCC.Core.GProp import GProp_GProps from OCC.Core.BRepGProp import brepgprop from OCC.Core.Bnd import Bnd_Box from OCC.Core.BRepBndLib import brepbndlib from OCC.Core.gp import gp_Dir dir_vec = np.array(parting_direction, dtype=np.float64) dir_norm = np.linalg.norm(dir_vec) if dir_norm < 1e-6: dir_vec = np.array([0, 0, 1]) else: dir_vec /= dir_norm parting_dir = gp_Dir(dir_vec[0], dir_vec[1], dir_vec[2]) undercut_faces = [] slider_regions = [] lifter_regions = [] total_undercut_area = 0.0 parting_z = 0.0 if parting_surface is not None: try: surface = BRepAdaptor_Surface(parting_surface) if surface.GetType() == 0: parting_z = surface.Plane().Location().Z() except Exception: pass explorer = TopExp_Explorer(shape, TopAbs_FACE) face_idx = 0 while explorer.More(): face = topods.Face(explorer.Current()) face_idx += 1 try: surface = BRepAdaptor_Surface(face) u = (surface.FirstUParameter() + surface.LastUParameter()) / 2 v = (surface.FirstVParameter() + surface.LastVParameter()) / 2 face_normal = None if surface.GetType() == 0: face_normal = surface.Plane().Position().Direction() else: from OCC.Core.BRepLProp import BRepLProp_SLProps props = BRepLProp_SLProps(surface, 1, 0.001) props.SetParameters(u, v) if props.IsNormalDefined(): face_normal = props.Normal() if face_normal is None: explorer.Next() continue dot = face_normal.Dot(parting_dir) face_props = GProp_GProps() brepgprop.SurfaceProperties(face, face_props) area = face_props.Mass() center = face_props.CentreOfMass() bbox = Bnd_Box() brepbndlib.Add(face, bbox) try: fxmin, fymin, fzmin, fxmax, fymax, fzmax = bbox.Get() except Exception: fxmin, fymin, fzmin, fxmax, fymax, fzmax = 0, 0, 0, 0, 0, 0 if dot < -0.1: face_center_z = center.Z() is_outer = face_center_z >= parting_z undercut_info = { "face_index": face_idx, "normal": [face_normal.X(), face_normal.Y(), face_normal.Z()], "dot_product": float(dot), "area": float(area), "center": [float(center.X()), float(center.Y()), float(center.Z())], "bbox": { "min": [float(fxmin), float(fymin), float(fzmin)], "max": [float(fxmax), float(fymax), float(fzmax)] }, "severity": "high" if dot < -0.5 else "medium", "is_outer": is_outer, } undercut_faces.append(undercut_info) total_undercut_area += area except Exception: pass explorer.Next() for uf in undercut_faces: normal = np.array(uf["normal"]) lateral_component = normal - np.dot(normal, dir_vec) * dir_vec lateral_norm = np.linalg.norm(lateral_component) if lateral_norm > 0.01: slide_direction = lateral_component / lateral_norm else: slide_direction = np.array([1, 0, 0]) mechanism = { "face_indices": [uf["face_index"]], "slide_direction": slide_direction.tolist(), "area": uf["area"], "center": uf["center"], "severity": uf["severity"], } if uf["is_outer"]: slider_regions.append(mechanism) else: lifter_regions.append(mechanism) requires_slider = len(slider_regions) > 0 requires_lifter = len(lifter_regions) > 0 total_count = len(slider_regions) + len(lifter_regions) if total_count == 0: complexity = "simple" elif total_count <= 2: complexity = "moderate" elif total_count <= 4: complexity = "complex" else: complexity = "very_complex" result = { "undercut_faces": undercut_faces, "slider_regions": slider_regions, "lifter_regions": lifter_regions, "total_undercut_area": total_undercut_area, "requires_slider": requires_slider, "requires_lifter": requires_lifter, "complexity": complexity, "parting_direction": parting_direction, } logger.info(f"倒扣检测完成: {len(undercut_faces)} 个倒扣面, " f"{len(slider_regions)} 个滑块, {len(lifter_regions)} 个斜顶, " f"复杂度={complexity}") return result except Exception as e: logger.error(f"倒扣检测失败: {e}") return { "undercut_faces": [], "slider_regions": [], "lifter_regions": [], "total_undercut_area": 0, "requires_slider": False, "requires_lifter": False, "complexity": "unknown", "parting_direction": parting_direction, } class SliderMechanismDesigner: """滑块机构设计器""" def design_slider(self, slider_region: Dict, mold_size: Dict, parting_direction: List[float]) -> Dict[str, Any]: """ 设计滑块机构 Args: slider_region: 倒扣区域信息 mold_size: 模具尺寸 parting_direction: 分型方向 Returns: 滑块机构设计方案 """ center = slider_region["center"] area = slider_region["area"] slide_dir = slider_region["slide_direction"] slide_stroke = self._calculate_slide_stroke(slider_region, mold_size) slide_angle = self._calculate_slide_angle(slide_dir, parting_direction) slide_block_size = self._calculate_slide_block_size(area, slide_stroke) guide_type = self._select_guide_type(slide_stroke, slide_angle) return { "type": "slider", "location": center, "slide_direction": slide_dir, "slide_stroke": slide_stroke, "slide_angle": slide_angle, "block_size": slide_block_size, "guide_type": guide_type, "locking_mechanism": self._select_locking(slide_angle), "actuation": "pneumatic" if slide_stroke > 50 else "mechanical", "components": self._generate_components(slide_block_size, guide_type), "manufacturing_notes": self._generate_slider_notes(slide_angle, slide_stroke), } def _calculate_slide_stroke(self, region: Dict, mold_size: Dict) -> float: """计算抽芯行程""" bbox = region.get("bbox", {}) if "max" in bbox and "min" in bbox: max_dim = max( abs(bbox["max"][0] - bbox["min"][0]), abs(bbox["max"][1] - bbox["min"][1]), abs(bbox["max"][2] - bbox["min"][2]) ) else: max_dim = 10.0 stroke = max_dim + 5.0 return round(max(stroke, 10.0), 1) def _calculate_slide_angle(self, slide_dir: List[float], parting_dir: List[float]) -> float: """计算滑块倾斜角度""" s = np.array(slide_dir) p = np.array(parting_dir) s_norm = np.linalg.norm(s) p_norm = np.linalg.norm(p) if s_norm < 1e-6 or p_norm < 1e-6: return 90.0 cos_angle = np.clip(np.dot(s, p) / (s_norm * p_norm), -1, 1) angle = math.degrees(math.acos(abs(cos_angle))) return round(angle, 1) def _calculate_slide_block_size(self, area: float, stroke: float) -> Dict[str, float]: """计算滑块尺寸""" width = max(math.sqrt(area) * 1.5, 15.0) height = max(math.sqrt(area) * 1.2, 12.0) length = stroke + width * 0.5 return { "width": round(width, 1), "height": round(height, 1), "length": round(length, 1), } def _select_guide_type(self, stroke: float, angle: float) -> str: """选择导滑方式""" if stroke > 80: return "T_slot_guide" elif angle > 20: return "angled_guide_pin" else: return "dovetail_guide" def _select_locking(self, angle: float) -> str: """选择锁紧方式""" if angle > 25: return "wedge_block" else: return "lock_block" def _generate_components(self, block_size: Dict, guide_type: str) -> List[Dict]: """生成滑块组件清单""" components = [ {"name": "slide_block", "material": "P20", "hardness": "HRC 28-32"}, {"name": "guide_strip", "material": "bronze", "hardness": "HB 80-100"}, {"name": "wear_plate", "material": "T8", "hardness": "HRC 45-50"}, {"name": "return_spring", "material": "spring_steel", "spec": "standard"}, ] if guide_type == "T_slot_guide": components.append({"name": "T_slot_insert", "material": "P20", "hardness": "HRC 28-32"}) elif guide_type == "angled_guide_pin": components.append({"name": "guide_pin", "material": "SUJ2", "hardness": "HRC 58-62"}) elif guide_type == "dovetail_guide": components.append({"name": "dovetail_block", "material": "P20", "hardness": "HRC 28-32"}) return components def _generate_slider_notes(self, angle: float, stroke: float) -> List[str]: """生成滑块加工注意事项""" notes = [] if angle > 25: notes.append("滑块角度较大，需确保锁紧可靠") if stroke > 50: notes.append("抽芯行程较长，建议使用气动抽芯") if stroke > 80: notes.append("大行程抽芯，需校核导滑槽强度") notes.append("滑块需设置限位装置，防止脱出") notes.append("配合面需做耐磨处理") return notes class LifterMechanismDesigner: """斜顶机构设计器""" def design_lifter(self, lifter_region: Dict, mold_size: Dict, parting_direction: List[float]) -> Dict[str, Any]: """ 设计斜顶机构 Args: lifter_region: 内侧倒扣区域信息 mold_size: 模具尺寸 parting_direction: 分型方向 Returns: 斜顶机构设计方案 """ center = lifter_region["center"] area = lifter_region["area"] lifter_angle = self._calculate_lifter_angle(lifter_region) lifter_stroke = self._calculate_lifter_stroke(lifter_region) lifter_size = self._calculate_lifter_size(area, lifter_stroke, lifter_angle) return { "type": "lifter", "location": center, "lifter_angle": lifter_angle, "lifter_stroke": lifter_stroke, "block_size": lifter_size, "guide_type": "angled_hole", "return_mechanism": "spring_return", "components": self._generate_lifter_components(lifter_size), "manufacturing_notes": self._generate_lifter_notes(lifter_angle), } def _calculate_lifter_angle(self, region: Dict) -> float: """基于倒扣深度和估算顶出行程计算斜顶角度（通常 5-15 度）。 angle = atan(undercut_depth / estimated_stroke) """ bbox = region.get("bbox", {}) if "max" in bbox and "min" in bbox: lateral = max( abs(bbox["max"][0] - bbox["min"][0]), abs(bbox["max"][1] - bbox["min"][1]), abs(bbox["max"][2] - bbox["min"][2]), ) else: lateral = 5.0 undercut_depth = lateral * 0.4 estimated_stroke = max(undercut_depth * 3, 20.0) angle = math.degrees(math.atan(undercut_depth / estimated_stroke)) return round(max(min(angle, 15.0), 5.0), 1) def _calculate_lifter_stroke(self, region: Dict) -> float: """计算斜顶行程""" bbox = region.get("bbox", {}) if "max" in bbox and "min" in bbox: max_dim = max( abs(bbox["max"][i] - bbox["min"][i]) for i in range(3) ) else: max_dim = 5.0 return round(max(max_dim + 3.0, 8.0), 1) def _calculate_lifter_size(self, area: float, stroke: float, angle: float) -> Dict[str, float]: """计算斜顶尺寸""" width = max(math.sqrt(area) * 1.2, 10.0) height = stroke / math.sin(math.radians(angle)) if angle > 0 else stroke * 3 thickness = max(width * 0.6, 8.0) return { "width": round(width, 1), "height": round(height, 1), "thickness": round(thickness, 1), } def _generate_lifter_components(self, size: Dict) -> List[Dict]: """生成斜顶组件清单""" return [ {"name": "lifter_body", "material": "P20", "hardness": "HRC 28-32"}, {"name": "guide_pin", "material": "SUJ2", "hardness": "HRC 58-62"}, {"name": "return_spring", "material": "spring_steel", "spec": "standard"}, {"name": "wear_bushing", "material": "bronze", "hardness": "HB 80-100"}, ] def _generate_lifter_notes(self, angle: float) -> List[str]: """生成斜顶加工注意事项""" notes = [] if angle > 12: notes.append("斜顶角度偏大，需校核脱模力") notes.append("斜顶导滑孔需精确加工") notes.append("斜顶头部需做耐磨处理") notes.append("需设置限位防止斜顶脱出") return notes class SideActionDesigner: """侧向分型机构综合设计器""" def __init__(self): self.undercut_detector = UndercutDetector() self.slider_designer = SliderMechanismDesigner() self.lifter_designer = LifterMechanismDesigner() def analyze_and_design(self, shape: TopoDS_Shape, parting_direction: List[float], mold_size: Dict, parting_surface: Optional[TopoDS_Face] = None) -> Dict[str, Any]: """ 综合分析倒扣并设计侧向分型机构 Returns: { "undercut_analysis": Dict, "slider_mechanisms": List[Dict], "lifter_mechanisms": List[Dict], "summary": Dict, "recommendations": List[str] } """ logger.info("开始侧向分型机构分析...") undercut_result = self.undercut_detector.detect_undercuts( shape, parting_direction, parting_surface ) slider_mechanisms = [] for region in undercut_result["slider_regions"]: slider = self.slider_designer.design_slider( region, mold_size, parting_direction ) slider_mechanisms.append(slider) lifter_mechanisms = [] for region in undercut_result["lifter_regions"]: lifter = self.lifter_designer.design_lifter( region, mold_size, parting_direction ) lifter_mechanisms.append(lifter) total_mechanisms = len(slider_mechanisms) + len(lifter_mechanisms) summary = { "total_undercut_faces": len(undercut_result["undercut_faces"]), "total_slider_count": len(slider_mechanisms), "total_lifter_count": len(lifter_mechanisms), "total_mechanism_count": total_mechanisms, "complexity": undercut_result["complexity"], } recommendations = self._generate_overall_recommendations(summary, undercut_result) result = { "undercut_analysis": undercut_result, "slider_mechanisms": slider_mechanisms, "lifter_mechanisms": lifter_mechanisms, "summary": summary, "recommendations": recommendations, } logger.info(f"侧向分型机构设计完成: {len(slider_mechanisms)} 个滑块, " f"{len(lifter_mechanisms)} 个斜顶") return result def _generate_overall_recommendations(self, summary: Dict, undercut: Dict) -> List[str]: """生成总体建议""" recs = [] if summary["total_mechanism_count"] == 0: recs.append("无倒扣区域，模具结构简单，无需侧向分型机构") return recs if summary["total_slider_count"] > 0: recs.append(f"需要 {summary['total_slider_count']} 个滑块机构处理外侧倒扣") if summary["total_lifter_count"] > 0: recs.append(f"需要 {summary['total_lifter_count']} 个斜顶机构处理内侧倒扣") if summary["total_slider_count"] > 0: recs.append("如存在大行程滑块，建议优先评估气动抽芯回路并预留稳定供气") if summary["complexity"] == "very_complex": recs.append("侧向分型机构复杂，建议评估是否可通过产品修改简化") recs.append("考虑使用二次分型或旋转脱模替代方案") if summary["total_mechanism_count"] > 3: recs.append("侧向机构较多，建议优化模具结构减少机构数量") recs.append("所有侧向机构需做运动仿真验证干涉") return recs