WordPress柔性供应链中的智能装箱与物流优化算法教程

引言：柔性供应链与智能物流的重要性

在当今电子商务快速发展的时代，WordPress作为全球最流行的内容管理系统之一，已成为众多电商网站的首选平台。随着业务规模扩大，供应链管理效率直接影响企业竞争力。柔性供应链能够快速响应市场变化，而智能装箱与物流优化算法则是提升供应链效率的关键技术。

本文将深入探讨如何在WordPress环境中实现智能装箱与物流优化算法，通过完整的代码示例和详细注释，帮助开发者提升电商网站的物流效率。

一、智能装箱算法基础

1.1 装箱问题概述

装箱问题(Bin Packing Problem)是组合优化中的经典问题，目标是将不同尺寸的物品放入尽可能少的容器中。在电商物流中，这直接关系到包装成本和运输效率。

1.2 首次适应递减算法实现

以下是一个基于PHP的首次适应递减算法(First Fit Decreasing)实现，适用于WordPress环境：

<?php
/**
 * 智能装箱算法类
 * 使用首次适应递减算法优化物品装箱
 */
class SmartPacking {
    private $items;      // 待装箱物品数组
    private $bin_capacity; // 箱子容量
    private $bins;       // 箱子数组
    
    /**
     * 构造函数
     * @param array $items 物品尺寸数组
     * @param float $bin_capacity 箱子容量
     */
    public function __construct($items, $bin_capacity) {
        $this->items = $items;
        $this->bin_capacity = $bin_capacity;
        $this->bins = [];
    }
    
    /**
     * 执行首次适应递减算法
     * @return array 装箱结果
     */
    public function firstFitDecreasing() {
        // 按物品尺寸递减排序
        rsort($this->items);
        
        // 初始化第一个箱子
        $this->bins[] = [
            'remaining' => $this->bin_capacity,
            'items' => []
        ];
        
        // 遍历所有物品
        foreach ($this->items as $item) {
            $placed = false;
            
            // 尝试放入现有箱子
            foreach ($this->bins as &$bin) {
                if ($bin['remaining'] >= $item) {
                    $bin['items'][] = $item;
                    $bin['remaining'] -= $item;
                    $placed = true;
                    break;
                }
            }
            
            // 如果现有箱子放不下，创建新箱子
            if (!$placed) {
                $this->bins[] = [
                    'remaining' => $this->bin_capacity - $item,
                    'items' => [$item]
                ];
            }
        }
        
        return $this->bins;
    }
    
    /**
     * 计算装箱效率
     * @return array 效率统计
     */
    public function getEfficiency() {
        $total_items = array_sum($this->items);
        $total_bins = count($this->bins);
        $total_capacity = $total_bins * $this->bin_capacity;
        
        return [
            'bins_used' => $total_bins,
            'space_utilization' => ($total_items / $total_capacity) * 100,
            'items_packed' => count($this->items)
        ];
    }
}

// 使用示例
$items = [0.5, 0.8, 0.3, 0.7, 0.4, 0.9, 0.6, 0.2];
$bin_capacity = 1.0;

$packer = new SmartPacking($items, $bin_capacity);
$result = $packer->firstFitDecreasing();
$efficiency = $packer->getEfficiency();

// 输出结果
echo "使用箱子数量: " . $efficiency['bins_used'] . "n";
echo "空间利用率: " . round($efficiency['space_utilization'], 2) . "%n";
?>

二、物流路径优化算法

2.1 旅行商问题与物流路径

物流路径优化本质上是旅行商问题(TSP)的变体，需要找到访问多个地点并返回起点的最短路径。

2.2 最近邻算法实现

以下是一个简化的最近邻算法实现，用于优化配送路线：

<?php
/**
 * 物流路径优化类
 * 使用最近邻算法寻找近似最优路径
 */
class LogisticsOptimizer {
    private $locations;  // 地点坐标数组
    private $distance_matrix; // 距离矩阵
    
    /**
     * 构造函数
     * @param array $locations 地点数组，格式：[['id'=>1, 'x'=>10, 'y'=>20], ...]
     */
    public function __construct($locations) {
        $this->locations = $locations;
        $this->distance_matrix = $this->calculateDistanceMatrix();
    }
    
