package com.algo.service;
|
|
import com.algo.model.AGVStatus;
|
import com.algo.model.BackpackData;
|
import com.algo.model.ExecutingTask;
|
import com.algo.model.TaskData;
|
import com.algo.util.JsonUtils;
|
|
import java.util.*;
|
|
/**
|
* 执行中任务提取器
|
* 负责从AGV状态中提取当前正在执行的任务
|
*/
|
public class ExecutingTaskExtractor {
|
|
/**
|
* 路径映射表
|
*/
|
private Map<String, Map<String, Integer>> pathMapping;
|
|
/**
|
* 任务数据映射表
|
*/
|
private Map<String, TaskData> taskDataMap;
|
|
/**
|
* 坐标到路径编号的映射
|
*/
|
private Map<String, String> coordToCode;
|
|
/**
|
* 取货位置列表
|
*/
|
private List<String> pickupPositions;
|
|
/**
|
* 充电位置列表
|
*/
|
private List<String> chargingPositions;
|
|
/**
|
* 送货位置列表
|
*/
|
private List<String> deliveryPositions;
|
|
/**
|
* 待机位置列表
|
*/
|
private List<String> standbyPositions;
|
|
/**
|
* 构造函数
|
*
|
* @param pathMapping 路径映射表
|
* @param taskDataList 任务数据列表
|
*/
|
public ExecutingTaskExtractor(Map<String, Map<String, Integer>> pathMapping, List<TaskData> taskDataList) {
|
this.pathMapping = pathMapping;
|
this.coordToCode = new HashMap<>();
|
this.taskDataMap = new HashMap<>();
|
|
// 构建任务数据映射表
|
if (taskDataList != null) {
|
for (TaskData taskData : taskDataList) {
|
taskDataMap.put(taskData.getTaskId(), taskData);
|
}
|
}
|
|
// 预计算坐标映射
|
buildCoordToCodeMapping();
|
|
// 预分类位置类型
|
classifyPositions();
|
|
System.out.println("任务提取器初始化完成，分类位置：取货=" + pickupPositions.size() +
|
", 充电=" + chargingPositions.size() +
|
", 送货=" + deliveryPositions.size() +
|
", 待机=" + standbyPositions.size() +
|
", 任务数据=" + taskDataMap.size());
|
}
|
|
/**
|
* 提取执行中的任务
|
*
|
* @param agvStatusList AGV状态列表
|
* @return 执行中任务列表
|
*/
|
public List<ExecutingTask> extractExecutingTasks(List<AGVStatus> agvStatusList) {
|
List<ExecutingTask> executingTasks = new ArrayList<>();
|
|
for (AGVStatus agvStatus : agvStatusList) {
|
List<ExecutingTask> agvTasks = extractAgvTasks(agvStatus);
|
executingTasks.addAll(agvTasks);
|
}
|
|
System.out.println("提取到 " + executingTasks.size() + " 个执行中任务");
|
return executingTasks;
|
}
|
|
/**
|
* 提取单个AGV的执行中任务
|
*
|
* @param agvStatus AGV状态
|
* @return 执行中任务列表
|
*/
|
private List<ExecutingTask> extractAgvTasks(AGVStatus agvStatus) {
|
List<ExecutingTask> tasks = new ArrayList<>();
|
|
// 检查AGV是否可用
|
if (!agvStatus.isAvailable()) {
|
return tasks;
|
}
|
|
// 分析背篓状态
|
List<BackpackData> backpack = agvStatus.getBackpack();
|
if (backpack == null || backpack.isEmpty()) {
|
return tasks;
|
}
|
|
// 分别收集已装载和未装载的任务
|
List<BackpackData> loadedTasks = new ArrayList<>();
|
List<BackpackData> unloadedTasks = new ArrayList<>();
|
|
for (BackpackData bp : backpack) {
|
if (bp.getTaskId() != null && !bp.getTaskId().trim().isEmpty()) {
|
TaskData taskData = getTaskData(bp.getTaskId());
|
if (taskData != null) {
|
if (bp.isLoaded()) {
|
loadedTasks.add(bp);
|
} else {
|
unloadedTasks.add(bp);
|
}
|
}
|
}
|
}
|
|
// 确定下一步最优行动
|
ExecutingTask nextTask = determineNextBestAction(agvStatus, loadedTasks, unloadedTasks);
|
if (nextTask != null) {
|
tasks.add(nextTask);
|
}
|
|
return tasks;
|
}
|
|
/**
|
* 确定AGV下一步最优行动
|
* 使用加权成本算法综合考虑距离和任务类型
|
*
|
* @param agvStatus AGV状态
|
* @param loadedTasks 已装载任务
|
* @param unloadedTasks 未装载任务
|
* @return 下一步执行任务
|
*/
|
private ExecutingTask determineNextBestAction(AGVStatus agvStatus,
|
List<BackpackData> loadedTasks,
|
List<BackpackData> unloadedTasks) {
|
String currentPosition = agvStatus.getPosition();
|
List<TaskOption> taskOptions = new ArrayList<>();
|
|
// 1. 收集所有可选的送货任务
|
for (BackpackData task : loadedTasks) {
|
TaskData taskData = getTaskData(task.getTaskId());
|
if (taskData != null && taskData.getEnd() != null) {
|
double distance = calculateDistance(currentPosition, taskData.getEnd());
|
if (distance >= 0) {
|
double cost = calculateTaskCost(distance, "delivery", taskData.getPriority(), agvStatus);
|
taskOptions.add(new TaskOption(task, true, distance, cost, "delivery"));
|
}
|
}
|
}
|
|
// 2. 收集所有可选的取货任务
|
for (BackpackData task : unloadedTasks) {
|
TaskData taskData = getTaskData(task.getTaskId());
|
if (taskData != null && taskData.getStart() != null) {
|
double distance = calculateDistance(currentPosition, taskData.getStart());
|
if (distance >= 0) {
|
double cost = calculateTaskCost(distance, "pickup", taskData.getPriority(), agvStatus);
|
taskOptions.add(new TaskOption(task, false, distance, cost, "pickup"));
|
}
|
}
|
}
|
|
// 3. 如果电量不足，添加充电选项
|
if (agvStatus.needsCharging()) {
|
String nearestCharging = findNearestChargingPosition(currentPosition);
|
if (nearestCharging != null && !nearestCharging.equals(currentPosition)) {
|
double distance = calculateDistance(currentPosition, nearestCharging);
|
if (distance >= 0) {
|
double cost = calculateChargingCost(distance, agvStatus.getVol(), agvStatus.getLowVol());
|
taskOptions.add(new TaskOption(null, false, distance, cost, "charging"));
|
}
|
}
|
}
|
|
// 4. 选择成本最低的任务
|
if (taskOptions.isEmpty()) {
|
return null;
|
}
|
|
// 按成本排序，选择最优选项
|
taskOptions.sort(Comparator.comparingDouble(option -> option.cost));
|
TaskOption bestOption = taskOptions.get(0);
|
|
// 输出决策日志
|
System.out.println("AGV " + agvStatus.getAgvId() + " 任务决策：");
|
for (int i = 0; i < Math.min(3, taskOptions.size()); i++) {
|
TaskOption option = taskOptions.get(i);
|
System.out.println(" " + (i == 0 ? "[选中]" : " ") +
|
" 类型: " + option.taskType +
|
", 距离: " + String.format("%.1f", option.distance) +
|
", 成本: " + String.format("%.2f", option.cost));
|
}
|
|
// 创建执行任务
|
if ("charging".equals(bestOption.taskType)) {
|
String nearestCharging = findNearestChargingPosition(currentPosition);
|
return createChargingTask(agvStatus, nearestCharging);
|
} else {
|
return createExecutingTask(agvStatus, bestOption.backpackData, bestOption.isLoaded);
|
}
|
}
|
|
/**
|
* 计算任务成本
|
*
|
* @param distance 距离
|
* @param taskType 任务类型
|
* @param taskPriority 任务优先级
|
* @param agvStatus AGV状态
|
* @return 任务成本
|
*/
|
private double calculateTaskCost(double distance, String taskType, int taskPriority, AGVStatus agvStatus) {
|
// 基础距离成本
|
double distanceCost = distance;
|
|
// 任务类型权重
|
double taskTypeWeight;
|
switch (taskType) {
|
case "delivery":
|
taskTypeWeight = 10.0; // 送货任务基础权重较低，优先执行
|
break;
|
case "pickup":
|
taskTypeWeight = 15.0; // 取货任务基础权重适中
|
break;
|
default:
|
taskTypeWeight = 20.0;
|
}
|
|
// 任务优先级影响（优先级越高，权重越低）
|
double priorityWeight = Math.max(1.0, 6.0 - taskPriority);
|
|
// 电量影响（电量低时偏向近距离任务）
|
double batteryFactor = 1.0;
|
if (agvStatus.needsCharging()) {
|
batteryFactor = 1.0 + (100.0 - agvStatus.getVol()) / 100.0; // 电量越低，距离成本越高
|
}
|
|
// 综合成本计算
|
double totalCost = (distanceCost * batteryFactor) + (taskTypeWeight * priorityWeight);
|
|
return totalCost;
|
}
|
|
/**
|
* 计算充电任务成本
|
*
|
* @param distance 到充电点的距离
|
* @param currentVol 当前电量
|
* @param lowVol 最低电量阈值
|
* @return 充电任务成本
|
*/
|
private double calculateChargingCost(double distance, int currentVol, int lowVol) {
|
// 基础距离成本
|
double distanceCost = distance;
|
|
// 电量紧急程度（电量越低，充电成本越低，即优先级越高）
|
double batteryUrgency;
|
if (currentVol <= lowVol) {
|
batteryUrgency = 5.0; // 必须充电，极高优先级
|
} else {
|
// 电量在lowVol到autoCharge之间，线性计算紧急程度
|
batteryUrgency = 30.0 - (currentVol - lowVol) * 0.5; // 电量越低优先级越高
|
}
|
|
return distanceCost + batteryUrgency;
|
}
|
|
/**
|
* 任务选项内部类
|
*/
|
private static class TaskOption {
|
BackpackData backpackData;
|
boolean isLoaded;
|
double distance;
|
double cost;
|
String taskType;
|
|
public TaskOption(BackpackData backpackData, boolean isLoaded, double distance, double cost, String taskType) {
|
this.backpackData = backpackData;
|
this.isLoaded = isLoaded;
|
this.distance = distance;
|
this.cost = cost;
|
this.taskType = taskType;
|
}
|
}
|
|
/**
|
* 获取任务数据
|
*
|
* @param taskId 任务ID
|
* @return 任务数据
|
*/
|
private TaskData getTaskData(String taskId) {
|
return taskDataMap.get(taskId);
|
}
|
|
|
/**
|
* 查找最近的充电位置
|
*
|
* @param currentPosition 当前位置
|
* @return 最近的充电位置
|
*/
|
private String findNearestChargingPosition(String currentPosition) {
|
String nearest = null;
|
double minDistance = Double.MAX_VALUE;
|
|
for (String chargingPos : chargingPositions) {
|
if (!chargingPos.equals(currentPosition)) {
|
double distance = calculateDistance(currentPosition, chargingPos);
|
if (distance >= 0 && distance < minDistance) {
|
minDistance = distance;
|
nearest = chargingPos;
|
}
|
}
|
}
|
|
return nearest;
|
}
|
|
/**
|
* 创建执行任务
|
*
|
* @param agvStatus AGV状态
|
* @param backpackData 背篓数据
|
* @param isLoaded 是否已装载
|
* @return 执行任务
|
*/
|
private ExecutingTask createExecutingTask(AGVStatus agvStatus, BackpackData backpackData, boolean isLoaded) {
|
TaskData taskData = getTaskData(backpackData.getTaskId());
|
if (taskData == null) {
|
return null;
|
}
|
|
ExecutingTask task = new ExecutingTask();
|
task.setAgvId(agvStatus.getAgvId());
|
task.setTaskId(backpackData.getTaskId());
|
task.setCurrentPosition(agvStatus.getPosition());
|
task.setLoaded(isLoaded);
|
task.setBackpackIndex(backpackData.getIndex());
|
task.setPriority(taskData.getPriority());
|
|
// 设置目标位置
|
if (isLoaded) {
|
task.setTargetPosition(taskData.getEnd());
|
task.setTaskType("delivery");
|
} else {
|
task.setTargetPosition(taskData.getStart());
|
task.setTaskType("pickup");
|
}
|
|
// 计算距离
|
task.setDistanceToStart(calculateDistance(agvStatus.getPosition(), taskData.getStart()));
|
task.setDistanceToEnd(calculateDistance(agvStatus.getPosition(), taskData.getEnd()));
|
|
return task;
|
}
|
|
/**
|
* 创建充电任务
|
*
|
* @param agvStatus AGV状态
|
* @param chargingPosition 充电位置
|
* @return 充电任务
|
*/
|
private ExecutingTask createChargingTask(AGVStatus agvStatus, String chargingPosition) {
|
ExecutingTask task = new ExecutingTask();
|
task.setAgvId(agvStatus.getAgvId());
|
task.setTaskId("CHARGING_" + agvStatus.getAgvId());
|
task.setCurrentPosition(agvStatus.getPosition());
|
task.setTargetPosition(chargingPosition);
|
task.setTaskType("charging");
|
task.setLoaded(false);
|
task.setBackpackIndex(-1);
|
task.setPriority(1); // 充电任务优先级较高
|
|
return task;
|
}
|
|
/**
|
* 计算两个位置之间的距离
|
*
|
* @param pos1 位置1
|
* @param pos2 位置2
|
* @return 距离值
|
*/
|
private double calculateDistance(String pos1, String pos2) {
|
if (pos1 == null || pos2 == null) {
|
return -1;
|
}
|
|
int[] coord1 = JsonUtils.getCoordinate(pos1, pathMapping);
|
int[] coord2 = JsonUtils.getCoordinate(pos2, pathMapping);
|
|
if (coord1 == null || coord2 == null) {
|
return -1;
|
}
|
|
return JsonUtils.calculateManhattanDistance(coord1, coord2);
|
}
|
|
/**
|
* 构建坐标到路径编号的映射
|
*/
|
private void buildCoordToCodeMapping() {
|
for (Map.Entry<String, Map<String, Integer>> entry : pathMapping.entrySet()) {
|
String code = entry.getKey();
|
Map<String, Integer> coordMap = entry.getValue();
|
|
if (coordMap.containsKey("x") && coordMap.containsKey("y")) {
|
String coordKey = coordMap.get("x") + "," + coordMap.get("y");
|
coordToCode.put(coordKey, code);
|
}
|
}
|
}
|
|
/**
|
* 预分类位置类型
|
*/
|
private void classifyPositions() {
|
pickupPositions = new ArrayList<>();
|
chargingPositions = new ArrayList<>();
|
deliveryPositions = new ArrayList<>();
|
standbyPositions = new ArrayList<>();
|
|
for (String position : pathMapping.keySet()) {
|
if (position.startsWith("1")) {
|
pickupPositions.add(position);
|
} else if (position.startsWith("2")) {
|
chargingPositions.add(position);
|
} else if (position.startsWith("3")) {
|
deliveryPositions.add(position);
|
} else if (position.startsWith("4")) {
|
standbyPositions.add(position);
|
}
|
}
|
}
|
|
// Getter方法
|
public List<String> getPickupPositions() {
|
return pickupPositions;
|
}
|
|
public List<String> getChargingPositions() {
|
return chargingPositions;
|
}
|
|
public List<String> getDeliveryPositions() {
|
return deliveryPositions;
|
}
|
|
public List<String> getStandbyPositions() {
|
return standbyPositions;
|
}
|
}
|
