路径规划的性能评估与测试

在这里插入图片描述

在路径规划领域，全局路径规划算法的性能评估和测试是确保系统可靠性和有效性的关键步骤。本节将详细介绍如何评估和测试路径规划算法的性能，包括常用的评估指标、测试方法以及如何通过仿真和实际测试来验证算法的有效性。

评估指标

1. 路径长度

路径长度是评估路径规划算法性能的基本指标之一。路径长度越短，通常意味着算法的效率越高。路径长度的计算方法通常基于路径上各节点之间的距离之和。

计算路径长度

import numpy as np



def calculate_path_length(path):

    """

    计算路径的总长度

    :param path: 二维数组，表示路径上的节点坐标

    :return: 路径的总长度

    """

    total_length = 0

    for i in range(len(path) - 1):

        # 计算两个节点之间的欧几里得距离

        length = np.linalg.norm(np.array(path[i]) - np.array(path[i + 1]))

        total_length += length

    return total_length



# 示例路径

path = [(0, 0), (1, 1), (2, 2), (3, 3)]

print(f"路径长度: {calculate_path_length(path)}")

2. 计算时间

计算时间是指算法从开始到结束所需的总时间。计算时间越短，算法的实时性越好。

测量计算时间

import time



def time_path_planning(algorithm, start, goal, map):

    """

    测量路径规划算法的计算时间

    :param algorithm: 路径规划算法函数

    :param start: 起始点坐标

    :param goal: 目标点坐标

    :param map: 地图数据

    :return: 计算时间

    """

    start_time = time.time()

    path = algorithm(start, goal, map)

    end_time = time.time()

    return end_time - start_time, path



# 示例路径规划算法

def simple_path_planning(start, goal, map):

    """

    简单的路径规划算法示例

    :param start: 起始点坐标

    :param goal: 目标点坐标

    :param map: 地图数据

    :return: 路径

    """

    # 假设算法返回一条简单的直线路径

    return [start, goal]



# 示例地图数据

map_data = np.zeros((10, 10))  # 10x10的空地图

start_point = (0, 0)

goal_point = (9, 9)



# 测量计算时间

time_taken, path = time_path_planning(simple_path_planning, start_point, goal_point, map_data)

print(f"计算时间: {time_taken}秒")

3. 路径平滑度

路径平滑度是指路径在空间中的连续性和平滑性。平滑度高的路径通常更符合实际导航的要求，减少急转弯和突变。

计算路径平滑度

def calculate_path_smoothness(path):

    """

    计算路径的平滑度

    :param path: 二维数组，表示路径上的节点坐标

    :return: 路径的平滑度

    """

    smoothness = 0

    for i in range(len(path) - 2):

        # 计算三个连续节点之间的夹角

        v1 = np.array(path[i + 1]) - np.array(path[i])

        v2 = np.array(path[i + 2]) - np.array(path[i + 1])

        angle = np.arccos(np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2)))

        smoothness += angle

    return smoothness



# 示例路径

path = [(0, 0), (1, 1), (2, 2), (3, 3)]

print(f"路径平滑度: {calculate_path_smoothness(path)}")

4. 路径安全性

路径安全性是指路径在避开障碍物和危险区域方面的表现。安全性高的路径能够有效避免碰撞和危险。

计算路径安全性

def calculate_path_safety(path, map):

    """

    计算路径的安全性

    :param path: 二维数组，表示路径上的节点坐标

    :param map: 二维数组，表示地图数据，0表示无障碍，1表示有障碍

    :return: 路径的安全性评分

    """

    safety_score = 0

    for node in path:

        if map[node[0], node[1]] == 1:

            safety_score -= 1  # 碰到障碍物减分

        else:

            safety_score += 1  # 无障碍加分

    return safety_score



# 示例地图数据

map_data = np.zeros((10, 10))  # 10x10的空地图

map_data[5, 5] = 1  # 在 (5, 5) 位置设置一个障碍物

path = [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6), (7, 7), (8, 8), (9, 9)]

print(f"路径安全性: {calculate_path_safety(path, map_data)}")