    /**
     * 计算两点间距离（欧几里得距离）
     * @param array $point1 点1坐标
     * @param array $point2 点2坐标
     * @return float 距离
     */
    private function calculateDistance($point1, $point2) {
        $dx = $point2['x'] - $point1['x'];
        $dy = $point2['y'] - $point1['y'];
        return sqrt($dx * $dx + $dy * $dy);
    }
    
    /**
     * 计算所有点之间的距离矩阵
     * @return array 距离矩阵
     */
    private function calculateDistanceMatrix() {
        $matrix = [];
        $count = count($this->locations);
        
        for ($i = 0; $i < $count; $i++) {
            for ($j = 0; $j < $count; $j++) {
                if ($i == $j) {
                    $matrix[$i][$j] = 0;
                } else {
                    $matrix[$i][$j] = $this->calculateDistance(
                        $this->locations[$i],
                        $this->locations[$j]
                    );
                }
            }
        }
        
        return $matrix;
    }
    
    /**
     * 执行最近邻算法
     * @param int $start_index 起始点索引
     * @return array 优化后的路径
     */
    public function nearestNeighbor($start_index = 0) {
        $num_locations = count($this->locations);
        $visited = array_fill(0, $num_locations, false);
        $path = [];
        $total_distance = 0;
        
        // 从起始点开始
        $current = $start_index;
        $visited[$current] = true;
        $path[] = $this->locations[$current]['id'];
        
        // 遍历所有地点
        for ($i = 1; $i < $num_locations; $i++) {
            $nearest = -1;
            $min_distance = PHP_FLOAT_MAX;
            
            // 寻找最近的未访问地点
            for ($j = 0; $j < $num_locations; $j++) {
                if (!$visited[$j] && $this->distance_matrix[$current][$j] < $min_distance) {
                    $min_distance = $this->distance_matrix[$current][$j];
                    $nearest = $j;
                }
            }
            
            // 移动到最近地点
            $total_distance += $min_distance;
            $current = $nearest;
            $visited[$current] = true;
            $path[] = $this->locations[$current]['id'];
        }
        
        // 返回起点
        $total_distance += $this->distance_matrix[$current][$start_index];
        $path[] = $this->locations[$start_index]['id'];
        
        return [
            'path' => $path,
            'total_distance' => $total_distance,
            'locations_visited' => count($path) - 1
        ];
    }
}

// 使用示例
$locations = [
    ['id' => '仓库', 'x' => 0, 'y' => 0],
    ['id' => '客户A', 'x' => 10, 'y' => 20],
    ['id' => '客户B', 'x' => 15, 'y' => 5],
    ['id' => '客户C', 'x' => 5, 'y' => 15],
    ['id' => '客户D', 'x' => 20, 'y' => 10]
];

$optimizer = new LogisticsOptimizer($locations);
$result = $optimizer->nearestNeighbor(0);

echo "最优路径: " . implode(' -> ', $result['path']) . "n";
echo "总距离: " . round($result['total_distance'], 2) . " 单位n";
?>

三、WordPress集成实现

3.1 创建智能物流插件框架

以下是一个基本的WordPress插件框架，用于集成智能装箱和物流优化功能：

<?php
/**
 * Plugin Name: 智能物流优化系统
 * Description: WordPress柔性供应链智能装箱与物流优化插件
 * Version: 1.0.0
 * Author: 您的名称
 */

// 防止直接访问
if (!defined('ABSPATH')) {
    exit;
}

/**
 * 主插件类
 */
class IntelligentLogisticsSystem {
    
    private static $instance = null;
    
    /**
     * 获取单例实例
     */
    public static function getInstance() {
        if (null === self::$instance) {
            self::$instance = new self();
        }
        return self::$instance;
    }
    
    /**
     * 构造函数
     */
    private function __construct() {
        $this->init_hooks();
    }
    
    /**
     * 初始化钩子
     */
    private function init_hooks() {
        // 后台管理菜单
        add_action('admin_menu', [$this, 'add_admin_menu']);
        
        // 订单处理钩子
        add_action('woocommerce_checkout_order_processed', [$this, 'process_order_packing'], 10, 3);
        
        // 短码支持
        add_shortcode('show_logistics_info', [$this, 'logistics_info_shortcode']);
    }
    
    /**
     * 添加管理菜单
     */
    public function add_admin_menu() {
        add_menu_page(
            '智能物流系统',
            '物流优化',
            'manage_options',
            'intelligent-logistics',
            [$this, 'admin_page_callback'],
            'dashicons-location-alt',
            30
        );
    }
    
