1070 lines
44 KiB
Python
1070 lines
44 KiB
Python
#!/usr/bin/env python3
|
||
# -*- coding: utf-8 -*-
|
||
"""
|
||
SUW Core - Door Drawer Manager Module
|
||
拆分自: suw_impl.py (Line 1809-1834, 6163-6240)
|
||
用途: Blender门抽屉管理、变换计算、属性设置
|
||
版本: 1.0.0
|
||
作者: SUWood Team
|
||
"""
|
||
|
||
from .geometry_utils import Vector3d, Point3d
|
||
from .memory_manager import memory_manager
|
||
from .data_manager import data_manager, get_data_manager
|
||
import math
|
||
import logging
|
||
from typing import Dict, Any, Optional, List, Tuple
|
||
|
||
# 设置日志
|
||
logger = logging.getLogger(__name__)
|
||
|
||
# 检查Blender可用性
|
||
try:
|
||
import bpy
|
||
import mathutils
|
||
BLENDER_AVAILABLE = True
|
||
except ImportError:
|
||
BLENDER_AVAILABLE = False
|
||
|
||
# 导入依赖模块
|
||
|
||
# ==================== 门抽屉管理器类 ====================
|
||
|
||
|
||
class DoorDrawerManager:
|
||
"""门抽屉管理器 - 负责所有门抽屉相关操作"""
|
||
|
||
def __init__(self):
|
||
"""
|
||
初始化门抽屉管理器 - 完全独立，不依赖suw_impl
|
||
"""
|
||
# 使用全局数据管理器
|
||
self.data_manager = get_data_manager()
|
||
|
||
if BLENDER_AVAILABLE:
|
||
try:
|
||
# 确保 DOOR_LAYER 集合存在
|
||
if hasattr(bpy.data, 'collections'):
|
||
self.door_layer = bpy.data.collections.get("DOOR_LAYER")
|
||
if not self.door_layer:
|
||
self.door_layer = bpy.data.collections.new("DOOR_LAYER")
|
||
if hasattr(bpy.context, 'scene') and bpy.context.scene:
|
||
bpy.context.scene.collection.children.link(self.door_layer)
|
||
|
||
# 确保 DRAWER_LAYER 集合存在
|
||
self.drawer_layer = bpy.data.collections.get("DRAWER_LAYER")
|
||
if not self.drawer_layer:
|
||
self.drawer_layer = bpy.data.collections.new("DRAWER_LAYER")
|
||
if hasattr(bpy.context, 'scene') and bpy.context.scene:
|
||
bpy.context.scene.collection.children.link(self.drawer_layer)
|
||
else:
|
||
logger.warning("⚠️ bpy.data.collections 不可用，跳过集合创建")
|
||
self.door_layer = None
|
||
self.drawer_layer = None
|
||
except Exception as e:
|
||
logger.warning(f"⚠️ 创建门抽屉集合失败: {e}")
|
||
self.door_layer = None
|
||
self.drawer_layer = None
|
||
else:
|
||
self.door_layer = None
|
||
self.drawer_layer = None
|
||
|
||
logger.info("DoorDrawerManager 初始化完成")
|
||
|
||
# ==================== 门抽屉属性设置 ====================
|
||
|
||
def set_drawer_properties(self, part, data):
|
||
"""设置抽屉属性"""
|
||
try:
|
||
drawer_type = data.get("drw", 0)
|
||
part["sw_drawer"] = drawer_type
|
||
|
||
if drawer_type in [73, 74]: # DR_LP/DR_RP
|
||
part["sw_dr_depth"] = data.get("drd", 0)
|
||
|
||
if drawer_type == 70: # DR_DP
|
||
drv = data.get("drv")
|
||
if drv:
|
||
drawer_dir = Vector3d.parse(drv)
|
||
part["sw_drawer_dir"] = (
|
||
drawer_dir.x, drawer_dir.y, drawer_dir.z)
|
||
|
||
except Exception as e:
|
||
logger.error(f"设置抽屉属性失败: {e}")
|
||
|
||
def set_door_properties(self, part, data):
|
||
"""设置门属性"""
|
||
try:
|
||
door_type = data.get("dor", 0)
|
||
part["sw_door"] = door_type
|
||
|
||
if door_type in [10, 15]:
|
||
part["sw_door_width"] = data.get("dow", 0)
|
||
part["sw_door_pos"] = data.get("dop", "F")
|
||
|
||
except Exception as e:
|
||
logger.error(f"设置门属性失败: {e}")
|
||
|
||
# ==================== 门变换计算 ====================
|
||
|
||
def calculate_swing_door_transform(self, door_ps, door_pe, door_off):
|
||
"""计算平开门变换 - 修复版本，正确处理单位转换"""
|
||
try:
|
||
if not BLENDER_AVAILABLE:
|
||
return None
|
||
|
||
# 【修复】确保坐标使用正确的单位（米）
|
||
# 如果输入是毫米，需要转换为米
|
||
def convert_to_meters(coord):
|
||
if isinstance(coord, (list, tuple)):
|
||
# 检查是否需要转换（如果数值大于100，可能是毫米）
|
||
return tuple(x * 0.001 if abs(x) > 100 else x for x in coord)
|
||
return coord
|
||
|
||
# 转换坐标到米
|
||
door_ps = convert_to_meters(door_ps)
|
||
door_pe = convert_to_meters(door_pe)
|
||
door_off = convert_to_meters(door_off)
|
||
|
||
logger.debug(f"🔧 转换后的坐标（米）:")
|
||
logger.debug(f" door_ps: {door_ps}")
|
||
logger.debug(f" door_pe: {door_pe}")
|
||
logger.debug(f" door_off: {door_off}")
|
||
|
||
# 计算旋转轴（从起点到终点的向量）
|
||
axis = (
|
||
door_pe[0] - door_ps[0],
|
||
door_pe[1] - door_ps[1],
|
||
door_pe[2] - door_ps[2]
|
||
)
|
||
|
||
# 归一化旋转轴
|
||
axis_length = math.sqrt(axis[0]**2 + axis[1]**2 + axis[2]**2)
|
||
if axis_length > 0:
|
||
axis = (axis[0]/axis_length, axis[1] /
|
||
axis_length, axis[2]/axis_length)
|
||
else:
|
||
logger.error("旋转轴长度为零")
|
||
return None
|
||
|
||
# 创建旋转矩阵（以door_ps为中心，绕axis轴旋转90度）
|
||
angle = 1.5708 # 90度 = π/2
|
||
|
||
# 【修复】简化变换计算，避免复杂的矩阵组合
|
||
# 直接创建以door_ps为中心的旋转矩阵
|
||
rot_matrix = mathutils.Matrix.Rotation(angle, 4, axis)
|
||
|
||
# 创建平移矩阵
|
||
trans_matrix = mathutils.Matrix.Translation(door_off)
|
||
|
||
# 组合变换：先旋转，再平移
|
||
final_transform = trans_matrix @ rot_matrix
|
||
|
||
logger.debug(f"🔧 平开门变换计算:")
|
||
logger.debug(f" 旋转中心: {door_ps}")
|
||
logger.debug(f" 旋转轴: {axis}")
|
||
logger.debug(f" 旋转角度: {angle} 弧度")
|
||
logger.debug(f" 偏移: {door_off}")
|
||
|
||
return final_transform
|
||
|
||
except Exception as e:
|
||
logger.error(f"计算平开门变换失败: {e}")
|
||
return None
|
||
|
||
def calculate_slide_door_transform(self, door_off):
|
||
"""计算推拉门变换"""
|
||
try:
|
||
if BLENDER_AVAILABLE:
|
||
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:
|
||
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 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 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 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 apply_transformation(self, obj, transform):
|
||
"""应用变换到对象"""
|
||
try:
|
||
if not BLENDER_AVAILABLE or not obj:
|
||
return False
|
||
|
||
# 检查对象是否有效
|
||
if not self._is_object_valid(obj):
|
||
return False
|
||
|
||
# 应用变换到对象的矩阵
|
||
if hasattr(obj, 'matrix_world'):
|
||
# 将变换矩阵应用到当前矩阵
|
||
obj.matrix_world = transform @ obj.matrix_world
|
||
logger.debug(f"✅ 变换应用到 {obj.name}: {transform}")
|
||
return True
|
||
else:
|
||
logger.warning(f"对象 {obj} 没有 matrix_world 属性")
|
||
return False
|
||
|
||
except Exception as e:
|
||
logger.error(f"应用变换失败: {e}")
|
||
return False
|
||
|
||
def transform_vector(self, vector, transform):
|
||
"""变换向量"""
|
||
try:
|
||
if not BLENDER_AVAILABLE or not transform:
|
||
return vector
|
||
|
||
if isinstance(vector, (list, tuple)) and len(vector) >= 3:
|
||
vec = mathutils.Vector(vector)
|
||
transformed = transform @ vec
|
||
return (transformed.x, transformed.y, transformed.z)
|
||
|
||
return vector
|
||
except Exception as e:
|
||
logger.error(f"变换向量失败: {e}")
|
||
return vector
|
||
|
||
def transform_point(self, point, transform):
|
||
"""变换点"""
|
||
try:
|
||
if not BLENDER_AVAILABLE or not transform:
|
||
return point
|
||
|
||
if hasattr(point, 'x'):
|
||
vec = mathutils.Vector((point.x, point.y, point.z))
|
||
elif isinstance(point, (list, tuple)) and len(point) >= 3:
|
||
vec = mathutils.Vector(point)
|
||
else:
|
||
return point
|
||
|
||
transformed = transform @ vec
|
||
return Point3d(transformed.x, transformed.y, transformed.z)
|
||
except Exception as e:
|
||
logger.error(f"变换点失败: {e}")
|
||
return point
|
||
|
||
# ==================== 管理器统计 ====================
|
||
|
||
def get_door_drawer_stats(self) -> Dict[str, Any]:
|
||
"""获取门抽屉管理器统计信息"""
|
||
try:
|
||
stats = {
|
||
"manager_type": "DoorDrawerManager",
|
||
"door_layer_objects": 0,
|
||
"has_door_layer": self.door_layer is not None,
|
||
"blender_available": BLENDER_AVAILABLE
|
||
}
|
||
|
||
if self.door_layer and BLENDER_AVAILABLE:
|
||
stats["door_layer_objects"] = len(self.door_layer.objects)
|
||
|
||
return stats
|
||
except Exception as e:
|
||
logger.error(f"获取门抽屉统计失败: {e}")
|
||
return {"error": str(e)}
|
||
|
||
def c10(self, data: Dict[str, Any]):
|
||
"""set_doorinfo - 设置门的方向、起点、终点、偏移等属性"""
|
||
try:
|
||
parts = self.data_manager.get_parts(data)
|
||
doors = data.get("drs", [])
|
||
for door in doors:
|
||
root = door.get("cp", 0)
|
||
door_dir = door.get("dov", "")
|
||
ps = door.get("ps")
|
||
pe = door.get("pe")
|
||
offset = door.get("off")
|
||
# 解析点和向量字符串
|
||
if isinstance(ps, str):
|
||
ps = self._parse_point3d(ps)
|
||
if isinstance(pe, str):
|
||
pe = self._parse_point3d(pe)
|
||
if isinstance(offset, str):
|
||
offset = self._parse_vector3d(offset)
|
||
if root > 0 and root in parts:
|
||
part = parts[root]
|
||
part["sw_door_dir"] = door_dir
|
||
part["sw_door_ps"] = ps
|
||
part["sw_door_pe"] = pe
|
||
part["sw_door_offset"] = offset
|
||
logger.info("✅ 门信息已设置")
|
||
return True
|
||
except Exception as e:
|
||
logger.error(f"设置门信息失败: {e}")
|
||
return False
|
||
|
||
def c18(self, data: Dict[str, Any]):
|
||
"""hide_door - 隐藏门板"""
|
||
try:
|
||
visible = not data.get("v", False)
|
||
logger.info(f" 设置门板可见性: {visible}")
|
||
|
||
if not BLENDER_AVAILABLE:
|
||
logger.warning("Blender 不可用，跳过门板隐藏操作")
|
||
return True
|
||
|
||
# 查找所有标记为门板图层的部件和板材
|
||
hidden_count = 0
|
||
for obj in bpy.data.objects:
|
||
try:
|
||
# 检查是否是门板部件 (layer=1)
|
||
if (obj.get("sw_layer") == 1 and
|
||
obj.get("sw_typ") == "part"):
|
||
obj.hide_viewport = not visible
|
||
hidden_count += 1
|
||
logger.debug(f"🚪 设置门板部件可见性: {obj.name} -> {visible}")
|
||
|
||
# 检查是否是门板板材 (父对象是门板部件)
|
||
elif (obj.get("sw_typ") == "board" and
|
||
obj.parent and
|
||
obj.parent.get("sw_layer") == 1):
|
||
obj.hide_viewport = not visible
|
||
hidden_count += 1
|
||
logger.debug(f"🚪 设置门板板材可见性: {obj.name} -> {visible}")
|
||
|
||
except Exception as e:
|
||
logger.debug(f"处理对象 {obj.name} 时出错: {e}")
|
||
continue
|
||
|
||
logger.info(f"✅ 门板隐藏操作完成: 处理了 {hidden_count} 个对象，可见性={visible}")
|
||
|
||
# 如果有门标签，也设置其可见性
|
||
if (hasattr(self.data_manager, 'door_labels') and
|
||
self.data_manager.door_labels):
|
||
if BLENDER_AVAILABLE:
|
||
self.data_manager.door_labels.hide_viewport = not visible
|
||
logger.info(f"✅ 门标签可见性已设置: {visible}")
|
||
|
||
return True
|
||
except Exception as e:
|
||
logger.error(f"隐藏门板失败: {e}")
|
||
return False
|
||
|
||
def c28(self, data: Dict[str, Any]):
|
||
"""hide_drawer - 隐藏抽屉"""
|
||
try:
|
||
visible = not data.get("v", False)
|
||
logger.info(f" 设置抽屉可见性: {visible}")
|
||
|
||
if not BLENDER_AVAILABLE:
|
||
logger.warning("Blender 不可用，跳过抽屉隐藏操作")
|
||
return True
|
||
|
||
# 查找所有标记为抽屉图层的部件和板材
|
||
hidden_count = 0
|
||
for obj in bpy.data.objects:
|
||
try:
|
||
# 检查是否是抽屉部件 (layer=2)
|
||
if (obj.get("sw_layer") == 2 and
|
||
obj.get("sw_typ") == "part"):
|
||
obj.hide_viewport = not visible
|
||
hidden_count += 1
|
||
logger.debug(f"📦 设置抽屉部件可见性: {obj.name} -> {visible}")
|
||
|
||
# 检查是否是抽屉板材 (父对象是抽屉部件)
|
||
elif (obj.get("sw_typ") == "board" and
|
||
obj.parent and
|
||
obj.parent.get("sw_layer") == 2):
|
||
obj.hide_viewport = not visible
|
||
hidden_count += 1
|
||
logger.debug(f"📦 设置抽屉板材可见性: {obj.name} -> {visible}")
|
||
|
||
except Exception as e:
|
||
logger.debug(f"处理对象 {obj.name} 时出错: {e}")
|
||
continue
|
||
|
||
logger.info(f"✅ 抽屉隐藏操作完成: 处理了 {hidden_count} 个对象，可见性={visible}")
|
||
|
||
# 如果有门标签，也设置其可见性（参考Ruby版本）
|
||
if (hasattr(self.data_manager, 'door_labels') and
|
||
self.data_manager.door_labels):
|
||
if BLENDER_AVAILABLE:
|
||
self.data_manager.door_labels.hide_viewport = not visible
|
||
logger.info(f"✅ 门标签可见性已设置: {visible}")
|
||
|
||
return True
|
||
except Exception as e:
|
||
logger.error(f"隐藏抽屉失败: {e}")
|
||
return False
|
||
|
||
def c1a(self, data: Dict[str, Any]):
|
||
"""open_doors - 打开门板"""
|
||
try:
|
||
if not BLENDER_AVAILABLE:
|
||
logger.warning("Blender 不可用，跳过门板打开操作")
|
||
return True
|
||
|
||
uid = data.get("uid")
|
||
mydoor = data.get("cp", 0)
|
||
value = data.get("v", False)
|
||
|
||
logger.info(f" 执行门板打开操作: uid={uid}, cp={mydoor}, v={value}")
|
||
|
||
# 【修复】在开始处理之前清理无效的对象引用
|
||
self._cleanup_invalid_references(data)
|
||
|
||
# 获取部件和硬件数据
|
||
parts = self.data_manager.get_parts(data)
|
||
hardwares = self.data_manager.get_hardwares(data)
|
||
|
||
processed_count = 0
|
||
|
||
for root, part in parts.items():
|
||
# 【修复】检查对象是否仍然有效，避免访问已删除的对象
|
||
if not self._is_object_valid(part):
|
||
logger.warning(f"⚠️ 部件对象已无效，跳过处理: {root}")
|
||
continue
|
||
|
||
# 检查是否匹配指定的门板
|
||
if mydoor != 0 and mydoor != root:
|
||
continue
|
||
|
||
# 检查门板类型
|
||
try:
|
||
door_type = part.get("sw_door", 0)
|
||
except Exception as e:
|
||
logger.warning(f"⚠️ 无法获取门板类型，跳过处理: {root}, 错误: {e}")
|
||
continue
|
||
|
||
if door_type <= 0:
|
||
continue
|
||
|
||
# 检查当前开门状态
|
||
try:
|
||
is_open = part.get("sw_door_open", False)
|
||
except Exception as e:
|
||
logger.warning(f"⚠️ 无法获取开门状态，跳过处理: {root}, 错误: {e}")
|
||
continue
|
||
|
||
if is_open == value:
|
||
continue
|
||
|
||
# 只处理平开门(10)和推拉门(15)
|
||
if door_type not in [10, 15]:
|
||
continue
|
||
|
||
logger.info(
|
||
f"🔧 处理门板 {root}: door_type={door_type}, is_open={is_open}, target={value}")
|
||
|
||
# 获取门板变换信息
|
||
try:
|
||
door_ps = part.get("sw_door_ps")
|
||
door_pe = part.get("sw_door_pe")
|
||
door_off = part.get("sw_door_offset")
|
||
except Exception as e:
|
||
logger.warning(f"⚠️ 无法获取门板变换信息，跳过处理: {root}, 错误: {e}")
|
||
continue
|
||
|
||
logger.debug(f" 门板变换信息（原始）:")
|
||
logger.debug(f" door_ps: {door_ps}")
|
||
logger.debug(f" door_pe: {door_pe}")
|
||
logger.debug(f" door_off: {door_off}")
|
||
|
||
# 【修复】检查门板当前位置
|
||
try:
|
||
if hasattr(part, 'location'):
|
||
logger.debug(f" 门板当前位置: {part.location}")
|
||
except Exception as e:
|
||
logger.warning(f"⚠️ 无法获取门板位置，跳过处理: {root}, 错误: {e}")
|
||
continue
|
||
|
||
if door_type == 10: # 平开门
|
||
if not all([door_ps, door_pe, door_off]):
|
||
logger.warning(f"门板 {root} 缺少变换信息，跳过")
|
||
continue
|
||
|
||
# 【修复】按照Ruby版本的正确逻辑
|
||
try:
|
||
# 【修复】坐标已经在c10中被转换过了，这里直接使用
|
||
# 检查坐标是否已经是元组格式（已转换）
|
||
if isinstance(door_ps, tuple):
|
||
# 已经是转换后的坐标，直接使用
|
||
door_ps_coords = door_ps
|
||
logger.debug(
|
||
f" 使用已转换的door_ps坐标: {door_ps_coords}")
|
||
else:
|
||
# 需要转换
|
||
door_ps_coords = self._parse_point3d(door_ps)
|
||
logger.debug(
|
||
f" 转换door_ps坐标: {door_ps} -> {door_ps_coords}")
|
||
|
||
if isinstance(door_pe, tuple):
|
||
# 已经是转换后的坐标，直接使用
|
||
door_pe_coords = door_pe
|
||
logger.debug(
|
||
f" 使用已转换的door_pe坐标: {door_pe_coords}")
|
||
else:
|
||
# 需要转换
|
||
door_pe_coords = self._parse_point3d(door_pe)
|
||
logger.debug(
|
||
f" 转换door_pe坐标: {door_pe} -> {door_pe_coords}")
|
||
|
||
if isinstance(door_off, tuple):
|
||
# 已经是转换后的坐标，直接使用
|
||
door_off_coords = door_off
|
||
logger.debug(
|
||
f" 使用已转换的door_off坐标: {door_off_coords}")
|
||
else:
|
||
# 需要转换
|
||
door_off_coords = self._parse_vector3d(door_off)
|
||
logger.debug(
|
||
f" 转换door_off坐标: {door_off} -> {door_off_coords}")
|
||
|
||
# 【新增】检查坐标值是否过小，如果是，说明被转换了两次
|
||
def check_and_fix_coordinates(coords, name):
|
||
"""检查并修复过小的坐标值"""
|
||
if any(abs(coord) < 0.001 for coord in coords):
|
||
# 坐标值过小，可能是被转换了两次，需要放大1000倍
|
||
fixed_coords = (
|
||
coords[0] * 1000, coords[1] * 1000, coords[2] * 1000)
|
||
logger.info(
|
||
f"🔄 修复过小的{name}坐标: {coords} -> {fixed_coords}")
|
||
return fixed_coords
|
||
return coords
|
||
|
||
# 检查并修复所有坐标
|
||
door_ps_coords = check_and_fix_coordinates(
|
||
door_ps_coords, "door_ps")
|
||
door_pe_coords = check_and_fix_coordinates(
|
||
door_pe_coords, "door_pe")
|
||
door_off_coords = check_and_fix_coordinates(
|
||
door_off_coords, "door_off")
|
||
|
||
logger.debug(f" 门板变换信息（修复后，米）:")
|
||
logger.debug(f" door_ps: {door_ps_coords}")
|
||
logger.debug(f" door_pe: {door_pe_coords}")
|
||
logger.debug(f" door_off: {door_off_coords}")
|
||
|
||
# 应用单元变换
|
||
if hasattr(self.data_manager, 'unit_trans') and uid in self.data_manager.unit_trans:
|
||
unit_trans = self.data_manager.unit_trans[uid]
|
||
door_ps_coords = self.transform_point(
|
||
door_ps_coords, unit_trans)
|
||
door_pe_coords = self.transform_point(
|
||
door_pe_coords, unit_trans)
|
||
door_off_coords = self.transform_vector(
|
||
door_off_coords, unit_trans)
|
||
logger.debug(f" 应用单元变换后:")
|
||
logger.debug(f" door_ps: {door_ps_coords}")
|
||
logger.debug(f" door_pe: {door_pe_coords}")
|
||
logger.debug(f" door_off: {door_off_coords}")
|
||
|
||
# 【修复】按照Ruby版本：以door_ps为旋转中心，以(door_pe-door_ps)为旋转轴
|
||
# 计算旋转轴（从起点到终点的向量）
|
||
rotation_axis = (
|
||
door_pe_coords[0] - door_ps_coords[0],
|
||
door_pe_coords[1] - door_ps_coords[1],
|
||
door_pe_coords[2] - door_ps_coords[2]
|
||
)
|
||
|
||
# 归一化旋转轴
|
||
axis_length = math.sqrt(
|
||
rotation_axis[0]**2 + rotation_axis[1]**2 + rotation_axis[2]**2)
|
||
if axis_length > 0:
|
||
rotation_axis = (
|
||
rotation_axis[0] / axis_length,
|
||
rotation_axis[1] / axis_length,
|
||
rotation_axis[2] / axis_length
|
||
)
|
||
else:
|
||
logger.error(f"旋转轴长度为零: {rotation_axis}")
|
||
continue
|
||
|
||
# 【修复】简化变换逻辑，直接按照Ruby版本的方式
|
||
angle = 1.5708 # 90度 = π/2
|
||
|
||
# 创建以door_ps为中心的旋转变换
|
||
rotation_transform = self._create_rotation_around_point(
|
||
door_ps_coords, rotation_axis, angle)
|
||
|
||
# 创建平移变换
|
||
translation_transform = mathutils.Matrix.Translation(
|
||
door_off_coords)
|
||
|
||
# 组合变换：先旋转，再平移
|
||
final_transform = translation_transform @ rotation_transform
|
||
|
||
# 如果门板已经打开，需要反转变换来关闭
|
||
if is_open:
|
||
final_transform = final_transform.inverted()
|
||
logger.info(f" 门板已打开，反转变换来关闭")
|
||
|
||
# 【调试】添加详细的变换信息
|
||
logger.info(f"🔧 门板 {root} 变换详情:")
|
||
logger.info(
|
||
f" 原始坐标: door_ps={door_ps_coords}, door_pe={door_pe_coords}, door_off={door_off_coords}")
|
||
logger.info(f" 旋转中心: {door_ps_coords}")
|
||
logger.info(f" 旋转轴: {rotation_axis}")
|
||
logger.info(f" 旋转角度: {angle} 弧度")
|
||
logger.info(f" 平移向量: {door_off_coords}")
|
||
logger.info(
|
||
f" 门板状态: {'已打开，需要关闭' if is_open else '已关闭，需要打开'}")
|
||
|
||
# 检查门板当前位置
|
||
try:
|
||
if hasattr(part, 'location'):
|
||
logger.info(f" 门板当前位置: {part.location}")
|
||
except Exception as e:
|
||
logger.warning(
|
||
f"⚠️ 无法获取门板位置，跳过处理: {root}, 错误: {e}")
|
||
continue
|
||
|
||
# 应用变换到门板
|
||
if self.apply_transformation(part, final_transform):
|
||
# 检查变换后的位置
|
||
try:
|
||
if hasattr(part, 'location'):
|
||
logger.info(f" 变换后位置: {part.location}")
|
||
except Exception as e:
|
||
logger.warning(f"⚠️ 无法获取变换后位置: {e}")
|
||
|
||
# 应用变换到关联的硬件
|
||
hw_count = 0
|
||
for hw_key, hardware in hardwares.items():
|
||
if hardware.get("sw_part") == root:
|
||
if self.apply_transformation(hardware, final_transform):
|
||
hw_count += 1
|
||
|
||
# 更新开门状态
|
||
part["sw_door_open"] = not is_open
|
||
processed_count += 1
|
||
logger.info(
|
||
f"✅ 平开门 {root} 变换完成，同时变换了 {hw_count} 个硬件")
|
||
else:
|
||
logger.error(f"❌ 门板 {root} 变换应用失败")
|
||
|
||
except Exception as e:
|
||
logger.error(f"❌ 门板 {root} 变换计算失败: {e}")
|
||
continue
|
||
|
||
else: # 推拉门 (door_type == 15)
|
||
if not door_off:
|
||
logger.warning(f"推拉门 {root} 缺少偏移信息，跳过")
|
||
continue
|
||
|
||
# 【修复】简化推拉门变换
|
||
try:
|
||
# 【修复】单位转换：毫米转米
|
||
door_off = self._parse_vector3d(door_off)
|
||
|
||
# 应用单元变换
|
||
if hasattr(self.data_manager, 'unit_trans') and uid in self.data_manager.unit_trans:
|
||
unit_trans = self.data_manager.unit_trans[uid]
|
||
door_off = self.transform_vector(
|
||
door_off, unit_trans)
|
||
|
||
# 创建平移变换
|
||
if is_open:
|
||
# 如果门是开的，需要关闭（反向平移）
|
||
door_off = (-door_off[0], -
|
||
door_off[1], -door_off[2])
|
||
|
||
trans_matrix = mathutils.Matrix.Translation(door_off)
|
||
|
||
# 应用变换到门板
|
||
if self.apply_transformation(part, trans_matrix):
|
||
# 应用变换到关联的硬件
|
||
hw_count = 0
|
||
for hw_key, hardware in hardwares.items():
|
||
if hardware.get("sw_part") == root:
|
||
if self.apply_transformation(hardware, trans_matrix):
|
||
hw_count += 1
|
||
|
||
# 更新开门状态
|
||
part["sw_door_open"] = not is_open
|
||
processed_count += 1
|
||
logger.info(
|
||
f"✅ 推拉门 {root} 变换完成，同时变换了 {hw_count} 个硬件")
|
||
else:
|
||
logger.error(f"❌ 推拉门 {root} 变换应用失败")
|
||
|
||
except Exception as e:
|
||
logger.error(f"❌ 推拉门 {root} 变换计算失败: {e}")
|
||
continue
|
||
|
||
logger.info(f"🎉 门板打开操作完成: 处理了 {processed_count} 个门板")
|
||
return True
|
||
|
||
except Exception as e:
|
||
logger.error(f"打开门板失败: {e}")
|
||
import traceback
|
||
logger.error(traceback.format_exc())
|
||
return False
|
||
|
||
def c1b(self, data: Dict[str, Any]):
|
||
"""slide_drawers - 打开抽屉"""
|
||
try:
|
||
if not BLENDER_AVAILABLE:
|
||
logger.warning("Blender 不可用，跳过抽屉打开操作")
|
||
return True
|
||
|
||
uid = data.get("uid")
|
||
value = data.get("v", False)
|
||
|
||
logger.info(f" 执行抽屉打开操作: uid={uid}, v={value}")
|
||
|
||
# 获取部件和硬件数据
|
||
parts = self.data_manager.get_parts(data)
|
||
hardwares = self.data_manager.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] = drawer_dir
|
||
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, dir_vector in drawers.items():
|
||
# 解析抽屉方向向量
|
||
if isinstance(dir_vector, str):
|
||
dir_vector = self._parse_vector3d(dir_vector)
|
||
elif hasattr(dir_vector, '__iter__'):
|
||
dir_vector = tuple(dir_vector)
|
||
|
||
# 获取抽屉深度
|
||
dr_depth = depths.get(drawer, 300)
|
||
|
||
# 【修复】单位转换：毫米转米
|
||
dr_depth_m = dr_depth * 0.001 # mm -> m
|
||
|
||
# 计算偏移向量（深度 * 0.9）
|
||
offset_length = dr_depth_m * 0.9
|
||
|
||
logger.debug(
|
||
f"🔧 抽屉 {drawer} 深度转换: {dr_depth} mm -> {dr_depth_m} m, 偏移长度: {offset_length} m")
|
||
|
||
# 归一化方向向量并设置长度
|
||
if dir_vector:
|
||
# 计算向量长度
|
||
length = math.sqrt(
|
||
dir_vector[0]**2 + dir_vector[1]**2 + dir_vector[2]**2)
|
||
if length > 0:
|
||
# 归一化并设置新长度
|
||
normalized_dir = (
|
||
dir_vector[0] / length,
|
||
dir_vector[1] / length,
|
||
dir_vector[2] / length
|
||
)
|
||
offset_vector = (
|
||
normalized_dir[0] * offset_length,
|
||
normalized_dir[1] * offset_length,
|
||
normalized_dir[2] * offset_length
|
||
)
|
||
|
||
# 应用单元变换
|
||
if hasattr(self.data_manager, 'unit_trans') and uid in self.data_manager.unit_trans:
|
||
unit_trans = self.data_manager.unit_trans[uid]
|
||
offset_vector = self.transform_vector(
|
||
offset_vector, unit_trans)
|
||
|
||
offsets[drawer] = offset_vector
|
||
|
||
# 处理每个抽屉
|
||
processed_count = 0
|
||
for drawer, offset_vector in offsets.items():
|
||
# 检查抽屉当前状态
|
||
is_open = False # 默认关闭状态
|
||
|
||
# 查找抽屉相关的部件，检查是否有打开状态标记
|
||
for root, part in parts.items():
|
||
if part.get("sw_pid") == drawer:
|
||
is_open = part.get("sw_drawer_open", False)
|
||
break
|
||
|
||
# 如果状态已经是目标状态，跳过
|
||
if is_open == value:
|
||
continue
|
||
|
||
# 创建变换矩阵
|
||
if is_open:
|
||
# 如果抽屉已经打开，需要关闭（反向变换）
|
||
offset_vector = (-offset_vector[0], -
|
||
offset_vector[1], -offset_vector[2])
|
||
|
||
trans_matrix = mathutils.Matrix.Translation(offset_vector)
|
||
|
||
# 应用变换到相关部件
|
||
part_count = 0
|
||
for root, part in parts.items():
|
||
if part.get("sw_pid") == drawer:
|
||
if self.apply_transformation(part, trans_matrix):
|
||
part["sw_drawer_open"] = not is_open
|
||
part_count += 1
|
||
|
||
# 应用变换到相关硬件
|
||
hw_count = 0
|
||
for hw_key, hardware in hardwares.items():
|
||
if hardware.get("sw_pid") == drawer:
|
||
if self.apply_transformation(hardware, trans_matrix):
|
||
hw_count += 1
|
||
|
||
processed_count += 1
|
||
logger.info(
|
||
f"✅ 抽屉 {drawer} 变换完成，处理了 {part_count} 个部件和 {hw_count} 个硬件")
|
||
|
||
logger.info(f"🎉 抽屉打开操作完成: 处理了 {processed_count} 个抽屉")
|
||
return True
|
||
|
||
except Exception as e:
|
||
logger.error(f"打开抽屉失败: {e}")
|
||
import traceback
|
||
logger.error(traceback.format_exc())
|
||
return False
|
||
|
||
def _parse_point3d(self, point_data):
|
||
"""解析3D点数据为元组 - 修复版本，统一处理毫米到米的转换"""
|
||
try:
|
||
coords = []
|
||
|
||
# 处理不同的数据类型
|
||
if isinstance(point_data, str):
|
||
# 处理字符串格式
|
||
point_str = point_data.strip("()")
|
||
coords = [float(x.strip()) for x in point_str.split(",")]
|
||
elif hasattr(point_data, '__iter__') and not isinstance(point_data, str):
|
||
# 处理IDPropertyArray、list、tuple等可迭代对象
|
||
try:
|
||
# 尝试转换为list并获取前3个元素
|
||
data_list = list(point_data)
|
||
if len(data_list) >= 3:
|
||
coords = [float(data_list[0]), float(
|
||
data_list[1]), float(data_list[2])]
|
||
else:
|
||
logger.warning(f"坐标数据长度不足: {point_data}")
|
||
return (0, 0, 0)
|
||
except Exception as e:
|
||
logger.warning(f"转换坐标数据失败: {e}, 数据: {point_data}")
|
||
return (0, 0, 0)
|
||
elif hasattr(point_data, '__len__') and hasattr(point_data, '__getitem__'):
|
||
# 处理类似数组的对象（如IDPropertyArray）
|
||
try:
|
||
if len(point_data) >= 3:
|
||
coords = [float(point_data[0]), float(
|
||
point_data[1]), float(point_data[2])]
|
||
else:
|
||
logger.warning(f"坐标数据长度不足: {point_data}")
|
||
return (0, 0, 0)
|
||
except Exception as e:
|
||
logger.warning(f"数组式访问失败: {e}, 数据: {point_data}")
|
||
return (0, 0, 0)
|
||
else:
|
||
logger.warning(f"不支持的坐标数据类型: {type(point_data)}")
|
||
return (0, 0, 0)
|
||
|
||
# 【修复】统一单位转换：假设所有输入都是毫米，转换为米
|
||
# 参考Ruby版本：Point3d.new(xyz[0].mm, xyz[1].mm, xyz[2].mm)
|
||
x = coords[0] * 0.001 # mm -> m
|
||
y = coords[1] * 0.001 # mm -> m
|
||
z = coords[2] * 0.001 # mm -> m
|
||
|
||
logger.debug(f"🔧 坐标转换: {coords} mm -> ({x}, {y}, {z}) m")
|
||
|
||
return (x, y, z)
|
||
except Exception as e:
|
||
logger.error(f"解析3D点失败: {e}")
|
||
return (0, 0, 0)
|
||
|
||
def _parse_vector3d(self, vector_str):
|
||
"""解析3D向量字符串为元组 - 修复单位转换（mm转m）"""
|
||
return self._parse_point3d(vector_str)
|
||
|
||
def _cleanup_invalid_references(self, data: Dict[str, Any]):
|
||
"""清理无效的对象引用"""
|
||
try:
|
||
uid = data.get("uid")
|
||
if not uid:
|
||
return
|
||
|
||
logger.info(f"🔄 开始清理无效的对象引用: uid={uid}")
|
||
|
||
# 清理parts中的无效引用
|
||
parts = self.data_manager.get_parts(data)
|
||
invalid_parts = []
|
||
for root, part in parts.items():
|
||
if not self._is_object_valid(part):
|
||
invalid_parts.append(root)
|
||
logger.debug(f"发现无效的部件引用: {root}")
|
||
|
||
for root in invalid_parts:
|
||
del parts[root]
|
||
logger.info(f"✅ 清理无效的部件引用: {root}")
|
||
|
||
# 清理hardwares中的无效引用
|
||
hardwares = self.data_manager.get_hardwares(data)
|
||
invalid_hardwares = []
|
||
for hw_id, hw in hardwares.items():
|
||
if not self._is_object_valid(hw):
|
||
invalid_hardwares.append(hw_id)
|
||
logger.debug(f"发现无效的硬件引用: {hw_id}")
|
||
|
||
for hw_id in invalid_hardwares:
|
||
del hardwares[hw_id]
|
||
logger.info(f"✅ 清理无效的硬件引用: {hw_id}")
|
||
|
||
# 清理zones中的无效引用
|
||
zones = self.data_manager.get_zones(data)
|
||
invalid_zones = []
|
||
for zid, zone in zones.items():
|
||
if not self._is_object_valid(zone):
|
||
invalid_zones.append(zid)
|
||
logger.debug(f"发现无效的区域引用: {zid}")
|
||
|
||
for zid in invalid_zones:
|
||
del zones[zid]
|
||
logger.info(f"✅ 清理无效的区域引用: {zid}")
|
||
|
||
logger.info(f"✅ 无效引用清理完成: uid={uid}")
|
||
|
||
except Exception as e:
|
||
logger.error(f"清理无效引用失败: {e}")
|
||
|
||
def _is_object_valid(self, obj):
|
||
"""检查对象是否有效（存在且不是空对象）- 改进版本，检测已删除的对象"""
|
||
try:
|
||
if obj is None:
|
||
return False
|
||
|
||
if not BLENDER_AVAILABLE:
|
||
return True
|
||
|
||
# 检查对象是否有基本属性
|
||
if not hasattr(obj, 'name'):
|
||
return False
|
||
|
||
# 检查对象是否在Blender数据中
|
||
if obj.name not in bpy.data.objects:
|
||
return False
|
||
|
||
# 【新增】检查对象是否已被标记为删除
|
||
try:
|
||
# 尝试访问一个简单的属性来检查对象是否仍然有效
|
||
_ = obj.name
|
||
_ = obj.type
|
||
return True
|
||
except Exception as e:
|
||
# 如果出现"StructRNA has been removed"错误，说明对象已被删除
|
||
if "StructRNA" in str(e) and "removed" in str(e):
|
||
logger.debug(
|
||
f"对象已被删除: {obj.name if hasattr(obj, 'name') else 'unknown'}")
|
||
return False
|
||
else:
|
||
# 其他错误，也认为对象无效
|
||
logger.debug(f"对象访问失败: {e}")
|
||
return False
|
||
|
||
except Exception as e:
|
||
logger.debug(f"检查对象有效性时发生错误: {e}")
|
||
return False
|
||
|
||
def _create_rotation_around_point(self, center_point, axis, angle):
|
||
"""创建绕指定点的旋转变换"""
|
||
try:
|
||
# 移动到中心点
|
||
move_to_center = mathutils.Matrix.Translation(center_point)
|
||
|
||
# 从中心点移回原点
|
||
move_from_center = mathutils.Matrix.Translation(
|
||
(-center_point[0], -center_point[1], -center_point[2]))
|
||
|
||
# 在原点旋转
|
||
rotation = mathutils.Matrix.Rotation(angle, 4, axis)
|
||
|
||
# 组合变换：移动到中心 -> 旋转 -> 移回原位置
|
||
return move_to_center @ rotation @ move_from_center
|
||
|
||
except Exception as e:
|
||
logger.error(f"创建绕点旋转变换失败: {e}")
|
||
return mathutils.Matrix.Identity(4)
|
||
|
||
|
||
# ==================== 模块实例 ====================
|
||
|
||
# 全局实例，将由SUWImpl初始化时设置
|
||
door_drawer_manager = None
|
||
|
||
|
||
def init_door_drawer_manager():
|
||
"""初始化门抽屉管理器 - 不再需要suw_impl参数"""
|
||
global door_drawer_manager
|
||
door_drawer_manager = DoorDrawerManager()
|
||
return door_drawer_manager
|
||
|
||
|
||
def get_door_drawer_manager():
|
||
"""获取门抽屉管理器实例"""
|
||
global door_drawer_manager
|
||
if door_drawer_manager is None:
|
||
door_drawer_manager = init_door_drawer_manager()
|
||
return door_drawer_manager
|