5. 路径鲁棒性

路径鲁棒性是指路径规划算法在面对环境变化时的适应能力。鲁棒性高的算法能够在动态环境中保持有效路径规划。

测试路径鲁棒性

def test_path_robustness(algorithm, start, goal, map, dynamic_obstacles):

    """

    测试路径规划算法的鲁棒性

    :param algorithm: 路径规划算法函数

    :param start: 起始点坐标

    :param goal: 目标点坐标

    :param map: 地图数据

    :param dynamic_obstacles: 动态障碍物列表，每个障碍物是一个 (x, y, t) 的元组，表示在时间 t 位置 (x, y)

    :return: 路径鲁棒性评分

    """

    robustness_score = 0

    for t, obstacle in enumerate(dynamic_obstacles):

        # 更新地图中的障碍物位置

        map[obstacle[0], obstacle[1]] = 1

        path = algorithm(start, goal, map)

        if path:

            robustness_score += 1

        else:

            robustness_score -= 1

        # 重置障碍物位置

        map[obstacle[0], obstacle[1]] = 0

    return robustness_score



# 示例动态障碍物

dynamic_obstacles = [(5, 5, 0), (6, 6, 1), (7, 7, 2)]



# 测试路径鲁棒性

robustness_score = test_path_robustness(simple_path_planning, start_point, goal_point, map_data, dynamic_obstacles)

print(f"路径鲁棒性: {robustness_score}")

测试方法

1. 单元测试

单元测试是指对路径规划算法的各个模块进行独立测试，确保每个模块都能正确工作。

单元测试示例

import unittest



class TestPathPlanning(unittest.TestCase):

    def test_calculate_path_length(self):

        path = [(0, 0), (1, 1), (2, 2), (3, 3)]

        expected_length = 4.242640687119285  # 3 * sqrt(2)

        self.assertAlmostEqual(calculate_path_length(path), expected_length, places=6)



    def test_calculate_path_smoothness(self):

        path = [(0, 0), (1, 1), (2, 2), (3, 3)]

        expected_smoothness = 0  # 直线路径，夹角和为0

        self.assertAlmostEqual(calculate_path_smoothness(path), expected_smoothness, places=6)



    def test_calculate_path_safety(self):

        map_data = np.zeros((10, 10))

        map_data[5, 5] = 1

        path = [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6), (7, 7), (8, 8), (9, 9)]

        expected_safety = 8  # 9个节点，碰到1个障碍物

        self.assertEqual(calculate_path_safety(path, map_data), expected_safety)



    def test_test_path_robustness(self):

        map_data = np.zeros((10, 10))

        dynamic_obstacles = [(5, 5, 0), (6, 6, 1), (7, 7, 2)]

        start_point = (0, 0)

        goal_point = (9, 9)

        expected_robustness = 1  # 3个动态障碍物，路径规划成功2次

        self.assertEqual(test_path_robustness(simple_path_planning, start_point, goal_point, map_data, dynamic_obstacles), expected_robustness)



if __name__ == '__main__':

    unittest.main()

2. 集成测试

集成测试是指将路径规划算法的各个模块组合起来进行测试，确保整体系统能够正常工作。

集成测试示例

def integrated_path_planning(start, goal, map, dynamic_obstacles):

    """

    集成路径规划测试

    :param start: 起始点坐标

    :param goal: 目标点坐标

    :param map: 地图数据

    :param dynamic_obstacles: 动态障碍物列表

    :return: 路径规划结果

    """

    path = simple_path_planning(start, goal, map)

    if not path:

        return None

    path_length = calculate_path_length(path)

    path_smoothness = calculate_path_smoothness(path)

    path_safety = calculate_path_safety(path, map)

    path_robustness = test_path_robustness(simple_path_planning, start, goal, map, dynamic_obstacles)

    

    return {

        "path": path,

        "length": path_length,

        "smoothness": path_smoothness,

        "safety": path_safety,

        "robustness": path_robustness

    }



# 测试集成路径规划

map_data = np.zeros((10, 10))

map_data[5, 5] = 1