    /**
     * 管理页面回调
     */
    public function admin_page_callback() {
        ?>
        <div class="wrap">
            <h1>智能物流优化系统</h1>
            
            <div class="card">
                <h2>装箱优化</h2>
                <form method="post" action="">
                    <?php wp_nonce_field('packing_optimization', 'logistics_nonce'); ?>
                    <p>
                        <label>订单ID: <input type="text" name="order_id"></label>
                    </p>
                    <p>
                        <input type="submit" name="optimize_packing" 
                               class="button button-primary" value="优化装箱">
                    </p>
                </form>
            </div>
            
            <div class="card">
                <h2>路径优化</h2>
                <form method="post" action="">
                    <?php wp_nonce_field('route_optimization', 'logistics_nonce'); ?>
                    <p>
                        <label>配送区域: 
                            <select name="delivery_zone">
                                <option value="east">东区</option>
                                <option value="west">西区</option>
                                <option value="north">北区</option>
                                <option value="south">南区</option>
                            </select>
                        </label>
                    </p>
                    <p>
                        <input type="submit" name="optimize_route" 
                               class="button button-primary" value="优化路径">
                    </p>
                </form>
            </div>
        </div>
        <?php
        
        // 处理表单提交
        $this->handle_form_submissions();
    }
    
    /**
     * 处理订单装箱
     */
    public function process_order_packing($order_id, $posted_data, $order) {
        // 获取订单商品
        $items = $order->get_items();
        $item_sizes = [];
        
        foreach ($items as $item) {
            $product = $item->get_product();
            // 假设产品有尺寸属性
            $size = $product->get_meta('package_size', true);
            if ($size) {
                $item_sizes[] = floatval($size);
            }
        }
        
        // 使用智能装箱算法
        if (!empty($item_sizes)) {
            require_once plugin_dir_path(__FILE__) . 'class-smart-packing.php';
            $packer = new SmartPacking($item_sizes, 1.0);
            $packing_result = $packer->firstFitDecreasing();
            
            // 保存装箱结果到订单元数据
            update_post_meta($order_id, '_packing_optimization', $packing_result);
            update_post_meta($order_id, '_packing_efficiency', 
                           $packer->getEfficiency());
        }
    }
    
    /**
     * 物流信息短码
     */
    public function logistics_info_shortcode($atts) {
        $atts = shortcode_atts([
            'order_id' => 0
        ], $atts);
        
        if (!$atts['order_id']) {
            return '<p>请提供订单ID</p>';
        }
        
        $packing_data = get_post_meta($atts['order_id'], '_packing_optimization', true);
        
        if (empty($packing_data)) {
            return '<p>暂无装箱优化数据</p>';
        }
        
        $output = '<div class="logistics-info">';
        $output .= '<h3>智能装箱方案</h3>';
        $output .= '<table class="packing-table">';
        $output .= '<tr><th>箱子</th><th>物品</th><th>剩余空间</th></tr>';
        
        foreach ($packing_data as $index => $bin) {
            $output .= '<tr>';
            $output .= '<td>箱子 ' . ($index + 1) . '</td>';
            $output .= '<td>' . implode(', ', $bin['items']) . '</td>';
            $output .= '<td>' . round($bin['remaining'], 2) . '</td>';
            $output .= '</tr>';
        }
        
        $output .= '</table></div>';
        
        return $output;
    }
    
    /**
     * 处理表单提交
     */
    private function handle_form_submissions() {
        if (isset($_POST['optimize_packing']) && 
            wp_verify_nonce($_POST['logistics_nonce'], 'packing_optimization')) {
            
            $order_id = intval($_POST['order_id']);
            if ($order_id) {
                $order = wc_get_order($order_id);
                if ($order) {
                    $this->process_order_packing($order_id, [], $order);
                    echo '<div class="notice notice-success"><p>装箱优化完成！</p></div>';
                }
            }
        }
    }
}

// 初始化插件
IntelligentLogisticsSystem::getInstance();
?>

四、高级优化与机器学习集成

4.1 基于历史数据的优化

通过分析历史订单数据，可以进一步优化算法参数：

<?php
/**
 * 基于历史学习的优化器
 */
class LearningOptimizer {
    private $historical_data;
    
    public function __construct() {
        $this->loadHistoricalData();
    }
    
