suwoodblender/blenderpython/suw_impl - 副本 (2).py

            # 清理选择状态
            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("测试完成")