start_point = (0, 0)

goal_point = (9, 9)

dynamic_obstacles = [(5, 5, 0), (6, 6, 1), (7, 7, 2)]



result = integrated_path_planning(start_point, goal_point, map_data, dynamic_obstacles)

print(f"集成路径规划结果: {result}")

3. 性能测试

性能测试是指在不同的环境和条件下去测试路径规划算法的性能，包括计算时间、路径长度等。

性能测试示例

def performance_test(algorithm, start, goal, maps, dynamic_obstacles):

    """

    性能测试

    :param algorithm: 路径规划算法函数

    :param start: 起始点坐标

    :param goal: 目标点坐标

    :param maps: 列表，包含多个地图数据

    :param dynamic_obstacles: 列表，包含多个动态障碍物列表

    :return: 性能测试结果

    """

    results = []

    for i, map in enumerate(maps):

        time_taken, path = time_path_planning(algorithm, start, goal, map)

        path_length = calculate_path_length(path)

        path_smoothness = calculate_path_smoothness(path)

        path_safety = calculate_path_safety(path, map)

        path_robustness = test_path_robustness(algorithm, start, goal, map, dynamic_obstacles[i])

        

        results.append({

            "map_index": i,

            "time_taken": time_taken,

            "path_length": path_length,

            "path_smoothness": path_smoothness,

            "path_safety": path_safety,

            "path_robustness": path_robustness

        })

    return results



# 示例地图数据

map_data1 = np.zeros((10, 10))

map_data2 = np.zeros((10, 10))

map_data2[5, 5] = 1

map_data3 = np.zeros((10, 10))

map_data3[5, 5] = 1

map_data3[6, 6] = 1



# 示例动态障碍物

dynamic_obstacles1 = [(5, 5, 0), (6, 6, 1)]

dynamic_obstacles2 = [(5, 5, 0), (6, 6, 1), (7, 7, 2)]

dynamic_obstacles3 = [(5, 5, 0), (6, 6, 1), (7, 7, 2), (8, 8, 3)]



# 测试性能

maps = [map_data1, map_data2, map_data3]

dynamic_obstacles = [dynamic_obstacles1, dynamic_obstacles2, dynamic_obstacles3]

start_point = (0, 0)

goal_point = (9, 9)



performance_results = performance_test(simple_path_planning, start_point, goal_point, maps, dynamic_obstacles)

for result in performance_results:

    print(f"地图 {result['map_index']}: 计算时间 {result['time_taken']}秒, 路径长度 {result['path_length']}, 路径平滑度 {result['path_smoothness']}, 路径安全性 {result['path_safety']}, 路径鲁棒性 {result['path_robustness']}")

4. 可扩展性测试

可扩展性测试是指测试路径规划算法在处理大规模地图和复杂环境时的性能表现。

可扩展性测试示例

def scalability_test(algorithm, start, goal, map_sizes):

    """

    可扩展性测试

    :param algorithm: 路径规划算法函数

    :param start: 起始点坐标

    :param goal: 目标点坐标

    :param map_sizes: 列表，包含多个地图尺寸

    :return: 可扩展性测试结果

    """

    results = []

    for size in map_sizes:

        map = np.zeros((size, size))

        time_taken, path = time_path_planning(algorithm, start, goal, map)

        path_length = calculate_path_length(path)

        path_smoothness = calculate_path_smoothness(path)

        path_safety = calculate_path_safety(path, map)

        

        results.append({

            "map_size": size,

            "time_taken": time_taken,

            "path_length": path_length,

            "path_smoothness": path_smoothness,

            "path_safety": path_safety

        })

    return results



# 示例地图尺寸

map_sizes = [10, 50, 100, 500, 1000]

start_point = (0, 0)

goal_point = (9, 9)



scalability_results = scalability_test(simple_path_planning, start_point, goal_point, map_sizes)

for result in scalability_results:

    print(f"地图尺寸 {result['map_size']}: 计算时间 {result['time_taken']}秒, 路径长度 {result['path_length']}, 路径平滑度 {result['path_smoothness']}, 路径安全性 {result['path_safety']}")

