＜代码分享＞ 一种无人机配合卡车配送的车辆路径规划模型

最新推荐文章于 2024-05-22 21:27:50 发布
最新推荐文章于 2024-05-22 21:27:50 发布
阅读量9.2k 收藏 172
点赞数 17
分类专栏： 整数规划 组合优化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zhang_0702_China/article/details/119391030
版权

本文为本人博客《一种无人机配合卡车配送的车辆路径规划模型》的代码分享。
由于近期此文的关注者较多，代码分享较为不便，因此决定专门写一篇博客以提供源码。
感谢各位博友关注，本人能力有限，如有错误，还请及时批评指正！
原文链接：https://blog.csdn.net/Zhang_0702_China/article/details/115215219


代码文件结构


代码的文件结构如下：
  • config: 参数、输入数据（随机生成）
  • docs: 模型文档、参考文献（见前面原文链接）
  • log: 运行日志
  • model: 模型核心模块
  • output: 输出文件，即可视化结果
  • utils: 工具模块，本文代码只涉及日志打印工具
  • visual: 可视化模块
  • main_tsp.py: TSP 模型主程序
  • main_vrp.py: VRP 模型主程序

把后面提供的代码粘贴到对应文件即可运行。
文件结构

具体代码


参数与输入数据


TSP：

from datetime import datetime
import random
import math

from utils.logger import log_tsp as log


dts = datetime.now()


# nodes
NUM_NODE = 50
NUM_NODE_NAV = 20
LIST_NODE_UAV = list(range(NUM_NODE - NUM_NODE_NAV + 1, NUM_NODE + 1))

# coordinates
random.seed(2021)
RANGE_COORDINATE = (0, 100)
LIST_COORDINATE = [(random.randint(RANGE_COORDINATE[0], RANGE_COORDINATE[1]),
                    random.randint(RANGE_COORDINATE[0], RANGE_COORDINATE[1])) for _ in range(NUM_NODE)]

# distance
ORIGIN = (round((RANGE_COORDINATE[1] - RANGE_COORDINATE[0]) / 2),
          round((RANGE_COORDINATE[1] - RANGE_COORDINATE[0]) / 2))
LIST_COORDINATE_ = [ORIGIN] + LIST_COORDINATE
MAT_DISTANCE = [[0.0 for _ in range(0, NUM_NODE + 1)] for _ in range(0, NUM_NODE + 1)]
range_wave = (0.8, 1.2)
for i in range(0, NUM_NODE + 1):
    for j in range(0, NUM_NODE + 1):
        distance = round(math.sqrt((LIST_COORDINATE_[i][0] - LIST_COORDINATE_[j][0]) ** 2
                                   + (LIST_COORDINATE_[i][1] - LIST_COORDINATE_[j][1]) ** 2)
                         * (range_wave[0] + random.random() * (range_wave[1] - range_wave[0])), 4)
        MAT_DISTANCE[i][j] = distance

# cost
COST_UAV = 0.2


dte = datetime.now()
tm = round((dte - dts).seconds + (dte - dts).microseconds / (10 ** 6), 3)
log.info(msg="random data generating time:  {} s".format(tm))

VRP：

from datetime import datetime
import random
import math

from utils.logger import log_vrp as log


dts = datetime.now()


# nodes
NUM_NODE = 50
NUM_NODE_NAV = 10
LIST_NODE_UAV = list(range(NUM_NODE - NUM_NODE_NAV + 1, NUM_NODE + 1))

# coordinates
random.seed(2021)
RANGE_COORDINATE = (0, 100)
LIST_COORDINATE = [(random.randint(RANGE_COORDINATE[0], RANGE_COORDINATE[1]),
                    random.randint(RANGE_COORDINATE[0], RANGE_COORDINATE[1])) for _ in range(NUM_NODE)]

# distance
ORIGIN = (round((RANGE_COORDINATE[1] - RANGE_COORDINATE[0]) / 2),
          round((RANGE_COORDINATE[1] - RANGE_COORDINATE[0]) / 2))
LIST_COORDINATE_ = [ORIGIN] + LIST_COORDINATE
MAT_DISTANCE = [[0.0 for _ in range(0, NUM_NODE + 1)] for _ in range(0, NUM_NODE + 1)]
range_wave = (0.8, 1.2)
for i in range(0, NUM_NODE + 1):
    for j in range(0, NUM_NODE + 1):
        distance = round(math.sqrt((LIST_COORDINATE_[i][0] - LIST_COORDINATE_[j][0]) ** 2
                                   + (LIST_COORDINATE_[i][1] - LIST_COORDINATE_[j][1]) ** 2)
                         * (range_wave[0] + random.random() * (range_wave[1] - range_wave[0])), 4)
        MAT_DISTANCE[i][j] = distance

# cost
COST_UAV = 0.1

# weight, load
upper_weight_item = 20
LIST_WEIGHT = [random.randint(0, upper_weight_item) for _ in range(NUM_NODE)]
UPPER_LOAD = 100
log.info(msg="total weight:  {}".format(sum(LIST_WEIGHT)))


dte = datetime.now()
tm = round((dte - dts).seconds + (dte - dts).microseconds / (10 ** 6), 3)
log.info(msg="random data generating time:  {} s".format(tm))

模型核心模块


在 TSP 模型中，通过 GG 模型的建模方式消除子回路；在 VRP 模型中，通过卡车载重约束的传递性消除子回路。
有关 TSP 模型的建模方式可见本人博客：https://blog.csdn.net/Zhang_0702_China/article/details/106983492

模型求解通过调用 Gurobi 求解器的方式实现，有关 Gurobi 求解器的 Python 调用，可见本人博客：
https://blog.csdn.net/Zhang_0702_China/article/details/115520346

TSP：

from datetime import datetime
from typing import List, Dict, Tuple

from gurobipy import *

