package com.algo.service;
|
|
import com.algo.model.AGVStatus;
|
import com.algo.model.BackpackData;
|
import com.algo.model.TaskAssignment;
|
import com.algo.model.TaskData;
|
import com.algo.util.JsonUtils;
|
import org.springframework.stereotype.Service;
|
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* 任务分配服务类
|
*/
|
public class TaskAllocationService {
|
|
private Map<String, Map<String, Integer>> pathMapping;
|
private Map<String, Object> environmentConfig;
|
|
/**
|
* 构造函数
|
*
|
* @param pathMapping 路径映射信息
|
* @param environmentConfig 环境配置信息
|
*/
|
public TaskAllocationService(Map<String, Map<String, Integer>> pathMapping,
|
Map<String, Object> environmentConfig) {
|
this.pathMapping = pathMapping;
|
this.environmentConfig = environmentConfig;
|
}
|
|
/**
|
* 执行任务分配
|
* 根据AGV状态和任务列表进行智能分配
|
*
|
* @param agvStatusList AGV状态列表
|
* @param taskList 任务列表
|
* @return 任务分配结果列表
|
*/
|
public List<TaskAssignment> allocateTasks(List<AGVStatus> agvStatusList, List<TaskData> taskList) {
|
System.out.println("开始任务分配，AGV数量: " + agvStatusList.size() + ", 任务数量: " + taskList.size());
|
|
// 输出环境信息
|
System.out.println("环境信息：宽度=" + environmentConfig.get("width") +
|
", 高度=" + environmentConfig.get("height") +
|
", 工作站数量=" + environmentConfig.get("stationCount"));
|
|
List<TaskAssignment> assignments = new ArrayList<>();
|
|
// 1. 过滤可用的AGV
|
List<AGVStatus> availableAgvs = agvStatusList.stream()
|
.filter(agv -> agv.isAvailable() && agv.getAvailableBackpackCount() > 0)
|
.collect(Collectors.toList());
|
|
System.out.println("可用AGV数量: " + availableAgvs.size());
|
|
if (availableAgvs.isEmpty()) {
|
System.out.println("没有可用的AGV，任务分配结束");
|
return assignments;
|
}
|
|
// 2. 过滤需要分配的任务（排除已指定AGV的任务）
|
List<TaskData> unassignedTasks = taskList.stream()
|
.filter(task -> !task.isAssignedToAgv() && task.isTransportTask())
|
.collect(Collectors.toList());
|
|
System.out.println("需要分配的运输任务数量: " + unassignedTasks.size());
|
|
// 3. 按优先级排序任务
|
unassignedTasks.sort((t1, t2) -> Integer.compare(t2.getPriority(), t1.getPriority()));
|
|
// 4. 使用智能分配策略（考虑工作站信息）
|
assignments.addAll(performIntelligentAllocation(availableAgvs, unassignedTasks));
|
|
System.out.println("任务分配完成，生成分配结果数量: " + assignments.size());
|
|
return assignments;
|
}
|
|
/**
|
* 执行智能分配策略
|
* 考虑AGV位置、任务位置、背篓容量、工作站容量等因素
|
*
|
* @param availableAgvs 可用AGV列表
|
* @param tasks 待分配任务列表
|
* @return 分配结果列表
|
*/
|
private List<TaskAssignment> performIntelligentAllocation(List<AGVStatus> availableAgvs, List<TaskData> tasks) {
|
List<TaskAssignment> assignments = new ArrayList<>();
|
|
// 为每个AGV维护一个工作负载记录
|
Map<String, Integer> agvWorkLoad = new HashMap<>();
|
Map<String, Integer> agvUsedBackpacks = new HashMap<>();
|
|
for (AGVStatus agv : availableAgvs) {
|
agvWorkLoad.put(agv.getAgvId(), 0);
|
agvUsedBackpacks.put(agv.getAgvId(), 0);
|
}
|
|
// 按地理位置分组任务（考虑工作站信息）
|
Map<String, List<TaskData>> tasksByStartLocation = groupTasksByStartLocation(tasks);
|
|
// 为每个位置分组分配AGV
|
for (Map.Entry<String, List<TaskData>> entry : tasksByStartLocation.entrySet()) {
|
String startLocation = entry.getKey();
|
List<TaskData> locationTasks = entry.getValue();
|
|
System.out.println("处理起点 " + startLocation + " 的任务，数量: " + locationTasks.size());
|
|
// 检查是否为工作站
|
if (JsonUtils.isStation(startLocation, environmentConfig)) {
|
Map<String, Object> stationInfo = JsonUtils.getStationInfo(startLocation, environmentConfig);
|
if (stationInfo != null) {
|
Integer capacity = (Integer) stationInfo.get("capacity");
|
System.out.println("工作站 " + startLocation + " 容量: " + capacity);
|
|
// 限制同时分配给该工作站的任务数量（不超过容量）
|
locationTasks = locationTasks.subList(0, Math.min(locationTasks.size(), capacity));
|
}
|
}
|
|
// 找到距离该位置最近的AGV
|
AGVStatus bestAgv = findNearestAvailableAgv(availableAgvs, startLocation, agvUsedBackpacks);
|
|
if (bestAgv != null) {
|
// 为该AGV分配尽可能多的任务（考虑背篓容量）
|
int availableBackpacks = bestAgv.getAvailableBackpackCount() - agvUsedBackpacks.get(bestAgv.getAgvId());
|
int tasksToAssign = Math.min(locationTasks.size(), availableBackpacks);
|
|
for (int i = 0; i < tasksToAssign; i++) {
|
TaskData task = locationTasks.get(i);
|
|
// 查找可用的背篓位置
|
int backpackIndex = findAvailableBackpackIndex(bestAgv, agvUsedBackpacks.get(bestAgv.getAgvId()));
|
|
if (backpackIndex != -1) {
|
// 创建取货任务分配
|
TaskAssignment takeAssignment = new TaskAssignment(
|
task.getTaskId(),
|
bestAgv.getAgvId(),
|
TaskAssignment.generateSegId(task.getTaskId(), bestAgv.getAgvId(), 1),
|
String.valueOf(backpackIndex),
|
TaskAssignment.TYPE_TAKE
|
);
|
assignments.add(takeAssignment);
|
|
// 创建放货任务分配
|
TaskAssignment putAssignment = new TaskAssignment(
|
task.getTaskId(),
|
bestAgv.getAgvId(),
|
TaskAssignment.generateSegId(task.getTaskId(), bestAgv.getAgvId(), 2),
|
String.valueOf(backpackIndex),
|
TaskAssignment.TYPE_PUT
|
);
|
assignments.add(putAssignment);
|
|
// 更新AGV工作负载
|
agvWorkLoad.put(bestAgv.getAgvId(), agvWorkLoad.get(bestAgv.getAgvId()) + 1);
|
agvUsedBackpacks.put(bestAgv.getAgvId(), agvUsedBackpacks.get(bestAgv.getAgvId()) + 1);
|
|
System.out.println("分配任务 " + task.getTaskId() + " 给AGV " + bestAgv.getAgvId() +
|
" 背篓 " + backpackIndex + " (起点: " + startLocation + ")");
|
} else {
|
System.out.println("AGV " + bestAgv.getAgvId() + " 没有可用的背篓位置");
|
break;
|
}
|
}
|
} else {
|
System.out.println("未找到可用的AGV处理起点 " + startLocation + " 的任务");
|
}
|
}
|
|
return assignments;
|
}
|
|
/**
|
* 按起点位置分组任务
|
*
|
* @param tasks 任务列表
|
* @return 按起点分组的任务Map
|
*/
|
private Map<String, List<TaskData>> groupTasksByStartLocation(List<TaskData> tasks) {
|
Map<String, List<TaskData>> grouped = new HashMap<>();
|
|
for (TaskData task : tasks) {
|
String startLocation = task.getStart();
|
grouped.computeIfAbsent(startLocation, k -> new ArrayList<>()).add(task);
|
}
|
|
return grouped;
|
}
|
|
/**
|
* 查找距离指定位置最近的可用AGV
|
*
|
* @param availableAgvs 可用AGV列表
|
* @param targetLocation 目标位置
|
* @param usedBackpacks 已使用背篓数量统计
|
* @return 最近的可用AGV
|
*/
|
private AGVStatus findNearestAvailableAgv(List<AGVStatus> availableAgvs, String targetLocation, Map<String, Integer> usedBackpacks) {
|
AGVStatus bestAgv = null;
|
double minDistance = Double.MAX_VALUE;
|
|
int[] targetCoord = JsonUtils.getCoordinate(targetLocation, pathMapping);
|
if (targetCoord == null) {
|
System.out.println("无法获取目标位置 " + targetLocation + " 的坐标");
|
return availableAgvs.isEmpty() ? null : availableAgvs.get(0);
|
}
|
|
for (AGVStatus agv : availableAgvs) {
|
// 检查AGV是否还有可用背篓
|
int availableBackpacks = agv.getAvailableBackpackCount() - usedBackpacks.get(agv.getAgvId());
|
if (availableBackpacks <= 0) {
|
continue;
|
}
|
|
int[] agvCoord = JsonUtils.getCoordinate(agv.getPosition(), pathMapping);
|
if (agvCoord != null) {
|
double distance = JsonUtils.calculateManhattanDistance(agvCoord, targetCoord);
|
|
// 考虑AGV的工作负载（距离越近且负载越轻越好）
|
double adjustedDistance = distance + usedBackpacks.get(agv.getAgvId()) * 2.0;
|
|
if (adjustedDistance < minDistance) {
|
minDistance = adjustedDistance;
|
bestAgv = agv;
|
}
|
}
|
}
|
|
return bestAgv;
|
}
|
|
/**
|
* 查找AGV的可用背篓位置
|
*
|
* @param agv AGV状态
|
* @param usedCount 已使用的背篓数量
|
* @return 可用背篓索引，如果没有可用则返回-1
|
*/
|
private int findAvailableBackpackIndex(AGVStatus agv, int usedCount) {
|
if (agv.getBackpack() == null || agv.getBackpack().isEmpty()) {
|
return usedCount == 0 ? 0 : -1;
|
}
|
|
int availableCount = 0;
|
for (BackpackData backpack : agv.getBackpack()) {
|
if (backpack.isAvailable()) {
|
if (availableCount >= usedCount) {
|
return backpack.getIndex();
|
}
|
availableCount++;
|
}
|
}
|
|
return -1;
|
}
|
|
/**
|
* 验证任务分配结果
|
*
|
* @param assignments 分配结果列表
|
* @return 验证是否通过
|
*/
|
public boolean validateAssignments(List<TaskAssignment> assignments) {
|
Map<String, Set<String>> agvBackpackUsage = new HashMap<>();
|
|
for (TaskAssignment assignment : assignments) {
|
if (!assignment.isValid()) {
|
System.out.println("发现无效的任务分配: " + assignment);
|
return false;
|
}
|
|
String agvId = assignment.getAgvId();
|
String backpackId = assignment.getLev();
|
|
agvBackpackUsage.computeIfAbsent(agvId, k -> new HashSet<>()).add(backpackId);
|
}
|
|
// 检查背篓使用冲突
|
for (Map.Entry<String, Set<String>> entry : agvBackpackUsage.entrySet()) {
|
String agvId = entry.getKey();
|
Set<String> usedBackpacks = entry.getValue();
|
|
System.out.println("AGV " + agvId + " 使用背篓: " + usedBackpacks);
|
}
|
|
return true;
|
}
|
}
|
