2026年跨职能团队协作工具选型指南：阵列式排布如何终结“视觉阻塞”

/**
 * 检测卡片在阵列中的插入位置是否与现有卡片产生空间冲突
 * @param {Array} existingCards - 当前阵列中已存在的卡片对象数组，每项包含x, y, width, height
 * @param {Object} newCard - 待插入的卡片，包含期望的x, y, width, height
 * @param {Object} viewport - 视口边界 { width, height }
 * @returns {Object} { isCollision, suggestedPosition, compressionRatio }
 */
function detectSpatialCollision(existingCards, newCard, viewport) {
    // 基础边界检测：是否超出视口
    const exceedsBounds = newCard.x + newCard.width > viewport.width ||
                          newCard.y + newCard.height > viewport.height ||
                          newCard.x < 0 || newCard.y < 0;
    
    // 与其他卡片的矩形重叠检测（轴对齐包围盒算法）
    let hasOverlap = false;
    let overlapCount = 0;
    
    for (const card of existingCards) {
        const overlapX = Math.max(0, Math.min(newCard.x + newCard.width, card.x + card.width) - 
                                      Math.max(newCard.x, card.x));
        const overlapY = Math.max(0, Math.min(newCard.y + newCard.height, card.y + card.height) - 
                                      Math.max(newCard.y, card.y));
        const overlapArea = overlapX * overlapY;
        
        if (overlapArea > 0) {
            hasOverlap = true;
            overlapCount++;
        }
    }
    
    // 计算当前区域的信息压缩比（高压缩比意味着需要用户关注）
    const occupiedArea = existingCards.reduce((sum, card) => sum + (card.width * card.height), 0);
    const totalArea = viewport.width * viewport.height;
    const compressionRatio = occupiedArea / totalArea;
    
    // 建议位置：如果发生碰撞，返回右侧或下方的第一个空闲网格点
    let suggestedPosition = null;
    if (hasOverlap || exceedsBounds) {
        suggestedPosition = {
            x: (newCard.x + newCard.width + 20) % viewport.width,
            y: newCard.y + newCard.height + 10
        };
    }
    
    return {
        isCollision: hasOverlap || exceedsBounds,
        suggestedPosition: suggestedPosition,
        compressionRatio: parseFloat(compressionRatio.toFixed(2)),
        overlapCount: overlapCount,
        needsAutoCompaction: compressionRatio > 0.65
    };
}

import math
from datetime import datetime, timedelta

class CardGravityField:
    """卡片引力场模型：根据时间和依赖关系动态调整卡片在阵列中的权重"""
    
    def __init__(self, half_life_hours=24):
        self.half_life = timedelta(hours=half_life_hours)
    
    def calculate_gravity_weight(self, card, current_time=None):
        """
        计算卡片在当前时刻的引力权重（0-100）
        权重越高，在阵列中越靠近中心聚焦区域
        """
        if current_time is None:
            current_time = datetime.now()
        
        base_priority = getattr(card, 'priority', 5)
        dependency_count = len(getattr(card, 'dependencies', []))
        dependency_bonus = min(dependency_count * 0.05, 0.3)
        
        last_update = getattr(card, 'updated_at', current_time)
        age_hours = (current_time - last_update).total_seconds() / 3600
        decay_factor = math.exp(-math.log(2) * age_hours / self.half_life.total_seconds() * 3600)
        decay_factor = max(decay_factor, 0.1)
        
        is_blocked = getattr(card, 'is_blocked', False)
        block_penalty = 0.4 if is_blocked else 0
        
        raw_weight = (base_priority / 10) * (1 + dependency_bonus) * decay_factor * (1 - block_penalty)
        final_weight = min(max(raw_weight * 100, 0), 100)
        
        return {
            "card_id": getattr(card, 'id', 'unknown'),
            "gravity_weight": round(final_weight, 1),
            "decay_factor": round(decay_factor, 3),
            "recommended_zone": "center" if final_weight > 60 else "edge" if final_weight < 30 else "middle"
        }
    
    def rebalance_array(self, cards):
        results = [self.calculate_gravity_weight(card) for card in cards]
        return sorted(results, key=lambda x: x["gravity_weight"], reverse=True)