from utils.logger import log_tsp as log


def tsp_gg(num_node: int, list_node_uav: List[int], mat_distance: List[List[int]], cost_uav: float = 0.5) \
        -> Tuple[List[int], Dict[int, Tuple[int, int]]]:
    """
    TSP model, GG formulation

    :param num_node:  number of nodes
    :param list_node_uav:  nodes can be served by uav
    :param mat_distance:  distance matrix,  0 index for hub
    :param cost_uav:  cost coefficient of uav

    :return: list_route:  list of nodes in truck route
    :return: dict_uav_route:  dict of uav routes
    """

    log.info(msg=">>> TSP model, GG formulation, start")

    model = Model('tsp_gg')

    """ variables """

    # if truck flow from i to j
    x = model.addVars([(i, j) for i in range(0, num_node + 1) for j in range(0, num_node + 1)], vtype=GRB.BINARY,
                      name='x_')

    # if uav flow from i to j
    y = model.addVars([(i, j) for i in range(0, num_node + 1) for j in range(0, num_node + 1)], vtype=GRB.BINARY,
                      name='y_')

    # if served by truck
    s = model.addVars([i for i in range(1, num_node + 1)], vtype=GRB.BINARY, name='s_')

    # sub-loop elimination
    a = model.addVars([(i, j) for i in range(0, num_node + 1) for j in range(0, num_node + 1)], vtype=GRB.CONTINUOUS,
                      name='a_')

    """ constraints """

    # cons 1: stream in / out
    for i in range(0, num_node + 1):
        # nodes can only served by truck
        if i not in list_node_uav:
            model.addConstr(quicksum(x[j, i] for j in range(0, num_node + 1)) == 1, name='cons_1_in_x_[{}]'.format(i))
            model.addConstr(quicksum(x[i, j] for j in range(0, num_node + 1)) == 1, name='cons_1_out_x_[{}]'.format(i))

        # nodes can served by truck or uav
        else:
            model.addConstr(quicksum(x[j, i] + y[j, i] for j in range(0, num_node + 1)) == 1,
                            name='cons_1_in_xy_[{}]'.format(i))
            model.addConstr(quicksum(x[i, j] + y[i, j] for j in range(0, num_node + 1)) == 1,
                            name='cons_1_out_xy_[{}]'.format(i))

            # truck or uav
            model.addConstr(quicksum(y[j, i] for j in range(0, num_node + 1))
                            == quicksum(y[i, j] for j in range(0, num_node + 1)), name='cons_1_y[{}]'.format(i))

    # cons 2: self-loop elimination
    model.addConstr(quicksum(x[i, i] for i in range(0, num_node + 1)) == 0, name='cons_2_x')
    model.addConstr(quicksum(y[i, i] for i in range(0, num_node + 1)) == 0, name='cons_2_y')

    # cons 3: get, if served by truck
    for i in range(1, num_node + 1):
        model.addConstr(s[i] == quicksum(x[i, j] for j in range(0, num_node + 1)), name='cons_3_[{}]'.format(i))

    # cons 4: sub-loop elimination
    for i in range(1, num_node + 1):
        list_n_i = list(range(0, i)) + list(range(i + 1, num_node + 1))
        list_n_i_ori = list(range(1, i)) + list(range(i + 1, num_node + 1))
        model.addConstr(quicksum(a[i, j] for j in list_n_i) - quicksum(a[j, i] for j in list_n_i_ori) == s[i],
                        name='cons_4_a_[{}]'.format(i))

        for j in range(0, num_node + 1):
            model.addConstr(a[i, j] <= num_node * x[i, j], name='cons_4_ax_[{},{}]'.format(i, j))

    # cons 5: uav order
    for j in list_node_uav:
        for i in range(0, num_node + 1):
            for k in range(0, num_node + 1):
                model.addConstr(y[i, j] + y[j, k] <= 2 * x[i, k] + 1, name='cons_5_[{},{},{}]'.format(i, j, k))

    # cons 6: only one uav
    for i in range(0, num_node + 1):
        model.addConstr(quicksum(y[i, j] for j in range(0, num_node + 1)) <= 1, name='cons_6_out_[{}]'.format(i))
        model.addConstr(quicksum(y[j, i] for j in range(0, num_node + 1)) <= 1, name='cons_6_in_[{}]'.format(i))

    """ objective & solve """

    # obj: total weighted distance
    cost = quicksum(x[i, j] * mat_distance[i][j] + y[i, j] * mat_distance[i][j] * cost_uav
                    for i in range(0, num_node + 1) for j in range(0, num_node + 1))
    model.setObjective(cost, sense=GRB.MINIMIZE)

    model.setParam(GRB.Param.TimeLimit, 300)
    model.setParam(GRB.Param.MIPGap, 0.02)

    dts_solve = datetime.now()
    model.optimize()
    dte_solve = datetime.now()
    tm_solve = round((dte_solve - dts_solve).seconds + (dte_solve - dts_solve).microseconds / (10 ** 6), 3)
    log.info(msg="solving time:  {} s".format(tm_solve))

    """ result """

    x_ = model.getAttr('X', x)
    y_ = model.getAttr('X', y)
    s_ = model.getAttr('X', s)

    # truck route
    list_route = [0]
    to = None
    while to != 0:
        for i in range(0, num_node + 1):
            if x_[list_route[-1], i] > 0.9:
                to = i
                list_route.append(i)
                break

    # uav routes
    list_node_uav_ = []
    dict_uav_route = {}
    for j in list_node_uav:
        if s_[j] < 0.1:
            list_node_uav_.append(j)

            fr, to = None, None
            for i in range(0, num_node + 1):
                if y_[i, j] > 0.9:
                    fr = i
                    break
            for k in range(0, num_node + 1):
                if y_[j, k] > 0.9:
                    to = k
                    break
            tup_fr_to = (fr, to)
            dict_uav_route[j] = tup_fr_to
    log.info(msg="nodes can be served by uav:  {}".format(list_node_uav))
    log.info(msg="nodes served by uav:  {}".format(list_node_uav_))

    log.info(msg="<<< TSP model, GG formulation, end")

    return list_route, dict_uav_route

