#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ SUW Core - Machining Manager Module 拆分自: suw_impl.py (Line 2292-3500, 4790-4990) 用途: Blender加工管理、几何体创建、布尔运算 版本: 1.0.0 作者: SUWood Team """ from .material_manager import material_manager from .memory_manager import memory_manager from .data_manager import data_manager, get_data_manager import time import logging import threading from typing import Dict, Any, List, Optional import math # 设置日志 logger = logging.getLogger(__name__) # 检查Blender可用性 try: import bpy import bmesh BLENDER_AVAILABLE = True except ImportError: BLENDER_AVAILABLE = False # 导入依赖模块 # ==================== 加工管理器类 ==================== class MachiningManager: """加工管理器 - 负责所有加工相关操作""" def __init__(self): """ 初始化加工管理器 - 完全独立，不依赖suw_impl """ # 使用全局数据管理器 self.data_manager = get_data_manager() # 【新增】添加材质管理器引用 from .material_manager import get_material_manager self.material_manager = get_material_manager() # 加工数据存储 self.machinings = {} # 加工统计 self.machining_stats = { "machinings_created": 0, "trim_operations": 0, "creation_errors": 0 } logger.info("✅ 加工管理器初始化完成") # ==================== 原始命令方法 ==================== def c05(self, data: Dict[str, Any]): """c05 - 添加加工 - 参考SUW IMPL实现，按板件分组批量创建""" try: logger.info("🔧 执行c05命令: 创建加工") if not BLENDER_AVAILABLE: logger.warning("Blender 不可用，跳过加工创建") return 0 uid = data.get("uid") items = data.get("items", []) logger.info(f"开始创建加工: uid={uid}, 项目数={len(items)}") # 【参考SUW IMPL】获取部件和硬件集合 parts = self._get_parts(data) hardwares = self._get_hardwares(data) # 【参考SUW IMPL】分类处理：可视化加工 vs 布尔运算 visual_works = [] boolean_works = [] for i, work in enumerate(items): # 【修复】不再跳过cancel=1的项目，所有项目都要创建 cp = work.get("cp") if not cp: continue # 【参考SUW IMPL】获取组件 component = None if cp in parts: component = parts[cp] elif cp in hardwares: component = hardwares[cp] if not component or not self._is_object_valid(component): logger.info(f"🚨 组件查找失败: cp={cp}, component={component}") continue work['component'] = component work['index'] = i if work.get("trim3d", 0) == 1: boolean_works.append(work) else: visual_works.append(work) created_count = 0 # 【参考SUW IMPL】1. 批量处理可视化加工 if visual_works: created_count += self._create_visual_machining_batch_suw_style( visual_works, uid) # 【参考SUW IMPL】2. 批量处理布尔运算 if boolean_works: created_count += self._create_boolean_machining_batch_suw_style( boolean_works) logger.info(f"✅ c05创建加工完成: {created_count} 个对象") return created_count except Exception as e: logger.error(f"c05创建加工异常: {e}") return 0 def _create_visual_machining_batch_suw_style(self, visual_works, uid): """批量创建可视化加工对象 - 参考SUW IMPL实现，支持材质区分""" try: import bmesh created_count = 0 # 【参考SUW IMPL】按组件分组，同一组件的加工可以批量创建 component_groups = {} for work in visual_works: component = work['component'] if component not in component_groups: component_groups[component] = [] component_groups[component].append(work) for component, works in component_groups.items(): logger.info(f"🔨 为组件 {component.name} 批量创建 {len(works)} 个加工对象") # 【参考SUW IMPL】创建主加工组 main_machining = bpy.data.objects.new( f"Machining_{component.name}", None) bpy.context.scene.collection.objects.link(main_machining) main_machining.parent = component main_machining["sw_typ"] = "work" # 【参考SUW IMPL】创建记录标准化，为c0a对称删除做准备 import time creation_record = { "type": "visual_batch", "main_machining": main_machining.name, "geometry_objects": [], "material_applied": None, "created_timestamp": time.time() } # 添加到数据管理器 self.data_manager.add_machining(uid, main_machining) # 【修复】按cancel状态分组，分别创建不同材质的几何体 active_works = [] # cancel=0，蓝色材质 cancelled_works = [] # cancel=1，灰色材质 for work in works: if work.get("cancel", 0) == 1: cancelled_works.append(work) else: active_works.append(work) # 创建有效加工组（蓝色） if active_works: created_count += self._create_work_group_with_material( main_machining, active_works, "active") # 创建取消加工组（灰色） if cancelled_works: created_count += self._create_work_group_with_material( main_machining, cancelled_works, "cancelled") return created_count except Exception as e: logger.error(f"批量创建可视化加工失败: {e}") return 0 def _create_work_group_with_material(self, main_machining, works, work_type): """为指定材质类型创建工作组""" try: if not works: return 0 import bmesh created_count = 0 # 创建bmesh bm = bmesh.new() for work in works: try: # 解析坐标 p1 = self._parse_point3d(work.get("p1", "(0,0,0)")) p2 = self._parse_point3d(work.get("p2", "(0,0,0)")) # 根据类型创建几何体 if "tri" in work: self._add_triangle_to_bmesh_suw_style(bm, work, p1, p2) elif "surf" in work: self._add_surface_to_bmesh_suw_style(bm, work, p1, p2) else: self._add_circle_to_bmesh_suw_style(bm, work, p1, p2) created_count += 1 except Exception as e: logger.error(f"创建单个加工几何体失败: {e}") # 创建网格对象 if bm.verts: mesh = bpy.data.meshes.new( f"MachiningMesh_{main_machining.name}_{work_type}") bm.to_mesh(mesh) mesh.update() # 创建对象 mesh_obj = bpy.data.objects.new( f"MachiningGeometry_{main_machining.name}_{work_type}", mesh) bpy.context.scene.collection.objects.link(mesh_obj) mesh_obj.parent = main_machining # 【修复】应用对应材质 try: if hasattr(self, 'material_manager'): if work_type == "active": # 蓝色材质 - 有效加工 self.material_manager.apply_machining_material(mesh_obj) else: # 灰色材质 - 取消的加工 self.material_manager.apply_cancelled_machining_material(mesh_obj) except Exception as e: logger.warning(f"应用材质失败: {e}") bm.free() return created_count except Exception as e: logger.error(f"创建工作组失败: {e}") return 0 def _add_circle_to_bmesh_suw_style(self, bm, work, p1, p2): """向bmesh添加圆形几何体 - 参考SUW IMPL实现，修复孔位朝向""" try: import bmesh dia = work.get("dia", 5.0) radius = dia * 0.001 / 2.0 # 【参考SUW IMPL】计算方向和位置 if BLENDER_AVAILABLE: import mathutils # 转换为mathutils.Vector p1_vec = mathutils.Vector(p1) p2_vec = mathutils.Vector(p2) # 计算方向和长度 direction = p2_vec - p1_vec length = direction.length midpoint = (p1_vec + p2_vec) / 2 if length < 0.0001: logger.warning("圆柱体长度过短，跳过创建") return logger.debug(f"🔧 创建圆柱体: 半径={radius:.3f}, 长度={length:.3f}") # 【参考SUW IMPL】计算旋转矩阵 - 将Z轴对齐到加工方向 # 使用rotation_difference计算精确旋转，避免万向节锁 z_axis = mathutils.Vector((0, 0, 1)) rotation_quat = z_axis.rotation_difference( direction.normalized()) rotation_matrix = rotation_quat.to_matrix().to_4x4() # 组合变换矩阵: 先旋转，再平移 translation_matrix = mathutils.Matrix.Translation(midpoint) final_transform_matrix = translation_matrix @ rotation_matrix # 在临时bmesh中创建标准圆柱体 temp_bm = bmesh.new() bmesh.ops.create_cone( temp_bm, cap_ends=True, # 生成端盖 cap_tris=False, # 端盖用 n 边而非三角 segments=12, radius1=radius, radius2=radius, # 与 radius1 相同 → 圆柱 depth=length ) # 应用变换矩阵 bmesh.ops.transform( temp_bm, matrix=final_transform_matrix, verts=temp_bm.verts) # 将变换后的几何体合并到主bmesh vert_map = {} for v in temp_bm.verts: new_v = bm.verts.new(v.co) vert_map[v] = new_v for f in temp_bm.faces: bm.faces.new(tuple(vert_map[v] for v in f.verts)) temp_bm.free() logger.debug( f"✅ 圆柱体变换完成: 世界坐标中点({midpoint.x:.3f}, {midpoint.y:.3f}, {midpoint.z:.3f})") else: # 非Blender环境的简化版本 direction = (p2[0] - p1[0], p2[1] - p1[1], p2[2] - p1[2]) length = (direction[0]**2 + direction[1] ** 2 + direction[2]**2)**0.5 center = ((p1[0] + p2[0])/2, (p1[1] + p2[1]) / 2, (p1[2] + p2[2])/2) # 创建圆柱体（简化版本，不做旋转） bmesh.ops.create_cone( bm, cap_ends=True, cap_tris=False, segments=12, radius1=radius, radius2=radius, depth=max(length, 0.01) ) # 移动到正确位置 bmesh.ops.translate( bm, vec=center, verts=bm.verts[-24:] # 圆柱体的顶点 ) except Exception as e: logger.error(f"添加圆形到bmesh失败: {e}") import traceback logger.error(traceback.format_exc()) def _add_triangle_to_bmesh_suw_style(self, bm, work, p1, p2): """向bmesh添加三角形几何体 - 参考SUW IMPL实现""" try: # 获取第三个点 tri = self._parse_point3d(work.get("tri", "(0,0,0)")) p3 = self._parse_point3d(work.get("p3", "(0,0,0)")) # 计算三角形顶点 pts = [ tri, (tri[0] + p2[0] - p1[0], tri[1] + p2[1] - p1[1], tri[2] + p2[2] - p1[2]), (p1[0] + p1[0] - tri[0], p1[1] + p1[1] - tri[1], p1[2] + p1[2] - tri[2]) ] # 创建三角形顶点 v1 = bm.verts.new(pts[0]) v2 = bm.verts.new(pts[1]) v3 = bm.verts.new(pts[2]) # 创建面 bm.faces.new([v1, v2, v3]) except Exception as e: logger.error(f"添加三角形到bmesh失败: {e}") def _add_surface_to_bmesh_suw_style(self, bm, work, p1, p2): """向bmesh添加表面几何体 - 参考SUW IMPL实现""" try: # 解析表面数据 surf = work.get("surf", {}) segs = surf.get("segs", []) if not segs: return # 简化的表面创建 # 这里需要根据实际的表面数据格式进行解析 # 暂时创建一个简单的平面 v1 = bm.verts.new(p1) v2 = bm.verts.new(p2) v3 = bm.verts.new([(p1[0] + p2[0])/2, p1[1], (p1[2] + p2[2])/2]) v4 = bm.verts.new([(p1[0] + p2[0])/2, p2[1], (p1[2] + p2[2])/2]) # 创建面 bm.faces.new([v1, v2, v3, v4]) except Exception as e: logger.error(f"添加表面到bmesh失败: {e}") def _create_boolean_machining_batch_suw_style(self, boolean_works): """批量创建布尔运算加工对象 - 参考SUW IMPL实现""" try: created_count = 0 # 按组件分组 component_groups = {} for work in boolean_works: component = work['component'] if component not in component_groups: component_groups[component] = [] component_groups[component].append(work) for component, works in component_groups.items(): logger.info( f"🔨 为组件 {component.name} 批量创建 {len(works)} 个布尔运算加工") # 按类型分组 circle_works = [] triangle_works = [] surface_works = [] for work in works: p1 = self._parse_point3d(work.get("p1", "(0,0,0)")) p2 = self._parse_point3d(work.get("p2", "(0,0,0)")) if "tri" in work: triangle_works.append((work, p1, p2)) elif "surf" in work: surface_works.append((work, p1, p2)) else: circle_works.append((work, p1, p2)) # 批量创建统一修剪器 if circle_works: unified_circle = self._create_unified_circle_trimmer_suw_style( circle_works, component.name) if unified_circle: created_count += len(circle_works) if triangle_works: unified_triangle = self._create_unified_triangle_trimmer_suw_style( triangle_works, component.name) if unified_triangle: created_count += len(triangle_works) if surface_works: unified_surface = self._create_unified_surface_trimmer_suw_style( surface_works, component.name) if unified_surface: created_count += len(surface_works) return created_count except Exception as e: logger.error(f"批量创建布尔运算加工失败: {e}") return 0 def _create_unified_circle_trimmer_suw_style(self, circle_data_list, component_name): """创建统一圆形剪切器 - 参考SUW IMPL实现""" try: if not circle_data_list: return None # 创建合并的圆形剪切器 bm = bmesh.new() for circle_data in circle_data_list: work, p1, p2 = circle_data # 使用相同的圆形创建逻辑 self._add_circle_to_bmesh_suw_style(bm, work, p1, p2) # 创建网格 mesh = bpy.data.meshes.new( f"UnifiedCircleTrimmer_{component_name}") bm.to_mesh(mesh) mesh.update() obj = bpy.data.objects.new( f"UnifiedCircleTrimmer_{component_name}", mesh) bpy.context.scene.collection.objects.link(obj) bm.free() return obj except Exception as e: logger.error(f"创建统一圆形剪切器失败: {e}") return None def _create_unified_triangle_trimmer_suw_style(self, triangle_data_list, component_name): """创建统一三角形剪切器 - 参考SUW IMPL实现""" try: if not triangle_data_list: return None # 简化实现 return None except Exception as e: logger.error(f"创建统一三角形剪切器失败: {e}") return None def _create_unified_surface_trimmer_suw_style(self, surface_data_list, component_name): """创建统一表面剪切器 - 参考SUW IMPL实现""" try: if not surface_data_list: return None # 简化实现 return None except Exception as e: logger.error(f"创建统一表面剪切器失败: {e}") return None def _create_cylinder_ultra_safe(self, machining, p1, p2, diameter, index): """使用超安全的方法创建圆柱体 - 避免所有依赖图问题""" try: # 计算长度和中心点 length = math.sqrt((p2[0] - p1[0])**2 + (p2[1] - p1[1])**2 + (p2[2] - p1[2])**2) if length < 0.001: length = 0.001 center = [(p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2, (p1[2] + p2[2]) / 2] radius = (diameter * 0.001) / 2.0 # mm -> m # 【修复】使用时间戳确保唯一命名 import time timestamp = int(time.time() * 1000) % 100000 unique_id = f"{machining.name}_{index}_{timestamp}" # 【修复】使用更简单的命名避免组件ID冲突 mesh_name = f"Mesh_{unique_id}" obj_name = f"Cylinder_{unique_id}" # 【修复】检查名称是否已存在 if mesh_name in bpy.data.meshes: bpy.data.meshes.remove(bpy.data.meshes[mesh_name]) if obj_name in bpy.data.objects: bpy.data.objects.remove(bpy.data.objects[obj_name]) # 创建网格数据 mesh = bpy.data.meshes.new(mesh_name) # 使用简单的顶点和面创建圆柱体 vertices = [] faces = [] # 创建6个分段的圆柱体（减少复杂度） segments = 6 for i in range(segments): angle = 2 * math.pi * i / segments cos_val = math.cos(angle) sin_val = math.sin(angle) # 第一个端面 x1 = center[0] + radius * cos_val y1 = center[1] + radius * sin_val z1 = center[2] - length / 2 vertices.append((x1, y1, z1)) # 第二个端面 x2 = center[0] + radius * cos_val y2 = center[1] + radius * sin_val z2 = center[2] + length / 2 vertices.append((x2, y2, z2)) # 创建侧面 for i in range(segments): v1 = i * 2 v2 = (i + 1) % segments * 2 v3 = (i + 1) % segments * 2 + 1 v4 = i * 2 + 1 faces.append((v1, v2, v3, v4)) # 创建端面 end1_verts = list(range(0, segments * 2, 2)) if len(end1_verts) >= 3: faces.append(end1_verts) end2_verts = list(range(1, segments * 2, 2)) if len(end2_verts) >= 3: faces.append(end2_verts) # 【修复】安全的网格创建 try: mesh.from_pydata(vertices, [], faces) mesh.update() except Exception as e: logger.error(f"创建网格数据失败: {e}") bpy.data.meshes.remove(mesh) return None # 【修复】安全的对象创建 try: cylinder_obj = bpy.data.objects.new(obj_name, mesh) except Exception as e: logger.error(f"创建对象失败: {e}") bpy.data.meshes.remove(mesh) return None # 【修复】安全的场景链接 try: bpy.context.scene.collection.objects.link(cylinder_obj) except Exception as e: logger.error(f"链接到场景失败: {e}") bpy.data.objects.remove(cylinder_obj) bpy.data.meshes.remove(mesh) return None # 【修复】安全的父对象设置 try: if machining and machining.name in bpy.data.objects: cylinder_obj.parent = machining except Exception as e: logger.warning(f"设置父对象失败: {e}") # 【修复】安全的属性设置 try: cylinder_obj["sw_typ"] = "work" cylinder_obj["sw_special"] = 0 except Exception as e: logger.warning(f"设置属性失败: {e}") # 【修复】强制更新对象 try: cylinder_obj.update_tag() bpy.context.view_layer.update() except: pass return cylinder_obj except Exception as e: logger.error(f"创建超安全圆柱体失败: {e}") return None def _create_simple_surface(self, machining, item, index): """创建简单的表面几何体 - 修复版本""" try: surf = item.get("surf", {}) segs = surf.get("segs", []) if not segs: return None # 【修复】使用时间戳确保唯一命名 import time timestamp = int(time.time() * 1000) % 100000 unique_id = f"{machining.name}_{index}_{timestamp}" mesh_name = f"SurfaceMesh_{unique_id}" obj_name = f"Surface_{unique_id}" # 【修复】检查名称是否已存在 if mesh_name in bpy.data.meshes: bpy.data.meshes.remove(bpy.data.meshes[mesh_name]) if obj_name in bpy.data.objects: bpy.data.objects.remove(bpy.data.objects[obj_name]) # 创建网格数据 mesh = bpy.data.meshes.new(mesh_name) # 【修复】使用更安全的方法创建平面 try: # 使用bmesh创建平面 bm = bmesh.new() # 使用正确的操作符名称 bmesh.ops.create_grid( bm, x_segments=1, y_segments=1, size=0.1 ) # 转换为网格 bm.to_mesh(mesh) mesh.update() bm.free() except Exception as e: logger.error(f"创建表面网格失败: {e}") bpy.data.meshes.remove(mesh) return None # 【修复】安全的对象创建 try: surface_obj = bpy.data.objects.new(obj_name, mesh) bpy.context.scene.collection.objects.link(surface_obj) except Exception as e: logger.error(f"创建表面对象失败: {e}") bpy.data.meshes.remove(mesh) return None # 【修复】安全的父对象设置 try: if machining and machining.name in bpy.data.objects: surface_obj.parent = machining except Exception as e: logger.warning(f"设置父对象失败: {e}") # 【修复】安全的属性设置 try: surface_obj["sw_typ"] = "work" surface_obj["sw_special"] = 0 except Exception as e: logger.warning(f"设置属性失败: {e}") return surface_obj except Exception as e: logger.error(f"创建简单表面失败: {e}") return None def c0a(self, data: Dict[str, Any]): """del_machining - 删除加工 - 最终版本，处理已删除对象的引用问题""" try: logger.info("🗑️ 执行c0a命令: 删除加工") uid = data.get("uid") typ = data.get("typ") # type is unit or source oid = data.get("oid") special = data.get("special", 1) logger.info( f"🗑️ 删除加工参数: uid={uid}, typ={typ}, oid={oid}, special={special}") # 获取加工数据 machinings = self.data_manager.get_machinings(uid) if not machinings: logger.info(f"未找到单元 {uid} 的加工数据") return 0 logger.info(f"🔍 找到 {len(machinings)} 个加工对象") deleted_count = 0 # 【修复】使用更安全的删除策略：先收集要删除的对象名称，再批量删除 objects_to_delete = [] # 第一步：收集要删除的对象名称 for entity in machinings: try: # 检查对象是否有效 if not self._is_object_valid(entity): continue # 条件1: typ匹配 typ_match = False if typ == "uid": typ_match = True else: # 尝试获取属性，如果不存在则返回None try: entity_attr = entity.get("sw_" + typ, None) typ_match = (entity_attr == oid) except Exception as e: logger.debug(f"获取对象属性失败: {e}") continue # 条件2: special匹配 special_match = False if special == 1: special_match = True else: # special == 0 # 获取sw_special属性，如果不存在则默认为0 try: entity_special = entity.get("sw_special", 0) special_match = (entity_special == 0) except Exception as e: logger.debug(f"获取special属性失败: {e}") continue # 如果两个条件都满足，添加到删除列表 if typ_match and special_match: logger.info(f"🗑️ 标记删除加工对象: {entity.name}") objects_to_delete.append(entity.name) except Exception as e: logger.debug(f"处理加工对象时出错: {e}") continue # 第二步：批量删除收集到的对象 logger.info(f"🔍 开始删除 {len(objects_to_delete)} 个对象") for obj_name in objects_to_delete: try: # 使用名称查找对象 if obj_name in bpy.data.objects: obj = bpy.data.objects[obj_name] if self._is_object_valid(obj): if self._delete_object_safe(obj): deleted_count += 1 else: logger.debug(f"删除对象失败: {obj_name}") else: logger.debug(f"对象已无效: {obj_name}") # 如果对象无效，检查是否已经被删除 if obj_name not in bpy.data.objects: deleted_count += 1 else: logger.debug(f"对象不在Blender数据中: {obj_name}") # 如果对象不在数据中，认为已经被删除 deleted_count += 1 except Exception as e: logger.debug(f"删除对象时出错: {e}") # 检查对象是否已经被删除 try: if obj_name not in bpy.data.objects: deleted_count += 1 except: pass continue # 【修复】按照Ruby版本：最后清理已删除的对象 self.data_manager.cleanup_machinings(uid) logger.info(f"✅ 删除加工完成: {deleted_count} 个对象") return deleted_count except Exception as e: logger.error(f"c0a命令执行失败: {e}") return 0 # ==================== 核心实现方法 ==================== def _create_machining_object(self, uid): """为本次加工批次创建一个空的父对象，并注册到data_manager - 修复版本""" try: import bpy # 检查Blender可用性 if not BLENDER_AVAILABLE: logger.error("Blender不可用，无法创建加工对象") return None # 检查uid是否有效 if not uid: logger.error("无效的uid") return None name = f"Machining_{uid}" # 检查是否已存在同名对象 if name in bpy.data.objects: logger.info(f"加工对象已存在: {name}") return bpy.data.objects[name] # 创建空对象 try: obj = bpy.data.objects.new(name, None) except Exception as e: logger.error(f"创建对象失败: {e}") return None # 检查对象是否创建成功 if not obj: logger.error("对象创建失败") return None # 链接到场景 try: if hasattr(bpy.context, 'scene') and bpy.context.scene: bpy.context.scene.collection.objects.link(obj) else: logger.error("无法获取场景") bpy.data.objects.remove(obj) return None except Exception as e: logger.error(f"链接对象到场景失败: {e}") bpy.data.objects.remove(obj) return None # 设置属性 try: obj["sw_typ"] = "work" except Exception as e: logger.warning(f"设置对象属性失败: {e}") # 添加到数据管理器 try: self.data_manager.add_machining(uid, obj) except Exception as e: logger.warning(f"添加到数据管理器失败: {e}") logger.info(f"✅ 创建加工对象成功: {name}") return obj except Exception as e: logger.error(f"创建加工对象异常: {e}") return None def _parse_point3d(self, point_str): """解析3D点字符串 - 修复单位转换""" try: # 移除括号和空格 point_str = point_str.strip("()").replace(" ", "") coords = point_str.split(",") if len(coords) >= 3: # 【修复】单位转换：毫米转米 x = float(coords[0]) * 0.001 # mm -> m y = float(coords[1]) * 0.001 # mm -> m z = float(coords[2]) * 0.001 # mm -> m return [x, y, z] else: return [0.0, 0.0, 0.0] except Exception as e: logger.error(f"解析3D点失败: {e}") return [0.0, 0.0, 0.0] def _parse_surface_vertices(self, surface): """解析表面顶点""" try: # 简化的表面解析 vertices = [] # 这里应该根据实际的表面数据格式解析 return vertices except Exception as e: logger.error(f"解析表面顶点失败: {e}") return [] def _set_machining_color(self, machining, item): """设置加工颜色""" try: # 获取加工材质 material = material_manager.get_texture("mat_machining") if material and hasattr(machining, 'data') and machining.data: if not machining.data.materials: machining.data.materials.append(material) else: machining.data.materials[0] = material except Exception as e: logger.error(f"设置加工颜色失败: {e}") def _is_object_valid(self, obj) -> bool: """检查对象是否有效 - 增强版本""" try: if not obj: return False if not BLENDER_AVAILABLE: return True # 【修复】更强的有效性检查 try: # 检查对象是否有name属性 if not hasattr(obj, 'name'): return False # 检查name是否为空 if not obj.name: return False # 检查对象是否在Blender数据中 if obj.name not in bpy.data.objects: return False # 尝试访问对象属性来验证其有效性 test_name = obj.name return True except Exception as e: logger.debug(f"对象有效性检查失败: {e}") return False except Exception as e: logger.debug(f"对象有效性检查异常: {e}") return False def _delete_object_safe(self, obj) -> bool: """安全删除对象 - 最终版本，处理已删除对象的引用问题""" try: if not obj or not BLENDER_AVAILABLE: return False # 【修复】更强的对象有效性检查 try: # 检查对象是否仍然存在于Blender数据中 if obj.name not in bpy.data.objects: logger.debug(f"对象 {obj.name} 已不在Blender数据中") return True # 如果对象已经不在数据中，认为删除成功 # 检查对象是否仍然有效（没有被删除） if not hasattr(obj, 'name') or not obj.name: logger.debug("对象已无效（没有name属性）") return True # 如果对象已经无效，认为删除成功 except Exception as e: logger.debug(f"对象有效性检查失败: {e}") return True # 如果检查失败，认为对象已经被删除 # 【修复】使用更安全的删除策略 try: # 先收集所有子对象（使用名称而不是对象引用） children_names = [] try: if hasattr(obj, 'children'): for child in obj.children: try: if child and hasattr(child, 'name') and child.name in bpy.data.objects: children_names.append(child.name) except Exception as e: logger.debug(f"检查子对象时出错: {e}") continue except Exception as e: logger.debug(f"获取子对象列表失败: {e}") # 先删除子对象（使用名称查找） for child_name in children_names: try: if child_name in bpy.data.objects: child_obj = bpy.data.objects[child_name] # 再次检查对象是否有效 if hasattr(child_obj, 'name') and child_obj.name == child_name: bpy.data.objects.remove( child_obj, do_unlink=True) logger.debug(f"删除子对象: {child_name}") except Exception as e: logger.debug(f"删除子对象 {child_name} 失败: {e}") # 再删除父对象 try: # 最终检查对象是否仍然有效 if obj.name in bpy.data.objects: # 再次验证对象引用是否有效 try: if hasattr(obj, 'name') and obj.name in bpy.data.objects: bpy.data.objects.remove(obj, do_unlink=True) logger.debug(f"删除父对象: {obj.name}") return True else: logger.debug(f"父对象 {obj.name} 在删除前已无效") return True # 对象已经无效，认为删除成功 except Exception as e: logger.debug(f"删除父对象时出错: {e}") # 检查对象是否已经被删除 if obj.name not in bpy.data.objects: logger.debug(f"父对象 {obj.name} 已被删除") return True return False else: logger.debug(f"父对象 {obj.name} 已不在Blender数据中") return True # 对象已经不在数据中，认为删除成功 except Exception as e: logger.debug(f"删除父对象过程中出错: {e}") # 检查对象是否已经被删除 try: if obj.name not in bpy.data.objects: logger.debug(f"父对象 {obj.name} 已被删除") return True except: pass return False except Exception as e: logger.debug(f"删除对象过程中出错: {e}") # 检查对象是否已经被删除 try: if obj.name not in bpy.data.objects: logger.debug(f"对象 {obj.name} 已被删除") return True except: pass return False except Exception as e: logger.debug(f"删除对象失败: {e}") # 最后检查对象是否已经被删除 try: if obj.name not in bpy.data.objects: logger.debug(f"对象 {obj.name} 已被删除") return True except: pass return False def _get_parts(self, data: Dict[str, Any]) -> Dict[str, Any]: """获取部件数据 - 使用data_manager""" return self.data_manager.get_parts(data) def _get_hardwares(self, data: Dict[str, Any]) -> Dict[str, Any]: """获取硬件数据 - 使用data_manager""" return self.data_manager.get_hardwares(data) # ==================== 统计和管理方法 ==================== def get_machining_stats(self) -> Dict[str, Any]: """获取加工统计信息""" try: total_machinings = sum(len(self.data_manager.get_machinings(uid)) for uid in self.data_manager.machinings.keys()) stats = { "total_units": len(self.data_manager.machinings), "total_machinings": total_machinings, "creation_stats": self.machining_stats.copy(), "memory_usage": { "machinings_dict_size": len(self.data_manager.machinings), } } if BLENDER_AVAILABLE: stats["blender_objects"] = len([obj for obj in bpy.data.objects if obj.get("sw_typ") == "work"]) return stats except Exception as e: logger.error(f"获取加工统计失败: {e}") return {"error": str(e)} def get_creation_stats(self) -> Dict[str, Any]: """获取创建统计信息""" return self.machining_stats.copy() def reset_creation_stats(self): """重置创建统计""" self.machining_stats = { "machinings_created": 0, "trim_operations": 0, "creation_errors": 0 } logger.info("加工统计已重置") def cleanup(self): """清理加工管理器""" try: # 清理所有加工数据 total_deleted = 0 for uid in list(self.data_manager.machinings.keys()): machinings = self.data_manager.get_machinings(uid) for machining in machinings: if self._delete_object_safe(machining): total_deleted += 1 self.data_manager.clear_machinings(uid) self.reset_creation_stats() logger.info(f"✅ 加工管理器清理完成，删除了 {total_deleted} 个对象") except Exception as e: logger.error(f"清理加工管理器失败: {e}") # ==================== 全局加工管理器实例 ==================== # 全局实例 machining_manager = None def init_machining_manager(): """初始化全局加工管理器实例 - 不再需要suw_impl参数""" global machining_manager machining_manager = MachiningManager() return machining_manager def get_machining_manager(): """获取全局加工管理器实例""" global machining_manager if machining_manager is None: machining_manager = init_machining_manager() return machining_manager