blenderpython/suw_core/machining_manager.py

#!/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