VRP：

from datetime import datetime
from typing import List, Dict, Tuple

from gurobipy import *

from utils.logger import log_vrp as log


def vrp_load(num_node: int, list_node_uav: List[int], list_weight: List[int], upper_load: int,
             mat_distance: List[List[int]], cost_uav: float = 0.5) \
        -> Tuple[List[List[int]], Dict[int, Tuple[int, int]]]:
    """
    VRP model, load limit mode

    :param num_node:  number of nodes
    :param list_node_uav:  nodes can be served by uav
    :param list_weight:  weight of each node
    :param upper_load:  upper limit of vehicle loads
    :param mat_distance:  distance matrix,  0 index for hub
    :param cost_uav:  cost coefficient of uav

    :return: list_routes:  list of truck routes
    :return: dict_uav_route:  dict of uav routes
    """

    log.info(msg=">>> VRP model, load limit mode, start")

    model = Model('vrp_load')

    """ variables """

    # if truck flow from i to j
    x = model.addVars([(i, j) for i in range(0, num_node + 1) for j in range(0, num_node + 1)], vtype=GRB.BINARY,
                      name='x_')

    # if uav flow from i to j
    y = model.addVars([(i, j) for i in range(0, num_node + 1) for j in range(0, num_node + 1)], vtype=GRB.BINARY,
                      name='y_')

    # if served by truck
    s = model.addVars([i for i in range(1, num_node + 1)], vtype=GRB.BINARY, name='s_')

    # load limit: arc weight
    z = model.addVars([(i, j) for i in range(0, num_node + 1) for j in range(0, num_node + 1)], ub=upper_load,
                      vtype=GRB.CONTINUOUS, name='a_')

    """ constraints """

    # cons 1: stream in / out, not including origin
    for i in range(1, num_node + 1):
        # nodes can only served by truck
        if i not in list_node_uav:
            model.addConstr(quicksum(x[j, i] for j in range(0, num_node + 1)) == 1, name='cons_1_in_x_[{}]'.format(i))
            model.addConstr(quicksum(x[i, j] for j in range(0, num_node + 1)) == 1, name='cons_1_out_x_[{}]'.format(i))

        # nodes can served by truck or uav
        else:
            model.addConstr(quicksum(x[j, i] + y[j, i] for j in range(0, num_node + 1)) == 1,
                            name='cons_1_in_xy_[{}]'.format(i))
            model.addConstr(quicksum(x[i, j] + y[i, j] for j in range(0, num_node + 1)) == 1,
                            name='cons_1_out_xy_[{}]'.format(i))

            # truck or uav
            model.addConstr(quicksum(y[j, i] for j in range(0, num_node + 1))
                            == quicksum(y[i, j] for j in range(0, num_node + 1)), name='cons_1_y[{}]'.format(i))

    # cons 2: self-loop elimination
    model.addConstr(quicksum(x[i, i] for i in range(0, num_node + 1)) == 0, name='cons_2_x')
    model.addConstr(quicksum(y[i, i] for i in range(0, num_node + 1)) == 0, name='cons_2_y')

    # cons 3: get, if served by truck
    for i in range(1, num_node + 1):
        model.addConstr(s[i] == quicksum(x[i, j] for j in range(0, num_node + 1)), name='cons_3_[{}]'.format(i))

    # cons 4: load limit, including sub-loop elimination
    big_m = 10 ** 6
    for j in range(1, num_node + 1):
        for i in range(0, num_node + 1):
            list_not_j = list(range(0, j)) + list(range(j + 1, num_node + 1))
            list_uav_not_j = list_node_uav.copy()
            if j in list_uav_not_j:
                list_uav_not_j.remove(j)
            model.addConstr(z[i, j] >= list_weight[j - 1] + quicksum(z[j, k] for k in list_not_j)
                            + quicksum(y[j, u] * list_weight[u - 1] for u in list_uav_not_j) + (x[i, j] - 1) * big_m,
                            name='cons_4_[{},{}]'.format(i, j))

            model.addConstr(z[i, j] <= x[i, j] * big_m, name='cons_4_zx_[{},{}]'.format(i, j))

            # todo: sun-loop elimination:  2-node loop
            if i:
                model.addConstr(x[i, j] + x[j, i] <= 1, name='cons_4_loop_2[{},{}]'.format(i, j))

    # cons 5: uav order
    for j in list_node_uav:
        for i in range(0, num_node + 1):
            for k in range(0, num_node + 1):
                model.addConstr(y[i, j] + y[j, k] <= 2 * x[i, k] + 1, name='cons_5_[{},{},{}]'.format(i, j, k))

    # cons 6: only one uav
    for i in range(0, num_node + 1):
        model.addConstr(quicksum(y[i, j] for j in range(0, num_node + 1)) <= 1, name='cons_6_out_[{}]'.format(i))
        model.addConstr(quicksum(y[j, i] for j in range(0, num_node + 1)) <= 1, name='cons_6_in_[{}]'.format(i))

    # cons 7: valid inequality
    model.addConstr(quicksum(x[0, j] for j in range(1, num_node + 1)) >= math.ceil(sum(list_weight) / upper_load),
                    name='cons_7')

    """ objective & solve """

    num_vehicle = quicksum(x[0, j] for j in range(1, num_node + 1))
    sum_distance = quicksum(x[i, j] * mat_distance[i][j] + y[i, j] * mat_distance[i][j] * cost_uav
                            for i in range(0, num_node + 1) for j in range(0, num_node + 1))
    model.setObjective(num_vehicle * big_m + sum_distance, sense=GRB.MINIMIZE)

    model.setParam(GRB.Param.TimeLimit, 600)
    model.setParam(GRB.Param.MIPGap, 0.05)

    dts_solve = datetime.now()
    model.optimize()
    dte_solve = datetime.now()
    tm_solve = round((dte_solve - dts_solve).seconds + (dte_solve - dts_solve).microseconds / (10 ** 6), 3)
    log.info(msg="solving time:  {} s".format(tm_solve))

    """ result """

    x_ = model.getAttr('X', x)
    y_ = model.getAttr('X', y)
    s_ = model.getAttr('X', s)

    num_vehicle_ = int(sum(x_[0, j] for j in range(1, num_node + 1)))
    log.info("total vehicles: {}".format(num_vehicle_))

    # uav routes
    list_node_uav_ = []
    dict_uav_route = {}
    for j in list_node_uav:
        if s_[j] < 0.1:
            list_node_uav_.append(j)

            fr, to = None, None
            for i in range(0, num_node + 1):
                if y_[i, j] > 0.9:
                    fr = i
                    break
            for k in range(0, num_node + 1):
                if y_[j, k] > 0.9:
                    to = k
                    break
            tup_fr_to = (fr, to)
            dict_uav_route[j] = tup_fr_to
    log.info(msg="nodes can be served by uav:  {}".format(list_node_uav))
    log.info(msg="nodes served by uav:  {}".format(list_node_uav_))

    # truck routes
    list_routes = []
    set_node = set(range(0, num_node + 1))
    while len(set_node) > 1 + len(list_node_uav_):  # todo: number of nodes served by truck
        list_route_cur = [0]
        to = None
        while to != 0:
            if to:
                set_node.remove(to)
            for i in set_node:
                if x_[list_route_cur[-1], i] > 0.9:
                    to = i
                    list_route_cur.append(to)
                    break
        list_routes.append(list_route_cur)

    log.info(msg="<<< TSP model, GG formulation, end")

    return list_routes, dict_uav_route