    /**
     * 从数据库加载历史数据
     */
    private function loadHistoricalData() {
        global $wpdb;
        
        $this->historical_data = $wpdb->get_results("
            SELECT order_id, packing_efficiency, shipping_cost, delivery_time
            FROM {$wpdb->prefix}logistics_history
            WHERE packing_efficiency > 0
            ORDER BY order_date DESC
            LIMIT 1000
        ");
    }
    
    /**
     * 计算最优箱子容量
     */
    public function calculateOptimalBinCapacity() {
        $total_volume = 0;
        $total_orders = 0;
        
        foreach ($this->historical_data as $record) {
            // 这里简化处理，实际应根据物品尺寸计算
            $total_volume += $record->packing_efficiency * 100; // 假设系数
            $total_orders++;
        }
        
        if ($total_orders > 0) {
            return $total_volume / $total_orders;
        }
        
        return 1.0; // 默认值
    }
    
    /**
     * 预测配送时间
     */
    public function predictDeliveryTime($route_length, $num_stops) {
        // 基于历史数据的简单线性回归
        $avg_speed = 30; // 平均速度 km/h
        $stop_time = 10; // 每站停留时间 分钟
        
        $travel_time = ($route_length / $avg_speed) * 60; // 转换为分钟
        $total_stop_time = $num_stops * $stop_time;
        
        return $travel_time + $total_stop_time;
    }
}
?>

五、性能优化与缓存策略

5.1 算法结果缓存

对于计算密集型的优化算法，实施缓存策略可以显著提升性能：

<?php
/**
 * 物流优化缓存管理器
 */
class LogisticsCacheManager {
    const CACHE_PREFIX = 'logistics_opt_';
    const CACHE_EXPIRY = 3600; // 1小时
    
    /**
     * 获取缓存结果
     */
    public static function getCachedResult($key) {
        $cache_key = self::CACHE_PREFIX . md5($key);
        $cached = wp_cache_get($cache_key, 'logistics');
        
        if (false !== $cached) {
            return $cached;
        }
        
        return null;
    }
    
    /**
     * 设置缓存结果
     */
    public static function setCachedResult($key, $data) {
        $cache_key = self::CACHE_PREFIX . md5($key);
        return wp_cache_set($cache_key, $data, 'logistics', self::CACHE_EXPIRY);
    }

六、实时物流追踪与动态调整

6.1 实时数据集成与动态路径重规划

<?php
/**
 * 实时物流追踪与动态优化类
 */
class RealTimeLogisticsTracker {
    private $api_key;
    private $current_routes;
    
    public function __construct($api_key) {
        $this->api_key = $api_key;
        $this->current_routes = [];
    }
    
    /**
     * 获取实时交通数据
     * @param array $coordinates 坐标点数组
     * @return array 交通状况数据
     */
    public function getTrafficData($coordinates) {
        $cache_key = 'traffic_' . md5(json_encode($coordinates));
        $cached_data = LogisticsCacheManager::getCachedResult($cache_key);
        
        if ($cached_data) {
            return $cached_data;
        }
        
        // 模拟API调用获取实时交通数据
        $traffic_data = $this->callTrafficAPI($coordinates);
        
        // 缓存结果（5分钟有效期）
        wp_cache_set($cache_key, $traffic_data, 'traffic', 300);
        
        return $traffic_data;
    }
    
    /**
     * 动态路径重规划
     * @param array $original_route 原始路径
     * @param array $obstacles 障碍物/拥堵点
     * @return array 重新规划的路径
     */
    public function dynamicReroute($original_route, $obstacles) {
        // 使用A*算法进行动态重规划
        $rerouted_path = $this->aStarReroute($original_route, $obstacles);
        
        // 记录重规划日志
        $this->logRerouteEvent($original_route, $rerouted_path);
        
        return [
            'original_route' => $original_route,
            'rerouted_path' => $rerouted_path,
            'timestamp' => current_time('mysql'),
            'reason' => 'traffic_congestion'
        ];
    }
    
