# 清理选择状态 if self.__class__._selected_uid == uid: self.__class__._selected_uid = None self.__class__._selected_obj = None self.__class__._selected_zone = None self.__class__._selected_part = None logger.debug(f"单元数据清理完成: {uid}") except Exception as e: logger.warning(f"清理单元数据失败: {e}") def _clear_labels_safe(self): """安全清理标签""" try: # 查找并删除标签对象 labels_to_delete = [] for obj in list(bpy.data.objects): try: if not self._is_object_valid(obj): continue if (obj.name.startswith("Label_") or obj.name.startswith("Dimension_") or obj.get("sw_typ") in ["label", "dimension"]): labels_to_delete.append(obj) except Exception: continue # 删除标签 for label_obj in labels_to_delete: self._delete_object_safe(label_obj) if labels_to_delete: logger.debug(f"清理标签完成: {len(labels_to_delete)} 个") except Exception as e: logger.error(f"清理标签失败: {e}") def c0a(self, data: Dict[str, Any]): """del_machining - 删除加工 - 线程安全版本""" try: if not BLENDER_AVAILABLE: return def delete_machining(): try: uid = data.get("uid") typ = data.get("typ") oid = data.get("oid") special = data.get("special", 1) if uid not in self.machinings: return True machinings = self.machinings[uid] valid_machinings = [] for machining in machinings: should_delete = False if machining and hasattr(machining, 'name') and machining.name in bpy.data.objects: if typ == "uid": should_delete = True else: attr_value = machining.get(f"sw_{typ}") should_delete = (attr_value == oid) if should_delete and special == 0: machining_special = machining.get( "sw_special", 0) should_delete = (machining_special == 0) if should_delete: try: bpy.data.objects.remove( machining, do_unlink=True) logger.debug(f"已删除加工: {machining.name}") except Exception as e: logger.warning(f"删除加工失败: {e}") else: valid_machinings.append(machining) self.machinings[uid] = valid_machinings return True except Exception as e: logger.error(f"删除加工失败: {e}") return False # 在主线程中执行删除操作 success = execute_in_main_thread(delete_machining) if success: logger.info(f"✅ 加工删除完成") else: logger.error(f"❌ 加工删除失败") except Exception as e: logger.error(f"❌ 删除加工失败: {e}") def c0c(self, data: Dict[str, Any]): """del_dim - 删除尺寸标注 - 线程安全版本""" try: if not BLENDER_AVAILABLE: return def delete_dimensions(): try: uid = data.get("uid") if uid in self.dimensions: dimensions = self.dimensions[uid] for dim in dimensions: try: if dim and hasattr(dim, 'name') and dim.name in bpy.data.objects: bpy.data.objects.remove( dim, do_unlink=True) logger.debug(f"已删除尺寸标注: {dim.name}") except Exception as e: logger.warning(f"删除尺寸标注失败: {e}") del self.dimensions[uid] return True except Exception as e: logger.error(f"删除尺寸标注失败: {e}") return False # 在主线程中执行删除操作 success = execute_in_main_thread(delete_dimensions) if success: logger.info(f"✅ 尺寸标注删除完成") else: logger.error(f"❌ 尺寸标注删除失败") except Exception as e: logger.error(f"❌ 删除尺寸标注失败: {e}") # ==================== 视图管理方法 ==================== def c15(self, data: Dict[str, Any]): """sel_unit - 选择单元""" try: self.sel_clear() zones = self.get_zones(data) for zid, zone in zones.items(): if zone and zone.name in bpy.data.objects: leaf = self._is_leaf_zone(zid, zones) zone.hide_viewport = leaf and self.hide_none except Exception as e: logger.error(f"选择单元失败: {e}") def _is_leaf_zone(self, zip_id, zones): """检查是否是叶子区域""" try: for zid, zone in zones.items(): if zone and zone.get("sw_zip") == zip_id: return False return True except Exception as e: logger.error(f"检查叶子区域失败: {e}") return True def c16(self, data: Dict[str, Any]): """sel_zone - 选择区域""" try: self._sel_zone_local(data) except Exception as e: logger.error(f"选择区域失败: {e}") def c17(self, data: Dict[str, Any]): """sel_elem - 选择元素""" try: if self.part_mode: self._sel_part_parent(data) else: self._sel_zone_local(data) except Exception as e: logger.error(f"选择元素失败: {e}") def _sel_part_parent(self, data): """选择零件父级""" try: self.sel_clear() zones = self.get_zones(data) parts = self.get_parts(data) hardwares = self.get_hardwares(data) uid = data.get("uid") zid = data.get("zid") pid = data.get("pid") parted = False # 选择零件 for v_root, part in parts.items(): if part and part.get("sw_pid") == pid: self.textured_part(part, True) self.__class__._selected_uid = uid self.__class__._selected_obj = pid parted = True # 选择硬件 for v_root, hw in hardwares.items(): if hw and hw.get("sw_pid") == pid: self._textured_hw(hw, True) # 处理区域 children = self._get_child_zones(zones, zid, True) for child in children: child_id = child.get("zid") child_zone = zones.get(child_id) leaf = child.get("leaf") if not child_zone: continue if leaf and child_id == zid: if not self.hide_none: child_zone.hide_viewport = False for face in child_zone.children: if hasattr(face, 'data'): selected = face.get("sw_child") == pid self._textured_face(face, selected) if selected: self.__class__._selected_uid = uid self.__class__._selected_obj = pid elif not leaf and child_id == zid: if not parted: child_zone.hide_viewport = False for face in child_zone.children: if (hasattr(face, 'data') and face.get("sw_child") == pid): self._textured_face(face, True) self.__class__._selected_uid = uid self.__class__._selected_obj = pid elif leaf and not self.hide_none: child_zone.hide_viewport = False for face in child_zone.children: if hasattr(face, 'data'): self._textured_face(face, False) else: child_zone.hide_viewport = True except Exception as e: logger.error(f"选择零件父级失败: {e}") # ==================== 门和抽屉功能方法 ==================== def c10(self, data: Dict[str, Any]): """set_doorinfo - 设置门信息""" try: parts = self.get_parts(data) doors = data.get("drs", []) for door in doors: root = door.get("cp", 0) door_dir = door.get("dov", "") ps = Point3d.parse(door.get("ps", "(0,0,0)")) pe = Point3d.parse(door.get("pe", "(0,0,0)")) offset = Vector3d.parse(door.get("off", "(0,0,0)")) if root > 0 and root in parts: part = parts[root] part["sw_door_dir"] = door_dir part["sw_door_ps"] = (ps.x, ps.y, ps.z) part["sw_door_pe"] = (pe.x, pe.y, pe.z) part["sw_door_offset"] = (offset.x, offset.y, offset.z) except Exception as e: logger.error(f"设置门信息失败: {e}") def c1a(self, data: Dict[str, Any]): """open_doors - 开门""" try: uid = data.get("uid") parts = self.get_parts(data) hardwares = self.get_hardwares(data) mydoor = data.get("cp", 0) value = data.get("v", False) for root, part in parts.items(): if mydoor != 0 and mydoor != root: continue door_type = part.get("sw_door", 0) if door_type <= 0: continue is_open = part.get("sw_door_open", False) if is_open == value: continue if door_type not in [10, 15]: continue # 获取门的参数 door_ps = part.get("sw_door_ps") door_pe = part.get("sw_door_pe") door_off = part.get("sw_door_offset") if not all([door_ps, door_pe, door_off]): continue # 应用单位变换 if uid in self.unit_trans: trans = self.unit_trans[uid] door_ps = self._transform_point(door_ps, trans) door_pe = self._transform_point(door_pe, trans) door_off = self._transform_vector(door_off, trans) # 计算变换 if door_type == 10: # 平开门 trans_a = self._calculate_swing_door_transform( door_ps, door_pe, door_off) else: # 推拉门 trans_a = self._calculate_slide_door_transform(door_off) if is_open: trans_a = self._invert_transform(trans_a) # 应用变换 self._apply_transformation(part, trans_a) part["sw_door_open"] = not is_open # 变换相关硬件 for key, hardware in hardwares.items(): if hardware.get("sw_part") == root: self._apply_transformation(hardware, trans_a) except Exception as e: logger.error(f"开门失败: {e}") def c1b(self, data: Dict[str, Any]): """slide_drawers - 滑动抽屉""" try: uid = data.get("uid") zones = self.get_zones(data) parts = self.get_parts(data) hardwares = self.get_hardwares(data) # 收集抽屉信息 drawers = {} depths = {} for root, part in parts.items(): drawer_type = part.get("sw_drawer", 0) if drawer_type > 0: if drawer_type == 70: # DR_DP pid = part.get("sw_pid") drawer_dir = part.get("sw_drawer_dir") if pid and drawer_dir: drawers[pid] = Vector3d( drawer_dir[0], drawer_dir[1], drawer_dir[2]) if drawer_type in [73, 74]: # DR_LP/DR_RP pid = part.get("sw_pid") dr_depth = part.get("sw_dr_depth", 300) if pid: depths[pid] = dr_depth # 计算偏移量 offsets = {} for drawer, direction in drawers.items(): zone = zones.get(drawer) if not zone: continue dr_depth = depths.get(drawer, 300) * 0.001 # mm to meters vector = Vector3d(direction.x, direction.y, direction.z) vector_length = math.sqrt( vector.x**2 + vector.y**2 + vector.z**2) if vector_length > 0: scale = (dr_depth * 0.9) / vector_length vector = Vector3d(vector.x * scale, vector.y * scale, vector.z * scale) # 应用单位变换 if uid in self.unit_trans: vector = self._transform_vector( (vector.x, vector.y, vector.z), self.unit_trans[uid]) offsets[drawer] = vector # 应用抽屉变换 value = data.get("v", False) for drawer, vector in offsets.items(): zone = zones.get(drawer) if not zone: continue is_open = zone.get("sw_drawer_open", False) if is_open == value: continue # 计算变换 trans_a = self._calculate_translation_transform(vector) if is_open: trans_a = self._invert_transform(trans_a) # 应用到区域 zone["sw_drawer_open"] = not is_open # 变换零件 for root, part in parts.items(): if part.get("sw_pid") == drawer: self._apply_transformation(part, trans_a) # 变换硬件 for root, hardware in hardwares.items(): if hardware.get("sw_pid") == drawer: self._apply_transformation(hardware, trans_a) except Exception as e: logger.error(f"滑动抽屉失败: {e}") # ==================== 视图控制方法 ==================== def c18(self, data: Dict[str, Any]): """hide_door - 隐藏门""" try: visible = not data.get("v", False) if self.door_layer: # 在Blender中控制集合可见性 self.door_layer.hide_viewport = not visible if self.door_labels: self.door_labels.hide_viewport = not visible except Exception as e: logger.error(f"隐藏门失败: {e}") def c28(self, data: Dict[str, Any]): """hide_drawer - 隐藏抽屉""" try: visible = not data.get("v", False) if self.drawer_layer: self.drawer_layer.hide_viewport = not visible if self.door_labels: self.door_labels.hide_viewport = not visible except Exception as e: logger.error(f"隐藏抽屉失败: {e}") def c0f(self, data: Dict[str, Any]): """view_front - 前视图""" try: if BLENDER_AVAILABLE: # 设置前视图 for area in bpy.context.screen.areas: if area.type == 'VIEW_3D': for region in area.regions: if region.type == 'WINDOW': override = {'area': area, 'region': region} bpy.ops.view3d.view_axis( override, type='FRONT') bpy.ops.view3d.view_all(override) break except Exception as e: logger.error(f"前视图失败: {e}") def c23(self, data: Dict[str, Any]): """view_left - 左视图""" try: if BLENDER_AVAILABLE: for area in bpy.context.screen.areas: if area.type == 'VIEW_3D': for region in area.regions: if region.type == 'WINDOW': override = {'area': area, 'region': region} bpy.ops.view3d.view_axis(override, type='LEFT') bpy.ops.view3d.view_all(override) break except Exception as e: logger.error(f"左视图失败: {e}") def c24(self, data: Dict[str, Any]): """view_right - 右视图""" try: if BLENDER_AVAILABLE: for area in bpy.context.screen.areas: if area.type == 'VIEW_3D': for region in area.regions: if region.type == 'WINDOW': override = {'area': area, 'region': region} bpy.ops.view3d.view_axis( override, type='RIGHT') bpy.ops.view3d.view_all(override) break except Exception as e: logger.error(f"右视图失败: {e}") def c25(self, data: Dict[str, Any]): """view_back - 后视图""" try: if BLENDER_AVAILABLE: for area in bpy.context.screen.areas: if area.type == 'VIEW_3D': for region in area.regions: if region.type == 'WINDOW': override = {'area': area, 'region': region} bpy.ops.view3d.view_axis(override, type='BACK') bpy.ops.view3d.view_all(override) break except Exception as e: logger.error(f"后视图失败: {e}") # ==================== 其他业务方法 ==================== def c00(self, data: Dict[str, Any]): """add_folder - 添加文件夹""" try: ref_v = data.get("ref_v", 0) if ref_v > 0: # 在实际应用中需要实现文件夹管理逻辑 logger.info(f"添加文件夹: ref_v={ref_v}") except Exception as e: logger.error(f"添加文件夹失败: {e}") def c01(self, data: Dict[str, Any]): """edit_unit - 编辑单元""" try: unit_id = data.get("unit_id") if "params" in data: params = data["params"] if "trans" in params: jtran = params.pop("trans") trans = Transformation.parse(jtran) self.unit_trans[unit_id] = trans time.sleep(0.5) # 等待 if unit_id in self.unit_param: values = self.unit_param[unit_id] values.update(params) params = values self.unit_param[unit_id] = params except Exception as e: logger.error(f"编辑单元失败: {e}") def c07(self, data: Dict[str, Any]): """add_dim - 添加尺寸标注 - 线程安全版本""" try: if not BLENDER_AVAILABLE: return uid = data.get("uid") def create_dimensions(): try: dims = data.get("dims", []) dimensions = [] for dim_data in dims: p1 = Point3d.parse(dim_data.get("p1", "(0,0,0)")) p2 = Point3d.parse(dim_data.get("p2", "(0,0,0)")) direction = Vector3d.parse( dim_data.get("dir", "(0,0,1)")) text = dim_data.get("text", "") dimension = self._create_dimension( p1, p2, direction, text) if dimension: dimensions.append(dimension) # 存储尺寸标注 if uid not in self.dimensions: self.dimensions[uid] = [] self.dimensions[uid].extend(dimensions) for dimension in dimensions: memory_manager.register_object(dimension) return len(dimensions) except Exception as e: logger.error(f"创建尺寸标注失败: {e}") return 0 # 在主线程中执行尺寸标注创建 count = execute_in_main_thread(create_dimensions) if count > 0: logger.info(f"✅ 成功创建尺寸标注: uid={uid}, count={count}") else: logger.error(f"❌ 尺寸标注创建失败: uid={uid}") except Exception as e: logger.error(f"❌ 添加尺寸标注失败: {e}") def c0d(self, data: Dict[str, Any]): """parts_seqs - 零件序列""" try: parts = self.get_parts(data) seqs = data.get("seqs", []) for d in seqs: root = d.get("cp") seq = d.get("seq") pos = d.get("pos") name = d.get("name") size = d.get("size") mat = d.get("mat") e_part = parts.get(root) if e_part: e_part["sw_seq"] = seq e_part["sw_pos"] = pos if name: e_part["sw_name"] = name if size: e_part["sw_size"] = size if mat: e_part["sw_mat"] = mat except Exception as e: logger.error(f"零件序列失败: {e}") def c0e(self, data: Dict[str, Any]): """explode_zones - 爆炸视图""" try: if not BLENDER_AVAILABLE: return # 清理标签 self._clear_labels(self.labels) self._clear_labels(self.door_labels) uid = data.get("uid") zones = self.get_zones(data) parts = self.get_parts(data) hardwares = self.get_hardwares(data) # 处理区域爆炸 jzones = data.get("zones", []) for zone in jzones: zoneid = zone.get("zid") offset = Vector3d.parse(zone.get("vec", "(0,0,0)")) if uid in self.unit_trans: offset = self._transform_vector( (offset.x, offset.y, offset.z), self.unit_trans[uid]) trans_a = self._calculate_translation_transform(offset) if zoneid in zones: azone = zones[zoneid] self._apply_transformation(azone, trans_a) # 处理零件爆炸 jparts = data.get("parts", []) for jpart in jparts: pid = jpart.get("pid") offset = Vector3d.parse(jpart.get("vec", "(0,0,0)")) if uid in self.unit_trans: offset = self._transform_vector( (offset.x, offset.y, offset.z), self.unit_trans[uid]) trans_a = self._calculate_translation_transform(offset) # 变换零件 for root, part in parts.items(): if part.get("sw_pid") == pid: self._apply_transformation(part, trans_a) # 变换硬件 for root, hardware in hardwares.items(): if hardware.get("sw_pid") == pid: self._apply_transformation(hardware, trans_a) # 添加序号标签 if data.get("explode", False): self._add_part_labels(uid, parts) except Exception as e: logger.error(f"爆炸视图失败: {e}") def _add_part_labels(self, uid, parts): """添加零件标签""" try: for root, part in parts.items(): center = self._get_object_center(part) pos = part.get("sw_pos", 1) # 确定标签方向 if pos == 1: vector = (0, -1, 0) # F elif pos == 2: vector = (0, 1, 0) # K elif pos == 3: vector = (-1, 0, 0) # L elif pos == 4: vector = (1, 0, 0) # R elif pos == 5: vector = (0, 0, -1) # B else: vector = (0, 0, 1) # T # 应用单位变换 if uid in self.unit_trans: vector = self._transform_vector( vector, self.unit_trans[uid]) # 创建文本标签 ord_seq = part.get("sw_seq", 0) text_obj = self._create_text_label( str(ord_seq), center, vector) if text_obj: # 根据图层选择父对象 if self._is_in_door_layer(part): text_obj.parent = self.door_labels else: text_obj.parent = self.labels except Exception as e: logger.error(f"添加零件标签失败: {e}") def c12(self, data: Dict[str, Any]): """add_contour - 添加轮廓 - 线程安全版本""" try: if not BLENDER_AVAILABLE: return def create_contour(): try: self.added_contour = True surf = data.get("surf", {}) contour = self._create_contour_from_surf(surf) if contour: memory_manager.register_object(contour) return True return False except Exception as e: logger.error(f"创建轮廓失败: {e}") return False # 在主线程中执行轮廓创建 success = execute_in_main_thread(create_contour) if success: logger.info(f"✅ 成功创建轮廓") else: logger.error(f"❌ 轮廓创建失败") except Exception as e: logger.error(f"❌ 添加轮廓失败: {e}") def add_surf(self, data: Dict[str, Any]): """add_surf - 添加表面""" try: surf = data.get("surf", {}) self.create_face(bpy.context.scene, surf) except Exception as e: logger.error(f"添加表面失败: {e}") def c13(self, data: Dict[str, Any]): """save_pixmap - 保存像素图 - 线程安全版本""" try: if not BLENDER_AVAILABLE: return def save_pixmap(): try: uid = data.get("uid") file_path = data.get("file") # 设置渲染参数 bpy.context.scene.render.filepath = file_path bpy.context.scene.render.image_settings.file_format = 'PNG' # 渲染当前视图 bpy.ops.render.render(write_still=True) return True except Exception as e: logger.error(f"保存像素图失败: {e}") return False # 在主线程中执行渲染操作 success = execute_in_main_thread(save_pixmap) if success: logger.info(f"✅ 成功保存像素图") else: logger.error(f"❌ 像素图保存失败") except Exception as e: logger.error(f"❌ 保存像素图失败: {e}") def c14(self, data: Dict[str, Any]): """pre_save_pixmap - 预保存像素图 - 线程安全版本""" try: if not BLENDER_AVAILABLE: return def pre_save_pixmap(): try: self.sel_clear() # 设置视图 if hasattr(bpy.context, 'space_data') and bpy.context.space_data: bpy.context.space_data.show_gizmo = False bpy.context.space_data.show_overlays = False return True except Exception as e: logger.error(f"预保存像素图失败: {e}") return False # 在主线程中执行预处理操作 success = execute_in_main_thread(pre_save_pixmap) if success: logger.info(f"✅ 预保存像素图完成") else: logger.error(f"❌ 预保存像素图失败") except Exception as e: logger.error(f"❌ 预保存像素图失败: {e}") def show_message(self, data: Dict[str, Any]): """显示消息""" try: message = data.get("message", "") logger.info(f"显示消息: {message}") # 在Blender中显示消息 if BLENDER_AVAILABLE: # 可以使用报告系统 pass except Exception as e: logger.error(f"显示消息失败: {e}") # ==================== 辅助方法 ==================== def _set_cmd(self, cmd, params): """设置命令（发送到客户端）""" try: # 在实际应用中需要实现客户端通信逻辑 logger.info(f"发送命令: {cmd}, 参数: {params}") except Exception as e: logger.error(f"设置命令失败: {e}") def _clear_labels(self, label_obj): """清理标签""" try: if label_obj and BLENDER_AVAILABLE: for child in label_obj.children: bpy.data.objects.remove(child, do_unlink=True) except Exception as e: logger.error(f"清理标签失败: {e}") # ==================== 属性访问器 ==================== @classmethod def selected_uid(cls): return cls._selected_uid @classmethod def selected_zone(cls): return cls._selected_zone @classmethod def selected_part(cls): return cls._selected_part @classmethod def selected_obj(cls): return cls._selected_obj @classmethod def server_path(cls): return cls._server_path @classmethod def default_zone(cls): return cls._default_zone # ==================== 清理和销毁 ==================== def shutdown(self): """关闭系统""" try: logger.info("开始关闭SUWood系统") # 执行最终清理 self.force_cleanup() # 清理所有缓存 self.mesh_cache.clear() self.material_cache.clear() self.object_references.clear() # 清理数据结构 self.parts.clear() self.zones.clear() self.hardwares.clear() self.machinings.clear() self.dimensions.clear() self.textures.clear() self.unit_param.clear() self.unit_trans.clear() logger.info("✅ SUWood系统关闭完成") except Exception as e: logger.error(f"关闭系统失败: {e}") def __del__(self): """析构函数""" try: self.shutdown() except: pass # ==================== 内存管理方法（保持原有的优化） ==================== def force_cleanup(self): """强制清理""" try: logger.info("开始强制清理") # 清理孤立数据 cleanup_count = memory_manager.cleanup_orphaned_data() # 清理缓存 self.mesh_cache.clear() # 清理过期的对象引用 current_time = time.time() expired_refs = [] for obj_name, ref_info in self.object_references.items(): if current_time - ref_info.get('creation_time', 0) > 3600: # 1小时 expired_refs.append(obj_name) for obj_name in expired_refs: del self.object_references[obj_name] # 强制垃圾回收 gc.collect() # 更新依赖图 if BLENDER_AVAILABLE: self._update_dependency_graph(full_update=True) logger.info( f"强制清理完成: 清理了 {cleanup_count} 个数据块，{len(expired_refs)} 个过期引用") except Exception as e: logger.error(f"强制清理失败: {e}") def _update_dependency_graph(self, full_update: bool = False): """更新Blender依赖图""" try: if not BLENDER_AVAILABLE: return if full_update: logger.info("执行全局依赖图更新") bpy.context.view_layer.update() bpy.context.evaluated_depsgraph_get().update() # 刷新视图 try: for area in bpy.context.screen.areas: if area.type in ['VIEW_3D', 'OUTLINER']: area.tag_redraw() except: pass logger.info("全局依赖图更新完成") else: # 快速更新 bpy.context.view_layer.update() except Exception as e: logger.error(f"依赖图更新失败: {e}") def get_creation_stats(self) -> Dict[str, Any]: """获取创建统计信息""" try: stats = { "object_references": len(self.object_references), "mesh_cache_size": len(self.mesh_cache), "material_cache_size": len(self.material_cache), "memory_manager_stats": memory_manager.creation_stats.copy(), "blender_available": BLENDER_AVAILABLE } if BLENDER_AVAILABLE: stats["total_objects"] = len(bpy.data.objects) stats["total_meshes"] = len(bpy.data.meshes) stats["total_materials"] = len(bpy.data.materials) return stats except Exception as e: logger.error(f"获取统计信息失败: {e}") return {"error": str(e)} def diagnose_system_state(self): """诊断系统状态""" try: logger.info("=== 系统状态诊断 ===") # 内存使用情况 stats = self.get_creation_stats() for key, value in stats.items(): logger.info(f"{key}: {value}") # 检查潜在问题 issues = [] if BLENDER_AVAILABLE: # 检查孤立数据 orphaned_meshes = [m for m in bpy.data.meshes if m.users == 0] if orphaned_meshes: issues.append(f"发现 {len(orphaned_meshes)} 个孤立网格") # 检查空网格 empty_meshes = [m for m in bpy.data.meshes if not m.vertices] if empty_meshes: issues.append(f"发现 {len(empty_meshes)} 个空网格") # 检查总顶点数 total_vertices = sum(len(m.vertices) for m in bpy.data.meshes) if total_vertices > 1000000: # 100万顶点 issues.append(f"顶点数量过多: {total_vertices}") if issues: logger.warning("发现问题:") for issue in issues: logger.warning(f" - {issue}") else: logger.info("✅ 系统状态正常") return issues except Exception as e: logger.error(f"系统诊断失败: {e}") return [f"诊断失败: {e}"] def get_memory_report(self) -> Dict[str, Any]: """获取内存报告""" try: report = { "timestamp": time.time(), "creation_stats": self.get_creation_stats(), "system_diagnosis": self.diagnose_system_state(), "memory_manager": { "object_registry_size": len(memory_manager.object_registry), "mesh_registry_size": len(memory_manager.mesh_registry), "last_cleanup": memory_manager.last_cleanup_time, "cleanup_interval": memory_manager.cleanup_interval } } if BLENDER_AVAILABLE: report["blender_data"] = { "objects": len(bpy.data.objects), "meshes": len(bpy.data.meshes), "materials": len(bpy.data.materials), "textures": len(bpy.data.textures), "images": len(bpy.data.images) } return report except Exception as e: logger.error(f"生成内存报告失败: {e}") return {"error": str(e)} # ==================== 几何变换辅助方法 ==================== def _transform_point(self, point, trans): """变换点""" try: if isinstance(point, (list, tuple)) and len(point) >= 3: # 简化的变换实现 return ( point[0] + trans.origin.x, point[1] + trans.origin.y, point[2] + trans.origin.z ) return point except Exception as e: logger.error(f"变换点失败: {e}") return point def _transform_vector(self, vector, trans): """变换向量""" try: if isinstance(vector, (list, tuple)) and len(vector) >= 3: # 简化的变换实现 return ( vector[0] * trans.x_axis.x, vector[1] * trans.y_axis.y, vector[2] * trans.z_axis.z ) return vector except Exception as e: logger.error(f"变换向量失败: {e}") return vector def _calculate_swing_door_transform(self, door_ps, door_pe, door_off): """计算平开门变换""" try: # 计算旋转轴和角度 axis = (door_pe[0] - door_ps[0], door_pe[1] - door_ps[1], door_pe[2] - door_ps[2]) angle = math.pi / 2 # 90度 # 在Blender中创建变换矩阵 if BLENDER_AVAILABLE: import mathutils rot_matrix = mathutils.Matrix.Rotation(angle, 4, axis) trans_matrix = mathutils.Matrix.Translation(door_off) return trans_matrix @ rot_matrix return None except Exception as e: logger.error(f"计算平开门变换失败: {e}") return None def _calculate_slide_door_transform(self, door_off): """计算推拉门变换""" try: if BLENDER_AVAILABLE: import mathutils return mathutils.Matrix.Translation(door_off) return None except Exception as e: logger.error(f"计算推拉门变换失败: {e}") return None def _calculate_translation_transform(self, vector): """计算平移变换""" try: if BLENDER_AVAILABLE: import mathutils if isinstance(vector, (list, tuple)): return mathutils.Matrix.Translation(vector) else: return mathutils.Matrix.Translation((vector.x, vector.y, vector.z)) return None except Exception as e: logger.error(f"计算平移变换失败: {e}") return None def _invert_transform(self, transform): """反转变换""" try: if transform and hasattr(transform, 'inverted'): return transform.inverted() return transform except Exception as e: logger.error(f"反转变换失败: {e}") return transform def _normalize_vector(self, x, y, z): """归一化向量""" try: length = math.sqrt(x*x + y*y + z*z) if length > 0: return (x/length, y/length, z/length) return (0, 0, 1) except Exception as e: logger.error(f"归一化向量失败: {e}") return (0, 0, 1) def _get_object_center(self, obj): """获取对象中心""" try: if BLENDER_AVAILABLE and obj and hasattr(obj, 'location'): return obj.location return (0, 0, 0) except Exception as e: logger.error(f"获取对象中心失败: {e}") return (0, 0, 0) def _is_in_door_layer(self, part): """检查是否在门图层""" try: if not part or not self.door_layer: return False return part in self.door_layer.objects except Exception as e: logger.error(f"检查门图层失败: {e}") return False def _create_text_label(self, text, location, direction): """创建文本标签""" try: if not BLENDER_AVAILABLE: return None # 创建文本对象 font_curve = bpy.data.curves.new(type="FONT", name="TextLabel") font_curve.body = text font_obj = bpy.data.objects.new("TextLabel", font_curve) # 设置位置和方向 font_obj.location = location if isinstance(direction, (list, tuple)) and len(direction) >= 3: # 简化的方向设置 font_obj.location = ( location[0] + direction[0] * 0.1, location[1] + direction[1] * 0.1, location[2] + direction[2] * 0.1 ) bpy.context.scene.collection.objects.link(font_obj) memory_manager.register_object(font_obj) return font_obj except Exception as e: logger.error(f"创建文本标签失败: {e}") return None def _create_contour_from_surf(self, surf): """从表面创建轮廓""" try: if not BLENDER_AVAILABLE: return xaxis = Vector3d.parse(surf.get("vx", "(1,0,0)")) zaxis = Vector3d.parse(surf.get("vz", "(0,0,1)")) segs = surf.get("segs", []) edges = [] for seg in segs: if "c" in seg: # 弧形段 c = Point3d.parse(seg["c"]) r = seg.get("r", 1.0) * 0.001 a1 = seg.get("a1", 0.0) a2 = seg.get("a2", math.pi * 2) n = seg.get("n", 12) # 创建弧形边 arc_edges = self._create_arc_edges( c, xaxis, zaxis, r, a1, a2, n) edges.extend(arc_edges) else: # 直线段 s = Point3d.parse(seg.get("s", "(0,0,0)")) e = Point3d.parse(seg.get("e", "(0,0,0)")) edge = self._create_line_edge_simple(bpy.context.scene, (s.x, s.y, s.z), (e.x, e.y, e.z)) if edge: edges.append(edge) # 尝试创建面 try: if edges: self._create_face_from_edges(bpy.context.scene, edges) except Exception as e: logger.warning(f"创建轮廓面失败: {e}") except Exception as e: logger.error(f"创建轮廓失败: {e}") def _create_arc_edges(self, center, xaxis, zaxis, radius, start_angle, end_angle, segments): """创建弧形边""" try: if not BLENDER_AVAILABLE: return [] edges = [] angle_step = (end_angle - start_angle) / segments for i in range(segments): angle1 = start_angle + i * angle_step angle2 = start_angle + (i + 1) * angle_step # 计算点 x1 = center.x + radius * math.cos(angle1) y1 = center.y + radius * math.sin(angle1) z1 = center.z x2 = center.x + radius * math.cos(angle2) y2 = center.y + radius * math.sin(angle2) z2 = center.z edge = self._create_line_edge_simple(bpy.context.scene, (x1, y1, z1), (x2, y2, z2)) if edge: edges.append(edge) return edges except Exception as e: logger.error(f"创建弧形边失败: {e}") return [] def _create_dimension(self, p1, p2, direction, text): """创建尺寸标注""" try: if not BLENDER_AVAILABLE: return None # 在Blender中创建尺寸标注的简化实现 # 创建文本对象显示尺寸 midpoint = ( (p1[0] + p2[0]) / 2 + direction[0] * 0.1, (p1[1] + p2[1]) / 2 + direction[1] * 0.1, (p1[2] + p2[2]) / 2 + direction[2] * 0.1 ) dimension_obj = self._create_text_label(text, midpoint, direction) # 创建尺寸线 if dimension_obj: # 添加线条表示尺寸 line_mesh = bpy.data.meshes.new("DimensionLine") vertices = [p1, p2] edges = [(0, 1)] line_mesh.from_pydata(vertices, edges, []) line_mesh.update() line_obj = bpy.data.objects.new("DimensionLine", line_mesh) line_obj.parent = dimension_obj bpy.context.scene.collection.objects.link(line_obj) memory_manager.register_mesh(line_mesh) memory_manager.register_object(line_obj) return dimension_obj except Exception as e: logger.error(f"创建尺寸标注失败: {e}") return None # ==================== 几何体创建的辅助方法（补充） ==================== def _create_triangle_face(self, container, tri, offset_vec, base_point): """创建三角形面""" try: if not BLENDER_AVAILABLE: return None # 计算三角形的三个顶点 p1 = (tri.x, tri.y, tri.z) p2 = (tri.x + offset_vec.x, tri.y + offset_vec.y, tri.z + offset_vec.z) p3 = (base_point.x + (base_point.x - tri.x), base_point.y + (base_point.y - tri.y), base_point.z + (base_point.z - tri.z)) # 创建网格 mesh = bpy.data.meshes.new("Triangle_Face") vertices = [p1, p2, p3] faces = [(0, 1, 2)] mesh.from_pydata(vertices, [], faces) mesh.update() # 创建对象 obj = bpy.data.objects.new("Triangle_Face_Obj", mesh) obj.parent = container bpy.context.scene.collection.objects.link(obj) memory_manager.register_mesh(mesh) memory_manager.register_object(obj) return obj except Exception as e: logger.error(f"创建三角形面失败: {e}") return None def _create_circle_face(self, container, center, normal, radius): """创建圆形面""" try: if not BLENDER_AVAILABLE: return None # 创建圆形网格 mesh = bpy.data.meshes.new("Circle_Face") # 生成圆形顶点 segments = 32 vertices = [(center.x, center.y, center.z)] # 中心点 for i in range(segments): angle = (i / segments) * 2 * math.pi x = center.x + radius * math.cos(angle) y = center.y + radius * math.sin(angle) z = center.z vertices.append((x, y, z)) # 创建面 faces = [] for i in range(segments): next_i = (i + 1) % segments faces.append((0, i + 1, next_i + 1)) mesh.from_pydata(vertices, [], faces) mesh.update() # 创建对象 obj = bpy.data.objects.new("Circle_Face_Obj", mesh) obj.parent = container bpy.context.scene.collection.objects.link(obj) memory_manager.register_mesh(mesh) memory_manager.register_object(obj) return obj except Exception as e: logger.error(f"创建圆形面失败: {e}") return None def _apply_material_to_face(self, face, material): """为面应用材质""" try: if not face or not material or not BLENDER_AVAILABLE: return if hasattr(face, 'data') and face.data: if not face.data.materials: face.data.materials.append(material) else: face.data.materials[0] = material except Exception as e: logger.error(f"为面应用材质失败: {e}") def _follow_me_face(self, face, path): """面跟随路径""" try: if not face or not path or not BLENDER_AVAILABLE: return # 在Blender中实现跟随路径 # 这里使用简化的实现 if hasattr(face, 'modifiers'): # 添加阵列修改器或其他相关修改器 pass except Exception as e: logger.error(f"面跟随路径失败: {e}") def _cleanup_path(self, path): """清理路径""" try: if path and BLENDER_AVAILABLE and path.name in bpy.data.objects: bpy.data.objects.remove(path, do_unlink=True) except Exception as e: logger.error(f"清理路径失败: {e}") def _cleanup_trimmer(self, trimmer): """清理修剪器""" try: if trimmer and BLENDER_AVAILABLE and trimmer.name in bpy.data.objects: bpy.data.objects.remove(trimmer, do_unlink=True) except Exception as e: logger.error(f"清理修剪器失败: {e}") def _trim_object(self, trimmer, target): """修剪对象""" try: if not trimmer or not target or not BLENDER_AVAILABLE: return target # 在Blender中实现布尔运算 # 这里使用简化的实现 return target except Exception as e: logger.error(f"修剪对象失败: {e}") return target def _mark_differ_faces(self, obj): """标记差异面""" try: if not obj or not BLENDER_AVAILABLE: return texture = self.get_texture("mat_default") if not texture: return # 标记所有使用默认材质的面为差异面 for child in obj.children: if hasattr(child, 'data') and child.data: if (child.data.materials and child.data.materials[0] == texture): child["sw_differ"] = True except Exception as e: logger.error(f"标记差异面失败: {e}") # ==================== 几何验证辅助方法 ==================== def _should_reverse_face(self, face, zaxis, reverse_face): """检查是否应该反转面""" try: if not face or not zaxis: return False # 简化的实现 return reverse_face except Exception as e: logger.error(f"检查面反转失败: {e}") return False def _face_normal_matches(self, face, zaxis): """检查面法向量是否匹配""" try: if not face or not zaxis: return False # 简化的实现 return True except Exception as e: logger.error(f"检查面法向量失败: {e}") return False def _reverse_face(self, face): """反转面""" try: if not face or not BLENDER_AVAILABLE: return if hasattr(face, 'data') and face.data: # 在Blender中反转面的法向量 bpy.context.view_layer.objects.active = face bpy.ops.object.mode_set(mode='EDIT') bpy.ops.mesh.select_all(action='SELECT') bpy.ops.mesh.flip_normals() bpy.ops.object.mode_set(mode='OBJECT') except Exception as e: logger.error(f"反转面失败: {e}") def _get_face_normal(self, face): """获取面法向量""" try: if not face or not BLENDER_AVAILABLE: return (0, 0, 1) if hasattr(face, 'data') and face.data and face.data.polygons: # 获取第一个多边形的法向量 return face.data.polygons[0].normal return (0, 0, 1) except Exception as e: logger.error(f"获取面法向量失败: {e}") return (0, 0, 1) def _apply_follow_me(self, face, path): """应用跟随路径""" try: if not face or not path or not BLENDER_AVAILABLE: return # 在Blender中实现跟随路径的简化版本 # 这里需要根据实际需求实现具体的几何操作 pass except Exception as e: logger.error(f"应用跟随路径失败: {e}") def _hide_edges(self, container): """隐藏边""" try: if not container or not BLENDER_AVAILABLE: return for child in container.children: if hasattr(child, 'data') and child.data and hasattr(child.data, 'edges'): for edge in child.data.edges: edge.use_edge_sharp = True except Exception as e: logger.error(f"隐藏边失败: {e}") def _create_face_fast(self, container, surface, material): """创建面 - 快速版本""" try: # 获取分段数据 segs = surface.get("segs", []) if not segs: return None # 快速解析顶点 vertices = [] for seg in segs: if len(seg) >= 2: coord_str = seg[0].strip('()') try: x, y, z = map(float, coord_str.split(',')) vertices.append((x * 0.001, y * 0.001, z * 0.001)) except: continue if len(vertices) < 3: return None # 创建简单网格 mesh = bpy.data.meshes.new(f"FastFace_{int(time.time())}") # 创建面（只支持三角形和四边形） if len(vertices) == 4: faces = [(0, 1, 2, 3)] elif len(vertices) == 3: faces = [(0, 1, 2)] else: # 复杂多边形简化为第一个三角形 faces = [(0, 1, 2)] vertices = vertices[:3] mesh.from_pydata(vertices, [], faces) mesh.update() # 创建对象 face_obj = bpy.data.objects.new(f"Face_{container.name}", mesh) face_obj.parent = container bpy.context.scene.collection.objects.link(face_obj) # 应用材质 if material: face_obj.data.materials.append(material) # 确保可见 face_obj.hide_viewport = False # 注册到内存管理器 memory_manager.register_mesh(mesh) memory_manager.register_object(face_obj) return face_obj except Exception as e: logger.error(f"快速创建面失败: {e}") return None def _create_board_six_faces_fast(self, leaf, data, color, scale, angle, color2, scale2, angle2): """快速创建板件六个面""" try: # 获取正反面数据 obv = data.get("obv") # 正面 rev = data.get("rev") # 反面 if not obv or not rev: logger.warning("缺少正反面数据") return # 处理材质 antiz = data.get("antiz", False) # 根据antiz决定材质分配 if antiz: # 交换正反面材质 obv_color = color2 if color2 else color rev_color = color else: # 正常材质分配 obv_color = color rev_color = color2 if color2 else color # 获取材质 material_obv = self.get_texture(obv_color) if obv_color else None material_rev = self.get_texture(rev_color) if rev_color else None edge_material = material_obv # 边面使用正面材质 # 1. 创建正面 (obverse) obv_face = self._create_face_fast(leaf, obv, material_obv) if obv_face: obv_face["sw_face_type"] = "obverse" obv_face["sw_face_id"] = "front" obv_face["sw_ckey"] = obv_color logger.debug("正面创建成功") # 2. 创建反面 (reverse) rev_face = self._create_face_fast(leaf, rev, material_rev) if rev_face: rev_face["sw_face_type"] = "reverse" rev_face["sw_face_id"] = "back" rev_face["sw_ckey"] = rev_color logger.debug("反面创建成功") # 3. 创建四个边面 self._create_board_edge_faces_fast(leaf, obv, rev, edge_material) logger.debug("板件六面创建完成") except Exception as e: logger.error(f"创建板件六面失败: {e}") def _create_board_edge_faces_fast(self, leaf, obv, rev, edge_material): """快速创建板件的四个边面""" try: # 解析正面和反面的顶点 obv_vertices = self._parse_surface_vertices(obv) rev_vertices = self._parse_surface_vertices(rev) if len(obv_vertices) != len(rev_vertices) or len(obv_vertices) < 3: logger.warning("正反面顶点数量不匹配或不足") return # 创建四个边面 vertex_count = len(obv_vertices) edge_count = 0 for i in range(vertex_count): next_i = (i + 1) % vertex_count # 边面的四个顶点：正面两个点 + 反面对应两个点 edge_vertices = [ obv_vertices[i], # 正面当前点 obv_vertices[next_i], # 正面下一点 rev_vertices[next_i], # 反面下一点 rev_vertices[i] # 反面当前点 ] # 创建边面 edge_face = self._create_face_from_vertices_fast( leaf, edge_vertices, edge_material, f"edge_{i}") if edge_face: edge_face["sw_face_type"] = "edge" edge_face["sw_face_id"] = f"edge_{i}" edge_face["sw_edge_index"] = i edge_count += 1 logger.debug(f"创建了 {edge_count}/{vertex_count} 个边面") except Exception as e: logger.error(f"创建边面失败: {e}") def _parse_surface_vertices(self, surface): """解析表面顶点坐标""" try: vertices = [] segs = surface.get("segs", []) for seg in segs: if len(seg) >= 2: coord_str = seg[0].strip('()') try: x, y, z = map(float, coord_str.split(',')) # 转换为米（Blender使用米作为单位） vertices.append((x * 0.001, y * 0.001, z * 0.001)) except ValueError: continue return vertices except Exception as e: logger.error(f"解析表面顶点失败: {e}") return [] def _create_face_from_vertices_fast(self, container, vertices, material, face_name): """从顶点快速创建面""" try: if len(vertices) < 3: return None # 创建网格 mesh = bpy.data.meshes.new(f"Face_{face_name}_{int(time.time())}") # 创建面 if len(vertices) == 4: faces = [(0, 1, 2, 3)] elif len(vertices) == 3: faces = [(0, 1, 2)] else: # 复杂多边形创建扇形三角形 faces = [] for i in range(1, len(vertices) - 1): faces.append((0, i, i + 1)) mesh.from_pydata(vertices, [], faces) mesh.update() # 创建对象 face_obj = bpy.data.objects.new(f"Face_{face_name}", mesh) face_obj.parent = container bpy.context.scene.collection.objects.link(face_obj) # 应用材质 if material: face_obj.data.materials.append(material) # 确保可见 face_obj.hide_viewport = False # 注册到内存管理器 memory_manager.register_mesh(mesh) memory_manager.register_object(face_obj) return face_obj except Exception as e: logger.error(f"从顶点创建面失败: {e}") return None def _add_part_board_fast(self, part, data): """创建板材部件 - 保持六面逻辑的快速版本""" try: # 创建叶子组 leaf = bpy.data.objects.new( f"Board_{part.name}_{int(time.time())}", None) leaf.parent = part bpy.context.scene.collection.objects.link(leaf) # 获取材质信息 color = data.get("ckey", "mat_default") scale = data.get("scale") angle = data.get("angle") color2 = data.get("ckey2") scale2 = data.get("scale2") angle2 = data.get("angle2") # 设置叶子属性 leaf["sw_ckey"] = color if scale: leaf["sw_scale"] = scale if angle: leaf["sw_angle"] = angle logger.debug(f"板材材质: {color}") # 创建板件的六个面（正面、反面、四个边面） self._create_board_six_faces_fast( leaf, data, color, scale, angle, color2, scale2, angle2) logger.debug(f"板材部件创建完成: {leaf.name}") return leaf except Exception as e: logger.error(f"创建板材部件失败: {e}") return None def _create_transparent_material(self): """创建透明材质用于容器对象""" try: material_name = "SUW_Container_Transparent" # 检查是否已存在 if material_name in bpy.data.materials: return bpy.data.materials[material_name] # 创建透明材质 material = bpy.data.materials.new(name=material_name) material.use_nodes = True # 清理默认节点 material.node_tree.nodes.clear() # 创建节点 bsdf = material.node_tree.nodes.new( type='ShaderNodeBsdfPrincipled') bsdf.location = (0, 0) output = material.node_tree.nodes.new( type='ShaderNodeOutputMaterial') output.location = (300, 0) # 连接节点 material.node_tree.links.new( bsdf.outputs['BSDF'], output.inputs['Surface']) # 设置完全透明 bsdf.inputs['Base Color'].default_value = ( 0.5, 0.5, 0.5, 1.0) # 灰色 bsdf.inputs['Alpha'].default_value = 0.0 # 完全透明 # 设置混合模式 material.blend_method = 'BLEND' material.use_backface_culling = False logger.info(f"✅ 创建容器透明材质: {material_name}") return material except Exception as e: logger.error(f"创建透明材质失败: {e}") return None def c03(self, data: Dict[str, Any]): """add_zone - 添加区域 - 修复父对象设置问题""" try: if not BLENDER_AVAILABLE: logger.error("Blender不可用") return uid = data.get("uid") zid = data.get("zid") zip_id = data.get("zip", -1) elements = data.get("children", []) logger.info(f"🏗️ 开始创建区域: uid={uid}, zid={zid}, zip={zip_id}") def create_zone(): try: # 创建区域组 - 保持为Empty对象 group_name = f"Zone_{zid}" group = bpy.data.objects.new(group_name, None) # 设置父对象 - 根据zip_id查找父Zone if zip_id > 0: # 查找父Zone parent_zone_name = f"Zone_{zip_id}" parent_zone = bpy.data.objects.get(parent_zone_name) if parent_zone: group.parent = parent_zone else: logger.warning(f"未找到父Zone: {parent_zone_name}") # 如果zip_id <= 0，则不设置父对象（顶级Zone） # 设置属性 group["sw_uid"] = uid group["sw_zid"] = zid group["sw_zip"] = zip_id group["sw_typ"] = "zid" bpy.context.scene.collection.objects.link(group) # 将Zone存储到zones字典中 zones_dict = self.get_zones(data) zones_dict[zid] = group # 处理子元素 - 给face应用透明材质 for element in elements: surf = element.get("surf") if surf: self.create_face_safe( group, surf, transparent=True) logger.info(f"✅ 区域创建完成: {group_name}") return group except Exception as e: logger.error(f"创建区域失败: {e}") return None # 在主线程执行 return execute_in_main_thread(create_zone) except Exception as e: logger.error(f"c03命令失败: {e}") return None def create_face_safe(self, container, surface, color=None, scale=None, angle=None, series=None, reverse_face=False, back_material=True, saved_color=None, typ=None, transparent=False): """创建面 - 支持透明材质选项""" try: if not BLENDER_AVAILABLE: logger.error("Blender不可用") return None # 获取分段数据 segs = surface.get("segs", []) if not segs: logger.error("没有分段数据") return None # 创建顶点 vertices = [] for i, seg in enumerate(segs): if len(seg) >= 2: coord_str = seg[0].strip('()') try: x, y, z = map(float, coord_str.split(',')) # 转换为米（Blender使用米作为单位） vertex = (x * 0.001, y * 0.001, z * 0.001) vertices.append(vertex) except ValueError as e: logger.error(f"解析顶点失败: {coord_str}, 错误: {e}") continue if len(vertices) < 3: logger.error(f"顶点数量不足，无法创建面: {len(vertices)}") return None # 创建网格 mesh_name = f"Face_{surface.get('f', 0)}_{int(time.time())}" mesh = bpy.data.meshes.new(mesh_name) # 创建面 edges = [] faces = [] if len(vertices) == 4: # 四边形 faces = [(0, 1, 2, 3)] elif len(vertices) == 3: # 三角形 faces = [(0, 1, 2)] else: # 复杂多边形，创建扇形三角形 for i in range(1, len(vertices) - 1): faces.append((0, i, i + 1)) # 从顶点、边、面创建网格 mesh.from_pydata(vertices, edges, faces) mesh.update() # 创建对象 obj_name = f"Face_{surface.get('f', 0)}" face_obj = bpy.data.objects.new(obj_name, mesh) # 设置父对象 face_obj.parent = container # 添加到场景 bpy.context.scene.collection.objects.link(face_obj) # 设置面属性 if surface.get("p"): face_obj["sw_p"] = surface["p"] if surface.get("f"): face_obj["sw_f"] = surface["f"] # 确保对象可见 face_obj.hide_viewport = False face_obj.hide_render = False face_obj.hide_set(False) # 应用材质 if transparent: # 应用透明材质 transparent_material = self._create_transparent_material() if transparent_material: face_obj.data.materials.append(transparent_material) logger.info(f"✅ Face {obj_name} 应用透明材质") elif color: # 应用指定材质 material = self.get_texture(color) if material: face_obj.data.materials.append(material) else: # 创建默认材质 default_mat = bpy.data.materials.new( name="DefaultMaterial") default_mat.use_nodes = True default_mat.node_tree.nodes["Principled BSDF"].inputs[0].default_value = ( 0.8, 0.8, 0.8, 1.0) face_obj.data.materials.append(default_mat) # 注册到内存管理器 memory_manager.register_mesh(mesh) memory_manager.register_object(face_obj) # 添加到series（如果提供） if series is not None: series.append(face_obj) return face_obj except Exception as e: logger.error(f"创建面失败: {e}") return None # ==================== 模块级别的便利函数 ==================== def create_suw_instance(): """创建SUW实例的便利函数""" return SUWImpl.get_instance() def cleanup_blender_memory(): """清理Blender内存的便利函数""" try: if BLENDER_AVAILABLE: cleanup_count = memory_manager.cleanup_orphaned_data() gc.collect() logger.info(f"清理了 {cleanup_count} 个孤立数据") return cleanup_count return 0 except Exception as e: logger.error(f"清理内存失败: {e}") return 0 def get_memory_usage_summary(): """获取内存使用摘要""" try: if BLENDER_AVAILABLE: return { "objects": len(bpy.data.objects), "meshes": len(bpy.data.meshes), "materials": len(bpy.data.materials), "memory_manager_stats": memory_manager.creation_stats.copy() } return {"blender_available": False} except Exception as e: logger.error(f"获取内存使用摘要失败: {e}") return {"error": str(e)} # ==================== 主程序入口 ==================== if __name__ == "__main__": # 测试代码 try: logger.info("开始测试SUWImpl内存管理") # 创建实例 suw = create_suw_instance() suw.startup() # 获取内存报告 report = suw.get_memory_report() logger.info(f"内存报告: {report}") # 执行诊断 issues = suw.diagnose_system_state() if not issues: logger.info("✅ 系统状态正常") # 清理测试 cleanup_count = cleanup_blender_memory() logger.info(f"清理测试完成: {cleanup_count}") except Exception as e: logger.error(f"测试失败: {e}") finally: logger.info("测试完成")