工具模块（日志打印工具）


源码中采用调用 logging 打印日志的方法。
参见本人另一篇博客：https://blog.csdn.net/Zhang_0702_China/article/details/107982958

import os
import logging
from logging.handlers import TimedRotatingFileHandler


PATH = os.path.dirname(os.path.dirname(__file__))


class Logger(object):
    """
    log writer
    """

    def __init__(self, log_name: str):
        """
        log writer, initialise

        :param log_name:  file name of log
        """

        self.log_name = log_name
        self.log = logging.getLogger(name=self.log_name)
        self.log.setLevel(logging.INFO)

        # initialise logging
        logging.basicConfig()

        # output format
        fmt_st = "%(asctime)s[%(levelname)s][%(processName)s][%(threadName)s]:%(message)s"
        formatter = logging.Formatter(fmt=fmt_st)

        # log file
        path_root = os.path.join(PATH, "log")  # root directory of log
        if not os.path.exists(path_root):
            os.makedirs(name=path_root)
        path = os.path.join(path_root, self.log_name)

        # level and format
        file_handler = logging.handlers.TimedRotatingFileHandler(filename=path)
        file_handler.setLevel(level=logging.INFO)
        file_handler.setFormatter(fmt=formatter)
        self.log.addHandler(hdlr=file_handler)

    def info(self, msg: str):
        """
        info

        :param msg:  info

        :return: nothing
        """

        msg_ = " " + msg
        self.log.info(msg=msg_)

    def error(self, msg: str):
        """
        error info

        :param msg:  error info

        :return: nothing
        """

        msg_ = " " + msg
        self.log.error(msg=msg_)


log_tsp = Logger(log_name='tsp.log')
log_vrp = Logger(log_name='vrp.log')

可视化模块


TSP：

import os
from typing import List, Dict, Tuple
import matplotlib.pyplot as plt

from config import tsp as config


PATH = os.path.dirname(os.path.dirname(__file__))


def scatter_route_tsp(list_route: List[int], dict_uav_route: Dict[int, Tuple[int, int]]):
    """
    scatters and route of tsp result

    :param list_route:  list of nodes in truck route
    :param dict_uav_route:  dict of uav routes

    :return: nothing
    """

    num_node = config.NUM_NODE
    list_node_uav = config.LIST_NODE_UAV
    origin = config.ORIGIN
    list_coordinate_ = config.LIST_COORDINATE_
    range_coordinate = config.RANGE_COORDINATE

    # scatters
    plt.scatter(x=origin[0], y=origin[1], s=50, c='black', label='origin')
    for i in range(1, num_node + 1):
        color = 'blue' if i not in list_node_uav else 'red'
        plt.scatter(x=list_coordinate_[i][0], y=list_coordinate_[i][1], s=20, c=color, label=str(i))

    width = 0.2
    head_width = 2
    head_length = 3
    alpha = 0.7
    color_truck, color_uav = 'green', 'orange'
    line_width = 0.5

    # truck route
    for i in range(len(list_route) - 1):
        plt.arrow(x=list_coordinate_[list_route[i]][0], y=list_coordinate_[list_route[i]][1],
                  dx=list_coordinate_[list_route[i + 1]][0] - list_coordinate_[list_route[i]][0],
                  dy=list_coordinate_[list_route[i + 1]][1] - list_coordinate_[list_route[i]][1],
                  width=width, length_includes_head=True, head_width=head_width, head_length=head_length,
                  alpha=alpha, color=color_truck, linestyle='-', linewidth=line_width)

    # uav route
    for i in dict_uav_route.keys():
        plt.arrow(x=list_coordinate_[dict_uav_route[i][0]][0], y=list_coordinate_[dict_uav_route[i][0]][1],
                  dx=list_coordinate_[i][0] - list_coordinate_[dict_uav_route[i][0]][0],
                  dy=list_coordinate_[i][1] - list_coordinate_[dict_uav_route[i][0]][1],
                  width=width, length_includes_head=True, head_width=head_width, head_length=head_length,
                  alpha=alpha, color=color_uav, linestyle='--', linewidth=line_width)
        plt.arrow(x=list_coordinate_[i][0], y=list_coordinate_[i][1],
                  dx=list_coordinate_[dict_uav_route[i][1]][0] - list_coordinate_[i][0],
                  dy=list_coordinate_[dict_uav_route[i][1]][1] - list_coordinate_[i][1],
                  width=width, length_includes_head=True, head_width=head_width, head_length=head_length,
                  alpha=alpha, color=color_uav, linestyle='--', linewidth=line_width)

    # x, y range
    edge = 5
    plt.xlim(range_coordinate[0] - edge, range_coordinate[1] + edge)
    plt.ylim(range_coordinate[0] - edge, range_coordinate[1] + edge)

    # save
    path = os.path.join(PATH, "output/tsp.png")
    plt.savefig(path)