    /**
     * A*算法实现动态路径规划
     */
    private function aStarReroute($route, $obstacles) {
        $graph = $this->buildGraphFromRoute($route);
        $start = $route[0];
        $goal = end($route);
        
        $open_set = [$start];
        $came_from = [];
        $g_score = [$start['id'] => 0];
        $f_score = [$start['id'] => $this->heuristic($start, $goal)];
        
        while (!empty($open_set)) {
            $current = $this->getLowestFScore($open_set, $f_score);
            
            if ($current['id'] === $goal['id']) {
                return $this->reconstructPath($came_from, $current);
            }
            
            $open_set = array_filter($open_set, function($node) use ($current) {
                return $node['id'] !== $current['id'];
            });
            
            foreach ($graph[$current['id']] as $neighbor) {
                // 检查是否为障碍点
                if ($this->isObstacle($neighbor, $obstacles)) {
                    continue;
                }
                
                $tentative_g_score = $g_score[$current['id']] + 
                    $this->calculateDistance($current, $neighbor);
                
                if (!isset($g_score[$neighbor['id']]) || 
                    $tentative_g_score < $g_score[$neighbor['id']]) {
                    
                    $came_from[$neighbor['id']] = $current;
                    $g_score[$neighbor['id']] = $tentative_g_score;
                    $f_score[$neighbor['id']] = $tentative_g_score + 
                        $this->heuristic($neighbor, $goal);
                    
                    if (!in_array($neighbor, $open_set)) {
                        $open_set[] = $neighbor;
                    }
                }
            }
        }
        
        return $route; // 无法找到更好路径，返回原路径
    }
    
    /**
     * 启发式函数（曼哈顿距离）
     */
    private function heuristic($a, $b) {
        return abs($a['x'] - $b['x']) + abs($a['y'] - $b['y']);
    }
}
?>

七、多目标优化与约束处理

7.1 多目标装箱优化算法

<?php
/**
 * 多目标优化装箱算法
 * 同时考虑空间利用率、箱子成本和环保因素
 */
class MultiObjectivePacking {
    private $items;
    private $bin_types;
    private $constraints;
    
    public function __construct($items, $bin_types, $constraints = []) {
        $this->items = $items;
        $this->bin_types = $bin_types;
        $this->constraints = array_merge([
            'max_weight' => 20,
            'max_boxes' => 10,
            'prefer_eco_friendly' => true,
            'cost_weight' => 0.4,
            'space_weight' => 0.4,
            'eco_weight' => 0.2
        ], $constraints);
    }
    
    /**
     * 多目标遗传算法优化
     */
    public function geneticAlgorithmOptimization($population_size = 100, $generations = 50) {
        // 初始化种群
        $population = $this->initializePopulation($population_size);
        
        for ($gen = 0; $gen < $generations; $gen++) {
            // 评估适应度
            $fitness_scores = $this->evaluatePopulation($population);
            
            // 选择
            $selected = $this->selection($population, $fitness_scores);
            
            // 交叉
            $offspring = $this->crossover($selected);
            
            // 变异
            $offspring = $this->mutation($offspring);
            
            // 替换
            $population = $this->replacement($population, $offspring, $fitness_scores);
        }
        
        // 返回最优解
        return $this->getBestSolution($population);
    }
    
    /**
     * 计算多目标适应度
     */
    private function calculateFitness($solution) {
        $objectives = [
            'cost' => $this->calculateTotalCost($solution),
            'space_utilization' => $this->calculateSpaceUtilization($solution),
            'eco_score' => $this->calculateEcoScore($solution)
        ];
        
        // 归一化处理
        $normalized = $this->normalizeObjectives($objectives);
        
        // 加权求和
        $fitness = 
            $normalized['cost'] * $this->constraints['cost_weight'] +
            $normalized['space_utilization'] * $this->constraints['space_weight'] +
            $normalized['eco_score'] * $this->constraints['eco_weight'];
        
        return $fitness;
    }
    
    /**
     * 计算环保评分
     */
    private function calculateEcoScore($solution) {
        $score = 0;
        $total_boxes = 0;
        
        foreach ($solution['bins'] as $bin) {
            $bin_type = $this->bin_types[$bin['type_id']];
            
            if ($bin_type['eco_friendly']) {
                $score += 10;
            }
            
            if ($bin_type['recyclable']) {
                $score += 5;
            }
            
            if ($bin_type['biodegradable']) {
                $score += 8;
            }
            
            $total_boxes++;
        }
        
        // 鼓励使用更少箱子
        $box_penalty = $total_boxes * 2;
        
        return max(0, $score - $box_penalty);
    }
}
?>

八、与WooCommerce深度集成

8.1 订单处理自动化流程

<?php
/**
 * WooCommerce订单自动化处理类
 */
class WooCommerceLogisticsAutomation {
    
