上传文件至 src/dispatch

src/dispatch/enhanced_agv_manager.h

@@ -0,0 +1,204 @@
+#ifndef ENHANCED_AGV_MANAGER_H
+#define ENHANCED_AGV_MANAGER_H
+
+#include "agv_manager_base.h"
+#include "resource_manager.h"
+#include <unordered_map>
+#include <functional>
+
+/**
+ * @brief AGV分配策略枚举
+ */
+enum class AssignmentStrategy {
+    FIRST_FIT,          // 第一个适配（当前策略）
+    NEAREST_FIT,        // 最近适配
+    BATTERY_AWARE,      // 考虑电量
+    LOAD_BALANCED,      // 负载均衡
+    PRIORITY_BASED,      // 基于优先级
+    COST_OPTIMAL         // 成本最优
+};
+
+/**
+ * @brief AGV评估结果
+ */
+struct AGVEvaluation {
+    AGV* agv;
+    double score;              // 评估分数
+    double estimated_time;     // 预计完成时间
+    double distance_to_task;   // 到任务起点的距离
+    std::string reason;        // 选择原因
+
+    AGVEvaluation(AGV* a, double s, double t, double d, const std::string& r)
+        : agv(a), score(s), estimated_time(t), distance_to_task(d), reason(r) {}
+};
+
+/**
+ * @brief 任务分配选项
+ */
+struct AssignmentOption {
+    Task* task;
+    AGV* agv;
+    std::vector<Path*> path;
+    double total_cost;          // 总成本（时间、距离等）
+    double estimated_duration;  // 预计执行时间
+    double battery_consumption;  // 预计电量消耗
+
+    AssignmentOption(Task* t, AGV* a, const std::vector<Path*>& p, double c, double d, double b)
+        : task(t), agv(a), path(p), total_cost(c), estimated_duration(d), battery_consumption(b) {}
+};
+
+/**
+ * @brief 增强的AGV管理器
+ * 支持多种任务分配策略
+ */
+class EnhancedAGVManager : public AGVManagerBase {
+private:
+    AssignmentStrategy strategy_;  // 当前分配策略
+    std::unordered_map<AssignmentStrategy, std::function<double(AGV*, Task*, double)>> scoring_functions_;
+    ResourceManager* resource_manager_;  // 资源管理器集成
+
+    // 分配权重
+    struct AssignmentWeights {
+        double distance_weight = 0.4;      // 距离权重
+        double battery_weight = 0.3;       // 电量权重
+        double load_weight = 0.2;          // 负载权重
+        double speed_weight = 0.1;         // 速度权重
+    } weights_;
+
+public:
+    EnhancedAGVManager(GraphMap* map, ResourceManager* resource_mgr = nullptr, AssignmentStrategy strategy = AssignmentStrategy::NEAREST_FIT)
+        : AGVManagerBase(map), strategy_(strategy), resource_manager_(resource_mgr) {
+        initializeScoringFunctions();
+    }
+
+    /**
+     * @brief 设置资源管理器
+     */
+    void setResourceManager(ResourceManager* resource_mgr) {
+        resource_manager_ = resource_mgr;
+    }
+
+    /**
+     * @brief 设置分配策略
+     */
+    void setStrategy(AssignmentStrategy strategy) {
+        strategy_ = strategy;
+    }
+
+    /**
+     * @brief 设置分配权重
+     */
+    void setWeights(const AssignmentWeights& weights) {
+        weights_ = weights;
+    }
+
+    /**
+     * @brief 智能任务分配
+     * 使用当前策略找到最优的AGV-任务匹配
+     */
+    int assignTasksSmart();
+
+    /**
+     * @brief 为特定任务寻找最佳AGV
+     * @param task 要分配的任务
+     * @param exclude_excluded 排除已分配任务的AGV
+     * @return 评估结果列表，按分数排序
+     */
+    std::vector<AGVEvaluation> findBestAGVForTask(Task* task, bool exclude_assigned = true);
+
+    /**
+     * @brief 计算任务-AGV匹配的成本
+     */
+    double calculateAssignmentCost(AGV* agv, Task* task, std::vector<Path*>& path);
+
+    /**
+     * @brief 批量任务分配优化
+     * 同时考虑多个任务，找到全局最优分配
+     */
+    std::vector<AssignmentOption> optimizeBatchAssignment(std::vector<Task*>& tasks,
+                                                        std::vector<AGV*>& available_agvs);
+
+    /**
+     * @brief 预测AGV在未来时间段的可用性
+     */
+    std::pair<double, bool> predictAvailability(AGV* agv, double future_time);
+
+    /**
+     * @brief 获取AGV负载情况
+     */
+    double getAGVLoad(AGV* agv);
+
+    /**
+     * @brief 打印分配策略分析
+     */
+    void printAssignmentAnalysis();
+
+    /**
+     * @brief 完成任务并释放资源
+     */
+    void completeTaskWithResources(AGV* agv, bool success = true);
+
+private:
+    void initializeScoringFunctions();
+
+    // 各种分配策略的评分函数
+    double scoreFirstFit(AGV* agv, Task* task, double distance);
+    double scoreNearestFit(AGV* agv, Task* task, double distance);
+    double scoreBatteryAware(AGV* agv, Task* task, double distance);
+    double scoreLoadBalanced(AGV* agv, Task* task, double distance);
+    double scorePriorityBased(AGV* agv, Task* task, double distance);
+    double scoreCostOptimal(AGV* agv, Task* task, double distance);
+
+    // 辅助函数
+    double calculateDistance(AGV* agv, Task* task);
+    double calculateBatteryConsumption(AGV* agv, Task* task, double distance);
+    double calculateLoadFactor(AGV* agv);
+    std::vector<Path*> findPathWithAvoidance(AGV* agv, Task* task);
+    std::string getReasonForSelection(AGV* agv, Task* task, double distance, double score);
+    std::string agvStateToString(AGVState state);
+
+    // 新增辅助方法
+    bool assignSingleTask(AGV* agv, Task* task);
+    std::string assignmentStrategyToString(AssignmentStrategy strategy);
+};
+
+/**
+ * @brief 任务分配分析器
+ * 用于分析和优化分配策略
+ */
+class AssignmentAnalyzer {
+private:
+    struct Metrics {
+        double avg_completion_time;
+        double agv_utilization;
+        double battery_efficiency;
+        int task_count;
+        int reassignments;
+    };
+
+    std::unordered_map<AssignmentStrategy, Metrics> strategy_metrics_;
+
+public:
+    /**
+     * @brief 记录任务分配结果
+     */
+    void recordAssignment(AssignmentStrategy strategy, AGV* agv, Task* task,
+                         double completion_time, double battery_used);
+
+    /**
+     * @brief 获取最优策略
+     */
+    AssignmentStrategy getOptimalStrategy();
+
+    /**
+     * @brief 生成分配报告
+     */
+    void generateReport();
+
+    /**
+     * @brief 重置统计数据
+     */
+    void reset();
+};
+
+#endif // ENHANCED_AGV_MANAGER_H