VRP：

import os
from typing import List, Dict, Tuple
import matplotlib.pyplot as plt

from config import vrp as config


PATH = os.path.dirname(os.path.dirname(__file__))


def scatter_route_vrp(list_routes: List[List[int]], dict_uav_route: Dict[int, Tuple[int, int]]):
    """
    scatters and route of vrp result

    :param list_routes:  list of truck route
    :param dict_uav_route:  dict of uav routes

    :return: nothing
    """

    num_node = config.NUM_NODE
    list_node_uav = config.LIST_NODE_UAV
    origin = config.ORIGIN
    list_coordinate_ = config.LIST_COORDINATE_
    range_coordinate = config.RANGE_COORDINATE

    # scatters
    plt.scatter(x=origin[0], y=origin[1], s=50, c='black', label='origin')
    for i in range(1, num_node + 1):
        color = 'blue' if i not in list_node_uav else 'red'
        plt.scatter(x=list_coordinate_[i][0], y=list_coordinate_[i][1], s=20, c=color, label=str(i))

    width = 0.2
    head_width = 2
    head_length = 3
    alpha = 0.7
    color_truck, color_uav = 'green', 'orange'
    line_width = 0.5

    # truck routes
    for route in list_routes:
        for i in range(len(route) - 1):
            plt.arrow(x=list_coordinate_[route[i]][0], y=list_coordinate_[route[i]][1],
                      dx=list_coordinate_[route[i + 1]][0] - list_coordinate_[route[i]][0],
                      dy=list_coordinate_[route[i + 1]][1] - list_coordinate_[route[i]][1],
                      width=width, length_includes_head=True, head_width=head_width, head_length=head_length,
                      alpha=alpha, color=color_truck, linestyle='-', linewidth=line_width)

    # uav routes
    for i in dict_uav_route.keys():
        plt.arrow(x=list_coordinate_[dict_uav_route[i][0]][0], y=list_coordinate_[dict_uav_route[i][0]][1],
                  dx=list_coordinate_[i][0] - list_coordinate_[dict_uav_route[i][0]][0],
                  dy=list_coordinate_[i][1] - list_coordinate_[dict_uav_route[i][0]][1],
                  width=width, length_includes_head=True, head_width=head_width, head_length=head_length,
                  alpha=alpha, color=color_uav, linestyle='--', linewidth=line_width)
        plt.arrow(x=list_coordinate_[i][0], y=list_coordinate_[i][1],
                  dx=list_coordinate_[dict_uav_route[i][1]][0] - list_coordinate_[i][0],
                  dy=list_coordinate_[dict_uav_route[i][1]][1] - list_coordinate_[i][1],
                  width=width, length_includes_head=True, head_width=head_width, head_length=head_length,
                  alpha=alpha, color=color_uav, linestyle='--', linewidth=line_width)

    # x, y range
    edge = 5
    plt.xlim(range_coordinate[0] - edge, range_coordinate[1] + edge)
    plt.ylim(range_coordinate[0] - edge, range_coordinate[1] + edge)

    # save
    path = os.path.join(PATH, "output/vrp.png")
    plt.savefig(path)

主程序


TSP（main_tsp.py）：

from datetime import datetime

from utils.logger import log_tsp as log
from config import tsp as config
from model.tsp import tsp_gg
from visual.tsp import scatter_route_tsp


DTS = datetime.now()

NUM_NODE = config.NUM_NODE
LIST_NODE_UAV = config.LIST_NODE_UAV.copy()
MAT_DISTANCE = config.MAT_DISTANCE.copy()
COST_UAV = config.COST_UAV
log.info(msg="number of nodes:  {}".format(NUM_NODE))
log.info(msg="node can served by uav:  {}".format(LIST_NODE_UAV))


# model
list_route, dict_uav_route = tsp_gg(num_node=NUM_NODE, list_node_uav=LIST_NODE_UAV, mat_distance=MAT_DISTANCE,
                                    cost_uav=COST_UAV)
log.info(msg="truck route:  {}".format(list_route))
for i in dict_uav_route.keys():
    log.info(msg="uav served node:  {},  {}".format(i, dict_uav_route[i]))

# visualisation
scatter_route_tsp(list_route=list_route, dict_uav_route=dict_uav_route)


DTE = datetime.now()
TM = round((DTE - DTS).seconds + (DTE - DTS).microseconds / (10 ** 6), 3)
log.info(msg="total time:  {} s".format(TM))

VRP（main_vrp.py）：

from datetime import datetime

from utils.logger import log_vrp as log
from config import vrp as config
from model.vrp import vrp_load
from visual.vrp import scatter_route_vrp


DTS = datetime.now()