    /**
     * 初始化自动化钩子
     */
    public function init() {
        // 订单状态变更时触发
        add_action('woocommerce_order_status_changed', 
            [$this, 'handleOrderStatusChange'], 10, 4);
        
        // 添加到购物车时预计算
        add_filter('woocommerce_add_cart_item_data', 
            [$this, 'preCalculatePacking'], 10, 3);
        
        // 结账页面显示优化信息
        add_action('woocommerce_checkout_before_order_review',
            [$this, 'displayOptimizationInfo']);
    }
    
    /**
     * 处理订单状态变更
     */
    public function handleOrderStatusChange($order_id, $old_status, $new_status, $order) {
        switch ($new_status) {
            case 'processing':
                $this->triggerPackingOptimization($order);
                break;
                
            case 'ready-for-shipment':
                $this->optimizeDeliveryRoute($order);
                break;
                
            case 'completed':
                $this->logPerformanceMetrics($order);
                break;
        }
    }
    
    /**
     * 触发装箱优化
     */
    private function triggerPackingOptimization($order) {
        $items = $order->get_items();
        $item_data = [];
        
        foreach ($items as $item) {
            $product = $item->get_product();
            $item_data[] = [
                'id' => $product->get_id(),
                'quantity' => $item->get_quantity(),
                'dimensions' => [
                    'length' => $product->get_length(),
                    'width' => $product->get_width(),
                    'height' => $product->get_height(),
                    'weight' => $product->get_weight()
                ],
                'fragile' => $product->get_meta('_fragile', true),
                'hazardous' => $product->get_meta('_hazardous', true)
            ];
        }
        
        // 调用3D装箱算法
        $packing_result = $this->threeDPacking($item_data);
        
        // 生成装箱单
        $packing_slip = $this->generatePackingSlip($packing_result);
        
        // 更新订单元数据
        $order->update_meta_data('_packing_optimization', $packing_result);
        $order->update_meta_data('_packing_slip', $packing_slip);
        $order->save();
        
        // 发送给仓库系统
        $this->sendToWarehouse($order_id, $packing_slip);
    }
    
    /**
     * 3D装箱算法（简化版）
     */
    private function threeDPacking($items) {
        // 按体积排序
        usort($items, function($a, $b) {
            $vol_a = $a['dimensions']['length'] * 
                    $a['dimensions']['width'] * 
                    $a['dimensions']['height'];
            $vol_b = $b['dimensions']['length'] * 
                    $b['dimensions']['width'] * 
                    $b['dimensions']['height'];
            return $vol_b <=> $vol_a;
        });
        
        $bins = [];
        $current_bin = [
            'remaining_volume' => 1000000, // 1立方米
            'remaining_weight' => 20000,   // 20kg
            'items' => [],
            'positions' => []
        ];
        
        foreach ($items as $item) {
            $item_volume = $item['dimensions']['length'] * 
                          $item['dimensions']['width'] * 
                          $item['dimensions']['height'];
            $item_weight = $item['dimensions']['weight'] * $item['quantity'];
            
            // 检查是否可以放入当前箱子
            if ($current_bin['remaining_volume'] >= $item_volume && 
                $current_bin['remaining_weight'] >= $item_weight) {
                
                // 尝试找到合适的位置（简化处理）
                $position = $this->findPositionInBin($current_bin, $item);
                
                if ($position) {
                    $current_bin['items'][] = [
                        'product_id' => $item['id'],
                        'quantity' => $item['quantity'],
                        'position' => $position,
                        'dimensions' => $item['dimensions']
                    ];
                    $current_bin['remaining_volume'] -= $item_volume;
                    $current_bin['remaining_weight'] -= $item_weight;
                    $current_bin['positions'][] = $position;
                } else {
                    // 创建新箱子
                    $bins[] = $current_bin;
                    $current_bin = [
                        'remaining_volume' => 1000000 - $item_volume,
                        'remaining_weight' => 20000 - $item_weight,
                        'items' => [[
                            'product_id' => $item['id'],
                            'quantity' => $item['quantity'],
                            'position' => ['x'=>0, 'y'=>0, 'z'=>0],
                            'dimensions' => $item['dimensions']
                        ]],
                        'positions' => [['x'=>0, 'y'=>0, 'z'=>0]]
                    ];
                }
            } else {
                // 创建新箱子
                $bins[] = $current_bin;
                $current_bin = [
                    'remaining_volume' => 1000000 - $item_volume,
                    'remaining_weight' => 20000 - $item_weight,
                    'items' => [[
                        'product_id' => $item['id'],
                        'quantity' => $item['quantity'],
                        'position' => ['x'=>0, 'y'=>0, 'z'=>0],
                        'dimensions' => $item['dimensions']
                    ]],
                    'positions' => [['x'=>0, 'y'=>0, 'z'=>0]]
                ];
            }
        }
        
        // 添加最后一个箱子
        if (!empty($current_bin['items'])) {
            $bins[] = $current_bin;
        }
        
        return [
            'bins' => $bins,
            'total_boxes' => count($bins),
            'space_utilization' => $this->calculate3DUtilization($bins)
        ];
    }
}
?>

九、数据分析与可视化

9.1 物流数据仪表板

<?php
/**
 * 物流数据可视化仪表板
 */
class LogisticsDashboard {
    
