概述
⛄一、无人机简介
0 引言
随着现代技术的发展，飞行器种类不断变多，应用也日趋专一化、完善化，如专门用作植保的大疆PS-X625无人机，用作街景拍摄与监控巡察的宝鸡行翼航空科技的X8无人机，以及用作水下救援的白鲨MIX水下无人机等，决定飞行器性能主要是内部的飞控系统和外部的路径规划问题。就路径问题而言，在具体实施任务时仅靠操作员手中的遥控器控制无人飞行器执行相应的工作，可能会对操作员心理以及技术提出极高的要求，为了避免个人操作失误，进而造成飞行器损坏的危险，一种解决问题的方法就是对飞行器进行航迹规划。
飞行器的测量精度，航迹路径的合理规划，飞行器工作时的稳定性、安全性等这些变化对飞行器的综合控制系统要求越来越高。无人机航路规划是为了保证无人机完成特定的飞行任务，并且能够在完成任务的过程中躲避各种障碍、威胁区域而设计出最优航迹路线的问题。常见的航迹规划算法如图1所示。
图1 常见路径规划算法
文中主要对无人机巡航阶段的航迹规划进行研究，假设无人机在飞行中维持高度与速度不变，那么航迹规划成为一个二维平面的规划问题。在航迹规划算法中,A算法计算简单，容易实现。在改进A算法基础上，提出一种新的、易于理解的改进A算法的无人机航迹规划方法。传统A算法将规划区域栅格化，节点扩展只限于栅格线的交叉点，在栅格线的交叉点与交叉点之间往往存在一定角度的两个运动方向。将存在角度的两段路径无限放大、细化，然后分别用两段上的相应路径规划点作为切点，找到相对应的组成内切圆的圆心，然后作弧，并求出相对应的两切点之间的弧所对应的圆心角，根据下式计算出弧线的长度
式中：R———内切圆的半径；
α———切点之间弧线对应的圆心角。
⛄二、蝙蝠优化算法（BA）简介
蝙蝠算法( BA) 是 Yang 教授于 2010 年基于群体智能提出的启发式搜索算法,是一种搜索全局最优解的有效方法。该算法是一种基于迭代的优化技术,初始化为一组随机解,然后 通过迭代搜寻最优解,且在最优解周围通过随机飞行产生局部新解,加强了局部搜索。与其他算法相比,BA 在准确性和有效性方面远优于其他算法,且没有许多参数要进行调整。
⛄三、差分进化算法简介
1 前言
在遗传、选择和变异的作用下，自然界生物体优胜劣汰，不断由低级向高级进化和发展。人们注意到，适者生存的进化规律可以模式化，从而构成一些优化算法；近年来发展的进化计算类算法受到了广泛的关注。
差分进化算法(Differential Evolution， DE) 是一种新兴的进化计算技术[1] 。它是由S torn等人于1995年提出的， 其最初的设想是用于解决切比雪夫多项式问题，后来发现它也是解决复杂优化问题的有
效技术。
差分进化算法是基于群体智能理论的优化算法，是通过群体内个体间的合作与竞争而产生的智能优化搜索算法。但相比于进化计算，它保留了基于种群的全局搜索策略，采用实数编码、基于差分的简单
变异操作和“一对一”的竞争生存策略，降低了进化计算操作的复杂性。同时，差分进化算法特有的记忆能力使其可以动态跟踪当前的搜索情况，以调整其搜索策略，它具有较强的全局收敛能力和稳健性，
且不需要借助问题的特征信息，适用于求解一些利用常规的数学规划方法很难求解甚至无法求解的复杂优化问题[2-5]。因此，差分进化算法作为一种高效的并行搜索算法，对其进行理论和应用研究具有重要的学术意义和工程价值。
目前，差分进化算法已经在许多领域得到了应用，如人工神经元网络、电力、机械设计、机器人、信号处理、生物信息、经济学、现代农业和运筹学等。然而，尽管差分进化算法获得了广泛研究，但相
对于其他进化算法而言，其研究成果相当分散，缺乏系统性，尤其在理论方面还没有重大突破。
2 差分进化算法理论
2.1差分进化算法原理
差分进化算法是一种随机的启发式搜索算法，简单易用，有较强的鲁棒性和全局寻优能力。它从数学角度看是一种随机搜索算法，从工程角度看是一种自适应的迭代寻优过程。除了具有较好的收敛性外，差分进化算法非常易于理解与执行，它只包含不多的几个控制参数，并且在整个迭代过程中，这些参数的值可以保持不变。差分进化算法是一种自组织最小化方法，用户只需很少的输入。它的关键思想与传统进化方法不同：传统方法是用预先确定的概率分布函数决定向量扰动；而差分进化算法的自组织程序利用种群中两个随机选择的不同向量来干扰一个现有向量，种群中的每一个向量都要进行干扰。差分进化算法利用一个向量种群，其中种群向量的随机扰动可独立进行，因此是并行的。如果新向量对应函数值的代价比它们的前辈代价小，它们将取代前辈向量。
同其他进化算法一样，差分进化算法也是对候选解的种群进行操作，但其种群繁殖方案与其他进化算法不同：它通过把种群中两个成员之间的加权差向量加到第三个成员上来产生新的参数向量，该操作
称为“变异”； 然后将变异向量的参数与另外预先确定的目标向量参数按一定规则混合来产生试验量，该操作称为“交叉”；最后，若试验向量的代价函数比目标向量的代价函数低，试验向量就在下一代中代替目标向量，该操作称为“选择”。种群中所有成员必须当作目标向量进行一次这样的操作，以便在下一代中出现相同个数竞争者。
在进化过程中对每一代的最佳参数向量都进行评价，以记录最小化过程。这样利用随机偏差扰动产生新个体的方式，可以获得一个收敛性非常好的结果，引导搜索过程向全局最优解逼近[6-7]。
2.2差分进化算法的特点
差分进化算法从提出到现在，在短短二十几年内人们对其进行了广泛的研究并取得了成功的应用。该算法主要有如下特点：
(1)结构简单，容易使用。差分进化算法主要通过差分变异算子来进行遗传操作，由于该算子只涉及向量的加减运算，因此很容易实现；该算法采用概率转移规则，不需要确定性的规则。此外，差分进化算法的控制参数少，这些参数对算法性能的影响已经得到一定的研究，并得出了一些指导性的建议，因而可以方便使用人员根据问题选择较优的参数设置。
(2)性能优越。差分进化算法具有较好的可靠性、高效性和鲁棒性，对于大空间、非线性和不可求导的连续问题，其求解效率比其他进化方法好，而且很多学者还在对差分进化算法继续改良，以不断提高其性能。
(3)自适应性。差分进化算法的差分变异算子可以是固定常数，也可以具有变异步长和搜索方向自适应的能力，根据不同目标函数进行自动调整，从而提高搜索质量。
(4)差分进化算法具有内在的并行性，可协同搜索，具有利用个体局部信息和群体全局信息指导算法进一步搜索的能力。在同样精度要求下，差分进化算法具有更快的收敛速度。
(5)算法通用，可直接对结构对象进行操作，不依赖于问题信息，不存在对目标函数的限定。差分进化算法操作十分简单，易于编程实现，尤其利于求解高维的函数优化问题。
3 差分进化算法种类
3.1基本差分进化算法
基本差分进化算法的操作程序如下[8]：
(1)初始化；
(2)变异；
(3)交叉；
(4)选择；
(5)边界条件处理。
初始化
差分进化算法利用NP个维数为D的实数值参数向量，将它们作为每
一代的种群，每个个体表示为：
另外一个方法是进行边界吸收处理，即将超过边界约束的个体值设置为临近的边界值。
3.2差分进化算法的其他形式
上面阐述的是最基本的差分进化算法操作程序，实际应用中还发展了差分进化算法的几个变形形式，用符号DE/x/y/z加以区分，其中：x限定当前被变异的向量是“随机的”或“最佳的”；y是所利用的差向量的个数；z指示交叉程序的操作方法。前面叙述的交叉操作表示为“bin”。利用这个表示方法， 基本差分进化算法策略可描述为DE/rand/1/bin。
还有其他形式[5，如：
3.3改进的差分进化算法
自适应差分进化算法
作为一种高效的并行优化算法，差分进化算法发展很快，出现了很多改进的差分进化算法。下面介绍一种具有自适应算子的差分进化算法[9].
4差分进化算法流程
差分进化算法采用实数编码、基于差分的简单变异操作和“一对一”的竞争生存策略，其具体步骤如下：
(1)确定差分进化算法的控制参数和所要采用的具体策略。差分进化算法的控制参数包括：种群数量、变异算子、交叉算子、最大进化代数、终止条件等。
(2)随机产生初始种群，进化代数k=1。
(3)对初始种群进行评价，即计算初始种群中每个个体的目标函数值。
(4)判断是否达到终止条件或达到最大进化代数：若是，则进化终止，将此时的最佳个体作为解输出；否则，继续下一步操作。
(5)进行变异操作和交叉操作，对边界条件进行处理，得到临时种群。
(6)对临时种群进行评价，计算临时种群中每个个体的目标函数值。
(7)对临时种群中的个体和原种群中对应的个体，进行“一对-”的选择操作，得到新种群。
(8)进化代数k=k+1，转步骤(4)。
差分进化算法运算流程如图3.1所示。
5关键参数的说明
控制参数对一个全局优化算法的影响是很大的，差分进化算法的控制变量选择也有一些经验规则。
种群数量NP
一般情况下，种群的规模AP越大，其中的个体就越多，种群的多样性也就越好，寻优的能力也就越强，但也因此增加了计算的难度。所以，NP不能无限取大。根据经验，种群数量NP的合理选择在5D~
10D之间，必须满足NP≥4，以确保差分进化算法具有足够的不同的变异向量。
变异算子F
变异算子FE[0，2]是一个实常数因数，它决定偏差向量的放大比例。变异算子熨小，则可能造成算法“早熟”。随着/值的增大，防止算法陷入局部最优的能力增强，但当F>1时，想要算法快速收敛到最优值会变得十分不易；这是由于当差分向量的扰动大于两个个体之间的距离时，种群的收敛性会变得很差。目前的研究表明，F小于0.4和大于1的值仅偶尔有效，/=0.5通常是一个较好的初始选择。若种
群过早收敛，那么F或NP应该增大。
交叉算子CR
交叉算子CR是一个范围在[0，1]内的实数，它控制着一个试验向量参数来自于随机选择的变异向量而不是原来向量的概率。交叉算子CK越大，发生交叉的可能性就越大。CR的一个较好的选择是0.1，但
较大的CK通常会加速收敛，为了看看是否可能获得一个快速解，可以先尝试CR=0.9或CF=1.0.
最大进化代数G
最大进化代数6是表示差分进化算法运行结束条件的一个参数，表示差分进化算法运行到指定的进化代数之后就停止运行，并将当前群体中的最佳个体作为所求问题的最优解输出。一般，6取100~500。
终止条件
除最大进化代数可作为差分进化算法的终止条件外，还可以增加其他判定准则。一般当目标函数值小于阈值时程序终止，阈值常选为10-6。上述参数中，F、CR与NP一样，在搜索过程中是常数，一般F和CR影响搜索过程的收敛速度和稳健性，它们的优化值不仅依赖于目标函数的特性，还与NP有关。通常可通过对不同值做一些试验之后，利用试验和结果误差找到F、CR和NP的合适值。
⛄四、部分源代码
clear all;
close all;
clc;
tic
%%
global k;
global Threat_radius;
global Threat_kind;
global d;
global Threat_center;
M=60; %种群规模
F1=0.7;
F2=0.8;
F3=0.9;
CR=0.5;
D=20; %函数优化的维度
NCmax=100;%迭代次数
start=[0;0]; %起始点坐标
aim=[80;100]; %执行任务终点
distance=sqrt((start(1)-aim(1))2+(start(2)-aim(2))2); %起始点和终点之间的距离
a=(aim(1)-start(1))/distance;%起始点终点连线与水平线之间夹角的余弦值
b=(aim(2)-start(2))/distance;%起始点终点连线与水平线之间夹角的正弦值
Threat_center=[10 30 90 20 50 65 60 30 60 75;50 80 80 20 55 38 80 42 10 65];%威胁中心
Threat_radius=[10 10 10 9 10 10 10 8 10 8];%威胁半径
Threat_kind=[8 4 10 6 7 6 7 5 6 8]; %威胁代价权值
k=0.9;%威胁代价权值
Path1=zeros(M,D);
Path2=zeros(M,D);
Path3=zeros(M,D);
cross_Path1=zeros(M,D);
cross_Path2=zeros(M,D);
cross_Path3=zeros(M,D);
mutate_Path1=zeros(M,D);
mutate_Path2=zeros(M,D);
mutate_Path3=zeros(M,D);
mutate_Path_glob1=zeros(M,D);
mutate_Path_glob2=zeros(M,D);
mutate_Path_glob3=zeros(M,D);
mutate_Path_loc1=zeros(M,D);
mutate_Path_loc2=zeros(M,D);
mutate_Path_loc3=zeros(M,D);
uavroute1=zeros(NCmax,D);
uavroute2=zeros(NCmax,D);
uavroute3=zeros(NCmax,D);
Path_bestmem=zeros(1,D);
Path_bestmemit1=zeros(1,D);
Path_bestmemit2=zeros(1,D);
Path_bestmemit3=zeros(1,D);
Path_bm1=zeros(M,D);
Path_bm2=zeros(M,D);
Path_bm3=zeros(M,D);
Best_solution1=zeros(1,D);
Best_solution2=zeros(1,D);
Best_solution3=zeros(1,D);
Fitness1=ones(1,M);
Fitness2=ones(1,M);
Fitness3=ones(1,M);
iteration_fitness1=zeros(1,NCmax);
iteration_fitness2=zeros(1,NCmax);
iteration_fitness3=zeros(1,NCmax);
%% 坐标系变换
size=length(Threat_kind);
for i=1:size
Threat_transform(1,i)=a*(Threat_center(1,i)-start(1))+b*(Threat_center(2,i)-start(2));
Threat_transform(2,i)=-b*(Threat_center(1,i)-start(1))+a*(Threat_center(2,i)-start(2));
end
start_transform=[0 0]; %起始点坐标转换
aim_transform(1)=a*(aim(1)-start(1))+b*(aim(2)-start(2));
aim_transform(2)=-b*(aim(1)-start(1))+a*(aim(2)-start(2)); %目标点坐标转换
%% 初始化航路
d=aim_transform(1)/(D+1); %旋转坐标系的横坐标间隔
for i=1:M
Path1(i,1)=(rand-0.45)20;
Path2(i,1)=(rand-0.55)20;
Path3(i,1)=(rand-0.5)20;
for j=2:D
Path1(i,j)=Path1(i,j-1)+(rand-0.45)10;
Path2(i,j)=Path2(i,j-1)+(rand-0.55)10;
Path3(i,j)=Path3(i,j-1)+(rand-0.5)10;
end %初始化横坐标
end
tic
%% 迭代计算
for NC=1:NCmax
I_best_index1=1;
I_best_index2=1;
I_best_index3=1;
I_strategy=3;
NDE_an1=1;
NDE_an2=2;
Nde=NC/NCmax;
for i=1:M
r1=ceil(Mrand);
r2=ceil(Mrand);
r3=ceil(Mrand);
while(r1r2||r1r3||r2==r3)
r1=ceil(Mrand);
r2=ceil(Mrand);
r3=ceil(Mrand);
end %选取不同的r1,r2,r3，且不等于i
if(NC>=2&&I_strategy==1)
mutate_Path1(i,:)=Path_bm1(i,:)+F1.*(Path1(r1,:)-Path1(r2,:));
mutate_Path2(i,:)=Path_bm1(i,:)+F2.*(Path2(r1,:)-Path2(r2,:));
mutate_Path3(i,:)=Path_bm1(i,:)+F3.*(Path3(r1,:)-Path3(r2,:));
elseif (NC>=2&&I_strategy==2)
mutate_Path1(i,:)=Path1(i,:)+F1*(Path_bm1(i,:)-Path1(i,:))+F1*(Path1(r1,:)-Path1(r2,:));
mutate_Path2(i,:)=Path2(i,:)+F2*(Path_bm1(i,:)-Path2(i,:))+F2*(Path2(r1,:)-Path2(r2,:));
mutate_Path3(i,:)=Path3(i,:)+F3*(Path_bm1(i,:)-Path3(i,:))+F3*(Path3(r1,:)-Path3(r2,:));
elseif(NC>=2&&I_strategy==3&&i>3)
FVr_Nind=randsrc(1,6,[i-3,i-2,i-1,i+1,i+2,i+3]);
NDE_an1=rem(FVr_Nind(fix(rand(1)*6)+1),M);
NDE_an2=rem(FVr_Nind(fix(rand(1)*6)+1),M);
while (NDE_an2==NDE_an1||NDE_an1==0||NDE_an2==0)
end
mutate_Path_glob1(i,:)=Path_bm1(i,:)+(Path_bm1(i,:)-Path1(i,:)).*((1-0.9999)*rand(1,D)+F1)+(Path1(r1,:)-Path1(r2,:)).*((1-0.9999)*rand(1,D)+F1);
mutate_Path_loc1(i,:)=Path1(i,:)+F1*(Path_bm1(i,:)-Path1(i,:))+F1*(Path1(NDE_an1,:)-Path1(NDE_an2,:));
mutate_Path1(i,:)=Nde*mutate_Path_glob1(i,:)+(1-Nde)*mutate_Path_loc1(i,:);
mutate_Path_glob2(i,:)=Path_bm1(i,:)+(Path_bm1(i,:)-Path2(i,:)).*((1-0.9999)*rand(1,D)+F2)+(Path2(r1,:)-Path2(r2,:)).*((1-0.9999)*rand(1,D)+F2);
mutate_Path_loc2(i,:)=Path2(i,:)+F2*(Path_bm1(i,:)-Path2(i,:))+F2*(Path2(NDE_an1,:)-Path2(NDE_an2,:));
mutate_Path2(i,:)=Nde*mutate_Path_glob2(i,:)+(1-Nde)*mutate_Path_loc2(i,:);
mutate_Path_glob3(i,:)=Path_bm1(i,:)+(Path_bm1(i,:)-Path3(i,:)).*((1-0.9999)*rand(1,D)+F3)+(Path3(r1,:)-Path3(r2,:)).*((1-0.9999)*rand(1,D)+F3);
mutate_Path_loc3(i,:)=Path3(i,:)+F3*(Path_bm1(i,:)-Path3(i,:))+F3*(Path3(NDE_an1,:)-Path3(NDE_an2,:));
mutate_Path3(i,:)=Nde*mutate_Path_glob3(i,:)+(1-Nde)*mutate_Path_loc3(i,:);
else
mutate_Path1(i,:)=Path1(r1,:)+F1.*(Path1(r2,:)-Path1(r3,:));
mutate_Path2(i,:)=Path2(r1,:)+F2.*(Path2(r2,:)-Path2(r3,:));
mutate_Path3(i,:)=Path3(r1,:)+F3.*(Path3(r2,:)-Path3(r3,:));
end
randr=ceil(D*rand);
for j=1:D
if j==randr||rand<=CR
cross_Path1(i,j)=mutate_Path1(i,j);
cross_Path2(i,j)=mutate_Path2(i,j);
cross_Path3(i,j)=mutate_Path3(i,j);
else
cross_Path1(i,j)=Path1(i,j);
cross_Path2(i,j)=Path2(i,j);
cross_Path3(i,j)=Path3(i,j);
end
end %产生交叉个体
new_threat1=Threat_count(aim_transform(),cross_Path1(i,:),Threat_transform);
formal_threat1=Threat_count(aim_transform(),Path1(i,:),Threat_transform);
new_threat2=Threat_count(aim_transform(),cross_Path2(i,:),Threat_transform);
formal_threat2=Threat_count(aim_transform(),Path2(i,:),Threat_transform);
new_threat3=Threat_count(aim_transform(),cross_Path3(i,:),Threat_transform);
formal_threat3=Threat_count(aim_transform(),Path3(i,:),Threat_transform);
if new_threat1<=formal_threat1
Fitness1(i)=new_threat1;
Path1(i,:)=cross_Path1(i,:);
else
Fitness1(i)=formal_threat1;
Path1(i,:)=Path1(i,:);
end
if(Fitness1(i)==min(Fitness1))
I_best_index1=i;
end
if new_threat2<=formal_threat2
Fitness1(i)=new_threat2;
Path2(i,:)=cross_Path2(i,:);
else
Fitness2(i)=formal_threat2;
Path2(i,:)=Path2(i,:);
end
if(Fitness2(i)==min(Fitness2))
I_best_index2=i;
end
if new_threat3<=formal_threat3
Fitness3(i)=new_threat3;
Path3(i,:)=cross_Path3(i,:);
else
if(Fitness3(i)==min(Fitness3))
I_best_index3=i;
end
end
[iteration_fitness1(NC),flag1]=min(Fitness1);
[iteration_fitness2(NC),flag2]=min(Fitness2);
[iteration_fitness3(NC),flag3]=min(Fitness3);
uavroute1(NC,:)=Path1(flag1,:);
uavroute2(NC,:)=Path2(flag2,:);
uavroute3(NC,:)=Path3(flag3,:);
fprintf('NC=%d ObjVal=%gn',NC,iteration_fitness1(NC));
fprintf('NC=%d ObjVal=%gn',NC,iteration_fitness2(NC));
fprintf('NC=%d ObjVal=%gn',NC,iteration_fitness3(NC));
iteration_fitness1(iteration_fitness1==1)=50;
iteration_fitness2(iteration_fitness2==1)=50;
iteration_fitness3(iteration_fitness3==1)=50;
Path_bestmemit1=Path1(I_best_index1,:);
Path_bestmemit2=Path2(I_best_index2,:);
Path_bestmemit3=Path3(I_best_index3,:);
for p=1:M
Path_bm1(p,:)=Path_bestmemit1;
Path_bm2(p,:)=Path_bestmemit2;
Path_bm3(p,:)=Path_bestmemit3;
end
end
[Best_fitness1,flag1]=min(iteration_fitness1);
[Best_fitness2,flag2]=min(iteration_fitness2);
[Best_fitness3,flag3]=min(iteration_fitness3);
Best_solution1=uavroute1(flag1,:);
Best_solution2=uavroute2(flag2,:);
Best_solution3=uavroute3(flag3,:);
for i=1:length(Best_solution1)
BestPath1(1,i+1)=aid-bBest_solution1(i)+start(1);
BestPath1(2,i+1)=bid+aBest_solution1(i)+start(2);
% BestPath1(BestPath1<0)=5;
end
for i=1:length(Best_solution2)
BestPath2(1,i+1)=aid-bBest_solution2(i)+start(1);
BestPath2(2,i+1)=bid+aBest_solution2(i)+start(2);
% BestPath2(BestPath2<0)=6;
end
for i=1:length(Best_solution3)
BestPath3(1,i+1)=aid-bBest_solution3(i)+start(1);
BestPath3(2,i+1)=bid+aBest_solution3(i)+start(2);
% BestPath3(BestPath3<0)=4;
end
BestPath1(1,i+2)=aim(1);
BestPath1(2,i+2)=aim(2);
BestPath2(1,i+2)=aim(1);
BestPath2(2,i+2)=aim(2);
BestPath3(1,i+2)=aim(1);
BestPath3(2,i+2)=aim(2);
figure (1);
plot(BestPath1(1,:),BestPath1(2,:),‘k*–’,‘LineWidth’,2);
hold on;
plot(BestPath2(1,:),BestPath2(2,:),‘bo–’,‘LineWidth’,2);
hold on;
plot(BestPath3(1,:),BestPath3(2,:),‘rx–’,‘LineWidth’,2);
hold on;
legend(‘CPFIBA’,‘DEBA’,‘BA’);
% hold on;
% plot(iteration_fitness1,‘k-’);
% plot(iteration_fitness2,‘b*’);
% plot(iteration_fitness3,‘r+’);
% title(‘the objective function value convergence curve’);
% xlabel(‘the number of iterations n’);
% ylabel(‘the value of objective function ObjVal’);
% hold off;
% hold on;
% plot(iteration_fitness1,‘k-’);
% plot(iteration_fitness2,‘b*’);
% plot(iteration_fitness3,‘r+’);
%
% title(‘the objective function value convergence curve’);
% xlabel(‘the number of iterations n’);
% ylabel(‘the value of objective function ObjVal’);
hold off;
toc
⛄五、运行结果
⛄六、matlab版本及参考文献
1 matlab版本
2014a
2 参考文献
[1] 包子阳,余继周,杨杉.智能优化算法及其MATLAB实例（第2版）[M].电子工业出版社，2016.
[2]张岩,吴水根.MATLAB优化算法源代码[M].清华大学出版社，2017.
[3]巫茜,罗金彪,顾晓群,曾青.基于改进PSO的无人机三维航迹规划优化算法[J].兵器装备工程学报. 2021,42(08)
[4]邓叶,姜香菊.基于改进人工势场法的四旋翼无人机航迹规划算法[J].传感器与微系统. 2021,40(07)
[5]马云红,张恒,齐乐融,贺建良.基于改进A*算法的三维无人机路径规划[J].电光与控制. 2019,26(10)
[6]焦阳.基于改进蚁群算法的无人机三维路径规划研究[J].舰船电子工程. 2019,39(03)
3 备注
简介此部分摘自互联网，仅供参考，若侵权，联系删除
最后
以上就是怕黑冬瓜为你收集整理的【路径规划】基于matlab多种算法无人机路径规划【含Matlab源码 1263期】的全部内容，希望文章能够帮你解决【路径规划】基于matlab多种算法无人机路径规划【含Matlab源码 1263期】所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
发表评论 取消回复