NUM_NODE = config.NUM_NODE
LIST_NODE_UAV = config.LIST_NODE_UAV.copy()
LIST_WEIGHT = config.LIST_WEIGHT
UPPER_LOAD = config.UPPER_LOAD
MAT_DISTANCE = config.MAT_DISTANCE.copy()
COST_UAV = config.COST_UAV
log.info(msg="number of nodes:  {}".format(NUM_NODE))
log.info(msg="node can served by uav:  {}".format(LIST_NODE_UAV))


# model
list_routes, dict_uav_route = vrp_load(
    num_node=NUM_NODE, list_node_uav=LIST_NODE_UAV, list_weight=LIST_WEIGHT, upper_load=UPPER_LOAD,
    mat_distance=MAT_DISTANCE, cost_uav=COST_UAV)
for i in range(len(list_routes)):
    log.info(msg="truck route {}:  {}".format(i + 1, list_routes[i]))
for i in dict_uav_route.keys():
    log.info(msg="uav served node:  {},  {}".format(i, dict_uav_route[i]))

# visualisation
scatter_route_vrp(list_routes=list_routes, dict_uav_route=dict_uav_route)


DTE = datetime.now()
TM = round((DTE - DTS).seconds + (DTE - DTS).microseconds / (10 ** 6), 3)
log.info(msg="total time:  {} s".format(TM))

运行效果


TSP


如前面参数与输入数据模块所示，源码中的 TSP 算例有 50 个点，其中后面 20 个可使用无人机配送，无人机的距离成本系数设为 0.2（即同样的距离又无人机配送的成本为卡车配送的 20%），源码的运行日志如下：

2021-08-04 19:37:03,923[INFO][MainProcess][MainThread]: random data generating time:  0.004 s
2021-08-04 19:37:04,787[INFO][MainProcess][MainThread]: number of nodes:  50
2021-08-04 19:37:04,787[INFO][MainProcess][MainThread]: node can served by uav:  [31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50]
2021-08-04 19:37:04,787[INFO][MainProcess][MainThread]: >>> TSP model, GG formulation, start
2021-08-04 19:38:16,624[INFO][MainProcess][MainThread]: solving time:  49.773 s
2021-08-04 19:38:16,633[INFO][MainProcess][MainThread]: nodes can be served by uav:  [31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50]
2021-08-04 19:38:16,633[INFO][MainProcess][MainThread]: nodes served by uav:  [31, 32, 33, 36, 37, 39, 40, 41, 42, 44, 49, 50]
2021-08-04 19:38:16,634[INFO][MainProcess][MainThread]: <<< TSP model, GG formulation, end
2021-08-04 19:38:16,690[INFO][MainProcess][MainThread]: truck route:  [0, 34, 24, 27, 5, 1, 21, 14, 35, 48, 12, 43, 17, 20, 18, 19, 2, 26, 15, 8, 47, 13, 29, 38, 28, 9, 22, 6, 4, 30, 10, 11, 25, 46, 16, 3, 23, 45, 7, 0]
2021-08-04 19:38:16,691[INFO][MainProcess][MainThread]: uav served node:  31,  (20, 18)
2021-08-04 19:38:16,691[INFO][MainProcess][MainThread]: uav served node:  32,  (10, 11)
2021-08-04 19:38:16,691[INFO][MainProcess][MainThread]: uav served node:  33,  (22, 6)
2021-08-04 19:38:16,691[INFO][MainProcess][MainThread]: uav served node:  36,  (1, 21)
2021-08-04 19:38:16,691[INFO][MainProcess][MainThread]: uav served node:  37,  (13, 29)
2021-08-04 19:38:16,691[INFO][MainProcess][MainThread]: uav served node:  39,  (9, 22)
2021-08-04 19:38:16,691[INFO][MainProcess][MainThread]: uav served node:  40,  (17, 20)
2021-08-04 19:38:16,691[INFO][MainProcess][MainThread]: uav served node:  41,  (18, 19)
2021-08-04 19:38:16,691[INFO][MainProcess][MainThread]: uav served node:  42,  (26, 15)
2021-08-04 19:38:16,691[INFO][MainProcess][MainThread]: uav served node:  44,  (21, 14)
2021-08-04 19:38:16,691[INFO][MainProcess][MainThread]: uav served node:  49,  (19, 2)
2021-08-04 19:38:16,691[INFO][MainProcess][MainThread]: uav served node:  50,  (6, 4)
2021-08-04 19:38:17,174[INFO][MainProcess][MainThread]: total time:  72.387 s

可视化结果图：
TSP 可视化结果

VRP


关于 VRP 模型的算例，源码中的设置为 50 个点，其中最后 10 个点可使用无人机配送，无人机的距离成本系数设为 0.1，每辆车的载重上限为 100，每个物品的重量上限为 20，源码的运行日志如下：