5. 实际测试

实际测试是指在真实环境中对路径规划算法进行测试，验证其在实际应用中的性能和可靠性。

实际测试示例

实际测试通常需要在真实环境中进行，例如使用机器人在实际地图上导航。以下是一个简单的示例，展示如何在模拟环境中进行实际测试。


import matplotlib.pyplot as plt



def simulate_real_environment(algorithm, start, goal, map, dynamic_obstacles):

    """

    模拟实际环境测试

    :param algorithm: 路径规划算法函数

    :param start: 起始点坐标

    :param goal: 目标点坐标

    :param map: 地图数据

    :param dynamic_obstacles: 动态障碍物列表

    :return: 路径规划结果

    """

    path = algorithm(start, goal, map)

    if not path:

        return None

    plt.figure()

    plt.imshow(map, cmap='Greys', origin='lower')

    plt.plot([node[1] for node in path], [node[0] for node in path], 'r-')

    for t, obstacle in enumerate(dynamic_obstacles):

        map[obstacle[0], obstacle[1]] = 1

        plt.imshow(map, cmap='Greys', origin='lower')

        plt.plot([node[1] for node in path], [node[0] for node in path], 'r-')

        plt.title(f"时间步 {t}")

        plt.pause(0.5)

        map[obstacle[0], obstacle[1]] = 0

    plt.show()

    return path



# 示例地图数据

map_data = np.zeros((10, 10))

map_data[5, 5] = 1

start_point = (0, 0)

goal_point = (9, 9)

dynamic_obstacles = [(5, 5, 0), (6, 6, 1), (7, 7, 2)]



# 模拟实际环境测试

simulate_real_environment(simple_path_planning, start_point, goal_point, map_data, dynamic_obstacles)

仿真工具

1. ROS (Robot Operating System)

ROS 是一个广泛使用的机器人操作系统，提供了一系列工具和库来模拟和测试路径规划算法。ROS 的仿真环境可以帮助开发者在虚拟环境中验证算法的性能和可靠性，而无需在实际环境中进行测试。

使用ROS进行仿真

# 安装ROS

sudo apt-get update

sudo apt-get install ros-noetic-ros-base



# 安装Gazebo仿真器

sudo apt-get install ros-noetic-gazebo-ros-pkgs ros-noetic-gazebo-ros

安装完成后，可以使用以下步骤来设置和运行路径规划仿真：

  1. 创建ROS工作空间：

    
mkdir -p ~/catkin_ws/src

cd ~/catkin_ws/

catkin_make

source devel/setup.bash

  2. 创建路径规划节点：

    在ROS工作空间中创建一个路径规划节点，该节点实现路径规划算法并发布路径。

    
# path_planning_node.py

import rospy

from nav_msgs.msg import Path

from geometry_msgs.msg import PoseStamped

import numpy as np



def simple_path_planning(start, goal, map):

    """

    简单的路径规划算法示例

    :param start: 起始点坐标

    :param goal: 目标点坐标

    :param map: 地图数据

    :return: 路径

    """

    # 假设算法返回一条简单的直线路径

    return [start, goal]



def plan_path(start, goal, map):

    path = simple_path_planning(start, goal, map)

    if not path:

        rospy.logerr("Path planning failed")

        return None

    path_msg = Path()

    path_msg.header.frame_id = "map"

    for node in path:

        pose = PoseStamped()

        pose.pose.position.x = node[0]

        pose.pose.position.y = node[1]

        path_msg.poses.append(pose)

    return path_msg



def path_planning_node():

    rospy.init_node('path_planning_node', anonymous=True)

    path_pub = rospy.Publisher('/planned_path', Path, queue_size=10)

    rate = rospy.Rate(1)  # 1 Hz



    start_point = (0, 0)

    goal_point = (9, 9)

    map_data = np.zeros((10, 10))

    map_data[5, 5] = 1  # 在 (5, 5) 位置设置一个障碍物



    while not rospy.is_shutdown():

        path_msg = plan_path(start_point, goal_point, map_data)

        if path_msg:

            path_pub.publish(path_msg)

        rate.sleep()