    public function displayDashboard() {
        ?>
        <div class="wrap">
            <h1>智能物流数据仪表板</h1>
            
            <div class="dashboard-grid">
                <!-- KPI指标 -->
                <div class="dashboard-card">
                    <h3>今日效率指标</h3>
                    <div class="kpi-grid">
                        <?php $today_kpis = $this->getTodayKPIs(); ?>
                        <div class="kpi-item">
                            <span class="kpi-value"><?php echo $today_kpis['packing_efficiency']; ?>%</span>
                            <span class="kpi-label">装箱效率</span>
                        </div>
                        <div class="kpi-item">
                            <span class="kpi-value"><?php echo $today_kpis['route_optimization']; ?>%</span>
                            <span class="kpi-label">路径优化</span>
                        </div>
                        <div class="kpi-item">
                            <span class="kpi-value"><?php echo $today_kpis['cost_reduction']; ?>%</span>
                            <span class="kpi-label">成本降低</span>
                        </div>
                    </div>
                </div>
                
                <!-- 实时监控 -->
                <div class="dashboard-card">
                    <h3>实时物流监控</h3>
                    <div id="realtime-map" style="height: 300px;">
                        <!-- 这里集成地图API -->
                    </div>
                </div>
                
                <!-- 历史趋势 -->
                <div class="dashboard-card">
                    <h3>效率趋势分析</h3>
                    <canvas id="efficiencyChart" width="400" height="200"></canvas>
                </div>
                
                <!-- 预警系统 -->
                <div class="dashboard-card">
                    <h3>系统预警</h3>
                    <div class="alerts-list">
                        <?php $alerts = $this->getSystemAlerts(); ?>
                        <?php foreach ($alerts as $alert): ?>
                        <div class="alert-item alert-<?php echo $alert['level']; ?>">
                            <span class="alert-time"><?php echo $alert['time']; ?></span>
                            <span class="alert-message"><?php echo $alert['message']; ?></span>
                        </div>
                        <?php endforeach; ?>
                    </div>
                </div>
            </div>
            
            <!-- 详细报告 -->
            <div class="dashboard-section">
                <h2>详细分析报告</h2>
                <div class="report-filters">
                    <select id="reportPeriod">
                        <option value="today">今日</option>
                        <option value="week">本周</option>
                        <option value="month">本月</option>
                    </select>
                    <button onclick="generateReport()" class="button button-primary">
                        生成报告
                    </button>
                </div>
                <div id="reportContent"></div>
            </div>
        </div>
        
        <script>
        // 使用Chart.js显示图表
        jQuery(document).ready(function($) {
            var ctx = document.getElementById('efficiencyChart').getContext('2d');
            var chart = new Chart(ctx, {
                type: 'line',
                data: {
                    labels: <?php echo json_encode($this->getChartLabels()); ?>,
                    datasets: [{
                        label: '装箱效率',
                        data: <?php echo json_encode($this->getPackingEfficiencyData()); ?>,
                        borderColor: 'rgb(75, 192, 192)',
                        tension: 0.1
                    }, {
                        label: '运输成本',
                        data: <?php echo json_encode($this->getShippingCostData()); ?>,
                        borderColor: 'rgb(255, 99, 132)',
                        tension: 0.1
                    }]
                },
                options: {
                    responsive: true,
                    plugins: {
                        legend: {
                            position: 'top',
                        }
                    }
                }
            });
        });
        
        function generateReport() {