2021-08-04 19:40:21,300[INFO][MainProcess][MainThread]: total weight:  486
2021-08-04 19:40:21,300[INFO][MainProcess][MainThread]: random data generating time:  0.004 s
2021-08-04 19:40:22,168[INFO][MainProcess][MainThread]: number of nodes:  50
2021-08-04 19:40:22,168[INFO][MainProcess][MainThread]: node can served by uav:  [41, 42, 43, 44, 45, 46, 47, 48, 49, 50]
2021-08-04 19:40:22,168[INFO][MainProcess][MainThread]: >>> VRP model, load limit mode, start
2021-08-04 19:41:23,075[INFO][MainProcess][MainThread]: solving time:  38.906 s
2021-08-04 19:41:23,092[INFO][MainProcess][MainThread]: total vehicles: 5
2021-08-04 19:41:23,093[INFO][MainProcess][MainThread]: nodes can be served by uav:  [41, 42, 43, 44, 45, 46, 47, 48, 49, 50]
2021-08-04 19:41:23,094[INFO][MainProcess][MainThread]: nodes served by uav:  [42, 43, 44, 45, 46, 47, 48, 49, 50]
2021-08-04 19:41:23,094[INFO][MainProcess][MainThread]: <<< TSP model, GG formulation, end
2021-08-04 19:41:23,175[INFO][MainProcess][MainThread]: truck route 1:  [0, 6, 4, 30, 25, 11, 10, 32, 3, 16, 23, 0]
2021-08-04 19:41:23,175[INFO][MainProcess][MainThread]: truck route 2:  [0, 7, 33, 22, 39, 9, 13, 29, 37, 38, 28, 0]
2021-08-04 19:41:23,175[INFO][MainProcess][MainThread]: truck route 3:  [0, 19, 2, 26, 15, 8, 0]
2021-08-04 19:41:23,175[INFO][MainProcess][MainThread]: truck route 4:  [0, 34, 24, 36, 1, 5, 27, 0]
2021-08-04 19:41:23,175[INFO][MainProcess][MainThread]: truck route 5:  [0, 41, 31, 18, 20, 17, 40, 12, 35, 14, 21, 0]
2021-08-04 19:41:23,176[INFO][MainProcess][MainThread]: uav served node:  42,  (26, 15)
2021-08-04 19:41:23,176[INFO][MainProcess][MainThread]: uav served node:  43,  (19, 2)
2021-08-04 19:41:23,176[INFO][MainProcess][MainThread]: uav served node:  44,  (36, 1)
2021-08-04 19:41:23,176[INFO][MainProcess][MainThread]: uav served node:  45,  (34, 24)
2021-08-04 19:41:23,176[INFO][MainProcess][MainThread]: uav served node:  46,  (3, 16)
2021-08-04 19:41:23,176[INFO][MainProcess][MainThread]: uav served node:  47,  (15, 8)
2021-08-04 19:41:23,176[INFO][MainProcess][MainThread]: uav served node:  48,  (35, 14)
2021-08-04 19:41:23,176[INFO][MainProcess][MainThread]: uav served node:  49,  (2, 26)
2021-08-04 19:41:23,176[INFO][MainProcess][MainThread]: uav served node:  50,  (0, 6)
2021-08-04 19:41:23,652[INFO][MainProcess][MainThread]: total time:  61.484 s

可视化结果图：
VRP 可视化结果


星海浮生
关注
  • 17
    点赞
  • 踩
  • 172
    收藏
    觉得还不错? 一键收藏
  • 30
    评论