if __name__ == '__main__':

    try:

        path_planning_node()

    except rospy.ROSInterruptException:

        pass

  3. 创建地图文件：

    创建一个地图文件（例如 map.pgm 和 map.yaml），并在ROS中加载该地图。

    
# map.yaml

image: map.pgm

resolution: 0.05

origin: [0.0, 0.0, 0.0]

negate: 0

occupied_thresh: 0.65

free_thresh: 0.196

  4. 启动Gazebo仿真器：

    使用Gazebo启动仿真环境，并加载地图和路径规划节点。

    
roslaunch gazebo_ros empty_world.launch

rosrun map_server map_server map.yaml

rosrun path_planning path_planning_node.py

  5. 可视化路径：

    使用RViz可视化路径规划结果。

    
rosrun rviz rviz

    在RViz中添加 Path 显示类型，并设置话题为 /planned_path，即可看到路径规划结果。

2. MATLAB

MATLAB 是一个强大的数学计算和仿真工具，可以用于路径规划算法的仿真和测试。MATLAB 提供了丰富的图形处理和仿真功能，适合进行详细的算法分析和可视化。

使用MATLAB进行仿真

% 路径规划仿真示例

function path_planning_simulation()

    % 创建地图

    map = zeros(10, 10);

    map(5, 5) = 1;  % 在 (5, 5) 位置设置一个障碍物

    

    % 起始点和目标点

    start_point = [0, 0];

    goal_point = [9, 9];

    

    % 路径规划

    path = simple_path_planning(start_point, goal_point, map);

    

    % 计算路径长度

    path_length = calculate_path_length(path);

    

    % 计算路径平滑度

    path_smoothness = calculate_path_smoothness(path);

    

    % 计算路径安全性

    path_safety = calculate_path_safety(path, map);

    

    % 可视化路径

    figure;

    imagesc(map);

    hold on;

    plot(path(:, 2), path(:, 1), 'r-');

    hold off;

    title('路径规划结果');

    xlabel('X轴');

    ylabel('Y轴');

    colorbar;

end



function path = simple_path_planning(start, goal, map)

    % 简单的路径规划算法示例

    path = [start; goal];

end



function length = calculate_path_length(path)

    % 计算路径的总长度

    total_length = 0;

    for i = 1:length(path)-1

        length = norm(path(i, :) - path(i+1, :));

        total_length = total_length + length;

    end

    length = total_length;

end



function smoothness = calculate_path_smoothness(path)

    % 计算路径的平滑度

    smoothness = 0;

    for i = 1:length(path)-2

        v1 = path(i+1, :) - path(i, :);

        v2 = path(i+2, :) - path(i+1, :);

        angle = acos(dot(v1, v2) / (norm(v1) * norm(v2)));

        smoothness = smoothness + angle;

    end

end



function safety = calculate_path_safety(path, map)

    % 计算路径的安全性

    safety_score = 0;

    for i = 1:length(path)

        node = path(i, :);

        if map(node(1)+1, node(2)+1) == 1

            safety_score = safety_score - 1;  % 碰到障碍物减分

        else

            safety_score = safety_score + 1;  % 无障碍加分

        end

    end

    safety = safety_score;

end



% 运行仿真

path_planning_simulation();

3. Python仿真库

Python 也有许多库可以用于路径规划的仿真，例如 pygame、matplotlib 和 gym。这些库提供了灵活的图形界面和仿真环境，适合进行路径规划算法的快速测试和验证。

使用 matplotlib 进行仿真

import matplotlib.pyplot as plt

import numpy as np



def simple_path_planning(start, goal, map):

    """

    简单的路径规划算法示例

    :param start: 起始点坐标

    :param goal: 目标点坐标

    :param map: 地图数据

    :return: 路径

    """

    # 假设算法返回一条简单的直线路径

    return [start, goal]



