修改实例变量后类函数未同步更新，3D盒子重叠判断结果异常

我来帮你搞定这个问题！你遇到的核心问题是Box类的顶点（或边界范围）没有随着中心坐标的修改同步更新，导致overlaps方法一直使用初始化时的旧位置数据进行判断，自然会得到错误结果。

问题根源分析 #

大概率你在Box类的__init__方法中预先计算并存储了8个顶点的坐标，但调用setCenter修改中心时，只更新了centerX/Y/Z这几个变量，没有重新计算顶点坐标。当overlaps方法依赖这些静态存储的顶点做判断时，就会用旧位置和其他盒子比较，结果肯定不对。

推荐解决方案：动态计算边界（高效且无同步问题） #

与其维护容易过期的顶点数据，不如每次需要判断重叠时，根据当前的中心和尺寸动态计算盒子的边界范围。这种方式不仅节省内存（不用存8个顶点），还彻底避免了数据不同步的问题。

以下是优化后的完整Box类实现：

class Box:
    def __init__(self, centerX, centerY, centerZ, width, height, depth):
        self.centerX = centerX
        self.centerY = centerY
        self.centerZ = centerZ
        self.width = width
        self.height = height
        self.depth = depth
    
    def setCenter(self, newX, newY, newZ):
        self.centerX = newX
        self.centerY = newY
        self.centerZ = newZ
    
    def _get_bounds(self):
        """私有方法：计算当前盒子在三个轴上的最小/最大值"""
        half_width = self.width / 2
        half_height = self.height / 2
        half_depth = self.depth / 2
        
        min_x = self.centerX - half_width
        max_x = self.centerX + half_width
        min_y = self.centerY - half_height
        max_y = self.centerY + half_height
        min_z = self.centerZ - half_depth
        max_z = self.centerZ + half_depth
        
        return (min_x, max_x, min_y, max_y, min_z, max_z)
    
    def overlaps(self, other_box):
        """判断当前盒子与另一个盒子是否重叠（轴对齐3D盒子判断逻辑）"""
        # 获取两个盒子的最新边界
        self_min_x, self_max_x, self_min_y, self_max_y, self_min_z, self_max_z = self._get_bounds()
        other_min_x, other_max_x, other_min_y, other_max_y, other_min_z, other_max_z = other_box._get_bounds()
        
        # 任意一个轴上没有重叠，则整体不重叠
        if self_max_x < other_min_x or self_min_x > other_max_x:
            return False
        if self_max_y < other_min_y or self_min_y > other_max_y:
            return False
        if self_max_z < other_min_z or self_min_z > other_max_z:
            return False
        
        # 所有轴都有重叠区间，返回True
        return True

测试验证 #

假设我们修改box1的中心到与box2重叠的位置：

box1 = Box(10.0, 5.0, 0.0, 2.0, 1.0, 1.0)
box2 = Box(0, 0, 0, 3.5, 2.5, 1.0)

# 修改box1的中心到(1,1,0)，此时两个盒子应该重叠
box1.setCenter(1, 1, 0)
print(box1.overlaps(box2))  # 输出：True

备选方案：修改中心时同步更新顶点 #

如果你一定要存储顶点数据，可以在setCenter方法中重新计算并更新顶点列表，确保数据同步：

class Box:
    def __init__(self, centerX, centerY, centerZ, width, height, depth):
        self.centerX = centerX
        self.centerY = centerY
        self.centerZ = centerZ
        self.width = width
        self.height = height
        self.depth = depth
        self.vertices = self._calculate_vertices()
    
    def _calculate_vertices(self):
        """计算8个顶点的坐标"""
        half_w = self.width / 2
        half_h = self.height / 2
        half_d = self.depth / 2
        return [
            (self.centerX - half_w, self.centerY - half_h, self.centerZ - half_d),
            (self.centerX + half_w, self.centerY - half_h, self.centerZ - half_d),
            (self.centerX - half_w, self.centerY + half_h, self.centerZ - half_d),
            (self.centerX + half_w, self.centerY + half_h, self.centerZ - half_d),
            (self.centerX - half_w, self.centerY - half_h, self.centerZ + half_d),
            (self.centerX + half_w, self.centerY - half_h, self.centerZ + half_d),
            (self.centerX - half_w, self.centerY + half_h, self.centerZ + half_d),
            (self.centerX + half_w, self.centerY + half_h, self.centerZ + half_d),
        ]
    
    def setCenter(self, newX, newY, newZ):
        self.centerX = newX
        self.centerY = newY
        self.centerZ = newZ
        # 同步更新顶点
        self.vertices = self._calculate_vertices()
    
    def overlaps(self, other_box):
        # 从顶点中提取边界范围
        self_min_x = min(v[0] for v in self.vertices)
        self_max_x = max(v[0] for v in self.vertices)
        self_min_y = min(v[1] for v in self.vertices)
        self_max_y = max(v[1] for v in self.vertices)
        self_min_z = min(v[2] for v in self.vertices)
        self_max_z = max(v[2] for v in self.vertices)
        
        other_min_x = min(v[0] for v in other_box.vertices)
        other_max_x = max(v[0] for v in other_box.vertices)
        other_min_y = min(v[1] for v in other_box.vertices)
        other_max_y = max(v[1] for v in other_box.vertices)
        other_min_z = min(v[2] for v in other_box.vertices)
        other_max_z = max(v[2] for v in other_box.vertices)
        
        # 重叠判断逻辑
        if self_max_x < other_min_x or self_min_x > other_max_x:
            return False
        if self_max_y < other_min_y or self_min_y > other_max_y:
            return False
        if self_max_z < other_min_z or self_min_z > other_max_z:
            return False
        return True

总结 #

推荐使用动态计算边界的方案，因为它更高效、更简洁，从根源上避免了数据同步问题。不管你怎么修改中心坐标，overlaps方法都会使用最新的位置数据进行判断。

内容的提问来源于stack exchange，提问作者Gabe Persaud