专栏目录
【配送路径规划】遗传算法卡车和两架无人机配送路径规划【含Matlab源码 2394期】
Matlab领域的博客
02-26 886
遗传算法卡车和两架无人机配送路径规划 完整的代码，方可运行；可提供运行操作视频！适合小白！
【无人机协同】无人飞行器协同车辆实现物资配送问题附matlab代码
qq_59747472的博客
06-14 1455
为了解决电商物流"最后1km"的配送问题,文章引入了卡车—无人机联合配送模式,并考虑特殊天气情况下无人机无法工作的约束,构建了以路径最短为目标的数学模型,在不同规模的算例试验中,通过卡车单独配送方案与联合配送方案对比可知无人机配送在解决物流配送问题中的重要性. ​ 3 仿真结果 [1]李敏. 浅析异常天气下无人机和车辆协同配送问题. 部分理论引用网络文献，若有侵权联系博主删除。...
【卡车和无人机协同配送路径优化】遗传算法求解利用一辆卡车和两架无人机配合，将小包裹递送给随机分布的客户，以使所有站点都由卡车或无人机递送一次后返回起始位置（中转站）研究（Matlab代码实现）
最新发布
weixin_67304359的博客
05-22 1001
解决卡车和两个无人机旅行推销员问题，称为串联团队，其中无人机负责最后一英里的工作。使用遗传算法（路径变异）来解决问题。该问题可以解决随机生成坐标的100个城市的D2TSP。解决方案是基于最小化时间而不是距离。最短时间计算基于卡车或任一无人机在一个操作中交付的最大时间。一个操作被定义为一个节点或停止点，其在其中无人机（或两者）被发射，发送交付，并在约会地点恢复。每个无人机受到范围和容量的限制。因此，操作中的范围和停止次数受到无人机约束的限制。卡车和 2 架 无人机 旅行推销员问题。
【卡车无人机协同】基于遗传算法卡车和两架无人机配送路径规划附matlab代码...
m0_60703264的博客
03-03 1429
✅作者简介：热爱科研的Matlab仿真开发者，修心和技术同步精进，matlab项目合作可私信。 ????个人主页：Matlab科研工作室????个人信条：格物致知。⛄ 内容介绍研究传染性公共卫生事件发生后疫区的应急物资供应问题,为避免传染,对中高风险疫区采用"无接触式"的无人机配送方式,低风险疫区采用卡车配送方式,在此基础上设计疫区应...
2024年五一数学建模竞赛C题具有无人机的物流配送问题思路解析及参考代码
Matlab_dashi的博客
05-01 2569
🔥 题目​​随着互联网的普及与应用，网上购物和物流业务迅速增长。卡车具有载重量大的优势，无人机速度快，可以不受道路拥堵或车辆不可达的影响执行任务。某公司希望引入无人机来提高配送效率，让无人机与卡车协同完成配送任务。有的包裹由卡车负责派送，有的由卡车上装载的无人机派送，卡车既承担派送包裹任务，又充当无人机流动仓库的角色。
2024年五一数学建模竞赛A题钢板最优切割路径问题思路解析及参考代码
qq_59747472的博客
05-01 1215
🔥 题目​​随着互联网的普及与应用，网上购物和物流业务迅速增长。卡车具有载重量大的优势，无人机速度快，可以不受道路拥堵或车辆不可达的影响执行任务。某公司希望引入无人机来提高配送效率，让无人机与卡车协同完成配送任务。有的包裹由卡车负责派送，有的由卡车上装载的无人机派送，卡车既承担派送包裹任务，又充当无人机流动仓库的角色。
一种无人机配合卡车配送的车辆路径规划模型
热门推荐
星海浮生
03-25 1万+
TSP; VRP
【配送路径规划】基于matlab遗传算法卡车和两架无人机配送路径规划【含Matlab源码 2394期】
订阅付费专栏（初级版），可赠送该付费专栏任意代码1份；
02-25 2230
遗传算法卡车和两架无人机配送路径规划 完整的代码，方可运行；可提供运行操作视频！适合小白！
【无人机】基于遗传算法的卡车结合两架无人机求解旅行推销员问题（D2TSP）附Matlab代码
matlab_dingdang的博客
12-30 286
城市配送中,"最后一公里"配送成本是物流企业经营成本的主要组成部分,随着无人机技术的发展,无人机飞行能力和运输成本愈加优化,无人机配送作为城市配送领域的重要发展方向,受到越来越多的物流企业和研究人员的关注.由Amazon公司首先提出了并联式配送模式,即采用无人机由配送中心出发直接前往需求点完成配送后返回配送中心的配送方式,以实现无人机的"最后一公里"配送.然而研究人员指出,并联式配送模式由于对配送中心选址,需求点降落平台的要求较高,造成物流网络建设成本大幅增加,并不适用于城市配送中的"最后一公里"问题.因此
优化模型验证23：带无人机停靠站的卡车无人机协同配送车辆路径问题、模型、gurobipy验证及结果可视化
AmieeXue的博客
02-23 3317
一类带无人机停靠站的卡车无人机协同配送路径问题模型及代码验证
2024年五一数学建模联赛B题具有无人机的物流配送问题
订阅付费专栏（初级版），可赠送该付费专栏任意代码1份；
05-01 2979
2024年五一数学建模联赛B题具有无人机的物流配送问题 完整的代码，方可运行；可提供运行操作视频！适合小白！
单卡车协同多无人机任务分配（包裹投递）算法
04-20
单卡车协同多无人机进行包裹投递或者收取Matlab代码 多机器人任务分配算法 卡车协同多无人机
VRP问题研究（附代码）_Solomon标准数据_VRP问题_vrp_车辆路径问题_测试数据_源码
10-02
车辆路径问题研究，可供研究人员下载和研究
【配送路径规划】基于matlab遗传算法卡车和两架无人机配送路径规划【含Matlab源码 2394期】.mp4
02-22
CSDN佛怒唐莲上传的视频均有对应的完整代码，皆可运行，亲测可用，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，...
干扰环境下车辆配送路径规划问题模型.zip
04-21
2.领域：智能优化算法、神经网络预测、信号处理、元胞自动机、图像处理、路径规划、无人机等多种领域的Matlab仿真，更多内容可点击博主头像 3.内容：标题所示，对于介绍可点击主页搜索博客 4.适合人群：本科，硕士...
邻域搜索求解最后一公里卡车+无人机协同配送问题
04-07
邻域搜索求解最后一公里2卡车+2无人机协同配送问题
【无人机路径规划】基于强化学习实现多无人机路径规划附matlab代码.zip
02-01
智能优化算法、神经网络预测、信号处理、元胞自动机、图像处理、路径规划、无人机等多种领域的Matlab仿真代码
【路径规划】基于改进差分算法实现三维多无人机协同航迹规划matlab源码.md
08-05
【路径规划】基于改进差分算法实现三维多无人机协同航迹规划
卡车无人机路径优化：代码实现与可复制性探究
ojpfHzqzPjlY的博客
05-04 238
此外，还需要考虑到卡车和无人机的交互配送问题，即如何合理安排卡车和无人机的配送任务，以提高配送效率。卡车无人机路径优化的优势在于可以充分利用卡车和无人机的特点，实现物流配送的灵活性和效率的提升。通过合理规划和组织卡车和无人机的配送任务，可以有效降低物流成本，并提高物流配送的响应速度和服务质量。通过建立车辆和无人机的实时定位和状态监控系统，可以实时监控卡车和无人机的位置和状态，及时调整配送任务。卡车无人机路径优化，是指在物流运输领域中，通过合理规划和优化卡车和无人机的路径，实现物流配送的高效性和成本的降低。
请编写一个可运行的matlab代码实现无人机路径规划
05-26
好的，以下是一个可以运行的Matlab代码实现无人机路径规划的示例： ``` clear all close all clc % 定义起点和终点 start_point = [0, 0]; end_point = [10, 10]; % 定义障碍物坐标 obstacles = [3, 4; 5, 6; 2, 8; 7, 2]; % 设置地图大小和分辨率 map = robotics.BinaryOccupancyGrid(10, 10, 20); % 将障碍物添加到地图中 setOccupancy(map, obstacles, 1); % 显示地图 figure(1) show(map) hold on % 定义规划器和约束条件 planner = robotics.PRM; planner.Map = map; planner.NumNodes = 100; planner.ConnectionDistance = 2; validator = robotics.StateValidityChecker; validator.Map = map; % 使用规划器和约束条件进行路径规划 path = plan(planner, start_point, end_point); % 显示路径 plot(path(:,1), path(:,2), 'r', 'LineWidth', 2); title('无人机路径规划'); % 计算路径长度 path_length = 0; for i = 2:size(path, 1) path_length = path_length + norm(path(i,:) - path(i-1,:)); end fprintf('路径长度为: %.2f\n', path_length); ``` 这个示例会生成一个大小为10x10，分辨率为20的地图，然后在地图上添加一些障碍物，并使用PRM规划器和状态有效性检查器进行路径规划。最后，将路径显示在地图上，并计算路径长度。你可以将障碍物和起点终点坐标修改为你需要的值，以便进行不同场景下的路径规划。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 30
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值