def simulate_path_planning(algorithm, start, goal, map, dynamic_obstacles):

    """

    模拟路径规划

    :param algorithm: 路径规划算法函数

    :param start: 起始点坐标

    :param goal: 目标点坐标

    :param map: 地图数据

    :param dynamic_obstacles: 动态障碍物列表

    :return: 路径规划结果

    """

    path = algorithm(start, goal, map)

    if not path:

        return None

    plt.figure()

    plt.imshow(map, cmap='Greys', origin='lower')

    plt.plot([node[1] for node in path], [node[0] for node in path], 'r-')

    for t, obstacle in enumerate(dynamic_obstacles):

        map[obstacle[0], obstacle[1]] = 1

        plt.imshow(map, cmap='Greys', origin='lower')

        plt.plot([node[1] for node in path], [node[0] for node in path], 'r-')

        plt.title(f"时间步 {t}")

        plt.pause(0.5)

        map[obstacle[0], obstacle[1]] = 0

    plt.show()

    return path



# 示例地图数据

map_data = np.zeros((10, 10))

map_data[5, 5] = 1

start_point = (0, 0)

goal_point = (9, 9)

dynamic_obstacles = [(5, 5, 0), (6, 6, 1), (7, 7, 2)]



# 模拟路径规划

simulate_path_planning(simple_path_planning, start_point, goal_point, map_data, dynamic_obstacles)

4. 实际测试

实际测试是指在真实环境中对路径规划算法进行测试，验证其在实际应用中的性能和可靠性。实际测试通常需要使用机器人平台和实际地图。

实际测试示例

实际测试通常需要在真实环境中进行，例如使用机器人在实际地图上导航。以下是一个简单的示例，展示如何在实际环境中进行测试。

  1. 准备机器人和地图：

    • 确保机器人配备有必要的传感器（如激光雷达、摄像头等）。

    • 准备实际地图数据，可以使用SLAM（Simultaneous Localization and Mapping）技术生成地图。

  2. 编写控制代码：

    编写控制代码，使机器人根据路径规划结果进行导航。

    
import rospy

from nav_msgs.msg import Path

from geometry_msgs.msg import PoseStamped

from move_base_msgs.msg import MoveBaseAction, MoveBaseGoal

import actionlib

import numpy as np



def simple_path_planning(start, goal, map):

    """

    简单的路径规划算法示例

    :param start: 起始点坐标

    :param goal: 目标点坐标

    :param map: 地图数据

    :return: 路径

    """

    # 假设算法返回一条简单的直线路径

    return [start, goal]



def plan_path(start, goal, map):

    path = simple_path_planning(start, goal, map)

    if not path:

        rospy.logerr("Path planning failed")

        return None

    path_msg = Path()

    path_msg.header.frame_id = "map"

    for node in path:

        pose = PoseStamped()

        pose.pose.position.x = node[0]

        pose.pose.position.y = node[1]

        path_msg.poses.append(pose)

    return path_msg



def send_goal(client, goal):

    move_base_goal = MoveBaseGoal()

    move_base_goal.target_pose.header.frame_id = "map"

    move_base_goal.target_pose.header.stamp = rospy.Time.now()

    move_base_goal.target_pose.pose.position.x = goal[0]

    move_base_goal.target_pose.pose.position.y = goal[1]

    move_base_goal.target_pose.pose.orientation.w = 1.0

    client.send_goal(move_base_goal)

    client.wait_for_result()

    return client.get_result()



def navigate_robot(start, goal, map):

    rospy.init_node('navigate_robot', anonymous=True)

    client = actionlib.SimpleActionClient('move_base', MoveBaseAction)

    client.wait_for_server()

    

    path_msg = plan_path(start, goal, map)

    if path_msg:

        for pose in path_msg.poses:

            result = send_goal(client, [pose.pose.position.x, pose.pose.position.y])

            if not result:

                rospy.logerr("Goal failed")

                return False

    rospy.loginfo("Navigation completed successfully")

    return True



if __name__ == '__main__':

    start_point = (0, 0)

    goal_point = (9, 9)

    map_data = np.zeros((10, 10))

    map_data[5, 5] = 1  # 在 (5, 5) 位置设置一个障碍物

    

    navigate_robot(start_point, goal_point, map_data)

5. 结合仿真和实际测试

结合仿真和实际测试可以更全面地评估路径规划算法的性能。可以通过仿真环境初步验证算法的有效性，然后再在实际环境中进行进一步测试。

结合仿真和实际测试示例

  1. 在仿真环境中验证算法：

    使用ROS仿真环境（如Gazebo）验证路径规划算法的有效性和性能。

  2. 在实际环境中测试：

    使用实际机器人平台（如 TurtleBot3）进行测试，确保算法在真实环境中的表现符合预期。

  3. 数据记录和分析：

    记录仿真和实际测试中的数据，包括路径长度、计算时间、路径平滑度、路径安全性和路径鲁棒性。使用数据分析工具（如Pandas、Matplotlib）进行详细的分析和可视化。


import pandas as pd

import matplotlib.pyplot as plt



def record_test_results(results, filename):

    """

    记录测试结果到CSV文件

    :param results: 测试结果列表

    :param filename: 文件名

    """

    df = pd.DataFrame(results)

    df.to_csv(filename, index=False)



def plot_test_results(filename):

    """

    绘制测试结果

    :param filename: 文件名

    """

    df = pd.read_csv(filename)

    plt.figure()

    plt.plot(df['map_size'], df['time_taken'], label='计算时间')

    plt.plot(df['map_size'], df['path_length'], label='路径长度')

    plt.plot(df['map_size'], df['path_smoothness'], label='路径平滑度')

    plt.plot(df['map_size'], df['path_safety'], label='路径安全性')

    plt.xlabel('地图尺寸')

    plt.ylabel('性能指标')

    plt.legend()

    plt.show()



# 示例测试结果

map_sizes = [10, 50, 100, 500, 1000]

start_point = (0, 0)

goal_point = (9, 9)



scalability_results = scalability_test(simple_path_planning, start_point, goal_point, map_sizes)

record_test_results(scalability_results, 'test_results.csv')



# 绘制测试结果

plot_test_results('test_results.csv')

通过上述方法，可以全面评估和测试路径规划算法的性能，确保其在各种环境和条件下的可靠性和有效性。

# 人工智能 # 机器学习 # 机器人 # 图搜索算法
Logo
天工造物局

北京人形旗下天工造物具身智能开源社区，聚焦具身天工与慧思开物两大平台

更多推荐

Handy 离线语音转写教程：免费开源，本地跑不连网

你肯定遇到过：语音输入 5 分钟，云转写服务要登录、要付费；或者出差没网，想口述一段会议纪要，发现全都没法用。Handy 离线语音转写工具就是为解决这个问题做的，声音全程不出你的电脑。## 🎯 这个工具是什么Handy 是一款免费、开源、跨平台（Windows / macOS / Linux）的离线语音转写应用。按住快捷键说话，松手后文字直接粘贴进任意输入框，全程不联网。核心能力就三条：

avatar 天工造物局

Supabase Edge Functions 编写与部署完整指南：Deno 运行时上的无服务器利器

Supabase Edge Functions 是基于 Deno 运行时编写、面向 Web 的无服务器函数服务，帮你把后端逻辑部署到全球边缘节点。作为 Postgres 开发平台的核心能力之一，它让你用 TypeScript 就能快速搭建低延迟的 API 端点、Webhook 接收器和 AI 集成服务，无需管理任何服务器。本文将从零带你完成一个 Edge Function 的创建、本地调试与全球部

avatar 天工造物局

celld从v0.1.0到v0.2.0为何不能滚动升级：两个破坏性变更详解

celld 是一个自托管、分布式的 Durable Objects 开源守护进程，它在你自己的机器上运行 Cloudflare Workers，每个对象对应一个独立的 SQLite 数据库，并持续复制到你自己拥有的 S3 兼容存储桶中。如果你正准备把 v0.1.0 的集群（fleet）升级到 v0.2.0，这篇文章必须先读：这次升级**不能滚动升级**，必须采用"先停光、再启动"的一次性发布方式。

avatar 天工造物局